@descryy/mcp 0.11.5 → 0.11.7

package/dist/browser/playwright-driver.js

@@ -0,0 +1,1545 @@
+/**
+ * The real `BrowserDriver`, over `@descryy/runtime-browser`. Import stays
+ * dynamic — `loadRuntimeModule` is a test injection seam (fake module, no
+ * browser needed). Adds only element refs over the runtime; stack-trace parsing is caller-supplied (rule 1: no language named here).
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// RT-263: static, unlike the dynamic `@descryy/runtime-browser` load below -- this
+// package is an ordinary dependency of @descryy/mcp regardless of whether the browser
+// backend is installed. Currently blocked on a runtime release: @descryy/mcp pins
+// @descryy/runtime-controller at 0.3.5, which predates preflight.ts.
+import { runPreflight, portAnswersCheck } from "@descryy/runtime-controller";
+import { BrowserSessionCrashedError, NoSuchOptionError, NotOperableError, NotSelectableError, NotSubmittableError, UnknownElementRefError, } from "./driver.js";
+import { clampWaitTimeout, describeWaitTarget, isEmptyWaitTarget, matchesWaitTarget, WAIT_POLL_INTERVAL_MS, } from "./wait-target.js";
+import { PROBE_CONSTANTS, probeInPage } from "./page-probe.js";
+/** The module the driver composes. Named once, imported at call time. */
+const RUNTIME_BROWSER_MODULE = "@descryy/runtime-browser";
+const defaultRuntimeModuleLoader = () => import(__rewriteRelativeImportExtension(RUNTIME_BROWSER_MODULE));
+/** Same seam, for the optional identity-grounding module — imported dynamically and only
+ *  when `groundIdentity` is set, so a build or a session that never asks for it pays nothing. */
+const IDENTITY_GROUNDING_MODULE = "@descryy/runtime-identity-grounding";
+const defaultIdentityGroundingModuleLoader = () => import(__rewriteRelativeImportExtension(IDENTITY_GROUNDING_MODULE));
+/** Ceiling on waiting for network activity to *start* — no signal proves "never will". Kept at the old fixed 300ms so a no-op action observes the same as before. */
+const ACTIVITY_GRACE_MS = 300;
+/** How long after the last request event counts as settled; fires only once activity is seen, so it measures a gap, not a guess about more coming. */
+const NETWORK_QUIET_MS = 120;
+/** Ceiling on the whole wait; reaching it is recorded on the observation and disclosed, never swallowed. */
+const SETTLE_TIMEOUT_MS = 5_000;
+/** How often the settle loop re-checks. Small enough not to add latency of its own. */
+const POLL_INTERVAL_MS = 10;
+/** Elements an agent can act on — deliberately narrow; a full-page snapshot would blow the reply budget. `[role]` included for custom controls. */
+const INTERACTIVE = "a, button, input, select, textarea, [role], [onclick], summary";
+/** How many scroll-and-re-check rounds a reveal pass runs before it stops and says it stopped. */
+const REVEAL_MAX_PASSES = 12;
+/** How long after a scroll before re-checking. A lazily-rendered row needs a frame or two to exist. */
+const REVEAL_SETTLE_MS = 150;
+/** `RawElementIdentity` -> the port's own `ElementComponentIdentity` — the one place the two
+ *  vocabularies are joined, so a change to either shows up as one diff here. */
+function mapIdentity(raw) {
+    switch (raw.outcome) {
+        case "grounded":
+            return {
+                outcome: "grounded",
+                component: raw.component.name,
+                file: raw.sourceLocation.file,
+                line: raw.sourceLocation.line,
+                authoredSource: raw.authoredSource,
+                reason: null,
+            };
+        case "component-only":
+            return {
+                outcome: "component-only",
+                component: raw.component.name,
+                file: null,
+                line: null,
+                authoredSource: false,
+                reason: raw.reason,
+            };
+        case "refused":
+            return {
+                outcome: "refused",
+                component: null,
+                file: null,
+                line: null,
+                authoredSource: false,
+                reason: raw.reason,
+            };
+    }
+}
+function withSessionWarnings(observation, warnings) {
+    if (warnings.length === 0)
+        return observation;
+    const drained = [...warnings];
+    warnings.length = 0;
+    return { ...observation, evidenceWarnings: [...observation.evidenceWarnings, ...drained] };
+}
+/** Grounds one selector, never throwing — a probe failure is reported as a named refusal
+ *  (rule 2: no guess), the same as every other outcome the grounder itself can name. */
+async function groundOne(grounder, page, selector) {
+    try {
+        const raw = await grounder.ground(page, selector);
+        return mapIdentity(raw);
+    }
+    catch (error) {
+        return {
+            outcome: "refused",
+            component: null,
+            file: null,
+            line: null,
+            authoredSource: false,
+            reason: `the identity probe failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/** What one element looks like from inside the page. Serialized and run there, so it closes over
+ *  nothing in this module — every helper it needs is declared inside it.
+ *
+ *  Exported for `browser-element-describe.test.ts`: role, name and renderedness are pure
+ *  functions of one element, and pinning their decision table should not need a browser. */
+export function describeElement(el) {
+    const tag = el.tagName.toLowerCase();
+    const explicit = el.getAttribute("role");
+    const type = el.getAttribute("type")?.toLowerCase() ?? null;
+    /** The HTML→ARIA role of this element. The old chain ended `: tag`, which reported
+     *  `input[type="number"]` as role `"input"` — a role no agent filters on and no verb
+     *  validates against, so a real control went silently missing from every role-filtered
+     *  read. The mapping below is HTML's own, and it names no framework (rule 1).
+     *
+     *  It still ends at the tag for a tag this does not know, deliberately: `[role]` and
+     *  `[onclick]` put arbitrary elements into the query, and inventing a role for one of
+     *  them would be this same defect pointed the other way. */
+    function derivedRole() {
+        if (tag === "a")
+            return "link";
+        if (tag === "button")
+            return "button";
+        if (tag === "textarea")
+            return "textbox";
+        // `summary` is the control that opens a `<details>`; a click is what it takes.
+        if (tag === "summary")
+            return "button";
+        if (tag === "select") {
+            const multiple = el.getAttribute("multiple") !== null;
+            const size = Number(el.getAttribute("size") ?? "1");
+            return multiple || size > 1 ? "listbox" : "combobox";
+        }
+        if (tag !== "input")
+            return tag;
+        switch (type) {
+            case "button":
+            case "submit":
+            case "reset":
+            case "image":
+                return "button";
+            case "checkbox":
+                return "checkbox";
+            case "radio":
+                return "radio";
+            case "range":
+                return "slider";
+            case "number":
+                return "spinbutton";
+            case "search":
+                return "searchbox";
+            // `password` has no ARIA role of its own; `textbox` is both the useful answer and the
+            // true one about how it is operated. The rest are HTML's textbox-mapped types.
+            case null:
+            case "text":
+            case "email":
+            case "tel":
+            case "url":
+            case "password":
+                return "textbox";
+            default:
+                // `file`, `color`, `date`, `hidden`, and anything a later HTML adds. Reporting the
+                // tag here is a disclosed gap; reporting `textbox` would be a wrong fact.
+                return tag;
+        }
+    }
+    const role = explicit ?? derivedRole();
+    /** A pragmatic accessible-name approximation, not a full AccName implementation.
+     *
+     *  One case is carved out rather than approximated: a **chooser's own contents are its
+     *  options**, so `innerText` on a `<select>` returns the list of things it can be set to,
+     *  and a period picker came back named `"This month\nLast month"`. That is not a rough
+     *  name, it is a false one — no person calls the control that, and the `select` verb
+     *  matches on name. A chooser therefore skips the text tiers entirely and is left unnamed
+     *  when nothing else names it. Unnamed is a gap; named after its options is a lie. */
+    function derivedName() {
+        const aria = el.getAttribute("aria-label");
+        if (aria !== null && aria.trim() !== "")
+            return aria;
+        if (tag !== "select") {
+            const inner = el.innerText?.trim();
+            if (inner !== undefined && inner !== "")
+                return inner;
+            const text = el.textContent?.trim();
+            if (text !== undefined && text !== null && text !== "")
+                return text;
+        }
+        // A push-button input carries its label in `value`, where no text tier would find it.
+        if (tag === "input" && (type === "button" || type === "submit" || type === "reset")) {
+            const value = el.getAttribute("value");
+            if (value !== null && value.trim() !== "")
+                return value.trim();
+        }
+        return el.getAttribute("placeholder") ?? el.getAttribute("title") ?? el.getAttribute("name") ?? "";
+    }
+    const name = derivedName();
+    /** Whether the page is laying this element out and painting it — true, false, or `null`
+     *  when nothing available could answer.
+     *
+     *  **Deliberately not a viewport test.** An element below the fold is on the page and the
+     *  reveal pass depends on finding it; treating off-screen as hidden would trade this
+     *  precision defect for a recall one. What it does reject is an element the page renders
+     *  nowhere at all: `display:none`, the `hidden` attribute, a closed `<dialog>`,
+     *  `content-visibility: hidden`, `visibility: hidden`, and `<canvas>` fallback content.
+     *
+     *  Opacity is **not** rejected: a zero-opacity element still occupies space and still
+     *  takes a click, and a fade-in caught mid-animation would vanish from the snapshot. */
+    function renderedState() {
+        if (typeof el.checkVisibility === "function") {
+            try {
+                return el.checkVisibility({ visibilityProperty: true });
+            }
+            catch {
+                return null;
+            }
+        }
+        if (typeof el.getClientRects !== "function")
+            return null;
+        try {
+            if (el.getClientRects().length === 0)
+                return false;
+        }
+        catch {
+            return null;
+        }
+        const view = globalThis.getComputedStyle;
+        if (typeof view !== "function")
+            return null;
+        try {
+            const visibility = view.call(globalThis, el)?.visibility;
+            if (visibility === undefined)
+                return null;
+            return visibility !== "hidden" && visibility !== "collapse";
+        }
+        catch {
+            return null;
+        }
+    }
+    // The node's own root: the document for a light-DOM element, the shadow root for one inside
+    // an open shadow root. Only a shadow root has a `host`, which is what tells them apart, and
+    // it is also the scope a uniqueness check has to run in — `ownerDocument.querySelectorAll`
+    // matches nothing at all for a shadow child, so every such element used to come back with a
+    // null selector for a reason that read like "no stable hook".
+    const root = typeof el.getRootNode === "function" ? el.getRootNode() : el.ownerDocument;
+    const inShadowRoot = root !== el.ownerDocument && root.host !== undefined && root.host !== null;
+    // Computed in this same round trip so role/name/selector read off one live DOM state.
+    // Rejects ids that look generated (hex run, React's `:r0:` useId
+    // style, or blank) — "stable across reload" is what a generated id lacks.
+    const GENERATED_ID = /[0-9a-f]{8}|:r[0-9a-z]+:|^\s*$/i;
+    const FORM_CONTROLS = ["input", "select", "textarea", "button"];
+    function escapeAttrValue(value) {
+        return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+    function isUnique(candidate) {
+        try {
+            return root.querySelectorAll(candidate).length === 1;
+        }
+        catch {
+            // Invalid selector (rare) is treated as "no candidate", not thrown.
+            return false;
+        }
+    }
+    /** The element's own stable-hook selector, or null. Used both on the target itself and while climbing for a structural path's anchor. */
+    function stableHookSelector(node) {
+        const testId = node.getAttribute("data-testid");
+        if (testId !== null && testId.trim() !== "")
+            return `[data-testid="${escapeAttrValue(testId)}"]`;
+        const testAttr = node.getAttribute("data-test");
+        if (testAttr !== null && testAttr.trim() !== "")
+            return `[data-test="${escapeAttrValue(testAttr)}"]`;
+        const id = node.getAttribute("id");
+        if (id !== null && !GENERATED_ID.test(id))
+            return `[id="${escapeAttrValue(id)}"]`;
+        return null;
+    }
+    function nthOfTypeSegment(node, parent) {
+        const nodeTag = node.tagName.toLowerCase();
+        const siblings = parent.querySelectorAll(`:scope > ${nodeTag}`);
+        if (siblings.length <= 1)
+            return nodeTag;
+        for (let i = 0; i < siblings.length; i += 1) {
+            if (siblings.item(i) === node)
+                return `${nodeTag}:nth-of-type(${i + 1})`;
+        }
+        return nodeTag;
+    }
+    /** A bounded path from the nearest ancestor carrying a stable hook, capped at 6 segments. Null
+     *  when none is found in range — including when the climb reaches a shadow boundary, where
+     *  `parentElement` is null and there is genuinely no further ancestor inside this root. */
+    function structuralPath(target) {
+        const segments = [];
+        let node = target;
+        for (let depth = 0; depth < 6; depth += 1) {
+            const parent = node.parentElement;
+            if (parent === null)
+                return null;
+            segments.unshift(nthOfTypeSegment(node, parent));
+            const hook = stableHookSelector(parent);
+            if (hook !== null) {
+                const candidate = `${hook} > ${segments.join(" > ")}`;
+                return isUnique(candidate) ? candidate : null;
+            }
+            node = parent;
+        }
+        return null;
+    }
+    function computeSelector(target) {
+        // Priority order: first unique candidate wins. Each tier is checked
+        // independently — a shared data-testid isn't addressable either,
+        // so the next tier gets a turn instead of stopping there.
+        const testId = target.getAttribute("data-testid");
+        if (testId !== null && testId.trim() !== "") {
+            const candidate = `[data-testid="${escapeAttrValue(testId)}"]`;
+            if (isUnique(candidate))
+                return candidate;
+        }
+        const testAttr = target.getAttribute("data-test");
+        if (testAttr !== null && testAttr.trim() !== "") {
+            const candidate = `[data-test="${escapeAttrValue(testAttr)}"]`;
+            if (isUnique(candidate))
+                return candidate;
+        }
+        const id = target.getAttribute("id");
+        if (id !== null && !GENERATED_ID.test(id)) {
+            const candidate = `[id="${escapeAttrValue(id)}"]`;
+            if (isUnique(candidate))
+                return candidate;
+        }
+        const controlTag = target.tagName.toLowerCase();
+        const controlName = target.getAttribute("name");
+        if (controlName !== null && controlName.trim() !== "" && FORM_CONTROLS.includes(controlTag)) {
+            const candidate = `${controlTag}[name="${escapeAttrValue(controlName)}"]`;
+            if (isUnique(candidate))
+                return candidate;
+        }
+        const explicitRole = target.getAttribute("role");
+        const ariaLabel = target.getAttribute("aria-label");
+        if (explicitRole !== null && ariaLabel !== null && ariaLabel.trim() !== "") {
+            const candidate = `[role="${escapeAttrValue(explicitRole)}"][aria-label="${escapeAttrValue(ariaLabel)}"]`;
+            if (isUnique(candidate))
+                return candidate;
+        }
+        return structuralPath(target);
+    }
+    return { role, name: name.slice(0, 200), selector: computeSelector(el), inShadowRoot, rendered: renderedState() };
+}
+/** Said once, so the cap and the sentence describing it cannot drift apart. */
+const CONTAINER_SCAN_NOTE = "this page holds more elements than the reveal pass scans for scrollable containers, so a list " +
+    "inside one past that point was not scrolled and anything only it holds is not above";
+/**
+ * One reveal step, run inside the page: scrolls the document **and every scrollable container
+ * in it** by just under their own height.
+ *
+ * The container half is the point. `window.scrollBy` does nothing to a list inside
+ * `overflow: auto` — a shape common enough that a window-only reveal reports "nothing below
+ * the fold" about a page whose entire content is below one. The step stays under a full
+ * viewport so a row sitting on the seam is never scrolled past between two enumerations.
+ *
+ * Serialized and run in the page, so it closes over nothing in this module — the scan cap is
+ * declared inside it for that reason and mirrored in `CONTAINER_SCAN_NOTE` above.
+ */
+function revealStep() {
+    const win = globalThis;
+    const doc = win.document;
+    const SCAN_CAP = 5000;
+    let scrolled = false;
+    if (win.scrollY + win.innerHeight < doc.documentElement.scrollHeight - 1) {
+        win.scrollBy(0, Math.round(win.innerHeight * 0.9));
+        scrolled = true;
+    }
+    const all = doc.querySelectorAll("*");
+    const limit = all.length > SCAN_CAP ? SCAN_CAP : all.length;
+    let containers = 0;
+    for (let i = 0; i < limit; i += 1) {
+        const node = all.item(i);
+        if (node === null)
+            continue;
+        // Geometry first, style second: the overflow read is the expensive one, and an element
+        // whose content fits inside it can never be a scroller whatever its overflow says.
+        if (typeof node.scrollHeight !== "number" || typeof node.clientHeight !== "number")
+            continue;
+        if (node.clientHeight === 0 || node.scrollHeight <= node.clientHeight + 1)
+            continue;
+        const overflow = typeof win.getComputedStyle === "function" ? win.getComputedStyle(node)?.overflowY : undefined;
+        if (overflow !== "auto" && overflow !== "scroll" && overflow !== "overlay")
+            continue;
+        containers += 1;
+        if (node.scrollTop + node.clientHeight < node.scrollHeight - 1) {
+            node.scrollBy(0, Math.round(node.clientHeight * 0.9));
+            scrolled = true;
+        }
+    }
+    return { y: win.scrollY, scrolled, containers, scanCapped: all.length > SCAN_CAP };
+}
+/** A frame's URL, or "" — a frame detaching mid-snapshot throws from `url()`. */
+function safeUrl(frame) {
+    try {
+        return typeof frame.url === "function" ? frame.url() : "";
+    }
+    catch {
+        return "";
+    }
+}
+/** Something a person can read back: the frame's name, else the iframe element's id or title.
+ *  Null when it carries none — the reply then falls back to the frame's URL. */
+async function frameLabel(frame) {
+    try {
+        const declared = typeof frame.name === "function" ? frame.name() : "";
+        if (declared !== "")
+            return declared;
+        if (typeof frame.frameElement !== "function")
+            return null;
+        const element = await frame.frameElement();
+        try {
+            if (typeof element.getAttribute !== "function")
+                return null;
+            const id = await element.getAttribute("id");
+            if (id !== null && id.trim() !== "")
+                return id;
+            const title = await element.getAttribute("title");
+            if (title !== null && title.trim() !== "")
+                return title;
+            return null;
+        }
+        finally {
+            await element.dispose().catch(() => { });
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** Identity for reveal accounting. Elements are compared as a multiset, not by ref: a ref is
+ *  issued per snapshot and two enumerations of the same row never share one. */
+function countKeys(elements) {
+    const counts = new Map();
+    for (const element of elements) {
+        const key = `${element.frame?.id ?? ""}\u0000${element.role}\u0000${element.name}\u0000${element.selector ?? ""}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+/** How many of `a` have no counterpart in `b`. */
+function surplus(a, b) {
+    let total = 0;
+    for (const [key, count] of a)
+        total += Math.max(0, count - (b.get(key) ?? 0));
+    return total;
+}
+export class BrowserBackendMissingError extends Error {
+    constructor(cause) {
+        super(`Could not load ${RUNTIME_BROWSER_MODULE}: ${cause instanceof Error ? cause.message : String(cause)}. ` +
+            "This build of @descryy/mcp does not have the browser backend installed.");
+        this.name = "BrowserBackendMissingError";
+    }
+}
+/**
+ * RT-263: the real implementation behind `BrowserDriver.probeTargetReachable` /
+ * `BrowserPageSession.probeTargetReachable` — single TCP connect, seconds, before
+ * either a real Chromium launch (`browser_start_session`) or a real replay step
+ * (`browser_run_scenario`) spends the slow path learning the same thing. Lives here,
+ * not in either tool, so the fake driver used across `packages/mcp/test`'s
+ * `createFakeBrowserDriver`-based suites never runs a real network probe against a
+ * URL nothing is actually listening on — the port method is optional precisely so
+ * those tests are unaffected by this existing.
+ */
+async function probeTargetReachable(targetUrl) {
+    let host;
+    let port;
+    try {
+        const parsed = new URL(targetUrl);
+        // Only a network target has a port to answer. `about:blank`, `data:` and
+        // `file:` pages load without one, so there is nothing to probe.
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            return null;
+        host = parsed.hostname;
+        port = parsed.port !== "" ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+    }
+    catch {
+        // Not this probe's problem to diagnose -- the real navigate/launch attempt
+        // reports its own, more specific error for an unparseable target.
+        return null;
+    }
+    const result = await runPreflight([portAnswersCheck(host, port, `${targetUrl} answers`)]);
+    if (result.status !== "broken")
+        return { reachable: true, message: "ok" };
+    return { reachable: false, message: result.checks.find((check) => !check.ok)?.message ?? `Nothing answered at ${targetUrl}.` };
+}
+const sharedBrowserManagers = new Map();
+function sharedBrowserManagerFor(runtime) {
+    if (typeof runtime.createSharedBrowserManager !== "function")
+        return null;
+    const cached = sharedBrowserManagers.get(runtime);
+    if (cached !== undefined)
+        return cached;
+    const created = runtime.createSharedBrowserManager();
+    sharedBrowserManagers.set(runtime, created);
+    return created;
+}
+export async function disposeSharedPlaywrightBrowsers() {
+    const managers = [...sharedBrowserManagers.values()];
+    sharedBrowserManagers.clear();
+    await Promise.all(managers.map((manager) => manager.dispose().catch(() => { })));
+}
+export async function createPlaywrightBrowserDriver(options = {}) {
+    let runtime;
+    try {
+        runtime = (await (options.loadRuntimeModule ?? defaultRuntimeModuleLoader)());
+    }
+    catch (error) {
+        throw new BrowserBackendMissingError(error);
+    }
+    return {
+        probeTargetReachable,
+        async launch(launchOptions) {
+            const auth = runtimeAuthFor(launchOptions);
+            const sessionOptions = {
+                headless: launchOptions.headless ?? true,
+                // B1. This used to be `{ headless }` and nothing else, while the port
+                // above already carried `storageState` and a reply note already said
+                // it had been seeded. The option reached the fake driver and stopped;
+                // against a real browser nothing was ever applied and the note was
+                // false. Building the seed here, from the target URL, is also what
+                // makes the origin a fact the runtime is *told* rather than one it
+                // has to work out.
+                ...(auth === null ? {} : { auth }),
+            };
+            const manager = sharedBrowserManagerFor(runtime);
+            const launchNotes = [];
+            let launch;
+            if (manager === null) {
+                launch = await runtime.launchBrowserSessionOrRefuse(sessionOptions);
+                launchNotes.push("Started a new browser for this check (this runtime-browser build can't reuse one).");
+            }
+            else {
+                const acquired = await manager.acquireSession(sessionOptions);
+                if (acquired.launched && acquired.relaunchedBrowser) {
+                    launchNotes.push("The shared browser had stopped; Descry started a new one.");
+                }
+                launch = acquired;
+            }
+            if (!launch.launched) {
+                const { launched: _launched, ...refusal } = launch;
+                return { launched: false, ...refusal };
+            }
+            const session = await openSession(runtime, launch.session, launchOptions, options, launchNotes);
+            return { launched: true, session };
+        },
+    };
+}
+async function openSession(runtime, session, launchOptions, options, launchNotes) {
+    const emitted = [];
+    const actions = [];
+    const unsettled = [];
+    // Never cleared, unlike `actions` — the session's whole-lifetime provenance record for
+    // `browser_save_scenario`, not per-drain evidence. Goes out of reach the moment this closure
+    // does (session closed/reaped) — there is no other path back to it.
+    const performed = [];
+    // inFlight/lastEventAt track request activity: counted, not slept through.
+    let inFlight = 0;
+    let lastEventAt = 0;
+    session.page.on("request", () => {
+        inFlight += 1;
+        lastEventAt = Date.now();
+    });
+    const settleOne = () => {
+        inFlight = Math.max(0, inFlight - 1);
+        lastEventAt = Date.now();
+    };
+    session.page.on("requestfinished", settleOne);
+    session.page.on("requestfailed", settleOne);
+    let refs = new Map();
+    let generation = 0;
+    let closed = false;
+    let finalObservation = null;
+    /** Set when a `saveStorageStateTo` write failed. Read by `storageStateSaveFailure()`. */
+    let storageStateSaveError = null;
+    /** Set when `groundIdentity` was asked for and installed successfully. Every snapshot
+     *  element with a selector is grounded through it; one with none is never attempted
+     *  (§B1's `identity: null` distinction — see `driver.ts`). */
+    let grounder = null;
+    const sessionWarnings = [...launchNotes];
+    const context = {
+        executionId: `mcp-browser-${session.sessionId}`,
+        configuration: { environmentTier: "tier-2-container", fidelityLevel: 2, timeoutMs: 30_000, services: {} },
+        emit: (evidence) => {
+            emitted.push(evidence);
+        },
+        ...(options.resolveSourceRoot === undefined ? {} : { resolveSourceRoot: options.resolveSourceRoot }),
+    };
+    const actionCollector = runtime.createBrowserActionCollector({
+        session,
+        ...(options.service === undefined ? {} : { service: options.service }),
+    });
+    const consoleCollector = runtime.createBrowserConsoleCollector({
+        session,
+        ...(options.service === undefined ? {} : { service: options.service }),
+        ...(options.stackParser === undefined ? {} : { stackTraceParser: options.stackParser }),
+    });
+    const networkCollector = runtime.createBrowserNetworkCollector({
+        session,
+        ...(options.service === undefined ? {} : { service: options.service }),
+        ...(options.stackParser === undefined ? {} : { stackTraceParser: options.stackParser }),
+    });
+    // Started before first navigation: Playwright's init-script contract means
+    // a collector started later misses instrumentation, reporting an
+    // honest-looking but empty stack.
+    await actionCollector.start(context);
+    await consoleCollector.start(context);
+    await networkCollector.start(context);
+    // Same contract as the collectors above, and for the same reason: the identity probe is
+    // an init script too, so it must install before the first navigation or it reports
+    // `probe-not-installed` for the document's whole lifetime. Off by default (B1) — a session
+    // that never asks for it pays no page.evaluate and loads no module.
+    if (options.groundIdentity === true) {
+        try {
+            const identityModule = (await (options.loadIdentityGroundingModule ?? defaultIdentityGroundingModuleLoader)());
+            grounder = identityModule.createFrameworkAwareGrounder(options.resolveSourceRoot === undefined ? {} : { resolveSourceRoot: options.resolveSourceRoot });
+            await grounder.install(session.page);
+        }
+        catch (error) {
+            // Honest degradation (rule 7): identity grounding could not be installed, so every
+            // element on this session reports `identity: null` — never a guess — and the reason
+            // travels on the observation rather than being swallowed.
+            grounder = null;
+            sessionWarnings.push(`identity grounding was requested (groundIdentity) but could not be installed: ` +
+                `${error instanceof Error ? error.message : String(error)}. Every element on this session ` +
+                "reports identity: null rather than a guess.");
+        }
+    }
+    await actionCollector.navigate(launchOptions.targetUrl);
+    function assertUsable() {
+        if (closed || !session.isUsable())
+            throw new BrowserSessionCrashedError(session.sessionId);
+    }
+    function resolve(ref) {
+        const found = refs.get(ref);
+        if (found === undefined)
+            throw new UnknownElementRefError(ref);
+        return found;
+    }
+    function recordAction(action, ref, mode) {
+        actions.push({ action, ref, mode, url: session.page.url(), at: new Date().toISOString() });
+    }
+    function recordPerformed(action, target, url, text) {
+        performed.push({ action, target, url, text, at: new Date().toISOString() });
+    }
+    /** Waits for the action's network effect (started within `ACTIVITY_GRACE_MS`, then quiet for `NETWORK_QUIET_MS`), capped at `SETTLE_TIMEOUT_MS` — reaching the cap is recorded, never swallowed. */
+    async function settleAfterAction(action, ref) {
+        const startedAt = Date.now();
+        lastEventAt = startedAt;
+        let sawActivity = inFlight > 0;
+        for (;;) {
+            const now = Date.now();
+            const waitedMs = now - startedAt;
+            if (inFlight > 0)
+                sawActivity = true;
+            if (waitedMs >= SETTLE_TIMEOUT_MS) {
+                unsettled.push({ action, ref, waitedMs });
+                return;
+            }
+            if (sawActivity) {
+                if (inFlight === 0 && now - lastEventAt >= NETWORK_QUIET_MS)
+                    return;
+            }
+            else if (waitedMs >= ACTIVITY_GRACE_MS) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        }
+    }
+    async function dropRefs() {
+        const handles = [...refs.values()].map((r) => r.handle);
+        refs = new Map();
+        await Promise.all(handles.map((h) => h.dispose().catch(() => { })));
+    }
+    /** Every document to read, main first. When the backend exposes no frame list the page
+     *  itself is the only one, and that limitation is reported as an unread frame rather than
+     *  passed off as "this page has no iframes". */
+    function documentsToRead() {
+        if (typeof session.page.frames !== "function")
+            return { frames: [{ frame: session.page, ref: null }], frameListUnavailable: true };
+        const all = session.page.frames();
+        const main = typeof session.page.mainFrame === "function" ? session.page.mainFrame() : all[0];
+        const out = [];
+        let index = 0;
+        for (const frame of all) {
+            if (frame === main) {
+                out.unshift({ frame, ref: null });
+                continue;
+            }
+            index += 1;
+            out.push({ frame, ref: { id: `frame-${index}`, url: safeUrl(frame), name: null } });
+        }
+        if (out.length === 0 || out[0]?.ref !== null)
+            out.unshift({ frame: session.page, ref: null });
+        return { frames: out, frameListUnavailable: false };
+    }
+    /** Reads the elements of one document, describing each in a single round trip. */
+    async function enumerateFrame(frame, frameRef) {
+        const handles = await frame.$$(INTERACTIVE);
+        const elements = [];
+        let ambiguousInDocument = 0;
+        let hidden = 0;
+        let untested = 0;
+        for (const handle of handles) {
+            const described = await handle.evaluate(describeElement).catch(() => null);
+            if (described === null) {
+                await handle.dispose().catch(() => { });
+                continue;
+            }
+            // The CSS query matches what is in the document; this is what is on the page. A
+            // `display:none` menu, a closed modal and an inactive tab panel all match the query,
+            // and reporting them as usable controls is Descry stating something false about the
+            // user's screen. Withheld and counted, never dropped in silence (rule 7).
+            if (described.rendered === false) {
+                hidden += 1;
+                await handle.dispose().catch(() => { });
+                continue;
+            }
+            // `null` is "nothing could answer". The element is kept — omitting on an unanswered
+            // question would hide real controls behind a test that did not run — and the fact that
+            // the question went unanswered travels with the snapshot.
+            if (described.rendered === null)
+                untested += 1;
+            let selector = described.selector;
+            // A hook unique inside its own shadow root is not necessarily unique in the document:
+            // two instances of the same component each carry `[data-testid="submit"]`. Playwright's
+            // own CSS resolution pierces, so asking it is the same question a replay would ask.
+            if (selector !== null && described.inShadowRoot === true) {
+                const matches = await frame.$$(selector).catch(() => null);
+                if (matches !== null)
+                    await Promise.all(matches.map((m) => m.dispose().catch(() => { })));
+                if (matches === null || matches.length !== 1) {
+                    selector = null;
+                    ambiguousInDocument += 1;
+                }
+            }
+            elements.push({
+                handle,
+                role: described.role,
+                name: described.name,
+                // An element inside a frame has no saveable selector: the scenario format carries no
+                // field to name the frame, so a stored selector would replay against the main document.
+                selector: frameRef === null ? selector : null,
+                inShadowRoot: described.inShadowRoot === true,
+                frame: frameRef,
+            });
+        }
+        return { elements, ambiguousInDocument, hidden, untested };
+    }
+    /** Counts custom elements that look like closed shadow hosts. Returns null when the probe could not run. */
+    async function probeClosedHosts(frame) {
+        if (typeof frame.evaluate !== "function")
+            return null;
+        return frame
+            .evaluate(() => {
+            const page = globalThis;
+            const all = page.document.querySelectorAll("*");
+            let suspected = 0;
+            for (let i = 0; i < all.length; i += 1) {
+                const element = all.item(i);
+                if (element === null)
+                    continue;
+                // A dash in the tag name is what the custom-element spec requires of every one of
+                // them; it names no language or framework (rule 1), only the HTML naming rule.
+                if (!element.tagName.toLowerCase().includes("-"))
+                    continue;
+                if (element.shadowRoot !== null && element.shadowRoot !== undefined)
+                    continue;
+                if ((element.childElementCount ?? 0) > 0)
+                    continue;
+                suspected += 1;
+            }
+            return suspected;
+        })
+            .catch(() => null);
+    }
+    /** Reads every document, and reports each one it could not read with the reason. */
+    async function enumerateAll() {
+        const { frames: documents, frameListUnavailable } = documentsToRead();
+        const elements = [];
+        const reach = [];
+        let ambiguousInDocument = 0;
+        let suspectedClosedHosts = 0;
+        let probed = false;
+        let hidden = 0;
+        let untested = 0;
+        for (const { frame, ref } of documents) {
+            let frameRef = ref;
+            if (frameRef !== null)
+                frameRef = { ...frameRef, name: await frameLabel(frame) };
+            try {
+                const read = await enumerateFrame(frame, frameRef);
+                elements.push(...read.elements);
+                ambiguousInDocument += read.ambiguousInDocument;
+                hidden += read.hidden;
+                untested += read.untested;
+                reach.push({ frame: frameRef, enumerated: true, elements: read.elements.length, reason: null });
+            }
+            catch (error) {
+                reach.push({
+                    frame: frameRef,
+                    enumerated: false,
+                    elements: 0,
+                    reason: `this frame could not be read: ${error instanceof Error ? error.message : String(error)}`,
+                });
+                continue;
+            }
+            const closed = await probeClosedHosts(frame);
+            if (closed !== null) {
+                probed = true;
+                suspectedClosedHosts += closed;
+            }
+        }
+        if (frameListUnavailable) {
+            reach.push({
+                frame: { id: "frames-unavailable", url: "", name: null },
+                enumerated: false,
+                elements: 0,
+                reason: "this browser backend exposes no frame list, so any iframe on this page was not read. " +
+                    "Nothing here claims the page has none.",
+            });
+        }
+        return {
+            elements,
+            frames: reach,
+            shadow: {
+                piercedElements: elements.filter((e) => e.inShadowRoot).length,
+                ambiguousInDocument,
+                suspectedClosedHosts,
+                probed,
+            },
+            hidden: { withheld: hidden, untested },
+        };
+    }
+    /** Scrolls the document **and every scrollable container in it** a viewport at a time until
+     *  nothing can move further, or the pass cap stops it. Containers are the half a window-only
+     *  scroll never reached: a list inside `overflow: auto` does not move when the page does. */
+    async function scrollToReveal() {
+        const page = session.page;
+        if (typeof page.evaluate !== "function") {
+            return {
+                passes: 0,
+                stoppedAtCap: false,
+                finalScrollY: 0,
+                containersScrolled: 0,
+                reason: "this browser backend exposes no page evaluation, so nothing below the fold could be revealed",
+            };
+        }
+        const evaluate = page.evaluate.bind(page);
+        let passes = 0;
+        let containers = 0;
+        let lastY = 0;
+        let scanCapped = false;
+        for (;;) {
+            const step = await evaluate(revealStep).catch(() => null);
+            if (step === null) {
+                return {
+                    passes,
+                    stoppedAtCap: false,
+                    finalScrollY: lastY,
+                    containersScrolled: containers,
+                    reason: "the page stopped answering mid-reveal",
+                };
+            }
+            lastY = step.y;
+            containers = Math.max(containers, step.containers);
+            scanCapped = scanCapped || step.scanCapped;
+            // Nothing left to move: the page and every container it holds are at their end, or
+            // none of them can scroll at all. Either way there is nothing further to reveal.
+            if (!step.scrolled) {
+                return {
+                    passes,
+                    stoppedAtCap: false,
+                    finalScrollY: step.y,
+                    containersScrolled: containers,
+                    reason: scanCapped ? CONTAINER_SCAN_NOTE : null,
+                };
+            }
+            passes += 1;
+            if (passes >= REVEAL_MAX_PASSES) {
+                return {
+                    passes,
+                    stoppedAtCap: true,
+                    finalScrollY: step.y,
+                    containersScrolled: containers,
+                    reason: scanCapped ? CONTAINER_SCAN_NOTE : null,
+                };
+            }
+            await new Promise((done) => setTimeout(done, REVEAL_SETTLE_MS));
+        }
+    }
+    /**
+   * Refuses a control the page has put out of reach.
+   *
+   * `click` never calls this: Playwright's own actionability checks already
+   * cover it, and duplicating them here would mean two rules that can
+   * disagree. `select` and `submit` do, because neither of their underlying
+   * operations hit-tests — see `NotOperableError`.
+   *
+   * A browser that cannot answer is treated as operable rather than refused.
+   * Refusing on an unanswered question would turn a missing capability into a
+   * false negative on every element, which is the same trade rule 2 rejects
+   * pointed the other way.
+   */
+    async function assertOperable(ref, handle) {
+        const state = await handle
+            .evaluate((el) => ({
+            // `inert` applies to a whole subtree and `HTMLElement.inert` reflects only the
+            // attribute on the node it is read from, so this has to walk ancestors.
+            inert: el.closest === undefined ? null : el.closest("[inert]") !== null,
+            disabled: el.disabled === true,
+        }))
+            .catch(() => null);
+        if (state === null)
+            return;
+        if (state.inert === true)
+            throw new NotOperableError(ref, "inert");
+        if (state.disabled)
+            throw new NotOperableError(ref, "disabled");
+    }
+    // Named rather than returned inline: `waitFor` re-enumerates the page each poll and does it
+    // by calling this same `snapshot()`, so the refs it hands back come from the one enumeration
+    // path instead of a second copy that could drift from it.
+    const api = {
+        sessionId: session.sessionId,
+        startedAt: session.startedAt,
+        isUsable: () => !closed && session.isUsable(),
+        currentUrl: () => session.page.url(),
+        probeTargetReachable,
+        async navigate(url) {
+            assertUsable();
+            await dropRefs();
+            await actionCollector.navigate(url);
+            recordAction("navigate", null, null);
+            recordPerformed("navigate", null, url, null);
+        },
+        async snapshot(options) {
+            assertUsable();
+            await dropRefs();
+            generation += 1;
+            let read = await enumerateAll();
+            let reveal = null;
+            if (options?.reveal === true) {
+                const before = countKeys(read.elements);
+                const scrolled = await scrollToReveal();
+                if (scrolled.passes > 0) {
+                    // Handles taken before the scroll may point at rows the list has since destroyed;
+                    // the page is re-read rather than merged, so every ref handed back is one that
+                    // exists now. What the scroll cost is reported, not hidden.
+                    await Promise.all(read.elements.map((e) => e.handle.dispose().catch(() => { })));
+                    read = await enumerateAll();
+                }
+                const after = countKeys(read.elements);
+                reveal = {
+                    passes: scrolled.passes,
+                    containersScrolled: scrolled.containersScrolled,
+                    revealedElements: surplus(after, before),
+                    recycledElements: surplus(before, after),
+                    stoppedAtCap: scrolled.stoppedAtCap,
+                    finalScrollY: scrolled.finalScrollY,
+                    framesNotScrolled: read.frames
+                        .filter((f) => f.frame !== null)
+                        .map((f) => f.frame?.name ?? f.frame?.url ?? f.frame?.id ?? ""),
+                    reason: scrolled.reason,
+                };
+            }
+            const elements = [];
+            for (const [index, found] of read.elements.entries()) {
+                const ref = `ref-${generation}-${index}`;
+                const element = {
+                    ref,
+                    role: found.role,
+                    name: found.name,
+                    selector: found.selector,
+                    frame: found.frame,
+                    inShadowRoot: found.inShadowRoot,
+                    // Grounding resolves a *document* selector, so a framed or hookless element
+                    // (selector === null) is never attempted — `identity` stays null rather than
+                    // guessed at, same reasoning `driver.ts` documents on the field itself.
+                    identity: grounder === null || found.selector === null
+                        ? null
+                        : await groundOne(grounder, session.page, found.selector),
+                };
+                refs.set(ref, { element, handle: found.handle });
+                elements.push(element);
+            }
+            return {
+                url: session.page.url(),
+                title: await session.page.title().catch(() => ""),
+                elements,
+                totalElements: elements.length,
+                frames: read.frames,
+                shadow: read.shadow,
+                hidden: read.hidden,
+                reveal,
+            };
+        },
+        async click(ref) {
+            assertUsable();
+            const { element, handle } = resolve(ref);
+            await handle.click();
+            recordAction("click", ref, null);
+            recordPerformed("click", { role: element.role, name: element.name, selector: element.selector }, null, null);
+            // requestfinished fires after the page's handler resolves; draining immediately would miss the very request being watched for.
+            await settleAfterAction("click", ref);
+        },
+        async type(ref, text) {
+            assertUsable();
+            const { element, handle } = resolve(ref);
+            if (handle.pressSequentially !== undefined)
+                await handle.pressSequentially(text);
+            else if (handle.type !== undefined)
+                await handle.type(text);
+            else
+                throw new Error("this Playwright build exposes no keystroke-level typing method");
+            recordAction("type", ref, "append");
+            recordPerformed("type", { role: element.role, name: element.name, selector: element.selector }, null, text);
+            await settleAfterAction("type", ref);
+        },
+        async fill(ref, text) {
+            assertUsable();
+            const { element, handle } = resolve(ref);
+            await handle.fill(text);
+            recordAction("fill", ref, "replace");
+            recordPerformed("fill", { role: element.role, name: element.name, selector: element.selector }, null, text);
+            await settleAfterAction("fill", ref);
+        },
+        async select(ref, value) {
+            assertUsable();
+            const { element, handle } = resolve(ref);
+            await assertOperable(ref, handle);
+            // Read what the element actually offers before touching it. Playwright's own
+            // selectOption would time out on a non-match and say nothing useful about why; the
+            // refusal a caller can act on has to carry the real option list, and that means one
+            // round trip to read it.
+            const offered = await handle.evaluate((el) => {
+                if (el.options === undefined)
+                    return null;
+                const out = [];
+                for (let i = 0; i < el.options.length; i += 1) {
+                    const option = el.options[i];
+                    out.push({ value: option.value, label: option.label === "" ? option.text : option.label });
+                }
+                return out;
+            });
+            if (offered === null)
+                throw new NotSelectableError(ref, element.role);
+            // By stored value first, then by the label a person reads — both exact. A caller
+            // reading a snapshot sees labels and a caller reading the page's source sees values;
+            // neither should have to know which one this element uses.
+            const matched = offered.find((o) => o.value === value) ?? offered.find((o) => o.label.trim() === value.trim());
+            if (matched === undefined) {
+                throw new NoSuchOptionError(ref, value, offered.map((o) => (o.label.trim() === "" ? o.value : o.label)));
+            }
+            if (handle.selectOption === undefined)
+                throw new Error("this Playwright build exposes no option-selecting method");
+            await handle.selectOption(matched.value);
+            recordAction("select", ref, "replace");
+            recordPerformed("select", { role: element.role, name: element.name, selector: element.selector }, null, matched.value);
+            await settleAfterAction("select", ref);
+        },
+        async submit(ref) {
+            assertUsable();
+            const { element, handle } = resolve(ref);
+            await assertOperable(ref, handle);
+            // Submitted through the form's own submit control rather than by synthesising a bare
+            // submit event: that is what a person's click does, it names the submitter the page's
+            // handler reads, and it runs the form's validation. A form with no such control is
+            // submitted by script on some other control — refused, not guessed at.
+            const outcome = await handle.evaluate((el) => {
+                const form = el.closest === undefined ? null : el.closest("form");
+                if (form === null)
+                    return "noForm";
+                const control = form.querySelector('button[type="submit"], input[type="submit"], button:not([type])');
+                if (control === null)
+                    return "noSubmitControl";
+                form.requestSubmit(control);
+                return "submitted";
+            });
+            if (outcome !== "submitted")
+                throw new NotSubmittableError(ref, outcome);
+            recordAction("submit", ref, null);
+            recordPerformed("submit", { role: element.role, name: element.name, selector: element.selector }, null, null);
+            await settleAfterAction("submit", ref);
+        },
+        async waitFor(target, waitOptions = {}) {
+            assertUsable();
+            if (isEmptyWaitTarget(target)) {
+                throw new Error("browser_wait_for needs a target: give a role, a name, or both. Waiting for nothing in particular " +
+                    `would return the first element on the page, which is not what any caller means. Got: ${describeWaitTarget(target)}.`);
+            }
+            const timeoutMs = clampWaitTimeout(waitOptions.timeoutMs);
+            const startedAt = Date.now();
+            for (;;) {
+                assertUsable();
+                // Re-enumerates each poll rather than watching one selector: the port has no
+                // selector to watch, and a fresh snapshot is what makes the matched element
+                // actionable at all. That cost is real, and is why the interval is not tighter.
+                const snapshot = await api.snapshot();
+                const matches = snapshot.elements.filter((e) => matchesWaitTarget(e, target));
+                const waitedMs = Date.now() - startedAt;
+                if (matches.length > 0) {
+                    return { appeared: true, waitedMs, timeoutMs, matched: matches[0], matchCount: matches.length, snapshot };
+                }
+                if (waitedMs >= timeoutMs) {
+                    return { appeared: false, waitedMs, timeoutMs, matched: null, matchCount: 0, snapshot };
+                }
+                await new Promise((done) => setTimeout(done, WAIT_POLL_INTERVAL_MS));
+            }
+        },
+        async injectStorageState(origin, state) {
+            assertUsable();
+            if (typeof session.injectStorageState !== "function") {
+                // Honest degradation (rule 7), same shape the groundIdentity install
+                // failure above uses: an older runtime-browser build predates this
+                // primitive, so nothing was injected and the reason travels on the
+                // result rather than a silent no-op or a thrown TypeError.
+                return {
+                    cookiesInjected: 0,
+                    localStorageInjected: 0,
+                    localStorageSkipped: "this build of @descryy/runtime-browser does not export injectStorageState -- nothing was injected. " +
+                        "Republish runtime-browser at a version that includes BrowserSession.injectStorageState.",
+                };
+            }
+            return session.injectStorageState({
+                origin,
+                ...(state.cookies === undefined ? {} : { cookies: state.cookies }),
+                ...(state.localStorage === undefined ? {} : { localStorage: state.localStorage }),
+            });
+        },
+        async drainEvidence() {
+            const observation = collect(emitted, actions, unsettled);
+            emitted.length = 0;
+            actions.length = 0;
+            unsettled.length = 0;
+            return withSessionWarnings(observation, sessionWarnings);
+        },
+        performedSteps() {
+            return [...performed];
+        },
+        storageStateSaveFailure: () => storageStateSaveError,
+        /**
+         * §4.2's probe. Reads the page and counts; decides nothing — `estimateReach`
+         * is the only thing that turns these counts into a claim, so a change of
+         * policy never touches a driver.
+         *
+         * The body lives in `page-probe.ts` rather than here: this file belongs to
+         * another lane, and a six-line delegation is mergeable where two hundred
+         * lines of DOM walking would not be.
+         */
+        async fingerprint() {
+            assertUsable();
+            const [root] = await session.page.$$("html");
+            if (root === undefined) {
+                // No document element at all. Refusing is right: a fingerprint of
+                // zeroes would read as a page with nothing on it.
+                throw new Error("the page exposed no document element to probe");
+            }
+            try {
+                return await root.evaluate(probeInPage, PROBE_CONSTANTS);
+            }
+            finally {
+                await root.dispose();
+            }
+        },
+        async close() {
+            if (finalObservation !== null)
+                return finalObservation;
+            closed = true;
+            // Stopped before observing: a stop flushes what each collector was
+            // still holding, which observing first would drop.
+            await actionCollector.stop().catch(() => { });
+            await consoleCollector.stop().catch(() => { });
+            await networkCollector.stop().catch(() => { });
+            const observation = withSessionWarnings(collect(emitted, actions, unsettled), sessionWarnings);
+            emitted.length = 0;
+            actions.length = 0;
+            unsettled.length = 0;
+            await dropRefs();
+            // Before `session.close()`, not after: a closed context holds no
+            // cookies to read, and a save that ran afterwards would write a file
+            // that looks like a session with nothing in it — which is worse than no
+            // file, because the next run would seed from it and silently drive the
+            // logged-out surface. A failure here is reported as a note by the
+            // caller rather than swallowed, but it never fails the close: evidence
+            // already collected must not be lost to a write that did not work.
+            if (launchOptions.saveStorageStateTo !== undefined && session.saveStorageState !== undefined) {
+                try {
+                    await session.saveStorageState(launchOptions.saveStorageStateTo);
+                }
+                catch (error) {
+                    storageStateSaveError = error instanceof Error ? error.message : String(error);
+                }
+            }
+            await session.close().catch(() => { });
+            finalObservation = observation;
+            return observation;
+        },
+    };
+    return api;
+}
+/** Turns collector evidence into the port's vocabulary. Joins request/response on `requestId`, keeping `status: null` (not guessed) when unanswered. Exported for `browser-request-outcome-mapping.test.ts`. */
+export function collect(emitted, actions, unsettled) {
+    // `requestId` is a correlation header the app must itself propagate, not a
+    // transport id — an id-only join silently reported `status: null` for
+    // every request without one, i.e. most of them, hence the URL fallback
+    // below. `status` and `outcome` are read from the *same* terminal event and
+    // stored together: two independent last-write-wins maps let a later
+    // terminal event for a *different* request overwrite one field but not the
+    // other (e.g. an id-less "unanswered" HTTP_ERROR with no numeric status
+    // updates only `outcome`), so a third, genuinely-still-pending id-less
+    // request sharing that URL could read back `status: 200` from one sibling
+    // and `outcome: "unanswered"` from another — a self-contradictory pair
+    // that is a real, reported defect (P6-D5), not a hypothetical one.
+    //
+    // **B4: that pairing was necessary and was not sufficient.** Three routes to
+    // a false fact survived it, each verified here rather than reasoned about,
+    // and each fixed at the line it occurs on below: the pair itself was never
+    // checked for self-consistency across a boundary that versions separately;
+    // "paired" was a set-membership test on the URL rather than a record of what
+    // this request consumed, so an in-flight sibling read as failed; and the
+    // HTTP_ERROR `descry-runtime` emits *alongside* a >= 400 NETWORK_RESPONSE
+    // took a second queue slot, handing one exchange's 500 to two requests.
+    const byRequestId = new Map();
+    // C3. A **transport-level** identity, when the collector carries one: an id
+    // the browser's own request object owns, not a header an application chose
+    // to propagate. It outranks `requestId` because it cannot be absent for
+    // application reasons, and where it is present the whole out-of-order
+    // question below simply does not arise. `descry-runtime`'s network
+    // collector already holds this identity — its pending map is keyed by the
+    // Playwright `Request` object itself, "not a URL or an id, which could
+    // collide across concurrent requests to the same endpoint" — and does not
+    // yet emit it. Read here the same way `outcome` was read before its
+    // producer shipped: validated, optional, and absent degrades to the join
+    // below rather than to a guess. See
+    // `DEC-NEXT-transport-level-exchange-id-for-browser-requests`.
+    const byExchangeId = new Map();
+    // FIFO per URL, fed only by unidentified terminal events. A URL is not
+    // unique the way an id is — a page can issue the same URL more than once —
+    // so a shared cache must hand each terminal event's (status, outcome) pair
+    // to at most one request, in arrival order, rather than broadcasting the
+    // most recent one to every request sharing that URL. An id-bearing terminal
+    // event is deliberately excluded from this pool: it is already claimed
+    // evidence for one specific request, and folding it into the shared pool
+    // would just relocate the same contamination.
+    //
+    // **C3: arrival order is not an answer, so it is no longer used as one.**
+    // Two unidentified requests to one URL whose responses arrive out of order
+    // swap records, and nothing at this layer can tell an in-order pair from a
+    // swapped one. A FIFO is therefore right about half the time and silent
+    // when it is wrong — the exact shape rule 2 forbids, because the failure
+    // leaves no trace in the reply. Where the assignment is genuinely
+    // undetermined the queue is not consulted at all and every request in that
+    // bucket is reported `unattributed` with the terminal events disclosed by
+    // URL instead. Where it is determined — one unidentified request, or
+    // several whose records are indistinguishable from one another, so that
+    // every possible assignment yields the same answer — it still pairs, since
+    // refusing there would trade a silent wrong answer for a loud missing one
+    // that nothing required.
+    const queueByUrl = new Map();
+    const warnings = new Set();
+    // URLs that produced an id-less NETWORK_RESPONSE, so the duplicate-HTTP_ERROR
+    // exclusion below can require its sibling rather than assume it. A build that
+    // ever emitted a numeric-status HTTP_ERROR *alone* would otherwise have it
+    // silently dropped, turning a real 4xx into "pending".
+    const respondedUrls = new Set();
+    for (const evidence of emitted) {
+        if (evidence.eventType !== "NETWORK_RESPONSE" || evidence.requestId !== null)
+            continue;
+        if (exchangeIdOf(evidence.payload) !== null)
+            continue;
+        const url = evidence.payload["url"];
+        if (typeof url === "string")
+            respondedUrls.add(url);
+    }
+    for (const evidence of emitted) {
+        if (evidence.eventType !== "NETWORK_RESPONSE" && evidence.eventType !== "HTTP_ERROR")
+            continue;
+        const url = evidence.payload["url"];
+        const rawStatus = evidence.payload["status"];
+        const status = typeof rawStatus === "number" ? rawStatus : null;
+        // B4. The pair is validated, not just each field: this payload crosses a
+        // package boundary that versions separately, which is the same reason
+        // `requestOutcomeOf` validates instead of casting. A numeric status means
+        // a response arrived; "unanswered" means none ever did. Both cannot be
+        // true of one request, and forwarding the pair verbatim is what produced
+        // the `status: 200` + `outcome: "unanswered"` record the cal.com pass
+        // reported. Neither field can be trusted to correct the other, so the
+        // directly-observed status is kept and the outcome degrades to the same
+        // "not reported" state an older collector build produces — and it is
+        // named in the reply rather than dropped quietly (rule 7).
+        const outcome = reconcile(status, requestOutcomeOf(evidence.payload), url, warnings);
+        const record = { status, outcome };
+        const exchangeId = exchangeIdOf(evidence.payload);
+        if (exchangeId !== null) {
+            byExchangeId.set(exchangeId, record);
+            continue;
+        }
+        if (evidence.requestId !== null) {
+            byRequestId.set(evidence.requestId, record);
+            continue;
+        }
+        if (typeof url !== "string")
+            continue;
+        // B4. One exchange, one slot. `descry-runtime`'s collector emits
+        // NETWORK_RESPONSE *and* a payload-sharing HTTP_ERROR for a single
+        // response with status >= 400, and a numeric status is the only shape in
+        // which it ever emits HTTP_ERROR — every other HTTP_ERROR it produces
+        // (requestfailed, its own timeout, a websocket socketerror, a session
+        // closing mid-flight) carries `status: null` and has no NETWORK_RESPONSE
+        // beside it. Keyed by requestId that duplicate is harmless (same content,
+        // one map entry); in this queue it took a second slot, so one 500
+        // exchange handed a 500 to a second request that never got a response at
+        // all. Excluded here only — an id-keyed one still records, in case a
+        // build ever emits it without its sibling.
+        if (evidence.eventType === "HTTP_ERROR" && status !== null && respondedUrls.has(url))
+            continue;
+        const queue = queueByUrl.get(url);
+        if (queue === undefined)
+            queueByUrl.set(url, [record]);
+        else
+            queue.push(record);
+    }
+    /** The record this evidence owns outright, or undefined when it must draw from the shared
+     *  URL queue. Exchange id first: it identifies the transport exchange, where `requestId`
+     *  identifies whatever the application decided to label. */
+    const keyedRecordFor = (evidence) => {
+        const exchangeId = exchangeIdOf(evidence.payload);
+        if (exchangeId !== null) {
+            const byExchange = byExchangeId.get(exchangeId);
+            if (byExchange !== undefined)
+                return byExchange;
+        }
+        return evidence.requestId === null ? undefined : byRequestId.get(evidence.requestId);
+    };
+    // C3. How many requests to each URL have no record of their own — exactly the set that
+    // draws from the shared queue, and therefore exactly the set the queue can be wrong about.
+    // Counted after the maps are built, not from the presence of an id: a request carrying an
+    // id that never came back on a terminal event falls through to the queue like any other,
+    // and counting it as identified would leave the queue one short of the requests using it.
+    const unkeyedByUrl = new Map();
+    for (const evidence of emitted) {
+        if (evidence.eventType !== "NETWORK_REQUEST")
+            continue;
+        const url = evidence.payload["url"];
+        if (typeof url !== "string")
+            continue;
+        if (keyedRecordFor(evidence) !== undefined)
+            continue;
+        unkeyedByUrl.set(url, (unkeyedByUrl.get(url) ?? 0) + 1);
+    }
+    // C3. The URLs whose assignment is undetermined. Not "has duplicates" — having two requests
+    // to one URL is ordinary and usually harmless. It is undetermined only when two different
+    // assignments would produce two different replies.
+    const undeterminedUrls = new Set();
+    for (const [url, records] of queueByUrl) {
+        const unkeyed = unkeyedByUrl.get(url) ?? 0;
+        if (unkeyed <= 1)
+            continue;
+        const first = records[0];
+        if (first === undefined)
+            continue;
+        const alike = records.every((record) => record.status === first.status && record.outcome === first.outcome);
+        // Enough alike records to go round means every request gets the same one, so which is
+        // which never comes up. One short means at least one request is still in flight and
+        // nothing can say which — and "pending" on the wrong one is a false fact about a healthy
+        // request, which is the defect B4 fixed in its first costume.
+        if (alike && records.length >= unkeyed)
+            continue;
+        undeterminedUrls.add(url);
+        warnings.add(undeterminedJoinWarning(url, unkeyed, records));
+    }
+    const requests = [];
+    const consoleErrors = [];
+    for (const evidence of emitted) {
+        if (evidence.eventType === "NETWORK_REQUEST") {
+            const method = evidence.payload["method"];
+            const url = evidence.payload["url"];
+            if (typeof method !== "string" || typeof url !== "string")
+                continue;
+            // The keyed match wins when it exists; only a request with no record of its own draws
+            // from the shared URL queue, and it draws once. C3: on an undetermined URL the queue is
+            // not consulted at all — consuming from it is what produced the swap.
+            const keyed = keyedRecordFor(evidence);
+            const undetermined = keyed === undefined && undeterminedUrls.has(url);
+            const matched = keyed ?? (undetermined ? undefined : queueByUrl.get(url)?.shift());
+            // B4. Paired is what this request *consumed*, not what its URL was seen
+            // in. It used to be a set-membership test on the URL, so a second,
+            // genuinely in-flight request to an already-answered URL came out with
+            // no outcome at all — which `isFailedRequest`'s older-build fallback
+            // reads as a failure, because its status is null. A healthy in-flight
+            // request reported as a failed one. No record consumed means no terminal
+            // event was ever attributable to this request, and "pending" is exactly
+            // that fact. An unrecognised outcome on a record that *was* consumed
+            // still leaves the field undefined, which is the older-build case the
+            // fallback exists for.
+            // C3. `unattributed` before `pending`: a terminal event for this URL exists, so claiming
+            // the request is still in flight would be as wrong as handing it a sibling's status —
+            // and wrong in the direction that reads as healthy.
+            const outcome = undetermined
+                ? "unattributed"
+                : matched === undefined
+                    ? "pending"
+                    : matched.outcome;
+            requests.push({
+                method,
+                url,
+                status: undetermined ? null : (matched?.status ?? null),
+                ...(outcome === undefined ? {} : { outcome }),
+                stackText: renderStack(evidence.stackTrace),
+                stackTrace: evidence.stackTrace,
+                scriptUrlMapping: scriptUrlOutcomesOf(evidence.payload),
+                at: evidence.timestamp,
+            });
+            continue;
+        }
+        // Uncaught page error and console error both mean "something went wrong"; callers don't need to know which listener fired.
+        if (evidence.eventType === "EXCEPTION" || evidence.eventType === "CONSOLE_MESSAGE") {
+            const level = evidence.payload["level"] ?? evidence.payload["type"];
+            if (evidence.eventType === "CONSOLE_MESSAGE" && level !== "error")
+                continue;
+            const text = evidence.payload["text"] ?? evidence.payload["message"];
+            consoleErrors.push({
+                text: typeof text === "string" ? text : JSON.stringify(evidence.payload),
+                stackText: renderStack(evidence.stackTrace),
+                scriptUrlMapping: scriptUrlOutcomesOf(evidence.payload),
+                at: evidence.timestamp,
+            });
+        }
+    }
+    return { actions: [...actions], consoleErrors, requests, unsettled: [...unsettled], evidenceWarnings: [...warnings] };
+}
+/** B4's pair check. Returns the outcome that may be published alongside `status`, dropping it —
+ *  and naming the drop in `warnings` — when the two cannot both be true. Deliberately one-sided:
+ *  a status is a number the collector read off a real response object, an outcome is a label it
+ *  derived, so when they disagree the derived half is the one that goes. `url` only names the
+ *  request in the warning; a missing one degrades the text, never the check. */
+function reconcile(status, outcome, url, warnings) {
+    const impossible = (outcome === "unanswered" && status !== null) || (outcome === "answered" && status === null);
+    if (!impossible)
+        return outcome;
+    const where = typeof url === "string" ? ` for ${url}` : "";
+    warnings.add(`Descry's browser collector reported a request${where} as both "${outcome}" and ` +
+        `status ${status === null ? "null" : String(status)}, which cannot both be true. The status is ` +
+        "what was read off the response, so it is kept and the outcome is dropped — this request is " +
+        "reported without one rather than with a contradiction. Usually a version mismatch between " +
+        "@descryy/mcp and @descryy/runtime-browser.");
+    return undefined;
+}
+/** Reads `outcome` off an untyped cross-package payload; validated not cast, since this build doesn't depend on `@descryy/runtime-browser`'s types — unrecognised values degrade to undefined, never a guessed literal. `"unattributed"` is deliberately not accepted here: it is this package's verdict about a join it could not make, and a collector is in no position to assert it. */
+function requestOutcomeOf(payload) {
+    const raw = payload["outcome"];
+    if (raw === "answered" || raw === "unanswered" || raw === "pending")
+        return raw;
+    return undefined;
+}
+/** Reads the collector's transport-level exchange id, when it carries one. Validated not cast,
+ *  and an empty string is treated as absent — an id that identifies nothing would put every
+ *  request into one bucket, which is worse than having none. */
+function exchangeIdOf(payload) {
+    const raw = payload["exchangeId"];
+    return typeof raw === "string" && raw !== "" ? raw : null;
+}
+/** C3's disclosure. Says what was observed and refuses to say whose it was — the terminal
+ *  events are named in full so a real 500 is never lost, only left unassigned. */
+function undeterminedJoinWarning(url, unkeyed, records) {
+    const describe = (record) => `${record.status === null ? "no status" : `status ${record.status}`}${record.outcome === undefined ? "" : ` (${record.outcome})`}`;
+    const shortfall = records.length < unkeyed
+        ? ` Fewer terminal events arrived than requests were issued, so at least one of them was still in flight, and which one is the same unanswerable question.`
+        : "";
+    return (`Descry saw ${unkeyed} requests to ${url} carrying no id of their own, and ${records.length} terminal ` +
+        `event(s) for that URL that do not all say the same thing: ${records.map(describe).join("; ")}.${shortfall} ` +
+        "Pairing them by arrival order would be right roughly half the time and silent when it was wrong, so none " +
+        "of these requests is reported with a status or an outcome. The events just listed did happen — Descry " +
+        "cannot say which request each one belongs to. A transport-level exchange id from the browser collector " +
+        "would remove this; the collector in this build does not emit one.");
+}
+/** Reads `scriptUrlMapping` off an untyped cross-package payload; validated not cast, so a malformed/absent field degrades to "no mapping reported" rather than a half-populated result. */
+function scriptUrlOutcomesOf(payload) {
+    const raw = payload["scriptUrlMapping"];
+    if (!Array.isArray(raw))
+        return [];
+    const outcomes = [];
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const record = entry;
+        const url = record["url"];
+        if (typeof url !== "string")
+            continue;
+        const mapped = record["mapped"];
+        const reason = record["reason"];
+        outcomes.push({
+            url,
+            mapped: typeof mapped === "string" ? mapped : null,
+            reason: typeof reason === "string" ? reason : null,
+        });
+    }
+    return outcomes;
+}
+/** Human-readable rendering of parsed stack frames, for the reply; the R4 write uses `stackTrace` itself, never this. Primary frame marked since it isn't always the innermost. */
+function renderStack(stack) {
+    if (stack === null || stack.frames.length === 0)
+        return null;
+    return stack.frames
+        .slice(0, 5)
+        .map((frame, index) => {
+        const where = `${frame.location.file}:${frame.location.line}`;
+        const name = frame.location.functionName ?? "(anonymous)";
+        return `${index === stack.primaryFrameIndex ? "> " : "  "}at ${name} (${where})`;
+    })
+        .join("\n");
+}
+/**
+ * The runtime's auth seed for this launch, or null when the caller named none.
+ *
+ * The origin comes from `targetUrl` and from nowhere else — it is the same
+ * value the registry records as the session's consented origin, so "the seed
+ * is scoped to what was consented" is a property of one derivation rather
+ * than of two that have to agree.
+ */
+function runtimeAuthFor(launchOptions) {
+    const state = launchOptions.storageState;
+    const headers = launchOptions.extraHttpHeaders;
+    if (state === undefined && headers === undefined)
+        return null;
+    let origin;
+    try {
+        origin = new URL(launchOptions.targetUrl).origin;
+    }
+    catch {
+        // Unparseable targets are refused far above this — the tool cannot mint
+        // consent for a URL it could not read an origin from. Carrying the raw
+        // string keeps this total rather than throwing from inside a launch.
+        origin = launchOptions.targetUrl;
+    }
+    return {
+        origin,
+        ...(state?.cookies === undefined ? {} : { cookies: state.cookies }),
+        ...(state?.localStorage === undefined ? {} : { localStorage: state.localStorage }),
+        ...(headers === undefined ? {} : { extraHttpHeaders: headers }),
+    };
+}
+//# sourceMappingURL=playwright-driver.js.map