@beyondwork/docx-react-component 1.0.0 → 1.0.1

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

@@ -1,911 +0,0 @@
-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();