@beyondwork/docx-react-component 1.0.0

package/services/react-word-editor/scripts/wave-9-live-usability-pilot.mjs

@@ -0,0 +1,911 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const serviceRootDir = path.resolve(moduleDir, "..");
+const repoRootDir = path.resolve(serviceRootDir, "../..");
+
+async function loadPlaywright() {
+  try {
+    return require("playwright");
+  } catch {
+    const fallbackPath = path.join(
+      repoRootDir,
+      ".tmp/wave-8-railway-pilot/node_modules/playwright",
+    );
+    try {
+      await access(fallbackPath);
+      return require(fallbackPath);
+    } catch {
+      throw new Error(
+        "Playwright is not installed. Add it to the harness package or restore the cached Wave 8 pilot toolchain before running the Wave 9 pilot.",
+      );
+    }
+  }
+}
+
+const { firefox } = await loadPlaywright();
+
+const BASE_URL =
+  process.env.HARNESS_PUBLIC_URL ??
+  "https://docx-react-component-early-access.up.railway.app";
+const DOCX_MIME_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const OUTPUT_DIR = path.join(repoRootDir, ".tmp/wave-9-pilot");
+const SCREENSHOT_DIR = path.join(OUTPUT_DIR, "screenshots");
+const RAW_DIR = path.join(OUTPUT_DIR, "raw");
+
+const performanceBudgets = {
+  loadMs: {
+    plainText: 5_000,
+    commentHeavy: 6_000,
+    redlineHeavy: 12_000,
+  },
+  reviewNavigationMs: 1_000,
+  revisionActionMs: 1_500,
+  exportMs: {
+    plainText: 5_000,
+    commentHeavy: 8_000,
+    redlineHeavy: 15_000,
+  },
+};
+
+const runs = [
+  {
+    id: "plain-text-f01",
+    label: "F01 Basic contract skeleton",
+    category: "plainText",
+    filePath: path.join(repoRootDir, "test/fixtures/docx/F01-basic-contract.docx"),
+    fileName: "F01-basic-contract.docx",
+    sourceKind: "fixture",
+    tasks: {
+      commentNavigation: false,
+      exportAndValidate: true,
+      markupSwitch: true,
+      revisionAction: false,
+    },
+  },
+  {
+    id: "comment-heavy-f10",
+    label: "F10 Threaded comments and resolve",
+    category: "commentHeavy",
+    filePath: path.join(repoRootDir, "test/fixtures/docx/F10-threaded-comments-resolve.docx"),
+    fileName: "F10-threaded-comments-resolve.docx",
+    sourceKind: "fixture",
+    tasks: {
+      commentNavigation: true,
+      exportAndValidate: true,
+      markupSwitch: true,
+      revisionAction: false,
+    },
+  },
+  {
+    id: "redline-heavy-s02",
+    label: "S02 BW Partner User Licence Agreement with review markup",
+    category: "redlineHeavy",
+    filePath: path.join(
+      repoRootDir,
+      "test/fixtures/scenarios/docx/S02-bw-partner-user-licence-agreement-redlines.docx",
+    ),
+    fileName: "S02-bw-partner-user-licence-agreement-redlines.docx",
+    sourceKind: "scenario",
+    tasks: {
+      commentNavigation: false,
+      exportAndValidate: true,
+      markupSwitch: true,
+      revisionAction: true,
+    },
+  },
+];
+
+const comparisonRuns = [
+  {
+    id: "table-heavy-f05",
+    label: "F05 Table-heavy agreement",
+    filePath: path.join(repoRootDir, "test/fixtures/docx/F05-table-heavy-agreement.docx"),
+    fileName: "F05-table-heavy-agreement.docx",
+    focus: "table-heavy",
+  },
+  {
+    id: "table-preserve-s01",
+    label: "S01 SOW template",
+    filePath: path.join(repoRootDir, "test/fixtures/scenarios/docx/S01-sow-template.docx"),
+    fileName: "S01-sow-template.docx",
+    focus: "table-and-preserve-only",
+  },
+];
+
+async function ensureDirs() {
+  await mkdir(OUTPUT_DIR, { recursive: true });
+  await mkdir(SCREENSHOT_DIR, { recursive: true });
+  await mkdir(RAW_DIR, { recursive: true });
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+async function writeJson(relativePath, value) {
+  const targetPath = path.join(OUTPUT_DIR, relativePath);
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function uploadDoc(filePath, fileName) {
+  const bytes = await readFile(filePath);
+  const form = new FormData();
+  form.set(
+    "file",
+    new File([bytes], fileName, {
+      type: DOCX_MIME_TYPE,
+    }),
+  );
+
+  const response = await fetch(`${BASE_URL}/api/uploads`, {
+    body: form,
+    method: "POST",
+  });
+  assert(response.ok, `Upload failed for ${fileName} with ${response.status}.`);
+  return response.json();
+}
+
+async function waitForBridge(page, timeout = 60_000) {
+  await page.waitForFunction(() => Boolean(window.__DOCX_REACT_HARNESS__), undefined, {
+    timeout,
+  });
+}
+
+async function waitForEditorReady(page, timeout = 120_000) {
+  await page.waitForFunction(
+    () =>
+      Boolean(window.__DOCX_REACT_HARNESS__) &&
+      window.__DOCX_REACT_HARNESS__.getState().eventLog.some((entry) =>
+        entry.detail.startsWith("Editor ready with"),
+      ),
+    undefined,
+    { timeout },
+  );
+}
+
+async function getHarnessState(page) {
+  return page.evaluate(() => window.__DOCX_REACT_HARNESS__.getState());
+}
+
+async function scrapeSignals(page) {
+  return page.evaluate(() => {
+    const sections = [...document.querySelectorAll("section")];
+    const runtimeSignals = sections.find((section) =>
+      section.textContent?.includes("Runtime Signals"),
+    );
+    const warningHeader = runtimeSignals
+      ? [...runtimeSignals.querySelectorAll("p")].find((node) => node.textContent === "Warnings")
+      : undefined;
+    const warningList = warningHeader?.parentElement?.querySelectorAll("li") ?? [];
+    const warnings = [...warningList].map((item) => {
+      const parts = [...item.querySelectorAll("div")].map((node) => node.textContent?.trim());
+      return { code: parts[0], message: parts[1] };
+    });
+
+    const errorsHeader = runtimeSignals
+      ? [...runtimeSignals.querySelectorAll("p")].find((node) => node.textContent === "Errors")
+      : undefined;
+    const errorList = errorsHeader?.parentElement?.querySelectorAll("li") ?? [];
+    const errors = [...errorList].map((item) => {
+      const parts = [...item.querySelectorAll("div")].map((node) => node.textContent?.trim());
+      return { code: parts[0], message: parts[1] };
+    });
+
+    return { errors, warnings };
+  });
+}
+
+async function takeScreenshot(page, filePath) {
+  await page.screenshot({ path: filePath });
+}
+
+async function getMarkupChip(page) {
+  return page.evaluate(() => {
+    const canvas = document.querySelector('[aria-label="Document canvas"]');
+    if (!canvas) {
+      return null;
+    }
+    return [...canvas.querySelectorAll("span")]
+      .map((node) => node.textContent?.trim())
+      .find((text) => text?.startsWith("markup "));
+  });
+}
+
+async function clickMarkupOption(page, label) {
+  const section = page.locator('[aria-label="Markup display"]');
+  await section
+    .getByRole("button", { name: new RegExp(`^${label}\\b`, "i") })
+    .evaluate((node) => node.click());
+}
+
+async function measureMarkupSwitch(page) {
+  const before = await getMarkupChip(page);
+  const started = Date.now();
+  await clickMarkupOption(page, "Clean");
+
+  try {
+    await page.waitForFunction(
+      () => {
+        const canvas = document.querySelector('[aria-label="Document canvas"]');
+        if (!canvas) {
+          return false;
+        }
+        return [...canvas.querySelectorAll("span")].some((node) =>
+          node.textContent?.trim().startsWith("markup clean"),
+        );
+      },
+      undefined,
+      { timeout: 2_000 },
+    );
+
+    return {
+      after: await getMarkupChip(page),
+      before,
+      latencyMs: Date.now() - started,
+      status: "passed",
+    };
+  } catch {
+    return {
+      after: await getMarkupChip(page),
+      before,
+      blocker:
+        "Markup display controls render, but the mounted canvas chip stays fixed at the initial mode.",
+      latencyMs: null,
+      status: "blocked",
+    };
+  }
+}
+
+async function measureReadySequence(page) {
+  await page.waitForTimeout(600);
+  const harnessState = await getHarnessState(page);
+  const eventLog = Array.isArray(harnessState?.eventLog) ? harnessState.eventLog : [];
+  const readyEvents = eventLog.filter((entry) =>
+    entry.detail.startsWith("Editor ready with"),
+  );
+
+  return {
+    blocker:
+      readyEvents.length <= 1
+        ? null
+        : `Expected one ready event after load, but recorded ${readyEvents.length}.`,
+    eventLog,
+    readyEventCount: readyEvents.length,
+    status: readyEvents.length <= 1 ? "passed" : "blocked",
+  };
+}
+
+async function measureCommentNavigation(page) {
+  const sidebar = page.locator('[aria-label="Comment sidebar"]');
+  if ((await sidebar.count()) === 0) {
+    return {
+      blocker: "Comment sidebar is not rendered.",
+      latencyMs: null,
+      status: "not-tested",
+    };
+  }
+
+  const threads = sidebar.locator("[data-comment-thread-id]");
+  const threadCount = await threads.count();
+  if (threadCount === 0) {
+    return {
+      blocker: "No mounted comment thread is available for navigation.",
+      latencyMs: null,
+      status: "not-tested",
+    };
+  }
+
+  let targetIndex = 0;
+  for (let index = 0; index < threadCount; index += 1) {
+    if ((await threads.nth(index).getAttribute("aria-current")) !== "true") {
+      targetIndex = index;
+      break;
+    }
+  }
+
+  const targetThread = threads.nth(targetIndex);
+  const commentId = await targetThread.getAttribute("data-comment-thread-id");
+  if (!commentId) {
+    return {
+      blocker: "Mounted comment thread metadata is missing a stable thread id.",
+      latencyMs: null,
+      status: "blocked",
+    };
+  }
+
+  const started = Date.now();
+  await targetThread.locator('[data-testid="comment-thread-open"]').click();
+  await page.waitForFunction(
+    (threadId) => {
+      const thread = document.querySelector(`[data-comment-thread-id="${threadId}"]`);
+      return thread?.getAttribute("aria-current") === "true";
+    },
+    commentId,
+    { timeout: 10_000 },
+  );
+
+  return {
+    commentId,
+    latencyMs: Date.now() - started,
+    status: "passed",
+  };
+}
+
+async function assessRevisionNavigation(page) {
+  return page.evaluate(() => {
+    const sidebar = document.querySelector('[aria-label="Revision review sidebar"]');
+    if (!sidebar) {
+      return {
+        blocker: "Revision review sidebar is not rendered.",
+        status: "not-tested",
+      };
+    }
+
+    const entryCards = [...sidebar.querySelectorAll("section")].filter((section) =>
+      section.textContent?.includes("Accept and reject"),
+    );
+    const navigationTargets = [...sidebar.querySelectorAll("[data-revision-nav], button[aria-label*='Open']")];
+
+    if (entryCards.length === 0) {
+      return {
+        blocker: "No actionable revision cards were present in the mounted sidebar.",
+        status: "not-tested",
+      };
+    }
+
+    if (navigationTargets.length === 0) {
+      return {
+        blocker:
+          "Revision cards expose accept/reject actions only; there is no direct anchor-jump or open-in-canvas navigation control.",
+        status: "blocked",
+      };
+    }
+
+    return {
+      blocker: null,
+      status: "passed",
+    };
+  });
+}
+
+async function readRevisionPendingCount(page) {
+  return page.evaluate(() => {
+    const valueNode = document.querySelector(
+      '[data-testid="revision-runtime-pending"] [data-summary-value="true"]',
+    );
+    if (valueNode?.textContent) {
+      const parsed = Number(valueNode.textContent.trim());
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+
+    const sidebar = document.querySelector('[aria-label="Revision review sidebar"]');
+    if (!sidebar) {
+      return null;
+    }
+
+    const chips = [...sidebar.querySelectorAll("div")].map((node) =>
+      node.textContent?.replace(/\s+/g, " ").trim(),
+    );
+    const pendingChip = chips.find((text) => text?.includes("Runtime pending"));
+    if (!pendingChip) {
+      return null;
+    }
+
+    const match = pendingChip.match(/^(\d+)/);
+    return match ? Number(match[1]) : null;
+  });
+}
+
+async function measureRevisionAction(page) {
+  await clickMarkupOption(page, "Clean");
+  await page.waitForFunction(
+    () => {
+      const pendingValue = document.querySelector(
+        '[data-testid="revision-runtime-pending"] [data-summary-value="true"]',
+      );
+      return Boolean(pendingValue?.textContent);
+    },
+    undefined,
+    { timeout: 15_000 },
+  );
+
+  const before = await readRevisionPendingCount(page);
+  if (before === null || before === 0) {
+    return {
+      blocker: "No pending revisions were available for a single-item accept action.",
+      latencyMs: null,
+      status: "not-tested",
+    };
+  }
+
+  const sidebar = page.locator('[aria-label="Revision review sidebar"]');
+  await sidebar.getByRole("button", { exact: true, name: "Accept" }).first().waitFor({
+    state: "visible",
+    timeout: 15_000,
+  });
+  const acceptButton = sidebar.getByRole("button", { exact: true, name: "Accept" }).first();
+  const started = Date.now();
+  await acceptButton.click();
+
+  try {
+    await page.waitForFunction(
+      (expectedMax) => {
+        const valueNode = document.querySelector(
+          '[data-testid="revision-runtime-pending"] [data-summary-value="true"]',
+        );
+        if (!valueNode?.textContent) {
+          return false;
+        }
+        const parsed = Number(valueNode.textContent.trim());
+        return Number.isFinite(parsed) && parsed < expectedMax;
+      },
+      before,
+      { timeout: 15_000 },
+    );
+
+    return {
+      afterPending: await readRevisionPendingCount(page),
+      beforePending: before,
+      latencyMs: Date.now() - started,
+      status: "passed",
+    };
+  } catch {
+    return {
+      afterPending: await readRevisionPendingCount(page),
+      beforePending: before,
+      blocker:
+        "Single-item accept did not produce a visible pending-count transition inside the mounted review rail.",
+      latencyMs: null,
+      status: "blocked",
+    };
+  }
+}
+
+async function measureExport(page, category, runId) {
+  const before = await page.evaluate(
+    () => window.__DOCX_REACT_HARNESS__.getState().latestExport?.exportId ?? null,
+  );
+  const started = Date.now();
+  await page.evaluate(async () => {
+    const bridge = window.__DOCX_REACT_HARNESS__;
+    if (!bridge) {
+      throw new Error("Harness bridge is not available.");
+    }
+    await bridge.exportCurrentSession();
+  });
+  await page.waitForFunction(
+    (previousId) => {
+      const currentId = window.__DOCX_REACT_HARNESS__.getState().latestExport?.exportId ?? null;
+      return Boolean(currentId) && currentId !== previousId;
+    },
+    before,
+    { timeout: 120_000 },
+  );
+  const exportState = await page.evaluate(() => window.__DOCX_REACT_HARNESS__.getState().latestExport);
+  const latencyMs = Date.now() - started;
+
+  return {
+    export: exportState,
+    latencyMs,
+    screenshot: path.relative(
+      OUTPUT_DIR,
+      path.join(SCREENSHOT_DIR, `${runId}-after-export.png`),
+    ),
+    status: "passed",
+    withinBudget: latencyMs <= performanceBudgets.exportMs[category],
+  };
+}
+
+async function measureValidation(page) {
+  const before = await page.evaluate(
+    () => window.__DOCX_REACT_HARNESS__.getState().latestValidation?.runId ?? null,
+  );
+  const started = Date.now();
+  await page.getByTestId("harness-validate-button").evaluate((node) => node.click());
+  await page.waitForFunction(
+    (previousId) => {
+      const currentId =
+        window.__DOCX_REACT_HARNESS__.getState().latestValidation?.runId ?? null;
+      return Boolean(currentId) && currentId !== previousId;
+    },
+    before,
+    { timeout: 120_000 },
+  );
+  const validationState = await page.evaluate(
+    () => window.__DOCX_REACT_HARNESS__.getState().latestValidation,
+  );
+  return {
+    latencyMs: Date.now() - started,
+    status: "passed",
+    validation: validationState,
+  };
+}
+
+async function scrapeDocumentSurface(page) {
+  return page.evaluate(() => {
+    const canvas = document.querySelector('[aria-label="Document canvas"]');
+    const documentSurface = document.querySelector('[aria-label="Document surface"]');
+    return {
+      canvasHeaderChips: canvas
+        ? [...canvas.querySelectorAll("span")]
+            .map((node) => node.textContent?.trim())
+            .filter(Boolean)
+        : [],
+      documentSurfaceText: documentSurface?.textContent?.slice(0, 1200) ?? "",
+    };
+  });
+}
+
+async function openEditorRun(browser, config) {
+  const upload = await uploadDoc(config.filePath, config.fileName);
+  const page = await browser.newPage({ viewport: { height: 1200, width: 1600 } });
+  const sessionUrl = `${BASE_URL}/editor/${upload.session.sessionId}?wave9=${Date.now()}`;
+  const loadStarted = Date.now();
+  await page.goto(sessionUrl, { timeout: 120_000, waitUntil: "domcontentloaded" });
+  await waitForBridge(page, 120_000);
+  await waitForEditorReady(page, 120_000);
+  const loadLatencyMs = Date.now() - loadStarted;
+
+  const screenshotPath = path.join(SCREENSHOT_DIR, `${config.id}-loaded.png`);
+  await takeScreenshot(page, screenshotPath);
+
+  const initialState = await getHarnessState(page);
+  const readySequence = await measureReadySequence(page);
+  const signals = await scrapeSignals(page);
+  const documentSurface = await scrapeDocumentSurface(page);
+
+  const result = {
+    category: config.category,
+    documentId: upload.session.documentId,
+    documentSurface,
+    fileName: config.fileName,
+    filePath: config.filePath,
+    id: config.id,
+    initialState,
+    label: config.label,
+    loadLatencyMs,
+    loadWithinBudget: loadLatencyMs <= performanceBudgets.loadMs[config.category],
+    runtimeSignals: signals,
+    screenshots: [path.relative(OUTPUT_DIR, screenshotPath)],
+    sessionId: upload.session.sessionId,
+    sessionUrl,
+    sourceId: upload.source.sourceId,
+    sourceKind: config.sourceKind,
+    tasks: {
+      readySequence:
+        readySequence ?? {
+          blocker: "Ready sequence capture did not return a result.",
+          eventLog: [],
+          readyEventCount: null,
+          status: "blocked",
+        },
+    },
+  };
+
+  if (config.tasks.markupSwitch) {
+    try {
+      result.tasks.markupSwitch = await measureMarkupSwitch(page);
+    } catch (error) {
+      result.tasks.markupSwitch = {
+        blocker: error instanceof Error ? error.message : "Markup switch measurement failed.",
+        latencyMs: null,
+        status: "blocked",
+      };
+    }
+  }
+
+  if (config.tasks.commentNavigation) {
+    try {
+      result.tasks.commentNavigation = await measureCommentNavigation(page);
+    } catch (error) {
+      result.tasks.commentNavigation = {
+        blocker:
+          error instanceof Error ? error.message : "Comment navigation measurement failed.",
+        latencyMs: null,
+        status: "blocked",
+      };
+    }
+  }
+
+  try {
+    result.tasks.revisionNavigation = await assessRevisionNavigation(page);
+  } catch (error) {
+    result.tasks.revisionNavigation = {
+      blocker:
+        error instanceof Error ? error.message : "Revision navigation assessment failed.",
+      status: "blocked",
+    };
+  }
+
+  if (config.tasks.revisionAction) {
+    try {
+      result.tasks.revisionAction = await measureRevisionAction(page);
+    } catch (error) {
+      result.tasks.revisionAction = {
+        blocker: error instanceof Error ? error.message : "Revision action measurement failed.",
+        latencyMs: null,
+        status: "blocked",
+      };
+    }
+  }
+
+  if (config.tasks.exportAndValidate) {
+    try {
+      result.tasks.export = await measureExport(page, config.category, config.id);
+      const exportScreenshot = path.join(SCREENSHOT_DIR, `${config.id}-after-export.png`);
+      await takeScreenshot(page, exportScreenshot);
+      result.screenshots.push(path.relative(OUTPUT_DIR, exportScreenshot));
+    } catch (error) {
+      result.tasks.export = {
+        blocker: error instanceof Error ? error.message : "Export measurement failed.",
+        latencyMs: null,
+        status: "blocked",
+        withinBudget: false,
+      };
+    }
+
+    if (result.tasks.export.status === "passed") {
+      try {
+        result.tasks.validate = await measureValidation(page);
+        const validateScreenshot = path.join(SCREENSHOT_DIR, `${config.id}-after-validate.png`);
+        await takeScreenshot(page, validateScreenshot);
+        result.screenshots.push(path.relative(OUTPUT_DIR, validateScreenshot));
+
+        const runId = result.tasks.validate.validation?.runId;
+        if (runId) {
+          const [runJson, runPage] = await Promise.all([
+            fetch(`${BASE_URL}/api/runs/${runId}`).then((response) => response.json()),
+            browser.newPage({ viewport: { height: 1200, width: 1600 } }),
+          ]);
+          await runPage.goto(`${BASE_URL}/runs/${runId}`, {
+            timeout: 120_000,
+            waitUntil: "networkidle",
+          });
+          const runScreenshot = path.join(SCREENSHOT_DIR, `${config.id}-run-page.png`);
+          await takeScreenshot(runPage, runScreenshot);
+          await runPage.close();
+
+          result.screenshots.push(path.relative(OUTPUT_DIR, runScreenshot));
+          result.validationArtifact = runJson;
+        }
+      } catch (error) {
+        result.tasks.validate = {
+          blocker: error instanceof Error ? error.message : "Validation measurement failed.",
+          latencyMs: null,
+          status: "blocked",
+        };
+      }
+    }
+  }
+
+  result.finalState = (await getHarnessState(page)) ?? null;
+  await writeJson(path.join("raw", `${config.id}.json`), result);
+  await page.close();
+  return result;
+}
+
+async function openComparisonRun(browser, config) {
+  const upload = await uploadDoc(config.filePath, config.fileName);
+  const page = await browser.newPage({ viewport: { height: 1200, width: 1600 } });
+  const sessionUrl = `${BASE_URL}/editor/${upload.session.sessionId}?wave9=${Date.now()}`;
+  await page.goto(sessionUrl, { timeout: 120_000, waitUntil: "domcontentloaded" });
+  await waitForBridge(page, 120_000);
+  await waitForEditorReady(page, 120_000);
+
+  const screenshotPath = path.join(SCREENSHOT_DIR, `${config.id}-loaded.png`);
+  await takeScreenshot(page, screenshotPath);
+  const signals = await scrapeSignals(page);
+  const documentSurface = await scrapeDocumentSurface(page);
+  const result = {
+    documentId: upload.session.documentId,
+    documentSurface,
+    focus: config.focus,
+    id: config.id,
+    label: config.label,
+    runtimeSignals: signals,
+    screenshots: [path.relative(OUTPUT_DIR, screenshotPath)],
+    sessionId: upload.session.sessionId,
+    sessionUrl,
+    sourceId: upload.source.sourceId,
+  };
+  await writeJson(path.join("raw", `${config.id}.json`), result);
+  await page.close();
+  return result;
+}
+
+async function inspectPrototype(browser) {
+  const page = await browser.newPage({ viewport: { height: 1200, width: 1600 } });
+  const started = Date.now();
+  await page.goto(`${BASE_URL}/demo?wave9=${Date.now()}`, {
+    timeout: 120_000,
+    waitUntil: "networkidle",
+  });
+  await page.waitForFunction(
+    () => document.body.textContent?.includes("Internal prototype · non-production"),
+    undefined,
+    { timeout: 30_000 },
+  );
+  const screenshotPath = path.join(SCREENSHOT_DIR, "prototype-review.png");
+  const screenshotRelativePath = path.relative(OUTPUT_DIR, screenshotPath);
+  await takeScreenshot(page, screenshotPath);
+  const result = await page.evaluate(
+    ({ loadMs, screenshot }) => {
+      const body = document.body;
+      return {
+        loadLatencyMs: loadMs,
+        postureLabel: body.textContent?.includes("Internal prototype · non-production") ?? false,
+        reducedMotionToggle: body.textContent?.includes("Reduced motion") ?? false,
+        screenshot,
+        sessionSwitcherVisible: Boolean(document.querySelector('[role="combobox"]')),
+        sourceLabel: [...document.querySelectorAll("h1, h2, h3")]
+          .map((node) => node.textContent?.trim())
+          .find(Boolean),
+        unifiedRailTabs: ["Comments", "Changes", "Health"].every((label) =>
+          [...document.querySelectorAll("button")].some((button) =>
+            button.textContent?.replace(/\s+/g, " ").includes(label),
+          ),
+        ),
+      };
+    },
+    {
+      loadMs: Date.now() - started,
+      screenshot: screenshotRelativePath,
+    },
+  );
+  await page.close();
+  return result;
+}
+
+function summarizeSmoke(measuredRuns) {
+  return measuredRuns.map((run) => ({
+    commentNavigationLatencyMs: run.tasks.commentNavigation?.latencyMs ?? null,
+    commentNavigationWithinBudget:
+      run.tasks.commentNavigation?.latencyMs == null
+        ? null
+        : run.tasks.commentNavigation.latencyMs <= performanceBudgets.reviewNavigationMs,
+    documentId: run.documentId,
+    errors: run.runtimeSignals.errors,
+    exportId: run.tasks.export?.export?.exportId ?? null,
+    exportLatencyMs: run.tasks.export?.latencyMs ?? null,
+    exportWithinBudget: run.tasks.export?.withinBudget ?? null,
+    id: run.id,
+    label: run.label,
+    loadLatencyMs: run.loadLatencyMs,
+    loadWithinBudget: run.loadWithinBudget,
+    packageFindingCount: run.tasks.validate?.validation?.packageFindingCount ?? null,
+    readyEventCount: run.tasks.readySequence?.readyEventCount ?? null,
+    readySequenceStatus: run.tasks.readySequence?.status ?? null,
+    revisionActionLatencyMs: run.tasks.revisionAction?.latencyMs ?? null,
+    revisionActionWithinBudget:
+      run.tasks.revisionAction?.latencyMs == null
+        ? null
+        : run.tasks.revisionAction.latencyMs <= performanceBudgets.revisionActionMs,
+    sdkFindingCount: run.tasks.validate?.validation?.sdkFindingCount ?? null,
+    sessionId: run.sessionId,
+    sourceId: run.sourceId,
+    taskStatuses: Object.fromEntries(
+      Object.entries(run.tasks).map(([key, value]) => [key, value.status]),
+    ),
+    validationIsValid: run.tasks.validate?.validation?.isValid ?? null,
+    validationRunId: run.tasks.validate?.validation?.runId ?? null,
+    warnings: run.runtimeSignals.warnings,
+  }));
+}
+
+function summarizeEditorLoadEvents(measuredRuns) {
+  return measuredRuns.map((run) => ({
+    eventLog: run.tasks.readySequence?.eventLog ?? [],
+    id: run.id,
+    readyEventCount: run.tasks.readySequence?.readyEventCount ?? null,
+    status: run.tasks.readySequence?.status ?? null,
+  }));
+}
+
+function summarizeEditorSessions(measuredRuns) {
+  return measuredRuns.map((run) => ({
+    documentId: run.documentId,
+    exportId: run.tasks.export?.export?.exportId ?? null,
+    id: run.id,
+    sessionId: run.sessionId,
+    sourceLoaded: run.initialState?.sourceLoaded ?? null,
+    validationRunId: run.tasks.validate?.validation?.runId ?? null,
+    warningCount: run.initialState?.warningCount ?? null,
+  }));
+}
+
+async function main() {
+  await ensureDirs();
+  const browser = await firefox.launch({ headless: true });
+
+  try {
+    const measuredRuns = [];
+    for (const config of runs) {
+      try {
+        measuredRuns.push(await openEditorRun(browser, config));
+      } catch (error) {
+        measuredRuns.push({
+          category: config.category,
+          fileName: config.fileName,
+          filePath: config.filePath,
+          id: config.id,
+          label: config.label,
+          runtimeSignals: { errors: [], warnings: [] },
+          sourceKind: config.sourceKind,
+          taskError: error instanceof Error ? error.message : "Run failed before task capture.",
+          tasks: {},
+        });
+      }
+    }
+
+    const comparisons = [];
+    for (const config of comparisonRuns) {
+      try {
+        comparisons.push(await openComparisonRun(browser, config));
+      } catch (error) {
+        comparisons.push({
+          focus: config.focus,
+          id: config.id,
+          label: config.label,
+          taskError:
+            error instanceof Error ? error.message : "Comparison run failed before capture.",
+        });
+      }
+    }
+
+    let prototype;
+    try {
+      prototype = await inspectPrototype(browser);
+    } catch (error) {
+      prototype = {
+        blocker:
+          error instanceof Error ? error.message : "Prototype inspection failed before capture.",
+        status: "blocked",
+      };
+    }
+    const capturedAtUtc = new Date().toISOString();
+    const performanceSmoke = {
+      baseUrl: BASE_URL,
+      budgets: performanceBudgets,
+      capturedAtUtc,
+      comparisonRuns: comparisons,
+      measuredRuns: summarizeSmoke(measuredRuns),
+      prototype,
+    };
+
+    await writeJson("performance-smoke.json", performanceSmoke);
+    await writeJson("editor-load-events.json", {
+      baseUrl: BASE_URL,
+      capturedAtUtc,
+      runs: summarizeEditorLoadEvents(measuredRuns),
+    });
+    await writeJson("editor-session-smoke.json", {
+      baseUrl: BASE_URL,
+      capturedAtUtc,
+      runs: summarizeEditorSessions(measuredRuns),
+    });
+    await writeJson("raw-results.json", {
+      baseUrl: BASE_URL,
+      capturedAtUtc,
+      comparisons,
+      measuredRuns,
+      prototype,
+    });
+
+    console.log(JSON.stringify(performanceSmoke, null, 2));
+  } finally {
+    await browser.close();
+  }
+}
+
+await main();