@@ -5,6 +5,18 @@ import { BenchApp } from "./bench-app";
 import { detectBrowserVersion } from "./bench-runtime";
 
 const APP_VERSION = import.meta.env.VITE_APP_VERSION as string;
+/**
+ * Which build this page IS, so a run can prove it measured the build it meant
+ * to. Written on `<html>` rather than inside the app so it survives whatever
+ * the adapter is doing, and so a check can read it before any grid mounts.
+ * Undefined under `vite dev` and vitest, where nothing is being published.
+ */
+const BENCH_BUILD_ID = import.meta.env.VITE_BENCH_BUILD_ID as
+  string | undefined;
+
+if (typeof document !== "undefined" && BENCH_BUILD_ID) {
+  document.documentElement.dataset.benchBuildId = BENCH_BUILD_ID;
+}
 
 export function App() {
   return (
 
@@ -18,6 +18,66 @@ const scriptName = process.env.PRETABLE_BENCH_SCRIPT ?? "initial";
 const updateRatePerSec = process.env.PRETABLE_BENCH_UPDATE_RATE_PER_SEC;
 const diagnostics = process.env.PRETABLE_BENCH_DIAGNOSTICS;
 const seed = process.env.PRETABLE_BENCH_SEED;
+/**
+ * Prove the page under test is the build in this checkout.
+ *
+ * A benchmark number is only worth something if it names a commit. These stopped
+ * doing that silently: with another worktree holding port 4173, `bench:matrix`
+ * printed `Error: Port 4173 is already in use` and ran the whole suite against
+ * that server anyway, writing artifacts that looked ordinary while describing a
+ * different branch's code. Post-fix runs read as failures for hours because
+ * they were measuring pre-fix code.
+ *
+ * `vite build` writes a fresh id into `dist/` and injects the same value into
+ * the bundle, so the two agree only when the server is serving THIS build. That
+ * also catches a stale `dist/` and a forgotten rebuild.
+ *
+ * Set `PRETABLE_BENCH_SKIP_BUILD_CHECK=1` when the target is deliberately not
+ * a local build (a deployed bench, someone else's preview).
+ */
+const skipBuildCheck = process.env.PRETABLE_BENCH_SKIP_BUILD_CHECK === "1";
+const BUILD_ID_PATH = path.join(
+  import.meta.dirname,
+  "..",
+  "dist",
+  "bench-build-id.txt",
+);
+
+async function expectServedBuildMatchesCheckout(page: {
+  getAttribute: (name: string) => Promise<string | null>;
+}): Promise<void> {
+  if (skipBuildCheck) return;
+
+  let expected: string;
+  try {
+    expected = (await readFile(BUILD_ID_PATH, "utf8")).trim();
+  } catch {
+    throw new Error(
+      `No ${BUILD_ID_PATH}. Build the bench before measuring it ` +
+        "(`pnpm --filter @pretable/app-bench build`), or set " +
+        "PRETABLE_BENCH_SKIP_BUILD_CHECK=1 if the target is deliberately not " +
+        "a local build.",
+    );
+  }
+
+  const served = await page.getAttribute("data-bench-build-id");
+  expect(
+    served,
+    [
+      "The page under test is not the build in this checkout, so every number",
+      "this run produces describes code you did not build.",
+      "",
+      `  expected (dist/): ${expected}`,
+      `  served  (page):   ${served ?? "(absent)"}`,
+      "",
+      "Usual cause: something else already holds the port, and the run",
+      "attached to it instead of failing — check `lsof -ti:4173` for another",
+      "worktree's `preview:bench`. An absent id means the server is serving a",
+      "build from before this check existed, or a `vite dev` server.",
+    ].join("\n"),
+  ).toBe(expected);
+}
+
 const adapterLabel =
   adapterId === "ag-grid"
     ? "AG Grid Community adapter"
@@ -47,6 +107,9 @@ test("writes benchmark artifacts for the selected Pretable run", async ({
     `/?adapter=${adapterId}&scenario=${scenarioId}&scale=${scale}&script=${scriptName}${rateParam}${diagnosticsParam}${seedParam}&autorun=1${triggerParam}`,
   );
 
+  // Before anything is measured: is this even our build?
+  await expectServedBuildMatchesCheckout(page.locator("html"));
+
   await expect(page.getByLabel(adapterLabel).first()).toBeVisible();
 
   let cdpSession: Awaited<
 
@@ -1,13 +1,51 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
 import { defineConfig } from "vitest/config";
 
 import pkg from "./package.json" with { type: "json" };
 
+/**
+ * A per-build identity, so a run can prove WHICH build it measured.
+ *
+ * The bench's numbers are only worth anything if they describe a known commit.
+ * They silently stopped doing that: with a second worktree holding port 4173,
+ * `bench:matrix` printed `Error: Port 4173 is already in use` and then ran the
+ * whole suite against that other branch's `vite preview`, writing artifacts as
+ * if nothing were wrong. Post-fix runs read as failures because they were
+ * measuring pre-fix code.
+ *
+ * A git SHA cannot do this job: the working tree is dirty for most of a
+ * development loop, so the SHA is identical across builds that differ. A fresh
+ * id per build is exactly the question being asked — "is the server answering
+ * me the one I just built?" — and it also catches a stale `dist/` and a
+ * forgotten rebuild, which have both bitten this repo.
+ *
+ * Written to `dist/` so the test can read the id it expects off disk, and
+ * injected into the bundle so the page can report the id it actually is.
+ */
+const BUILD_ID = randomUUID();
+const BUILD_ID_FILE = "bench-build-id.txt";
+
 export default defineConfig({
-  plugins: [react(), tailwindcss()],
+  plugins: [
+    react(),
+    tailwindcss(),
+    {
+      name: "bench-build-id",
+      apply: "build",
+      writeBundle(options) {
+        const dir = options.dir ?? path.join(import.meta.dirname, "dist");
+        fs.writeFileSync(path.join(dir, BUILD_ID_FILE), BUILD_ID, "utf8");
+      },
+    },
+  ],
   define: {
     "import.meta.env.VITE_APP_VERSION": JSON.stringify(pkg.version),
+    "import.meta.env.VITE_BENCH_BUILD_ID": JSON.stringify(BUILD_ID),
   },
   build: {
     sourcemap: true,
 
@@ -234,6 +234,7 @@ async function run() {
 
   try {
     await waitForServer(BENCH_BASE_URL, server);
+    await assertServerIsOurBuild(BENCH_BASE_URL, previewLaunch.preview.cwd);
 
     for (const entry of createBenchMatrixEntries(parsedArgs)) {
       runEntries.push(await runBenchEntry(entry, parsedArgs.passthroughArgs));
@@ -374,6 +375,54 @@ function parsePositiveInteger(value, fallback) {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+/**
+ * `waitForServer` asks only whether SOMETHING answers, which is why a second
+ * worktree already holding 4173 satisfied it instantly: our own `vite preview`
+ * failed to bind, the run continued, and the whole matrix measured another
+ * branch's build while writing ordinary-looking artifacts.
+ *
+ * `vite build` writes a fresh id into `dist/` and serves it as a static file,
+ * so asking the server for it and comparing to the one on disk answers the
+ * question that matters — is this the build we just made?
+ */
+async function assertServerIsOurBuild(url, benchCwd) {
+  const expected = (
+    await readFile(path.join(benchCwd, "dist", "bench-build-id.txt"), "utf8")
+  ).trim();
+
+  let served = null;
+  try {
+    const response = await fetch(new URL("/bench-build-id.txt", url));
+    if (response.ok) {
+      // A build from before this file existed still answers 200 here: the
+      // preview server falls back to index.html for anything it cannot find.
+      // Treat only a lone id-shaped token as an answer, so the report says
+      // "no id" rather than quoting a page of HTML at the reader.
+      const body = (await response.text()).trim();
+      if (/^[A-Za-z0-9-]{8,64}$/.test(body)) served = body;
+    }
+  } catch {
+    // Falls through to the mismatch report below, which says more than the
+    // fetch error would.
+  }
+
+  if (served === expected) return;
+
+  throw new Error(
+    [
+      `${url} is not serving the build this checkout just produced, so every`,
+      "number the matrix is about to write would describe code from somewhere",
+      "else.",
+      "",
+      `  expected (dist/): ${expected}`,
+      `  served:           ${served ?? "(no id — an older build, or not a bench server)"}`,
+      "",
+      "Usual cause: another worktree's `preview:bench` already holds the port.",
+      "Check `lsof -ti:4173`.",
+    ].join("\n"),
+  );
+}
+
 async function waitForServer(url, server, timeoutMs = 30_000) {
   const deadline = Date.now() + timeoutMs;