waygraph 0.15.53 → 0.16.0

package/dist/runner/main.js

@@ -1,469 +0,0 @@
-// Moved verbatim from the former CHAIN_RUNNER_SCRIPT template string in cli.ts (see src/ARCHITECTURE.md).
-// Runs inside the target project's own waygraph copy - keep it dependency-light and self-contained.
-import { findBlock, findFlow, parseChainSpec } from "./discovery.js";
-import { seedMemForBlock, seedMemForFlow } from "./seed-mem.js";
-import { join } from "node:path";
-import { mkdirSync } from "node:fs";
-import { isExpectedChainFailure, parseVideoViewport, runChainedFlows, runJsonReportMode } from "./chain-run.js";
-import { runStepMode } from "./step-mode.js";
-import { connect } from "../types.js";
-import { MemPage } from "../mem-page.js";
-import { Engine, start, end, chainFlow, isFastForwardBlock, branchRoutes, runBranchRegression } from "../core.js";
-import { withWebServer } from "../webserver.js";
-import { resolveVideoDir } from "../video-dir.js";
-import { chromiumExecutablePath, extensionPathsFromEnv, launchContext } from "../browser.js";
-
-async function runMain() {
-  const projectDir = process.argv[2];
-  const spec = process.argv[3];
-    const mem = new MemPage();
-  // Computed early - JSON-report mode's stdout is meant to be ONE parseable
-  // JSON object for whatever's reading it afterward (a script, an agent),
-  // not a human's console. Every informational console.log below is
-  // skipped for it; only the final JSON report (or a thrown Error, for a
-  // truly unexpected failure outside runJsonReportMode's own try/catch)
-  // reaches stdout.
-  const jsonReport = process.env.WAYGRAPH_JSON === "1";
-  const ffExpand =
-    process.env.WAYGRAPH_FF_EXPAND === "1" || process.env.WAYGRAPH_FF_DISABLED === "1";
-  const ffDisabled = process.env.WAYGRAPH_FF_DISABLED === "1";
-  /** Expand or keep fastForwardComposeBlock units for demo/run step lists. */
-  const flattenBlockInfos = (blockInfos) => {
-    const out = [];
-    for (const bi of blockInfos) {
-      const b = bi.block;
-      if (ffExpand && isFastForwardBlock(b)) {
-        for (const step of b.steps()) {
-          out.push({
-            name: step.name,
-            block: step.block,
-            ...(step.routes ? { routes: step.routes } : {}),
-            ...(bi.resetSessionBefore ? { resetSessionBefore: true } : {}),
-            // Dispute / --ff-disabled: keep blitz pacing on former FF inners so
-            // wall-clock stays comparable to opaque FF (same real acts).
-            wasFastForward: true,
-            ffSource: b.name,
-          });
-        }
-      } else {
-        out.push(bi);
-      }
-    }
-    return out;
-  };
-  let resolved = [];
-  let chainFlows = null;
-  // A bare identifier (no "(", no "then") might name an existing Flow
-  // that's already wired up (e.g. loginFlow) - try that FIRST so pointing
-  // at real, already-built flows needs no chain-spec typing at all. Falls
-  // through to ordinary block-chain parsing if nothing matches.
-  const bareRef = /^[A-Za-z_$][\w]*$/.test(spec.trim()) ? spec.trim() : null;
-  if (bareRef) {
-    const flow = await findFlow(projectDir, bareRef);
-    if (flow && typeof flow.blocks === "function") {
-      const blockInfos = flattenBlockInfos(flow.blocks());
-      // Same --data / WAYGRAPH_DATA seeding as the multi-segment path.
-      // Without this, `waygraph run shop.flow.ts --data '{...}'` (and bare
-      // export names) hit preflight with an empty MemPage.
-      const stubActive = flow.memStub === true || process.env.WAYGRAPH_MEM_STUB === "1";
-      const seedMem = () => seedMemForFlow(mem, blockInfos, undefined, bareRef, stubActive);
-      resolved = blockInfos.map((bi, idx) => ({
-        block: bi.block,
-        exportName: bi.name,
-        seedMem: idx === 0 ? seedMem : undefined,
-        highlightFixtures: flow.highlightFixtures,
-        demoPace: flow.demoPace,
-        highlightStyle: flow.highlightStyle,
-        expectedFailureReason:
-          flow.expectedFailureReason && idx === blockInfos.length - 1
-            ? flow.expectedFailureReason
-            : undefined,
-        ...(bi.wasFastForward ? { wasFastForward: true, ffSource: bi.ffSource } : {}),
-      }));
-      chainFlows = [flow];
-      if (!jsonReport) {
-        console.log(
-          'waygraph: running existing flow "' + bareRef + '" - ' +
-            resolved.map((r) => r.block.name).join(" -> ") + " (" + resolved.length + " block" +
-            (resolved.length === 1 ? "" : "s") + ", no chain spec needed)",
-        );
-        if (ffDisabled) {
-          console.error(
-            "waygraph demo: --ff-disabled - FFCompose expanded to inners (dispute / step locus); blitz pacing kept on former FF steps",
-          );
-        }
-      }
-    }
-  }
-  if (resolved.length === 0) {
-    const segments = parseChainSpec(spec);
-    if (segments.length === 0) {
-      throw new Error("waygraph chain: empty spec - give at least one block name");
-    }
-    // Each "then"-separated segment can ALSO name an existing Flow (a
-    // Flow's own requires, unioned across its Blocks, take the same
-    // JSON-payload shape a single Block's requires would), not just a
-    // Block. "loginFlow then dashboardFlow" chains two whole Flows one
-    // after another - a bare Block segment gets wrapped as its own
-    // trivial one-Block Flow so the whole spec reduces to one thing:
-    // chainFlow(...) does the actual sequencing (session-reset boundaries
-    // included) that used to be hand-rolled here - this is a thin wrapper
-    // over the real engine primitive, not a second copy of its logic.
-    const wrapEngine = new Engine();
-    const flows = [];
-    // Parallel to flows - only a REAL named Flow (found via findFlow)
-    // counts as an "episode" a human would want labeled; a bare Block
-    // segment gets wrapped as its own trivial one-Block Flow so it can
-    // still flow through chainFlow's sequencing uniformly, but it's not
-    // an authored scenario and gets no episode number - keeps the plain
-    // "quick ad hoc block chain" case free of meaningless "Episode 1"/
-    // "Episode 2" labels on things that were never episodes to begin with.
-    const flowMeta = [];
-    let episodeCounter = 0;
-    // seedMem is a closure, NOT called here - seeding every segment's own
-    // json payload eagerly, all upfront during resolution, was a real bug:
-    // mem is one shared object, so when two segments require the SAME key
-    // (e.g. two segments both requiring LoginCreds, each with a DIFFERENT
-    // payload - "login as standard_user then login as locked_out_user"),
-    // the LAST segment resolved silently overwrote the first's value
-    // before either segment had even started running - so the FIRST
-    // segment's own blocks would run against the SECOND segment's
-    // credentials. Deferred to execution time instead (runStepMode calls
-    // this exactly once, right as each segment's first block is reached -
-    // see resolved[i].seedMem below), same moment session-reset already
-    // happens for the same reason.
-    for (const seg of segments) {
-      const flow = await findFlow(projectDir, seg.ref);
-      if (flow && typeof flow.blocks === "function") {
-        flows.push(flow);
-        episodeCounter += 1;
-        const stubActive = flow.memStub === true || process.env.WAYGRAPH_MEM_STUB === "1";
-        flowMeta.push({
-          episodeNumber: episodeCounter,
-          episodeTitle: flow.title || seg.ref,
-          expectedFailureReason: flow.expectedFailureReason,
-          highlightFixtures: flow.highlightFixtures,
-          demoPace: flow.demoPace,
-          highlightStyle: flow.highlightStyle,
-          seedMem: () => seedMemForFlow(mem, flow.blocks(), seg.json, seg.ref, stubActive),
-        });
-      } else {
-        const r = await findBlock(projectDir, seg.ref);
-        flows.push(wrapEngine.defineFlow([start, r.block, end]));
-        // A bare Block segment (no Flow, no withMemStub to opt in) only gets
-        // memStub via the global --mem-stub/WAYGRAPH_MEM_STUB override.
-        const stubActive = process.env.WAYGRAPH_MEM_STUB === "1";
-        flowMeta.push({
-          episodeNumber: undefined,
-          episodeTitle: undefined,
-          highlightFixtures: undefined,
-          demoPace: undefined,
-          highlightStyle: undefined,
-          seedMem: () => seedMemForBlock(mem, r, seg.json, stubActive),
-        });
-      }
-    }
-    const combinedBlocks = flattenBlockInfos(chainFlow(...flows).blocks());
-    let fi = 0;
-    // Episode lengths must follow the same flatten so remainingInFlow stays aligned.
-    const flowLengths = flows.map((f) => flattenBlockInfos(f.blocks()).length);
-    let remainingInFlow = flowLengths[0];
-    let isFirstOfSegment = true;
-    resolved = combinedBlocks.map((bi) => {
-      while (remainingInFlow === 0) {
-        fi += 1;
-        remainingInFlow = flowLengths[fi];
-        isFirstOfSegment = true;
-      }
-      const meta = flowMeta[fi];
-      const entry = {
-        block: bi.block,
-        exportName: bi.name,
-        resetSession: bi.resetSessionBefore === true,
-        episodeNumber: meta.episodeNumber,
-        episodeTitle: meta.episodeTitle,
-        highlightFixtures: meta.highlightFixtures,
-        demoPace: meta.demoPace,
-        highlightStyle: meta.highlightStyle,
-        expectedFailureReason:
-          meta.expectedFailureReason && remainingInFlow === 1 ? meta.expectedFailureReason : undefined,
-        seedMem: isFirstOfSegment ? meta.seedMem : undefined,
-        ...(bi.wasFastForward ? { wasFastForward: true, ffSource: bi.ffSource } : {}),
-      };
-      remainingInFlow -= 1;
-      isFirstOfSegment = false;
-      return entry;
-    });
-    chainFlows = flows;
-    if (!jsonReport) {
-      console.log(
-        "waygraph: chaining " + resolved.map((r) => r.block.name).join(" -> ") +
-          " (" + resolved.length + " block" + (resolved.length === 1 ? "" : "s") + ")",
-      );
-    }
-  }
-  const step = process.env.WAYGRAPH_STEP === "1";
-  // Stepping through headless defeats the point for a MANUAL demo - a
-  // human can't watch it. But an explicit WAYGRAPH_HEADED=0 always wins
-  // over that default: --auto-play-video sets STEP=1 (it still needs the
-  // overlay/narration machinery) AND HEADED=0 (unattended + recorded,
-  // nobody has to watch a live window for it to be right).
-  const headed =
-    process.env.WAYGRAPH_HEADED === "0" ? false : process.env.WAYGRAPH_HEADED === "1" || step;
-  // Step mode: blitz Playwright slowMo when any opaque FF **or** former-FF
-  // inners (--ff-disabled) are in the resolved list. Explicit WAYGRAPH_SLOWMO wins.
-  const hasFfBlitz = resolved.some(
-    (r) =>
-      r &&
-      ((r.block && r.block.fastForward === true) || r.wasFastForward === true),
-  );
-  const slowMo = process.env.WAYGRAPH_SLOWMO !== undefined
-    ? Number(process.env.WAYGRAPH_SLOWMO)
-    : step
-      ? hasFfBlitz
-        ? 0
-        : 350
-      : undefined;
-  if (step && hasFfBlitz && process.env.WAYGRAPH_SLOWMO === undefined && !jsonReport) {
-    console.error(
-      ffDisabled
-        ? "waygraph demo: --ff-disabled (expanded) -> Playwright slowMo=0 on former FF steps (blitz; same acts as opaque FF)"
-        : "waygraph demo: opaque FFCompose in flow -> Playwright slowMo=0 (blitz); set WAYGRAPH_SLOWMO to override",
-    );
-  }
-  // Step (demo) mode: slowMo is waygraph's own beat after each action, not Playwright's per-operation slowMo, so a
-  // step's pace can remove it and typing is not taxed per keystroke. The browser launches at 0.
-  const launchSlowMo = step ? 0 : slowMo;
-  const baseURL = process.env.WAYGRAPH_BASE_URL;
-  const title = process.env.WAYGRAPH_TITLE;
-  // Comma-separated Block names (their real .name, e.g. "login") that
-  // should blow past the overlay's own added dwell (ring pop, cursor
-  // travel, typing delay, and that block's own gates) - "I want the login
-  // block to be faster than the rest of the demo," Dan's own phrase.
-  // FFCompose blocks get the same skipTheater automatically (no need to
-  // list them here). Distinct from --fast (gates only).
-  const fastBlockNames = new Set(
-    (process.env.WAYGRAPH_FAST_BLOCKS || "")
-      .split(",")
-      .map((s) => s.trim())
-      .filter(Boolean),
-  );
-  // Off by default - a same-user chain (login -> dashboard -> ...) needs
-  // to STAY authenticated across its own blocks. Only a chain deliberately
-  // re-visiting an auth entry point (e.g. "login" appearing twice, to
-  // demo the same flow starting fresh each time) needs this.
-  const clearSession = process.env.WAYGRAPH_CLEAR_SESSION === "1";
-  const videoEnv = process.env.WAYGRAPH_VIDEO;
-  let videoDir = null;
-  if (videoEnv) {
-    videoDir = videoEnv === "1" ? await resolveVideoDir(projectDir) : videoEnv;
-    mkdirSync(videoDir, { recursive: true });
-  }
-  /** Fixed 16:9 capture for --video (demo QA and headless run). Step+video no longer maximizes. */
-  const DEFAULT_VIDEO_VIEWPORT = { width: 1920, height: 1080 };
-  const DEFAULT_RUN_VIDEO_VIEWPORT = { width: 1280, height: 720 };
-  const videoViewportParsed = parseVideoViewport(process.env.WAYGRAPH_VIDEO_VIEWPORT);
-  const fixedVideoViewport = videoDir
-    ? (videoViewportParsed ?? (step ? DEFAULT_VIDEO_VIEWPORT : DEFAULT_RUN_VIDEO_VIEWPORT))
-    : null;
-  const engine = new Engine({ headless: !headed, slowMo: launchSlowMo });
-  let result;
-  // Non-interactive execution (no --step) runs the whole chain as one
-  // composed flow with no per-block loop of its own to defer seeding
-  // into - it can't support two segments needing DIFFERENT values for the
-  // SAME mem key (e.g. two segments both requiring LoginCreds, each with
-  // its own payload). Fall back to seeding every segment eagerly, upfront -
-  // the same limitation "chain" always had; only --step's own runStepMode
-  // loop actually needs (and correctly supports, via resolved[i].seedMem)
-  // per-segment differentiated values.
-  if (!step && !jsonReport) {
-    for (const r of resolved) {
-      if (r.seedMem) r.seedMem();
-    }
-  }
-  if (process.env.WAYGRAPH_ALL_BRANCHES === "1") {
-    return runAllBranchesMode(chainFlows, mem, baseURL, headed, engine);
-  }
-  if (step || jsonReport || baseURL || videoDir) {
-    const { chromium } = await import("@playwright/test");
-    // --start-maximized (step mode only): viewport: null alone only made
-    // the PAGE content track the window - the actual browser WINDOW still
-    // launched at Chromium's own default size/position, which stayed put
-    // where it was for a previous, larger monitor and looked chopped off on
-    // a smaller one. Maximizing fills whatever screen it's actually on.
-    const executablePath = chromiumExecutablePath();
-    // Maximized for interactive step, and for fixed video viewport so the
-    // locked record size can actually fit (otherwise .webm gets grey pad).
-    const contextOpts = fixedVideoViewport
-      ? {
-          baseURL,
-          viewport: fixedVideoViewport,
-          // Lock DPR so --video-viewport 800x450 stays 800x450 in the .webm
-          // (HiDPI hosts otherwise scale recordVideo to e.g. 1920x1080).
-          deviceScaleFactor: 1,
-          hasTouch: true,
-        }
-      : step
-        ? { baseURL, viewport: null, hasTouch: true }
-        : { baseURL, viewport: { width: 1280, height: 720 }, hasTouch: true };
-    if (videoDir) {
-      contextOpts.recordVideo = fixedVideoViewport
-        ? { dir: videoDir, size: fixedVideoViewport }
-        : { dir: videoDir };
-    }
-    const { context, close: closeBrowser } = await launchContext({
-      launcher: chromium,
-      launch: {
-        headless: !headed,
-        slowMo: launchSlowMo,
-        args: step || fixedVideoViewport ? ["--start-maximized"] : [],
-        ...(executablePath ? { executablePath } : {}),
-      },
-      context: contextOpts,
-      extensions: extensionPathsFromEnv(),
-    });
-    let pageForVideo = null;
-    try {
-      if (step) {
-        const page = await context.newPage();
-        pageForVideo = page;
-        if (fixedVideoViewport) page.__wgVideoViewport = fixedVideoViewport;
-        // Step 1's "before" panel used to sit over a blank about:blank page
-        // until the human clicked Run - show the real destination first.
-        if (baseURL) {
-          await page.goto(baseURL).catch(() => {});
-        }
-        result = await runStepMode(engine, start, end, context, page, mem, resolved, slowMo, title, fastBlockNames, clearSession, baseURL);
-      } else if (jsonReport) {
-        const page = await context.newPage();
-        pageForVideo = page;
-        if (fixedVideoViewport) page.__wgVideoViewport = fixedVideoViewport;
-        if (baseURL) {
-          await page.goto(baseURL).catch(() => {});
-        }
-        const report = await runJsonReportMode(engine, start, end, context, page, mem, resolved, baseURL);
-        console.log(JSON.stringify(report, null, 2));
-        if (!report.ok) process.exitCode = 1;
-        return;
-      } else {
-        const page = await context.newPage();
-        pageForVideo = page;
-        if (fixedVideoViewport) page.__wgVideoViewport = fixedVideoViewport;
-        if (baseURL) {
-          await page.goto(baseURL).catch(() => {});
-        }
-        if (chainFlows && chainFlows.length > 0) {
-          result = await runChainedFlows(chainFlow, chainFlows, context, mem, page);
-        } else {
-          const blocks = resolved.map((r) => r.block);
-          const chained = blocks.reduce((a, b) => connect(a, b));
-          const flow = engine.defineFlow([start, chained, end]);
-          result = await flow.run(context, mem, { page, closeOnFinish: false });
-        }
-      }
-    } finally {
-      // A recorded run's last visible state (a fixture ring, the network panel, a todo dock update)
-      // gets cut off mid-fade otherwise - context.close() used to fire the instant the flow's own
-      // promise resolved, with zero trailing room. Real, confirmed case: defineApiBlock's network
-      // panel only became visible in the recording's final ~1-2s because of this.
-      if (process.env.WAYGRAPH_VIDEO && pageForVideo && !pageForVideo.isClosed()) {
-        await new Promise((r) => setTimeout(r, 1800));
-      }
-      await context.close();
-      const savedVideo =
-        pageForVideo?.video() !== null && pageForVideo?.video() !== undefined
-          ? await pageForVideo.video()?.path().catch(() => null)
-          : null;
-      if (savedVideo) {
-        console.log("waygraph: video saved to " + savedVideo);
-      }
-      await closeBrowser();
-    }
-  } else {
-    if (chainFlows && chainFlows.length > 0) {
-      try {
-        result = await chainFlow(...chainFlows).run(mem);
-      } catch (err) {
-        if (isExpectedChainFailure(chainFlows, err)) {
-          result = { __expectedFailure: true, message: err && err.message ? err.message : String(err) };
-        } else {
-          throw err;
-        }
-      }
-    } else {
-      const blocks = resolved.map((r) => r.block);
-      const chained = blocks.reduce((a, b) => connect(a, b));
-      const flow = engine.defineFlow([start, chained, end]);
-      const recordVideo = videoDir ? { dir: videoDir } : undefined;
-      result = await flow.run(mem, recordVideo ? { recordVideo } : undefined);
-    }
-  }
-  if (result && result.__expectedFailure) {
-    console.log("waygraph: chain finished (expected failure on last episode) -- " + result.message);
-  } else {
-    console.log("waygraph: chain finished -- " + JSON.stringify(result));
-  }
-}
-
-/**
- * `waygraph run --blocks <flowName> --all-branches`: explore every path through that flow's own
- * `.branch()` tree (see src/core/branch-regression.ts), not just whichever one the live state
- * would dispatch to. Needs a single, bare Flow reference - a multi-segment chain spec has no one
- * Flow to walk. `--shared-session` opts out of session cloning (WAYGRAPH_SHARED_SESSION=1).
- */
-async function runAllBranchesMode(chainFlows, mem, baseURL, headed, engine) {
-  if (!chainFlows || chainFlows.length !== 1) {
-    console.error(
-      "waygraph run --all-branches: needs a single Flow reference (e.g. --blocks loginFlow), " +
-        "not a multi-segment chain spec - nothing else has one branch tree to explore.",
-    );
-    process.exitCode = 1;
-    return;
-  }
-  const flow = chainFlows[0];
-  if (!branchRoutes(flow)) {
-    console.error(
-      "waygraph run --all-branches: this Flow was not built with MapBuilder.branch() - " +
-        "there is no branch tree to explore. Run it normally instead.",
-    );
-    process.exitCode = 1;
-    return;
-  }
-  if (extensionPathsFromEnv().length > 0) {
-    console.warn("waygraph run --all-branches: extensions are not loaded (branches run in cloned contexts)");
-  }
-  const { chromium } = await import("@playwright/test");
-  const browser = await chromium.launch({ headless: !headed });
-  const cloneSession = process.env.WAYGRAPH_SHARED_SESSION !== "1";
-  try {
-    const context = await browser.newContext(baseURL ? { baseURL } : undefined);
-    const results = await runBranchRegression(flow, context, mem, { cloneSession });
-    for (const r of results) {
-      const line = `waygraph run --all-branches: ${r.path || "(root)"} -> ${r.status}` +
-        (r.result ? ` (${JSON.stringify(r.result)})` : "") +
-        (r.error ? ` - ${r.error}` : "");
-      console.log(line);
-    }
-    const failed = results.filter((r) => r.status === "failed");
-    if (failed.length) {
-      console.error(`waygraph run --all-branches: ${failed.length}/${results.length} path(s) failed`);
-      process.exitCode = 1;
-    }
-  } finally {
-    await browser.close();
-  }
-  void engine;
-}
-
-// Here, not in the host CLI: importing playwright.config loads the project's own @playwright/test,
-// which would collide with the CLI's copy.
-async function main() {
-  await withWebServer(process.argv[2], runMain);
-}
-
-export function startRunner() {
-  main().catch((err) => {
-    console.error(err && err.stack ? err.stack : String(err));
-    process.exitCode = 1;
-  });
-}

package/dist/runner/network-capture.d.ts

@@ -1,9 +0,0 @@
-import type { Page } from "@playwright/test";
-import type { NetworkEntry } from "./inpage/network.js";
-
-/** Records one network-tab entry (and paints it live) - see network-capture.js's own header. */
-export function recordNetworkEntry(page: Page, entry: NetworkEntry): Promise<void>;
-/** Replays page.__wgNetworkHistory into a freshly (re)installed panel after a navigation. */
-export function restoreNetworkHistory(page: Page): Promise<void>;
-/** Hooks page.on('request'/'requestfinished') to capture real page traffic into the same panel. */
-export function installNetworkCapture(page: Page): void;

package/dist/runner/network-capture.js

@@ -1,126 +0,0 @@
-// Real page network traffic -> the same network-tab overlay defineApiBlock's own calls use (see
-// inpage/network.js's own header). Playwright's page.on('request'/'requestfinished') events cover
-// every real request the PAGE makes (XHR/fetch/navigation) - not page.request.get()-style calls,
-// which go through a separate APIRequestContext entirely and never touch the browser at all (that
-// side is covered by defineApiBlock's own explicit call, in src/core/blocks/api.ts).
-import { addNetworkEntry, clearNetworkLog } from "./inpage/network.js";
-
-// Fetch/XHR/navigation only - a real page can fire dozens of image/font/stylesheet requests per
-// second, which would flood a panel meant to answer "what API calls did this page just made".
-const RELEVANT_TYPES = new Set(["xhr", "fetch", "document"]);
-// Response bodies this size or smaller, and only if they look text-ish, get captured for the
-// detail view - a multi-MB image/video response has no business being buffered into page memory
-// just because a demo happened to be running.
-const MAX_BODY_BYTES = 200_000;
-// Matches the in-page addNetworkEntry's own cap (network.js) - the Node-side history this backs
-// stays in sync with what the panel can actually show.
-const MAX_HISTORY = 30;
-
-/**
- * Records one entry AND paints it live - the single place that touches page.__wgNetworkHistory,
- * so every caller (this file's own listeners, defineApiBlock) stays in sync automatically. History
- * lives on the Playwright `Page` object (Node side), which survives navigation - the panel DOM
- * (page side, inside the shadow root) does not, and gets wiped on every real navigation. Without
- * this, the "network tab" reset to empty on every step that navigated - not what a persistent
- * Network tab is supposed to do.
- */
-export function recordNetworkEntry(page, entry) {
-  page.__wgNetworkHistory = page.__wgNetworkHistory || [];
-  page.__wgNetworkHistory.push(entry);
-  while (page.__wgNetworkHistory.length > MAX_HISTORY) page.__wgNetworkHistory.shift();
-  return page.evaluate(addNetworkEntry, entry).catch(() => {});
-}
-
-/**
- * Replays whatever history survived the last navigation back into a freshly (re)installed panel -
- * call this after ensureShadowRoot, every step, same as the rest of the overlay's own per-step
- * resync (banner/todos/device), and BEFORE that step's own network activity can add anything new
- * (installOverlay runs at the very start of a step, so this is always true in practice - no
- * interleaving race between "replay old" and "record new" to reason about). A no-op when there's
- * no history yet, or the panel already shows exactly as many entries as history has (nothing was
- * wiped this step). Otherwise clears and rebuilds from scratch, in order - simpler and more
- * obviously correct than trying to diff/append just the "missing" ones.
- */
-export async function restoreNetworkHistory(page) {
-  const history = page.__wgNetworkHistory;
-  if (!history || history.length === 0) return;
-  // page.__wgNetworkNeedsRestore is set by installNetworkCapture's own framenavigated listener -
-  // skip the page.evaluate() round-trip entirely (an extra one on EVERY step otherwise, since this
-  // runs from installOverlay every step) unless a real navigation actually happened since the last
-  // successful restore. A real, caught perf regression: this used to always evaluate() a shown-count
-  // check first, which measurably slowed down every step of every test that had ever captured any
-  // traffic at all, not just ones that navigate.
-  if (!page.__wgNetworkNeedsRestore) return;
-  page.__wgNetworkNeedsRestore = false;
-  await page.evaluate(clearNetworkLog).catch(() => {});
-  for (const entry of history) {
-    await page.evaluate(addNetworkEntry, entry).catch(() => {});
-  }
-}
-
-export function installNetworkCapture(page) {
-  if (page.__wgNetworkCaptureInstalled) return;
-  page.__wgNetworkCaptureInstalled = true;
-
-  // Marks history as needing a replay - see restoreNetworkHistory's own comment. Main frame only;
-  // an iframe navigating doesn't wipe the top-level shadow root the panel lives in.
-  page.on("framenavigated", (frame) => {
-    if (frame === page.mainFrame()) page.__wgNetworkNeedsRestore = true;
-  });
-
-  const startedAt = new Map();
-
-  page.on("request", (request) => {
-    startedAt.set(request, Date.now());
-  });
-
-  page.on("requestfinished", async (request) => {
-    try {
-      if (!RELEVANT_TYPES.has(request.resourceType())) return;
-      const response = await request.response();
-      if (!response) return;
-      const start = startedAt.get(request);
-      startedAt.delete(request);
-      let resBody;
-      try {
-        const contentType = (await response.headerValue("content-type")) || "";
-        if (/json|text|xml|html|javascript/.test(contentType)) {
-          const buf = await response.body();
-          if (buf.length <= MAX_BODY_BYTES) resBody = buf.toString("utf8");
-        }
-      } catch {
-        /* body already consumed / redirected away / not available - best-effort only */
-      }
-      const [reqHeaders, resHeaders] = await Promise.all([
-        request.allHeaders().catch(() => undefined),
-        response.allHeaders().catch(() => undefined),
-      ]);
-      await recordNetworkEntry(page, {
-        method: request.method(),
-        url: request.url(),
-        status: response.status(),
-        ok: response.ok(),
-        ms: start !== undefined ? Date.now() - start : undefined,
-        reqHeaders,
-        resHeaders,
-        reqBody: request.postData() || undefined,
-        resBody,
-      });
-    } catch {
-      /* a capture failure must never break the actual run it's observing */
-    }
-  });
-
-  page.on("requestfailed", (request) => {
-    startedAt.delete(request);
-    if (!RELEVANT_TYPES.has(request.resourceType())) return;
-    recordNetworkEntry(page, {
-      method: request.method(),
-      url: request.url(),
-      status: 0,
-      ok: false,
-      reqBody: request.postData() || undefined,
-      resBody: request.failure() ? request.failure().errorText : undefined,
-    });
-  });
-}

package/dist/runner/overlay-css.d.ts

@@ -1,3 +0,0 @@
-export const RUNNER_EXTRA_CSS: string;
-export const HOST_CSS: string;
-export const WAYGRAPH_FAVICON: string;