@vostride/agent-qa-web 0.1.21 → 0.2.2

package/dist/index.js

@@ -1,5 +1,14 @@
 // src/adapter.ts
-import { convertKeysForPlatform, isMacPlatform, warnIfOutOfBounds } from "@vostride/agent-qa-core";
+import {
+  assertNever,
+  buildScreenState as buildScreenState3,
+  createSnapshotLiveStream,
+  LIVE_KEEPALIVE_QUIET_MS
+} from "@vostride/agent-qa-runner";
+import { convertKeysForPlatform, isMacPlatform } from "@vostride/agent-qa-runner";
+
+// src/observer.ts
+import { buildScreenState } from "@vostride/agent-qa-runner";
 
 // src/dom-extractor.ts
 var SKIP_TAGS = /* @__PURE__ */ new Set([
@@ -112,59 +121,87 @@ var CONTENT_ROLES = /* @__PURE__ */ new Set([
   "region",
   "navigation",
   "progressbar",
-  "tabpanel"
+  "tabpanel",
+  "row",
+  "dialog",
+  "alertdialog"
 ]);
+var LIMIT_KEYS = ["valuenow", "valuemin", "valuemax"];
 var LINE_PATTERN = /^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/;
 var QUOTED_LINE_PATTERN = /^(\s*-\s*)'(\w+)(?:\s+"([^"]*)")?(.*)'\s*$/;
+var REF_ANNOTATION = /\[ref=([A-Za-z0-9_-]+)\]/;
+var BRACKET_ATTR = /\[(\w+)(?:=([^\]]*))?\]/g;
+var INLINE_TEXT = /^(?:\s*\[[^\]]*\])*\s*:\s*(.*)$/;
+function inlineText(suffix) {
+  const raw = suffix?.match(INLINE_TEXT)?.[1]?.trim();
+  if (!raw) return void 0;
+  if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw;
+}
+function appendText(node, text) {
+  const tidy2 = text?.replace(/\s+/g, " ").trim();
+  if (!tidy2) return;
+  node.text = node.text === void 0 ? tidy2 : `${node.text} ${tidy2}`;
+}
 function parseAriaSnapshot(ariaTree) {
   const lines = ariaTree.split("\n");
-  const elements = [];
-  const refs = {};
-  const resultLines = [];
-  let refCounter = 0;
-  const roleNameCounts = /* @__PURE__ */ new Map();
-  const refToKey = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const nativeRefs = [];
+  const ancestors = [];
   for (const line of lines) {
     const match = line.match(LINE_PATTERN) || line.match(QUOTED_LINE_PATTERN);
-    if (!match) {
-      resultLines.push(line);
-      continue;
-    }
-    const [, prefix, role, name, suffix] = match;
+    if (!match) continue;
+    const [, , role, name, suffix] = match;
     const roleLower = role.toLowerCase();
-    const shouldGetRef = INTERACTIVE_ROLES.has(roleLower) || CONTENT_ROLES.has(roleLower);
-    if (!shouldGetRef) {
-      resultLines.push(line);
+    const leadingSpaces = line.length - line.trimStart().length;
+    const depth = Math.floor(leadingSpaces / 2);
+    while (ancestors.length > 0 && ancestors[ancestors.length - 1].depth >= depth) {
+      ancestors.pop();
+    }
+    let keptAncestor;
+    for (let k = ancestors.length - 1; k >= 0; k--) {
+      if (ancestors[k].index !== void 0) {
+        keptAncestor = ancestors[k].index;
+        break;
+      }
+    }
+    if (!INTERACTIVE_ROLES.has(roleLower) && !CONTENT_ROLES.has(roleLower)) {
+      if (keptAncestor !== void 0) {
+        appendText(nodes[keptAncestor], name);
+        appendText(nodes[keptAncestor], inlineText(suffix));
+      }
+      ancestors.push({ depth });
       continue;
     }
-    refCounter++;
-    const ref = `e${refCounter}`;
-    const key = `${roleLower}:${name ?? ""}`;
-    const currentCount = roleNameCounts.get(key) ?? 0;
-    roleNameCounts.set(key, currentCount + 1);
-    refToKey.set(ref, key);
-    refs[ref] = { role: roleLower, name, nth: currentCount };
+    const parentIndex = keptAncestor;
+    const refMatch = suffix?.match(REF_ANNOTATION);
+    const nativeRef = refMatch ? refMatch[1] : void 0;
     const attributes = {};
-    const attrMatches = suffix?.matchAll(/\[(\w+)(?:=([^\]]*))?\]/g);
-    if (attrMatches) {
-      for (const am of attrMatches) {
+    if (suffix) {
+      for (const am of suffix.matchAll(BRACKET_ATTR)) {
+        if (am[1] === "ref") continue;
         attributes[am[1]] = am[2] ?? "true";
       }
     }
-    elements.push({ ref, role: roleLower, name: name ?? "", attributes });
-    let enhanced = `${prefix}${role}`;
-    if (name) enhanced += ` "${name}"`;
-    enhanced += ` [ref=${ref}]`;
-    if (suffix?.trim()) enhanced += suffix;
-    resultLines.push(enhanced);
-  }
-  for (const [ref, data] of Object.entries(refs)) {
-    const key = refToKey.get(ref);
-    if ((roleNameCounts.get(key) ?? 0) <= 1) {
-      delete refs[ref].nth;
-    }
+    const node = { role: roleLower };
+    if (name) node.name = name;
+    if (parentIndex !== void 0) node.parentIndex = parentIndex;
+    if (Object.keys(attributes).length > 0) node.attributes = attributes;
+    if ("disabled" in attributes) node.state = { enabled: false };
+    if (CONTENT_ROLES.has(roleLower)) appendText(node, inlineText(suffix));
+    const index = nodes.length;
+    nodes.push(node);
+    nativeRefs.push(nativeRef);
+    ancestors.push({ depth, index });
   }
-  return { tree: resultLines.join("\n"), elements, refs };
+  return { nodes, nativeRefs };
 }
 function hideAgentQaElements() {
   const doc = globalThis.document;
@@ -180,8 +217,133 @@ function restoreAgentQaElements() {
     el.removeAttribute("aria-hidden");
   });
 }
+async function captureWebScroll(page) {
+  const fallbackViewport = page.viewportSize() ?? { width: 0, height: 0 };
+  try {
+    const raw = await page.evaluate(() => {
+      const w = globalThis;
+      const docEl = w.document.documentElement;
+      return {
+        width: w.innerWidth,
+        height: w.innerHeight,
+        offsetX: w.scrollX,
+        offsetY: w.scrollY,
+        contentWidth: docEl.scrollWidth,
+        contentHeight: docEl.scrollHeight
+      };
+    });
+    if (raw && typeof raw === "object") {
+      return {
+        viewport: {
+          width: numberOr(raw.width, fallbackViewport.width),
+          height: numberOr(raw.height, fallbackViewport.height)
+        },
+        scroll: {
+          offsetX: numberOr(raw.offsetX, 0),
+          offsetY: numberOr(raw.offsetY, 0),
+          contentWidth: numberOr(raw.contentWidth, 0),
+          contentHeight: numberOr(raw.contentHeight, 0)
+        }
+      };
+    }
+  } catch {
+  }
+  return {
+    viewport: fallbackViewport,
+    scroll: { offsetX: 0, offsetY: 0, contentWidth: 0, contentHeight: 0 }
+  };
+}
+async function enrichWebNodes(page, nodes, nativeRefs) {
+  try {
+    const handles = [];
+    const targetIndices = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const ref = nativeRefs[i];
+      if (!ref) continue;
+      try {
+        const handle = await page.locator("aria-ref=" + ref).elementHandle();
+        if (handle) {
+          handles.push(handle);
+          targetIndices.push(i);
+        }
+      } catch {
+      }
+    }
+    if (handles.length === 0) return;
+    const raw = await page.evaluate((els) => {
+      const w = globalThis;
+      const active = w.document.activeElement;
+      return els.map((el) => {
+        if (!el) return null;
+        const rect = typeof el.getBoundingClientRect === "function" ? el.getBoundingClientRect() : null;
+        const style = typeof w.getComputedStyle === "function" ? w.getComputedStyle(el) : null;
+        const hidden = style ? style.visibility === "hidden" || style.display === "none" : false;
+        const hasBox = !!rect && rect.width > 0 && rect.height > 0;
+        const disabled = el.disabled === true || typeof el.hasAttribute === "function" && el.hasAttribute("disabled") || typeof el.getAttribute === "function" && el.getAttribute("aria-disabled") === "true";
+        const attr = (n) => typeof el.getAttribute === "function" ? el.getAttribute(n) : null;
+        const inputType = el.tagName === "INPUT" && typeof el.type === "string" ? el.type : "";
+        const isRange = inputType === "range";
+        const isNumber = inputType === "number";
+        return {
+          bounds: rect ? { x: rect.x, y: rect.y, width: rect.width, height: rect.height } : null,
+          enabled: !disabled,
+          focused: el === active,
+          visible: hasBox && !hidden,
+          testId: attr("data-testid"),
+          ariaLabel: attr("aria-label"),
+          placeholder: attr("placeholder"),
+          title: attr("title"),
+          valuenow: attr("aria-valuenow") ?? (isRange || isNumber ? String(el.value) : null),
+          valuemin: attr("aria-valuemin") ?? (isRange ? el.min || "0" : isNumber ? el.min || null : null),
+          valuemax: attr("aria-valuemax") ?? (isRange ? el.max || "100" : isNumber ? el.max || null : null)
+        };
+      });
+    }, handles);
+    if (!Array.isArray(raw)) return;
+    for (let k = 0; k < targetIndices.length; k++) {
+      const info = raw[k];
+      if (!info || typeof info !== "object") continue;
+      const node = nodes[targetIndices[k]];
+      const bounds = coerceBounds(info.bounds);
+      if (bounds) node.bounds = bounds;
+      const state = { ...node.state ?? {} };
+      if (typeof info.enabled === "boolean") state.enabled = info.enabled;
+      if (typeof info.focused === "boolean") state.focused = info.focused;
+      if (typeof info.visible === "boolean") state.visible = info.visible;
+      if (Object.keys(state).length > 0) node.state = state;
+      const labels = { ...node.labels ?? {} };
+      const testId = coerceString(info.testId);
+      if (testId) labels.testId = testId;
+      const ariaLabel = coerceString(info.ariaLabel);
+      if (ariaLabel) labels.ariaLabel = ariaLabel;
+      const placeholder = coerceString(info.placeholder);
+      if (placeholder) labels.placeholder = placeholder;
+      const title = coerceString(info.title);
+      if (title) labels.title = title;
+      if (Object.keys(labels).length > 0) node.labels = labels;
+      const limits = {};
+      for (const key of LIMIT_KEYS) {
+        const value = coerceString(info[key]);
+        if (value) limits[key] = value;
+      }
+      if (Object.keys(limits).length > 0) node.attributes = { ...node.attributes ?? {}, ...limits };
+    }
+  } catch {
+  }
+}
+function coerceBounds(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const v = value;
+  const x = v.x, y = v.y, width = v.width, height = v.height;
+  if (typeof x === "number" && Number.isFinite(x) && typeof y === "number" && Number.isFinite(y) && typeof width === "number" && Number.isFinite(width) && typeof height === "number" && Number.isFinite(height)) {
+    return { x, y, width, height };
+  }
+  return void 0;
+}
+function coerceString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 async function observePage(page, options) {
-  const viewport = page.viewportSize();
   const locator = options?.filterSelector ? page.locator(options.filterSelector) : page.locator(":root");
   await page.evaluate(hideAgentQaElements);
   let ariaTree;
@@ -190,141 +352,9 @@ async function observePage(page, options) {
   } finally {
     await page.evaluate(restoreAgentQaElements);
   }
-  if (!ariaTree) {
-    return {
-      tree: "(empty)",
-      elements: [],
-      url: page.url(),
-      timestamp: Date.now(),
-      metadata: {
-        coordSpace: "viewport",
-        viewportWidth: viewport?.width ?? 0,
-        viewportHeight: viewport?.height ?? 0,
-        refMap: {}
-      }
-    };
-  }
-  const { tree, elements, refs } = parseAriaSnapshot(ariaTree);
-  try {
-    const refEntries = Object.entries(refs);
-    if (refEntries.length > 0) {
-      const refArgs = refEntries.map(
-        ([ref, data]) => [ref, data.role, data.name, data.nth]
-      );
-      const result = await Promise.race([
-        page.evaluate((args) => {
-          const doc = globalThis.document;
-          const IMPLICIT_ROLES = {
-            button: "button",
-            a: "link",
-            input: "textbox",
-            select: "combobox",
-            textarea: "textbox",
-            h1: "heading",
-            h2: "heading",
-            h3: "heading",
-            h4: "heading",
-            h5: "heading",
-            h6: "heading",
-            nav: "navigation",
-            main: "main",
-            aside: "complementary",
-            footer: "contentinfo",
-            header: "banner",
-            form: "form",
-            table: "table",
-            img: "img",
-            ul: "list",
-            ol: "list",
-            li: "listitem",
-            dialog: "dialog",
-            details: "group",
-            summary: "button",
-            progress: "progressbar",
-            meter: "meter",
-            output: "status",
-            article: "article",
-            section: "region",
-            fieldset: "group",
-            legend: "legend"
-          };
-          const INPUT_TYPE_ROLES = {
-            checkbox: "checkbox",
-            radio: "radio",
-            range: "slider",
-            number: "spinbutton",
-            search: "searchbox",
-            email: "textbox",
-            tel: "textbox",
-            url: "textbox",
-            password: "textbox"
-          };
-          function getAccessibleName(el) {
-            const label = el.getAttribute("aria-label");
-            if (label) return label.trim();
-            const labelledBy = el.getAttribute("aria-labelledby");
-            if (labelledBy) {
-              const parts = labelledBy.split(/\s+/).map((id) => {
-                const ref = doc.getElementById(id);
-                return ref ? (ref.textContent || "").trim() : "";
-              }).filter(Boolean);
-              if (parts.length) return parts.join(" ");
-            }
-            const title = el.getAttribute("title");
-            if (title) return title.trim();
-            const alt = el.getAttribute("alt");
-            if (alt) return alt.trim();
-            return (el.textContent || "").trim();
-          }
-          function matchesName(elName, targetName) {
-            return elName.toLowerCase().includes(targetName.toLowerCase());
-          }
-          function getImplicitRole(el) {
-            const tag = el.tagName.toLowerCase();
-            if (tag === "input") {
-              const type = (el.getAttribute("type") || "text").toLowerCase();
-              return INPUT_TYPE_ROLES[type] || "textbox";
-            }
-            if (tag === "a" && el.hasAttribute("href")) return "link";
-            return IMPLICIT_ROLES[tag] || null;
-          }
-          const results = [];
-          for (const [ref, role, name, nth] of args) {
-            const candidates = [];
-            doc.querySelectorAll(`[role="${role}"]`).forEach((el) => candidates.push(el));
-            doc.querySelectorAll("*").forEach((el) => {
-              if (el.getAttribute("role")) return;
-              if (getImplicitRole(el) === role) candidates.push(el);
-            });
-            let matched = candidates;
-            if (name) {
-              matched = candidates.filter((el) => matchesName(getAccessibleName(el), name));
-            }
-            const target = matched[nth ?? 0];
-            if (target) {
-              const rect = target.getBoundingClientRect();
-              results.push([ref, {
-                x: Math.round(rect.x),
-                y: Math.round(rect.y),
-                width: Math.round(rect.width),
-                height: Math.round(rect.height)
-              }]);
-            } else {
-              results.push([ref, null]);
-            }
-          }
-          return results;
-        }, refArgs),
-        new Promise((resolve) => setTimeout(() => resolve(null), 3e3))
-      ]);
-      if (result) {
-        for (const [ref, box] of result) {
-          if (box) refs[ref].bounds = box;
-        }
-      }
-    }
-  } catch {
-  }
+  const timestamp = Date.now();
+  const url = page.url();
+  const { viewport: capturedViewport, scroll } = await captureWebScroll(page);
   let domContext;
   if (options?.extractDom) {
     try {
@@ -332,23 +362,44 @@ async function observePage(page, options) {
     } catch {
     }
   }
-  return {
-    tree,
-    elements,
-    url: page.url(),
-    timestamp: Date.now(),
-    metadata: {
-      coordSpace: "viewport",
-      viewportWidth: viewport?.width ?? 0,
-      viewportHeight: viewport?.height ?? 0,
-      refMap: refs,
-      ...domContext ? { domContext } : {}
-    }
-  };
+  const { nodes, nativeRefs } = ariaTree ? parseAriaSnapshot(ariaTree) : { nodes: [], nativeRefs: [] };
+  if (nodes.length > 0) {
+    await enrichWebNodes(page, nodes, nativeRefs);
+  }
+  const { state } = buildScreenState({
+    platform: "web",
+    nodes,
+    viewport: capturedViewport,
+    scroll,
+    coordSpace: "viewport",
+    timestamp,
+    url,
+    ...domContext ? { domContext } : {}
+  });
+  return state;
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 
 // src/element-resolver.ts
-var ACTIONS_WITHOUT_REF = /* @__PURE__ */ new Set(["navigate", "waitFor", "delay", "waitForUrl", "assert"]);
+import { rowTextOf } from "@vostride/agent-qa-runner";
+var ACTIONS_WITHOUT_REF = /* @__PURE__ */ new Set(["navigate", "waitFor", "delay", "waitForUrl", "assertValue"]);
+function buildRefMap(binding, nodes, nativeRefs, elements) {
+  const refs = {};
+  for (const [ref, bind] of Object.entries(binding)) {
+    const node = nodes[bind.index];
+    const nativeRef = nativeRefs[bind.index];
+    const element = elements[bind.index];
+    if (!node || nativeRef === void 0 || !element) continue;
+    const entry = { nativeRef, role: node.role, name: node.name ?? "" };
+    const rowText = rowTextOf(element, elements);
+    if (rowText !== void 0) entry.rowText = rowText;
+    if (node.bounds !== void 0) entry.bounds = node.bounds;
+    refs[ref] = entry;
+  }
+  return refs;
+}
 var ElementResolver = class {
   constructor(page, refs) {
     this.page = page;
@@ -359,16 +410,7 @@ var ElementResolver = class {
     if (!data) {
       throw new Error(`Unknown ref "${ref}". Available refs: ${Object.keys(this.refs).join(", ") || "none"}`);
     }
-    let locator;
-    if (data.name) {
-      locator = this.page.getByRole(data.role, { name: data.name, exact: true });
-    } else {
-      locator = this.page.getByRole(data.role);
-    }
-    if (data.nth !== void 0) {
-      locator = locator.nth(data.nth);
-    }
-    return locator;
+    return this.page.locator("aria-ref=" + data.nativeRef);
   }
   resolveAction(action) {
     if (ACTIONS_WITHOUT_REF.has(action.type)) {
@@ -389,6 +431,120 @@ var ElementResolver = class {
   }
 };
 
+// src/binding.ts
+import { buildScreenState as buildScreenState2, rowTextOf as rowTextOf2 } from "@vostride/agent-qa-runner";
+var BINDING_LANES = ["ref", "fromRef", "toRef"];
+var FRAME_REF = /^f\d+e/;
+var INVALID_FRAME = /invalid frame/i;
+var WHAT_CHANGED = {
+  "stale-observation": "the page holds a new document since the observation",
+  "frame-detached": "the frame that held the observed element is gone",
+  "binding-lost": "the observed element is no longer on the page",
+  "binding-changed": "the observed element now has a different role, name or row"
+};
+function hideAgentQaElements2() {
+  const doc = globalThis.document;
+  doc.querySelectorAll("[data-agent-qa-internal]").forEach((el) => {
+    el.style.display = "none";
+    el.setAttribute("aria-hidden", "true");
+  });
+}
+function restoreAgentQaElements2() {
+  const doc = globalThis.document;
+  doc.querySelectorAll("[data-agent-qa-internal]").forEach((el) => {
+    el.style.display = "";
+    el.removeAttribute("aria-hidden");
+  });
+}
+async function snapshotRoot(page, options = {}) {
+  const { timeoutMs, retryTimeoutMs } = options;
+  await page.evaluate(hideAgentQaElements2);
+  try {
+    if (timeoutMs === void 0) return await page.locator(":root").ariaSnapshot({ mode: "ai" });
+    return await page.locator(":root").ariaSnapshot({ mode: "ai", timeout: timeoutMs }).catch((error) => {
+      if (!(error instanceof Error && error.name === "TimeoutError")) throw error;
+      return page.locator(":root").ariaSnapshot({
+        mode: "ai",
+        ...retryTimeoutMs !== void 0 ? { timeout: retryTimeoutMs } : {}
+      });
+    });
+  } finally {
+    await page.evaluate(restoreAgentQaElements2);
+  }
+}
+async function captureEpoch(page) {
+  const document = await page.evaluateHandle(() => globalThis.document);
+  return { page, document };
+}
+async function disposeEpoch(epoch) {
+  try {
+    await epoch?.document.dispose();
+  } catch {
+  }
+}
+function isChildFrameRef(nativeRef) {
+  return FRAME_REF.test(nativeRef);
+}
+async function checkDocument(page, epoch) {
+  if (epoch === void 0 || epoch.page !== page) return { outcome: "stale-observation" };
+  try {
+    const same = await epoch.document.evaluate((d) => d === globalThis.document);
+    return same === true ? { outcome: "ok" } : { outcome: "stale-observation" };
+  } catch {
+    return { outcome: "stale-observation" };
+  }
+}
+async function frameDetached(page, nativeRef) {
+  if (!isChildFrameRef(nativeRef)) return false;
+  try {
+    await page.locator("aria-ref=" + nativeRef).count();
+    return false;
+  } catch (error) {
+    return error instanceof Error && INVALID_FRAME.test(error.message);
+  }
+}
+function tidy(text) {
+  return text?.replace(/\s+/g, " ").trim();
+}
+async function checkBinding(page, epoch, entry, snapshot) {
+  const document = await checkDocument(page, epoch);
+  if (document.outcome !== "ok") return document;
+  const { nodes, nativeRefs } = parseAriaSnapshot(await snapshotRoot(page, snapshot));
+  const index = nativeRefs.indexOf(entry.nativeRef);
+  if (index < 0) {
+    const detached = await frameDetached(page, entry.nativeRef);
+    return { outcome: detached ? "frame-detached" : "binding-lost" };
+  }
+  const { state } = buildScreenState2({
+    platform: "web",
+    nodes,
+    viewport: { width: 0, height: 0 },
+    scroll: { offsetX: 0, offsetY: 0, contentWidth: 0, contentHeight: 0 },
+    coordSpace: "viewport",
+    timestamp: 0
+  });
+  const current = state.elements[index];
+  if (current === void 0 || current.role !== entry.role || tidy(current.name) !== tidy(entry.name) || tidy(rowTextOf2(current, state.elements)) !== tidy(entry.rowText)) {
+    return { outcome: "binding-changed" };
+  }
+  return { outcome: "ok" };
+}
+function laneRefs(action) {
+  const refs = [];
+  for (const lane of BINDING_LANES) {
+    const ref = Reflect.get(action, lane);
+    if (typeof ref === "string") refs.push(ref);
+  }
+  return refs;
+}
+function bindingRefusal(outcome, ref) {
+  return {
+    success: false,
+    error: `${outcome}: ref ${ref} \u2014 ${WHAT_CHANGED[outcome]}; nothing was sent`,
+    metadata: { binding: { outcome, ref, inputSent: false } }
+  };
+}
+
 // src/action-validator.ts
 var ActionValidationError = class extends Error {
   suggestion;
@@ -400,8 +556,8 @@ var ActionValidationError = class extends Error {
 };
 var FILL_ROLES = /* @__PURE__ */ new Set(["textbox", "searchbox", "spinbutton", "combobox"]);
 var SELECT_ROLES = /* @__PURE__ */ new Set(["listbox", "combobox"]);
-var NO_REF_ACTIONS = /* @__PURE__ */ new Set(["scroll", "navigate", "waitFor", "delay", "waitForUrl", "assert", "pinch", "multiTap", "keyDown", "keyUp", "refresh", "navigateHistory", "readConsoleLogs", "readNetworkLogs", "readCookies", "setCookies", "readLocalStorage", "setLocalStorage", "executeScript"]);
-var ANY_ROLE_ACTIONS = /* @__PURE__ */ new Set(["click", "hover", "keypress", "paste", "doubleClick", "rightClick"]);
+var NO_REF_ACTIONS = /* @__PURE__ */ new Set(["scroll", "navigate", "waitFor", "delay", "waitForUrl", "tab", "inspect", "route", "unroute", "networkState", "storageState", "handleDialog", "uniqueValue", "assertValue", "assertAI", "extractAI", "reportValue", "setCookies", "setLocalStorage", "executeScript", "setVariable"]);
+var ANY_ROLE_ACTIONS = /* @__PURE__ */ new Set(["click", "hover", "keypress", "paste", "doubleClick", "rightClick", "focus"]);
 function validateAction(action, elementRole) {
   if (NO_REF_ACTIONS.has(action.type)) {
     return { valid: true };
@@ -525,150 +681,541 @@ async function runReadinessChecks(page) {
   }
 }
 
+// src/compound-web.ts
+import {
+  compareFillReread,
+  runUntilVisibleLoop,
+  runDirectionScroll,
+  runToEndScroll,
+  swipeSignalFromOffsets,
+  scrollerSetSwipeSignal
+} from "@vostride/agent-qa-runner";
+
 // src/scroll-helper.ts
-async function scrollWithRef(page, refData, deltaX, deltaY, scrollAxis) {
-  return page.evaluate(
-    (args) => {
-      const [role, name, nth, dx, dy, axis] = args;
-      const doc = globalThis.document;
-      const win = globalThis.window;
-      const IMPLICIT_ROLES = {
-        button: "button",
-        a: "link",
-        input: "textbox",
-        select: "combobox",
-        textarea: "textbox",
-        h1: "heading",
-        h2: "heading",
-        h3: "heading",
-        h4: "heading",
-        h5: "heading",
-        h6: "heading",
-        nav: "navigation",
-        main: "main",
-        aside: "complementary",
-        footer: "contentinfo",
-        header: "banner",
-        form: "form",
-        table: "table",
-        img: "img",
-        ul: "list",
-        ol: "list",
-        li: "listitem",
-        dialog: "dialog",
-        details: "group",
-        summary: "button",
-        progress: "progressbar",
-        meter: "meter",
-        output: "status",
-        article: "article",
-        section: "region",
-        fieldset: "group",
-        legend: "legend"
-      };
-      const INPUT_TYPE_ROLES = {
-        checkbox: "checkbox",
-        radio: "radio",
-        range: "slider",
-        number: "spinbutton",
-        search: "searchbox",
-        email: "textbox",
-        tel: "textbox",
-        url: "textbox",
-        password: "textbox"
-      };
-      function getAccessibleName(el) {
-        const label = el.getAttribute("aria-label");
-        if (label) return label.trim();
-        const labelledBy = el.getAttribute("aria-labelledby");
-        if (labelledBy) {
-          const parts = labelledBy.split(/\s+/).map((id) => {
-            const ref = doc.getElementById(id);
-            return ref ? (ref.textContent || "").trim() : "";
-          }).filter(Boolean);
-          if (parts.length) return parts.join(" ");
+var NOT_FOUND = { bounds: null, scrolledContainer: "notFound", scrolled: false };
+var EVALUATE_TIMEOUT_MS = 1e3;
+async function scrollWithRef(page, lastRefs, ref, deltaX, deltaY, scrollAxis) {
+  const nativeRef = lastRefs[ref]?.nativeRef;
+  if (nativeRef !== void 0 && isChildFrameRef(nativeRef)) return NOT_FOUND;
+  try {
+    const locator = new ElementResolver(page, lastRefs).resolve(ref);
+    if (await locator.count() === 0) return NOT_FOUND;
+    const scrolled = await locator.evaluate(
+      (target, args) => {
+        const [dx, dy, axis] = args;
+        const win = globalThis;
+        const doc = win.document;
+        const el = target;
+        const prop = axis === "horizontal" ? "scrollLeft" : "scrollTop";
+        const maxOf = (node) => axis === "horizontal" ? node.scrollWidth - node.clientWidth : node.scrollHeight - node.clientHeight;
+        const boundsOf = () => {
+          const rect = el.getBoundingClientRect();
+          return { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) };
+        };
+        const scrollable = (node) => {
+          const style = win.getComputedStyle(node);
+          const overflow = axis === "horizontal" ? style.overflowX : style.overflowY;
+          return (overflow === "auto" || overflow === "scroll" || overflow === "hidden") && maxOf(node) > 0;
+        };
+        const scroller = doc.scrollingElement;
+        const rootStyle = win.getComputedStyle(doc.documentElement);
+        const bodyPropagates = rootStyle.overflowX === "visible" && rootStyle.overflowY === "visible";
+        const isDocumentScroller = (node) => node === doc.documentElement || node === scroller || bodyPropagates && node === doc.body;
+        const parentOf = (node) => {
+          if (node.assignedSlot) return node.assignedSlot;
+          if (node.parentElement) return node.parentElement;
+          const parent = node.parentNode;
+          return parent && parent.host ? parent.host : null;
+        };
+        if (!isDocumentScroller(el)) {
+          if (scrollable(el)) {
+            const before2 = el[prop];
+            el.scrollBy(dx, dy);
+            const after2 = el[prop];
+            return { bounds: boundsOf(), scrolledContainer: "element", scrolled: before2 !== after2, offsets: { before: before2, after: after2, max: maxOf(el) } };
+          }
+          for (let parent = parentOf(el); parent && !isDocumentScroller(parent); parent = parentOf(parent)) {
+            if (!scrollable(parent)) continue;
+            const before2 = parent[prop];
+            parent.scrollBy(dx, dy);
+            const after2 = parent[prop];
+            return { bounds: boundsOf(), scrolledContainer: "ancestor", scrolled: before2 !== after2, offsets: { before: before2, after: after2, max: maxOf(parent) } };
+          }
         }
-        const title = el.getAttribute("title");
-        if (title) return title.trim();
-        const alt = el.getAttribute("alt");
-        if (alt) return alt.trim();
-        return (el.textContent || "").trim();
-      }
-      function getImplicitRole(el) {
-        const tag = el.tagName.toLowerCase();
-        if (tag === "input") {
-          const type = (el.getAttribute("type") || "text").toLowerCase();
-          return INPUT_TYPE_ROLES[type] || "textbox";
+        if (!scroller) {
+          const x = win.scrollX;
+          const y = win.scrollY;
+          win.scrollBy(dx, dy);
+          return { bounds: boundsOf(), scrolledContainer: "documentElement", scrolled: x !== win.scrollX || y !== win.scrollY };
         }
-        if (tag === "a" && el.hasAttribute("href")) return "link";
-        return IMPLICIT_ROLES[tag] || null;
-      }
-      const candidates = [];
-      doc.querySelectorAll(`[role="${role}"]`).forEach((el) => candidates.push(el));
-      doc.querySelectorAll("*").forEach((el) => {
-        if (el.getAttribute("role")) return;
-        if (getImplicitRole(el) === role) candidates.push(el);
-      });
-      let matched = candidates;
-      if (name) {
-        matched = candidates.filter(
-          (el) => getAccessibleName(el).toLowerCase().includes(name.toLowerCase())
-        );
-      }
-      const target = matched[nth];
-      if (!target) {
-        win.scrollBy(dx, dy);
-        return { bounds: null, scrolledContainer: "notFound", scrolled: true };
-      }
-      const targetStyle = win.getComputedStyle(target);
-      const targetOverflow = axis === "horizontal" ? targetStyle.overflowX : targetStyle.overflowY;
-      const targetScrollable = targetOverflow === "auto" || targetOverflow === "scroll" || targetOverflow === "hidden";
-      const targetHasContent = axis === "horizontal" ? target.scrollWidth > target.clientWidth : target.scrollHeight > target.clientHeight;
-      if (targetScrollable && targetHasContent) {
-        const prop2 = axis === "horizontal" ? "scrollLeft" : "scrollTop";
-        const before2 = target[prop2];
-        target.scrollBy(dx, dy);
-        const after2 = target[prop2];
-        const rect2 = target.getBoundingClientRect();
+        const before = scroller[prop];
+        scroller.scrollBy(dx, dy);
+        const after = scroller[prop];
+        const max = maxOf(scroller);
         return {
-          bounds: { x: Math.round(rect2.x), y: Math.round(rect2.y), width: Math.round(rect2.width), height: Math.round(rect2.height) },
-          scrolledContainer: "element",
-          scrolled: before2 !== after2
+          bounds: boundsOf(),
+          scrolledContainer: "documentElement",
+          scrolled: before !== after,
+          ...max > 0 ? { offsets: { before, after, max } } : {}
         };
-      }
-      let parent = target.parentElement;
-      while (parent && parent !== doc.documentElement) {
-        const style = win.getComputedStyle(parent);
-        const overflow = axis === "horizontal" ? style.overflowX : style.overflowY;
-        const isScrollable = overflow === "auto" || overflow === "scroll" || overflow === "hidden";
-        const hasContent = axis === "horizontal" ? parent.scrollWidth > parent.clientWidth : parent.scrollHeight > parent.clientHeight;
-        if (isScrollable && hasContent) {
-          const prop2 = axis === "horizontal" ? "scrollLeft" : "scrollTop";
-          const before2 = parent[prop2];
-          parent.scrollBy(dx, dy);
-          const after2 = parent[prop2];
-          const rect2 = target.getBoundingClientRect();
-          return {
-            bounds: { x: Math.round(rect2.x), y: Math.round(rect2.y), width: Math.round(rect2.width), height: Math.round(rect2.height) },
-            scrolledContainer: "ancestor",
-            scrolled: before2 !== after2
-          };
+      },
+      [deltaX, deltaY, scrollAxis],
+      { timeout: EVALUATE_TIMEOUT_MS }
+    );
+    return scrolled && typeof scrolled === "object" ? scrolled : NOT_FOUND;
+  } catch {
+    return NOT_FOUND;
+  }
+}
+
+// src/compound-web.ts
+async function safeInputValue(locator) {
+  try {
+    return await locator.inputValue();
+  } catch {
+    try {
+      const value = await locator.evaluate((el) => {
+        const node = el;
+        return node.value ?? node.textContent;
+      });
+      return typeof value === "string" ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+}
+async function runWebFillCompound(locator, boundingBox, action) {
+  const isAppend = action.clearMode === "append";
+  const prior = isAppend ? await safeInputValue(locator) ?? "" : "";
+  const secure = await locator.getAttribute("type") === "password";
+  if (isAppend) {
+    await locator.click();
+    await locator.press("End");
+    await locator.pressSequentially(action.text);
+  } else {
+    await locator.fill(action.text);
+  }
+  const expected = isAppend ? prior + action.text : action.text;
+  const actual = await safeInputValue(locator);
+  const box = boundingBox ? { boundingBox } : {};
+  if (actual === void 0) {
+    return { success: true, ...box, metadata: { fillVerdict: { verb: "fill", verdict: "unverified" } } };
+  }
+  const verdict = compareFillReread({ expected, actual, secure });
+  if (verdict.ok && action.submit) {
+    await locator.press("Enter");
+  }
+  const metadata = {
+    ...verdict.meta ? { fillReread: verdict.meta } : {},
+    fillVerdict: {
+      verb: "fill",
+      verdict: verdict.verdict,
+      ...verdict.secure ? { secure: true } : {}
+    }
+  };
+  return verdict.ok ? { success: true, ...box, metadata } : { success: false, error: verdict.selfCorrectingError, ...box, metadata };
+}
+function deltaFor(direction, magnitude) {
+  switch (direction) {
+    case "down":
+      return { dx: 0, dy: magnitude, axis: "vertical" };
+    case "up":
+      return { dx: 0, dy: -magnitude, axis: "vertical" };
+    case "right":
+      return { dx: magnitude, dy: 0, axis: "horizontal" };
+    case "left":
+      return { dx: -magnitude, dy: 0, axis: "horizontal" };
+  }
+}
+async function settle(page) {
+  await page.evaluate(`new Promise(resolve => {
+    const t = setTimeout(() => resolve('timeout'), 500);
+    requestAnimationFrame(() => requestAnimationFrame(() => {
+      clearTimeout(t);
+      resolve('raf');
+    }));
+  })`);
+}
+function snapshotScrollers(axis) {
+  const g = globalThis;
+  const doc = g.document;
+  const root = doc.scrollingElement ?? doc.documentElement;
+  const read = (el) => ({
+    x: el.scrollLeft,
+    y: el.scrollTop,
+    maxX: el.scrollWidth - el.clientWidth,
+    maxY: el.scrollHeight - el.clientHeight
+  });
+  const scrolls = (value) => value === "auto" || value === "scroll" || value === "overlay";
+  const rootStyle = g.getComputedStyle(doc.documentElement);
+  const bodyPropagates = rootStyle.overflowX === "visible" && rootStyle.overflowY === "visible";
+  const offsets = /* @__PURE__ */ new Map();
+  offsets.set(root, read(root));
+  const all = doc.querySelectorAll("*");
+  for (let i = 0; i < all.length; i += 1) {
+    const el = all[i];
+    if (el === root || el === doc.documentElement) continue;
+    if (el === doc.body && bodyPropagates) continue;
+    const o = read(el);
+    if (!((axis === "vertical" ? o.maxY : o.maxX) > 0)) continue;
+    const style = g.getComputedStyle(el);
+    if (!scrolls(axis === "vertical" ? style.overflowY : style.overflowX)) continue;
+    offsets.set(el, o);
+  }
+  const state = {
+    offsets,
+    target: null,
+    listener: () => void 0
+  };
+  state.listener = (event) => {
+    state.target = event.target;
+  };
+  g.addEventListener("wheel", state.listener, { capture: true, once: true, passive: true });
+  return state;
+}
+function readPointerChain(state) {
+  const g = globalThis;
+  const s = state;
+  if (!s.target) {
+    g.removeEventListener("wheel", s.listener, { capture: true });
+    return void 0;
+  }
+  const root = g.document.scrollingElement ?? g.document.documentElement;
+  const chain = [];
+  for (let el = s.target; el; el = el.parentElement) {
+    if (s.offsets.has(el) && !chain.includes(el)) chain.push(el);
+  }
+  if (!chain.includes(root)) chain.push(root);
+  return {
+    before: chain.map((el) => s.offsets.get(el)),
+    after: chain.map((el) => ({
+      x: el.scrollLeft,
+      y: el.scrollTop,
+      maxX: el.scrollWidth - el.clientWidth,
+      maxY: el.scrollHeight - el.clientHeight
+    }))
+  };
+}
+async function wheelPointerChain(page, dx, dy, axis) {
+  let handle;
+  try {
+    handle = await page.evaluateHandle(snapshotScrollers, axis);
+  } catch {
+    handle = void 0;
+  }
+  await page.mouse.wheel(dx, dy);
+  await settle(page);
+  if (!handle) return void 0;
+  try {
+    const chain = await handle.evaluate(readPointerChain);
+    if (!chain || typeof chain !== "object" || !Array.isArray(chain.before) || !Array.isArray(chain.after)) {
+      return void 0;
+    }
+    return { before: chain.before, after: chain.after };
+  } catch {
+    return void 0;
+  } finally {
+    await handle.dispose().catch(() => void 0);
+  }
+}
+var FRAME_PROBE_TIMEOUT_MS = 1e3;
+function judgeCandidates(elements) {
+  const g = globalThis;
+  const doc = g.document;
+  const root = doc.documentElement;
+  const rootStyle = g.getComputedStyle(root);
+  const bodyPropagates = rootStyle.overflowX === "visible" && rootStyle.overflowY === "visible";
+  const parentOf = (node) => node.assignedSlot ?? node.parentElement ?? node.parentNode?.host ?? null;
+  const clips = (node) => {
+    const style = g.getComputedStyle(node);
+    return style.overflowX !== "visible" || style.overflowY !== "visible";
+  };
+  const escapes = (node) => {
+    const position = g.getComputedStyle(node).position;
+    return position === "fixed" || position === "absolute";
+  };
+  const contentRects = (node) => {
+    const range = doc.createRange();
+    range.selectNodeContents(node);
+    return Array.from(range.getClientRects());
+  };
+  const replaced = /^(IMG|VIDEO|CANVAS|IFRAME|EMBED|OBJECT|SVG|INPUT|TEXTAREA|SELECT)$/;
+  const unpainted = (s) => s.backgroundImage === "none" && /^(transparent|rgba\(.*,\s*0\))$/.test(s.backgroundColor);
+  const emptyPseudo = (p) => p.content === "none" || p.content === "normal" || p.content === '""' && unpainted(p);
+  const transparent = (node, x, y) => {
+    const s = g.getComputedStyle(node);
+    if (s.opacity === "0") return true;
+    if (node.namespaceURI !== "http://www.w3.org/1999/xhtml") return false;
+    if (replaced.test(node.tagName)) return false;
+    if (node.shadowRoot || node.tagName.includes("-")) return false;
+    if (!unpainted(s) || s.backdropFilter !== "none") return false;
+    if (!emptyPseudo(g.getComputedStyle(node, "::before"))) return false;
+    if (!emptyPseudo(g.getComputedStyle(node, "::after"))) return false;
+    return !contentRects(node).some(
+      (t) => t.left <= x && x <= t.right && t.top <= y && y <= t.bottom
+    );
+  };
+  const judge = (el) => {
+    const style = g.getComputedStyle(el);
+    if (style.visibility !== "visible") return { state: "hidden" };
+    for (let n = el; n; n = parentOf(n)) {
+      if (g.getComputedStyle(n).opacity === "0") return { state: "hidden" };
+    }
+    let r = el.getBoundingClientRect();
+    const byText = style.display === "contents" || r.width === 0 || r.height === 0;
+    if (byText) {
+      const clipped = clips(el) || style.clip !== "auto" || style.clipPath !== "none";
+      if (style.display !== "contents" && clipped) return { state: "unknown" };
+      const rects = contentRects(el).filter((t) => t.width > 0 && t.height > 0);
+      if (rects.length === 0) return { state: "unknown" };
+      r = {
+        left: Math.min(...rects.map((t) => t.left)),
+        top: Math.min(...rects.map((t) => t.top)),
+        right: Math.max(...rects.map((t) => t.right)),
+        bottom: Math.max(...rects.map((t) => t.bottom))
+      };
+    } else if (r.width < 2 || r.height < 2) {
+      return { state: "hidden" };
+    }
+    let left = Math.max(r.left, 0);
+    let top = Math.max(r.top, 0);
+    let right = Math.min(r.right, g.innerWidth);
+    let bottom = Math.min(r.bottom, g.innerHeight);
+    if (!(right > left && bottom > top)) return { state: "hidden" };
+    let positioned = escapes(el);
+    for (let a = parentOf(el); a && a !== root; a = parentOf(a)) {
+      if (!(a === doc.body && bodyPropagates) && !positioned && clips(a)) {
+        const b = a.getBoundingClientRect();
+        const cl = b.left + a.clientLeft;
+        const ct = b.top + a.clientTop;
+        left = Math.max(left, cl);
+        top = Math.max(top, ct);
+        right = Math.min(right, cl + a.clientWidth);
+        bottom = Math.min(bottom, ct + a.clientHeight);
+        if (!(right > left && bottom > top)) return { state: "unknown" };
+      }
+      if (escapes(a)) positioned = true;
+    }
+    if (right - left < 2 || bottom - top < 2) return { state: "unknown" };
+    const x = (left + right) / 2;
+    const y = (top + bottom) / 2;
+    const seen = { state: "visible", rect: { left, top, right, bottom } };
+    for (const hit of el.getRootNode().elementsFromPoint(x, y)) {
+      if (hit === el || el.contains(hit)) return seen;
+      if (style.pointerEvents === "none" || byText) {
+        for (let a = parentOf(el); a; a = parentOf(a)) {
+          if (a === hit) return seen;
         }
-        parent = parent.parentElement;
       }
-      const prop = axis === "horizontal" ? "scrollLeft" : "scrollTop";
-      const before = doc.documentElement[prop];
-      doc.documentElement.scrollBy(dx, dy);
-      const after = doc.documentElement[prop];
-      const rect = target.getBoundingClientRect();
-      return {
-        bounds: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
-        scrolledContainer: "documentElement",
-        scrolled: before !== after
-      };
+      if (!transparent(hit, x, y)) return { state: "unknown" };
+    }
+    return { state: "unknown" };
+  };
+  return elements.map(judge);
+}
+function projectThroughFrame(frameElement, box) {
+  const g = globalThis;
+  const doc = g.document;
+  const root = doc.documentElement;
+  const el = frameElement;
+  const rootStyle = g.getComputedStyle(root);
+  const bodyPropagates = rootStyle.overflowX === "visible" && rootStyle.overflowY === "visible";
+  const parentOf = (node) => node.assignedSlot ?? node.parentElement ?? node.parentNode?.host ?? null;
+  const clips = (node) => {
+    const style2 = g.getComputedStyle(node);
+    return style2.overflowX !== "visible" || style2.overflowY !== "visible";
+  };
+  if (g.getComputedStyle(el).visibility !== "visible") return null;
+  for (let n = el; n; n = parentOf(n)) {
+    if (g.getComputedStyle(n).opacity === "0") return null;
+  }
+  for (let n = el; n; n = parentOf(n)) {
+    const style2 = g.getComputedStyle(n);
+    if (style2.transform !== "none") return null;
+    const zoom = Number.parseFloat(style2.zoom);
+    if (Number.isFinite(zoom) && zoom !== 1) return null;
+  }
+  const style = g.getComputedStyle(el);
+  const padLeft = Number.parseFloat(style.paddingLeft) || 0;
+  const padTop = Number.parseFloat(style.paddingTop) || 0;
+  const padRight = Number.parseFloat(style.paddingRight) || 0;
+  const padBottom = Number.parseFloat(style.paddingBottom) || 0;
+  const r = el.getBoundingClientRect();
+  const ox = r.left + el.clientLeft + padLeft;
+  const oy = r.top + el.clientTop + padTop;
+  let left = Math.max(box.left + ox, ox, 0);
+  let top = Math.max(box.top + oy, oy, 0);
+  let right = Math.min(box.right + ox, ox + el.clientWidth - padLeft - padRight, g.innerWidth);
+  let bottom = Math.min(box.bottom + oy, oy + el.clientHeight - padTop - padBottom, g.innerHeight);
+  if (!(right > left && bottom > top)) return null;
+  for (let a = parentOf(el); a && a !== root; a = parentOf(a)) {
+    if (a === doc.body && bodyPropagates) continue;
+    if (!clips(a)) continue;
+    const b = a.getBoundingClientRect();
+    const cl = b.left + a.clientLeft;
+    const ct = b.top + a.clientTop;
+    left = Math.max(left, cl);
+    top = Math.max(top, ct);
+    right = Math.min(right, cl + a.clientWidth);
+    bottom = Math.min(bottom, ct + a.clientHeight);
+    if (!(right > left && bottom > top)) return null;
+  }
+  const hit = el.getRootNode().elementFromPoint((left + right) / 2, (top + bottom) / 2);
+  if (hit !== el) return null;
+  return { left, top, right, bottom };
+}
+function candidatesIn(scope, target) {
+  return scope.getByText(target).or(scope.getByLabel(target)).or(scope.getByAltText(target)).or(scope.getByTitle(target));
+}
+async function judgeIn(scope, target) {
+  const judged = await candidatesIn(scope, target).evaluateAll(judgeCandidates);
+  if (!Array.isArray(judged)) throw new Error("probe answered no list");
+  return judged.map((candidate) => {
+    const state = candidate?.state;
+    if (state === "visible" && candidate?.rect) return { state, rect: candidate.rect };
+    return { state: state === "hidden" ? "hidden" : "unknown" };
+  });
+}
+function combine(states) {
+  if (states.includes("visible")) return "visible";
+  if (states.includes("unknown")) return "unknown";
+  return "hidden";
+}
+async function projectToMainFrame(frame, box) {
+  let current = frame;
+  let projected = box;
+  for (let parent = current.parentFrame(); parent; parent = current.parentFrame()) {
+    const handle = await current.frameElement();
+    try {
+      const next = await handle.evaluate(projectThroughFrame, projected);
+      if (!next || typeof next !== "object") return false;
+      projected = next;
+    } finally {
+      await handle.dispose().catch(() => void 0);
+    }
+    current = parent;
+  }
+  return true;
+}
+async function probeChildFrame(frame, target) {
+  try {
+    const states = [];
+    for (const candidate of await judgeIn(frame, target)) {
+      if (candidate.state === "visible" && candidate.rect && await projectToMainFrame(frame, candidate.rect)) {
+        return "visible";
+      }
+      states.push("unknown");
+    }
+    return combine(states);
+  } catch {
+    return "unknown";
+  }
+}
+async function probeChildFrameBounded(frame, target, pending) {
+  if (frame.url() === "" || pending.has(frame)) return "unknown";
+  const liveness = frame.evaluate("1");
+  let timer;
+  const bound = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve("timeout");
+    }, FRAME_PROBE_TIMEOUT_MS);
+  });
+  let answer;
+  try {
+    answer = await Promise.race([liveness.then(() => "alive"), bound]);
+  } catch {
+    return "unknown";
+  } finally {
+    clearTimeout(timer);
+  }
+  if (answer === "alive") return await probeChildFrame(frame, target);
+  pending.set(frame, liveness);
+  const release = () => {
+    if (pending.get(frame) === liveness) pending.delete(frame);
+  };
+  liveness.then(release, release);
+  return "unknown";
+}
+async function probeOnScreen(page, target, pending) {
+  let states;
+  try {
+    states = (await judgeIn(page, target)).map((candidate) => candidate.state);
+  } catch {
+    return "unknown";
+  }
+  if (combine(states) === "visible") return "visible";
+  try {
+    const main = page.mainFrame();
+    const children = page.frames().filter((frame) => frame !== main && !frame.isDetached());
+    states.push(...await Promise.all(children.map((frame) => probeChildFrameBounded(frame, target, pending))));
+  } catch {
+    states.push("unknown");
+  }
+  return combine(states);
+}
+function buildScrollPrimitives(page, lastRefs, magnitude) {
+  const pending = /* @__PURE__ */ new WeakMap();
+  return {
+    async swipeOnce(direction, ref) {
+      const { dx, dy, axis } = deltaFor(direction, magnitude);
+      if (ref) {
+        const scrolled = await scrollWithRef(page, lastRefs, ref, dx, dy, axis);
+        if (scrolled.scrolledContainer !== "notFound") await settle(page);
+        return swipeSignalFromOffsets(direction, scrolled.offsets);
+      }
+      const chain = await wheelPointerChain(page, dx, dy, axis);
+      return scrollerSetSwipeSignal(direction, chain?.before, chain?.after);
     },
-    [refData.role, refData.name, refData.nth ?? 0, deltaX, deltaY, scrollAxis]
-  );
+    async nativeSearchScroll(target) {
+      try {
+        await page.getByText(target).first().scrollIntoViewIfNeeded();
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async readInterimTree() {
+      const tree = await page.locator(":root").ariaSnapshot({ mode: "ai" });
+      return parseAriaSnapshot(tree).nodes;
+    },
+    async probeTargetVisible(target) {
+      return probeOnScreen(page, target, pending);
+    }
+  };
+}
+async function runWebScrollCompound(page, lastRefs, action) {
+  const viewport = page.viewportSize() ?? { width: 1280, height: 720 };
+  const horizontal = action.direction === "left" || action.direction === "right";
+  if (action.mode === "untilVisible") {
+    const magnitude2 = horizontal ? viewport.width : viewport.height;
+    const primitives2 = buildScrollPrimitives(page, lastRefs, magnitude2);
+    const { meta: meta2 } = await runUntilVisibleLoop(primitives2, {
+      target: action.text,
+      direction: action.direction,
+      maxSwipes: action.maxSwipes,
+      retryOpposite: action.retryOpposite,
+      ...action.ref ? { ref: action.ref } : {}
+    });
+    return { success: true, metadata: { scrollUntilVisible: meta2 } };
+  }
+  const factor = action.amount === "halfPage" ? 0.5 : 1;
+  const magnitude = Math.round((horizontal ? viewport.width : viewport.height) * factor);
+  const primitives = buildScrollPrimitives(page, lastRefs, magnitude);
+  if (action.amount === "toEnd") {
+    const { meta: meta2 } = await runToEndScroll(primitives, action.direction, action.ref);
+    return { success: true, metadata: { scrollUntilVisible: meta2 } };
+  }
+  const { meta } = await runDirectionScroll(primitives, {
+    direction: action.direction,
+    ...action.ref ? { ref: action.ref } : {}
+  });
+  return { success: true, metadata: { scrollUntilVisible: meta } };
+}
+function webOpenAppError() {
+  return {
+    success: false,
+    error: "openApp is not executable on web \u2014 use navigate(url) with the target app's web address instead."
+  };
 }
 
 // src/browser-install-error.ts
@@ -693,29 +1240,856 @@ function formatMissingBrowserError(browserName) {
   ].join("\n");
 }
 
-// src/adapter.ts
-function clickDelayOption(clickDelay) {
-  return clickDelay !== void 0 && clickDelay > 0 ? { delay: clickDelay } : {};
+// src/recording.ts
+import { randomUUID } from "crypto";
+import { mkdir, rm } from "fs/promises";
+import { join } from "path";
+var RECORDING_DEFAULT_SIZE = { width: 1280, height: 720 };
+function jpegSize(bytes) {
+  if (bytes[0] !== 255 || bytes[1] !== 216) return void 0;
+  for (let i = 2; i + 8 < bytes.length; ) {
+    if (bytes[i++] !== 255) return void 0;
+    const marker = bytes[i++];
+    const length = bytes.readUInt16BE(i);
+    if (length < 2 || i + length > bytes.length) return void 0;
+    if ([192, 193, 194].includes(marker)) {
+      return { height: bytes.readUInt16BE(i + 3), width: bytes.readUInt16BE(i + 5) };
+    }
+    i += length;
+  }
+  return void 0;
 }
-var WebPlatformAdapter = class {
-  platform = "web";
-  browser = null;
-  context = null;
-  page = null;
+function createScreencastRecording(getPage, config, getPageRevision) {
+  let active;
+  let recovery;
+  let busy = false;
+  let firstFrameEpoch;
+  let scene;
+  let sceneRevision = 0;
+  let bracket;
+  async function recover() {
+    if (!recovery) return;
+    await recovery.page.screencast.stop();
+    await rm(recovery.stagingPath, { force: true });
+    recovery = void 0;
+  }
+  return {
+    async start() {
+      if (busy || active) throw new Error("Recording already started");
+      busy = true;
+      try {
+        await recover();
+        const page = getPage();
+        if (!page) throw new Error("Recording requires an initialized page");
+        const stagingPath = join(config.videoDir, `${randomUUID()}.webm`);
+        const size = config.videoSize ?? page.viewportSize() ?? RECORDING_DEFAULT_SIZE;
+        firstFrameEpoch = void 0;
+        scene = void 0;
+        sceneRevision++;
+        recovery = { page, stagingPath };
+        try {
+          await mkdir(config.videoDir, { recursive: true });
+          await page.screencast.start({
+            path: stagingPath,
+            size,
+            onFrame: async (frame) => {
+              firstFrameEpoch ??= frame.timestamp;
+              const pixels = jpegSize(frame.data);
+              const next = pixels?.width === size.width && pixels.height === size.height && frame.viewportWidth === size.width && frame.viewportHeight === size.height ? { width: size.width, height: size.height } : void 0;
+              if (next?.width !== scene?.width || next?.height !== scene?.height) sceneRevision++;
+              scene = next;
+            }
+          });
+        } catch (error) {
+          try {
+            await recover();
+          } catch {
+          }
+          throw error;
+        }
+        active = recovery;
+        recovery = void 0;
+        return { zeroMs: performance.now() };
+      } finally {
+        busy = false;
+      }
+    },
+    beginAnnotation() {
+      const recording = active;
+      const before = scene;
+      const epoch = firstFrameEpoch;
+      const revision = sceneRevision;
+      if (!getPageRevision) return void 0;
+      const pageRevision = getPageRevision();
+      if (!recording || !before || epoch === void 0 || getPage() !== recording.page) return void 0;
+      const viewport = recording.page.viewportSize();
+      if (viewport?.width !== before.width || viewport.height !== before.height) return void 0;
+      const startMs = performance.timeOrigin + performance.now() - epoch;
+      const settle2 = () => {
+        const after = recording.page.viewportSize();
+        const endMs = performance.timeOrigin + performance.now() - epoch;
+        if (active !== recording || getPage() !== recording.page || revision !== sceneRevision || pageRevision !== getPageRevision() || after?.width !== before.width || after.height !== before.height || !Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs < 0 || endMs <= startMs) return void 0;
+        return { startMs, endMs, scene: "recorded-page", transform: "identity", ...before };
+      };
+      let ended;
+      bracket = { end() {
+        ended = { witness: settle2() };
+      } };
+      return () => ended ? ended.witness : settle2();
+    },
+    endAction() {
+      bracket?.end();
+    },
+    async stop() {
+      if (busy) throw new Error("Recording operation already in progress");
+      busy = true;
+      try {
+        const recording = active;
+        if (!recording) {
+          await recover();
+          return void 0;
+        }
+        active = void 0;
+        try {
+          await recording.page.screencast.stop();
+        } catch (error) {
+          recovery = recording;
+          try {
+            await recover();
+          } catch {
+          }
+          throw error;
+        }
+        return { stagingPath: recording.stagingPath, contentType: "video/webm" };
+      } finally {
+        busy = false;
+      }
+    }
+  };
+}
+
+// src/operation-capture.ts
+import { createHash } from "crypto";
+import { extname } from "path";
+import { CLIPBOARD_TEXT_LIMIT } from "@vostride/agent-qa-runner";
+var DOWNLOAD_START_GRACE_MS = 500;
+var NAVIGATION_SETTLE_MS = 250;
+var DOWNLOAD_COMPLETION_CAP_MS = 12e4;
+var NAVIGATION_WINDOW_CAP_MS = 5e3;
+var DOWNLOAD_HOLD_FILE_CAP = 1024 * 1024;
+var DOWNLOAD_HOLD_TOTAL_CAP = 8 * 1024 * 1024;
+var DOWNLOAD_ACTIVATION_ACTIONS = /* @__PURE__ */ new Set([
+  "click",
+  "doubleClick",
+  "rightClick",
+  "keypress",
+  "select",
+  "navigate",
+  "executeScript",
+  "handleDialog",
+  "fileUpload",
+  "tab"
+]);
+function isDownloadActivation(action) {
+  if (action.type === "fill") return action.submit === true;
+  if (action.type === "tab") return action.action === "new";
+  return DOWNLOAD_ACTIVATION_ACTIONS.has(action.type);
+}
+var UNFINISHED = /* @__PURE__ */ Symbol("unfinished");
+var CLIPBOARD_BINDING = "__agentQaAppClipboardWrite";
+var CLIPBOARD_EXCLUDED_ACTIONS = /* @__PURE__ */ new Set(["copy", "paste"]);
+var CLIPBOARD_SOURCES = /* @__PURE__ */ new Set(["writeText", "write", "copy-event"]);
+var READ_BACK_TIMEOUT_MS = 2e3;
+var CLIPBOARD_CLAIMS_PER_ACTION = 8;
+var CLIPBOARD_READBACK_ORIGIN = "https://agent-qa-readback.invalid";
+var PROBE_MATCHED = 1;
+var PROBE_DIFFERENT = 0;
+function installProbeReadback() {
+  const scope = globalThis;
+  let preImage;
+  let status = "none";
+  const read = async () => {
+    try {
+      const text = await scope.navigator.clipboard.readText();
+      return typeof text === "string" ? text : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  Object.defineProperty(globalThis, "__agentQaReadback", {
+    value: Object.freeze({
+      get status() {
+        return status;
+      },
+      async snapshot() {
+        preImage = void 0;
+        status = "none";
+        const text = await read();
+        if (text === void 0) {
+          status = "unreadable";
+        } else {
+          preImage = text;
+          status = "read";
+        }
+        return status;
+      },
+      async compare(finalText) {
+        if (status !== "read") return -2;
+        const now = await read();
+        if (now === void 0) return -2;
+        if (now === preImage) return -3;
+        return now === finalText ? 1 : 0;
+      }
+    })
+  });
+}
+var CLIPBOARD_HOOK = `(() => {
+  const binding = ${JSON.stringify(CLIPBOARD_BINDING)};
+  const report = (via, text) => {
+    const send = window[binding];
+    if (typeof send !== 'function' || typeof text !== 'string' || text.length === 0) return;
+    try { Promise.resolve(send({ via, text })).catch(() => {}); } catch {}
+  };
+  // 2026-10-08 (436-14): a write is reported only once the browser accepted it; the app still
+  // gets the original promise, rejections included.
+  const proto = typeof Clipboard === 'function' ? Clipboard.prototype : undefined;
+  if (proto && typeof proto.writeText === 'function') {
+    const writeText = proto.writeText;
+    proto.writeText = function (data) {
+      let text;
+      try { text = String(data); } catch {}
+      const result = writeText.apply(this, arguments);
+      try { Promise.resolve(result).then(() => report('writeText', text), () => {}); } catch {}
+      return result;
+    };
+  }
+  if (proto && typeof proto.write === 'function') {
+    const write = proto.write;
+    proto.write = function (items) {
+      const texts = [];
+      try {
+        for (const item of Array.from(items || [])) {
+          if (!item || !Array.from(item.types || []).includes('text/plain')) continue;
+          texts.push(item.getType('text/plain').then((blob) => blob.text()).catch(() => undefined));
+        }
+      } catch {}
+      const result = write.apply(this, arguments);
+      try {
+        Promise.resolve(result).then(
+          () => Promise.all(texts).then((all) => { for (const text of all) report('write', text); }),
+          () => {},
+        );
+      } catch {}
+      return result;
+    };
+  }
+  // A copy event is tracked from window's capture phase, which runs before any app handler can
+  // stop propagation, and settled once dispatch is over: a prevented copy writes what the app
+  // set (seen through setData), an unprevented one writes the selection taken at dispatch.
+  let pending = null;
+  const selected = (event) => {
+    for (const el of [event.target, document.activeElement]) {
+      if (!el || (el.tagName !== 'TEXTAREA' && el.tagName !== 'INPUT')) continue;
+      try {
+        const start = el.selectionStart, end = el.selectionEnd;
+        if (typeof start === 'number' && typeof end === 'number' && end > start) return el.value.slice(start, end);
+      } catch {}
+    }
+    const selection = document.getSelection();
+    return selection ? selection.toString() : '';
+  };
+  const settle = () => {
+    const copy = pending;
+    pending = null;
+    if (!copy) return;
+    if (!copy.event.defaultPrevented) return report('copy-event', copy.selection);
+    if (copy.set !== undefined) return report('copy-event', copy.set);
+    try { report('copy-event', copy.event.clipboardData ? copy.event.clipboardData.getData('text/plain') : ''); } catch {}
+  };
+  if (typeof DataTransfer === 'function' && typeof DataTransfer.prototype.setData === 'function') {
+    const setData = DataTransfer.prototype.setData;
+    DataTransfer.prototype.setData = function (format, data) {
+      if (pending && this === pending.event.clipboardData && /^text(\\/plain)?$/i.test(String(format))) pending.set = String(data);
+      return setData.apply(this, arguments);
+    };
+  }
+  window.addEventListener('copy', (event) => {
+    settle();
+    pending = { event, selection: selected(event), set: undefined };
+    setTimeout(settle, 0);
+  }, true);
+})();`;
+var PLAYWRIGHT_DEBUG_ENV = ["PWDEBUG", "npm_config_pwdebug", "npm_package_config_pwdebug"];
+var DEBUG_OFF = /* @__PURE__ */ new Set(["", "0", "false"]);
+function isHeadlessLaunch(launch, env) {
+  if (launch.headless !== true || launch.channel !== void 0) return false;
+  return PLAYWRIGHT_DEBUG_ENV.every((name) => env[name] === void 0 || DEBUG_OFF.has(env[name]));
+}
+var OperationCapture = class {
+  completionCapMs;
+  startGraceMs;
+  attachedPages = /* @__PURE__ */ new WeakSet();
+  downloads = [];
+  /** Downloads that started while no start window was open, kept for the next action. */
+  held = [];
+  /** Completed downloads' bytes by sha256, oldest first; memory only (439 D-04). */
+  heldBytes = /* @__PURE__ */ new Map();
+  heldByteTotal = 0;
+  pendingNavigations = /* @__PURE__ */ new Map();
+  clipboardWrites = [];
+  armed = false;
+  startWindow = false;
+  navigationWindow = false;
+  navigationSettledAt = 0;
+  navigationSettledMain = false;
+  actingPage;
+  clipboardArmed = false;
+  activation = false;
+  boundAt = 0;
+  abortSignal;
+  notify = null;
+  appContext = null;
+  probe = null;
+  probeContext = null;
+  probeGeneration = 0;
+  readsClipboard;
+  /** The probe generation holding this action's pre-image; -1 when none was read. */
+  preImageGeneration = -1;
+  /** A probe generation whose read did not settle; skipped until resetProbe() replaces it. */
+  unreadableGeneration = -1;
+  constructor(options = {}) {
+    this.completionCapMs = options.completionCapMs ?? DOWNLOAD_COMPLETION_CAP_MS;
+    this.startGraceMs = options.startGraceMs ?? DOWNLOAD_START_GRACE_MS;
+    this.readsClipboard = options.headless === true;
+  }
+  async attach(context) {
+    this.appContext = context;
+    for (const page of context.pages()) this.attachPage(page);
+    context.on("page", (page) => this.attachPage(page));
+    context.on("request", (request) => this.onRequest(request));
+    context.on("response", (response) => {
+      this.settleNavigation(response.request());
+    });
+    context.on("requestfailed", (request) => {
+      this.settleNavigation(request);
+    });
+    await context.exposeBinding(CLIPBOARD_BINDING, (source, payload) => {
+      this.onClipboardWrite(source.frame, payload);
+    });
+    await context.addInitScript(CLIPBOARD_HOOK);
+  }
+  async arm(action, options = {}, actingPage) {
+    const carried = [...this.downloads.map((entry) => entry.download), ...this.held];
+    this.held = [];
+    this.downloads = carried.map((download) => ({ download, late: true }));
+    this.clipboardWrites = [];
+    this.armed = true;
+    this.startWindow = true;
+    this.clipboardArmed = false;
+    this.activation = isDownloadActivation(action);
+    this.navigationWindow = this.activation;
+    this.navigationSettledAt = 0;
+    this.navigationSettledMain = false;
+    this.actingPage = actingPage;
+    this.pendingNavigations.clear();
+    const remaining = options.remainingStepMs;
+    this.boundAt = Date.now() + (typeof remaining === "number" && Number.isFinite(remaining) ? Math.max(0, remaining) : this.completionCapMs);
+    this.abortSignal = options.abortSignal;
+    this.preImageGeneration = -1;
+    const clipboardAction = !CLIPBOARD_EXCLUDED_ACTIONS.has(action.type);
+    if (this.readsClipboard && clipboardAction && this.timeLeft() > 0) await this.takePreImage();
+    this.clipboardArmed = this.armed && clipboardAction;
+  }
+  timeLeft() {
+    return this.abortSignal?.aborted ? 0 : this.boundAt - Date.now();
+  }
+  // Calls `fire` once when the action's abort signal fires; the returned function removes it.
+  onAbort(fire) {
+    const signal = this.abortSignal;
+    if (!signal) return () => void 0;
+    if (signal.aborted) {
+      queueMicrotask(fire);
+      return () => void 0;
+    }
+    signal.addEventListener("abort", fire, { once: true });
+    return () => {
+      signal.removeEventListener("abort", fire);
+    };
+  }
+  async collect() {
+    if (!this.armed) return void 0;
+    let next = 0;
+    try {
+      await this.waitForStartWindow();
+      this.closeStartWindow();
+      const writes = this.clipboardWrites;
+      this.clipboardArmed = false;
+      this.clipboardWrites = [];
+      const clipboard = !this.readsClipboard ? writes.map(({ source, text }) => ({ source, text, readBack: "unavailable" })) : writes.length > 0 ? await this.readBack(writes) : [];
+      const evidence = [];
+      while (next < this.downloads.length) {
+        const { download, late } = this.downloads[next++];
+        const finished = await this.finish(download);
+        evidence.push(late ? { ...finished, late: true } : finished);
+      }
+      if (evidence.length === 0 && clipboard.length === 0) return void 0;
+      return {
+        ...evidence.length > 0 ? { downloads: evidence } : {},
+        ...clipboard.length > 0 ? { clipboard } : {}
+      };
+    } finally {
+      this.held.push(...this.downloads.slice(next).map((entry) => entry.download));
+      this.closeStartWindow();
+      this.armed = false;
+      this.clipboardArmed = false;
+      this.downloads = [];
+      this.clipboardWrites = [];
+      this.abortSignal = void 0;
+      this.actingPage = void 0;
+      this.preImageGeneration = -1;
+    }
+  }
+  // The grace after an activation action, then for as long as a navigation it started has neither
+  // a response nor a failure, plus NAVIGATION_SETTLE_MS after the last answer; all bounded by the
+  // action's time left. Fixed when the wait begins: the acting page's main-frame navigation ends at
+  // mainEnd (half the time left), any other at capEnd (also NAVIGATION_WINDOW_CAP_MS).
+  async waitForStartWindow() {
+    if (!this.activation) return;
+    const start = Date.now();
+    const graceEnd = start + Math.min(this.startGraceMs, Math.max(0, this.timeLeft()));
+    const reserve = Math.max(0, this.timeLeft()) / 2;
+    const capEnd = start + Math.min(NAVIGATION_WINDOW_CAP_MS, reserve);
+    const mainEnd = start + reserve;
+    for (; ; ) {
+      const left = this.timeLeft();
+      if (left <= 0) return;
+      const now = Date.now();
+      const settleEnd = Math.min(
+        this.navigationSettledAt + NAVIGATION_SETTLE_MS,
+        this.navigationSettledMain ? mainEnd : capEnd
+      );
+      const openFor = Math.max(graceEnd, settleEnd) - now;
+      const pendingEnd = this.pendingNavigationEnd(mainEnd, capEnd);
+      if (openFor > 0) await this.waitForSignal(Math.min(openFor, left));
+      else if (now < pendingEnd) await this.waitForSignal(Math.min(pendingEnd - now, left));
+      else return;
+    }
+  }
+  // mainEnd while a main-frame navigation of the acting page is pending, else capEnd while any
+  // other is, else 0.
+  pendingNavigationEnd(mainEnd, capEnd) {
+    let end = 0;
+    for (const { main } of this.pendingNavigations.values()) {
+      if (main) return mainEnd;
+      end = capEnd;
+    }
+    return end;
+  }
+  closeStartWindow() {
+    this.startWindow = false;
+    this.navigationWindow = false;
+    this.pendingNavigations.clear();
+  }
+  onRequest(request) {
+    if (!this.navigationWindow || !request.isNavigationRequest()) return;
+    let page;
+    let main = false;
+    try {
+      const frame = request.frame();
+      page = frame.page();
+      main = this.actingPage !== void 0 && frame === this.actingPage.mainFrame();
+    } catch {
+    }
+    this.pendingNavigations.set(request, { page, main });
+  }
+  settleNavigation(request) {
+    const pending = this.pendingNavigations.get(request);
+    if (!pending) return;
+    this.pendingNavigations.delete(request);
+    this.navigationSettledAt = Date.now();
+    this.navigationSettledMain = pending.main;
+    this.notify?.();
+  }
+  onClipboardWrite(frame, payload) {
+    if (!this.armed || !this.clipboardArmed) return;
+    if (!payload || typeof payload !== "object") return;
+    const { via, text } = payload;
+    if (typeof via !== "string" || !CLIPBOARD_SOURCES.has(via) || typeof text !== "string") return;
+    this.clipboardWrites.push({ source: via, text, frame });
+    if (this.clipboardWrites.length > CLIPBOARD_CLAIMS_PER_ACTION) this.clipboardWrites.shift();
+  }
+  // Takes the probe page's pre-image of the clipboard; a closed or crashed probe is replaced once.
+  async takePreImage() {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const probe = await this.openProbe();
+      if (!probe) return;
+      if (probe.isClosed()) {
+        await this.resetProbe();
+        continue;
+      }
+      const generation = this.probeGeneration;
+      const bound = Math.min(READ_BACK_TIMEOUT_MS, this.timeLeft());
+      if (generation === this.unreadableGeneration || bound <= 0) return;
+      try {
+        const status = await this.bounded(
+          probe.evaluate(() => globalThis.__agentQaReadback.snapshot()),
+          bound
+        );
+        if (status === void 0) this.markUnreadable(generation, bound);
+        else if (status === "read" && generation === this.probeGeneration) this.preImageGeneration = generation;
+        return;
+      } catch {
+        await this.resetProbe();
+      }
+    }
+  }
+  // Only the final claim is compared, against a clipboard that changed during the action; an
+  // earlier claim is matched only when its text equals a matched final claim.
+  async readBack(writes) {
+    const last = writes.length - 1;
+    const final = writes[last];
+    const answer = await this.readClipboard(final.frame, final.text);
+    return writes.map(({ source, text }, position) => ({
+      source,
+      text,
+      readBack: answer === PROBE_MATCHED && text === final.text ? "matched" : answer === PROBE_DIFFERENT && position === last ? "mismatched" : "unavailable"
+    }));
+  }
+  // PROBE_MATCHED or PROBE_DIFFERENT when the clipboard changed during the action, else undefined.
+  // Only the final claim's text enters the probe page and only a number comes back.
+  async readClipboard(frame, finalText) {
+    const generation = this.preImageGeneration;
+    if (generation < 0 || generation !== this.probeGeneration || generation === this.unreadableGeneration) {
+      return void 0;
+    }
+    if (frame.isDetached()) return void 0;
+    try {
+      if (new URL(frame.url()).origin === "null") return void 0;
+    } catch {
+      return void 0;
+    }
+    const frameBound = Math.min(READ_BACK_TIMEOUT_MS, this.timeLeft());
+    if (frameBound <= 0) return void 0;
+    const secure = await this.bounded(
+      frame.evaluate("window.isSecureContext && !!(navigator.clipboard && navigator.clipboard.readText)"),
+      frameBound
+    ).catch(() => false);
+    if (secure !== true) return void 0;
+    const probe = await this.openProbe();
+    const bound = Math.min(READ_BACK_TIMEOUT_MS, this.timeLeft());
+    if (!probe || generation !== this.probeGeneration || bound <= 0) return void 0;
+    let answer;
+    try {
+      if (probe.isClosed()) throw new Error("probe closed");
+      answer = await this.bounded(
+        probe.evaluate((text) => globalThis.__agentQaReadback.compare(text), finalText),
+        bound
+      );
+    } catch {
+      await this.resetProbe();
+      return void 0;
+    }
+    if (answer === void 0) this.markUnreadable(generation, bound);
+    return answer === PROBE_MATCHED || answer === PROBE_DIFFERENT ? answer : void 0;
+  }
+  // A read cut short by the step's time or its abort says nothing about the probe.
+  markUnreadable(generation, bound) {
+    if (bound >= READ_BACK_TIMEOUT_MS && !this.abortSignal?.aborted) this.unreadableGeneration = generation;
+  }
+  // Resolves undefined after `ms` or on the action's abort; rejects when `promise` rejects.
+  async bounded(promise, ms) {
+    let off = () => void 0;
+    try {
+      return await Promise.race([
+        withTimeout(promise, ms),
+        new Promise((resolve) => {
+          off = this.onAbort(() => {
+            resolve(void 0);
+          });
+        })
+      ]);
+    } finally {
+      off();
+    }
+  }
+  openProbe() {
+    if (!this.readsClipboard) return Promise.resolve(void 0);
+    this.probe ??= this.createProbe(this.probeGeneration);
+    return this.probe;
+  }
+  // A separate context of the app's browser: only the reserved origin loads (a blank document, no
+  // init script), every other request is aborted, and only that origin may read the clipboard.
+  async createProbe(generation) {
+    let context;
+    try {
+      const browser = this.appContext?.browser();
+      if (!browser) return void 0;
+      context = await browser.newContext();
+      if (generation !== this.probeGeneration) {
+        await context.close().catch(() => void 0);
+        return void 0;
+      }
+      this.probeContext = context;
+      await context.route("**/*", (route) => {
+        let origin = "";
+        try {
+          origin = new URL(route.request().url()).origin;
+        } catch {
+        }
+        return origin === CLIPBOARD_READBACK_ORIGIN ? route.fulfill({ contentType: "text/html", body: "<!doctype html>" }) : route.abort();
+      });
+      await context.grantPermissions(["clipboard-read"], { origin: CLIPBOARD_READBACK_ORIGIN });
+      const page = await context.newPage();
+      page.once("crash", () => {
+        if (generation === this.probeGeneration) void this.resetProbe();
+      });
+      await page.goto(`${CLIPBOARD_READBACK_ORIGIN}/`);
+      await page.evaluate(installProbeReadback);
+      return page;
+    } catch {
+      if (generation === this.probeGeneration) {
+        this.probe = null;
+        this.probeContext = null;
+      }
+      await context?.close().catch(() => void 0);
+      return void 0;
+    }
+  }
+  /** The bytes of a completed download with this sha256 while the hold keeps them. */
+  readDownloadBytes(sha256) {
+    return this.heldBytes.get(sha256);
+  }
+  holdBytes(sha256, bytes) {
+    if (bytes.length > DOWNLOAD_HOLD_FILE_CAP) return;
+    const previous = this.heldBytes.get(sha256);
+    if (previous !== void 0) {
+      this.heldBytes.delete(sha256);
+      this.heldByteTotal -= previous.length;
+    }
+    this.heldBytes.set(sha256, bytes);
+    this.heldByteTotal += bytes.length;
+    for (const [key, value] of this.heldBytes) {
+      if (this.heldByteTotal <= DOWNLOAD_HOLD_TOTAL_CAP) break;
+      this.heldBytes.delete(key);
+      this.heldByteTotal -= value.length;
+    }
+  }
+  /** Cancels and deletes every held download, clears the held bytes, then closes the read-back probe context. */
+  async dispose() {
+    this.heldBytes.clear();
+    this.heldByteTotal = 0;
+    const held = this.held;
+    this.held = [];
+    for (const download of held) {
+      await download.cancel().catch(() => void 0);
+      await download.delete().catch(() => void 0);
+    }
+    await this.resetProbe();
+  }
+  // Closes only the probe context; held downloads are never touched here.
+  async resetProbe() {
+    const context = this.probeContext;
+    this.probeGeneration += 1;
+    this.unreadableGeneration = -1;
+    this.probe = null;
+    this.probeContext = null;
+    await context?.close().catch(() => void 0);
+  }
+  attachPage(page) {
+    if (this.attachedPages.has(page)) return;
+    this.attachedPages.add(page);
+    page.on("download", (download) => {
+      if (!this.startWindow) {
+        this.held.push(download);
+        return;
+      }
+      this.downloads.push({ download, late: false });
+      this.notify?.();
+    });
+    page.on("close", () => {
+      for (const [request, pending] of this.pendingNavigations) if (pending.page === page) this.settleNavigation(request);
+    });
+  }
+  // Resolves on a download start, a settled navigation, the abort, or after `ms`.
+  async waitForSignal(ms) {
+    let off = () => void 0;
+    await new Promise((resolve) => {
+      const timer = setTimeout(done, ms);
+      function done() {
+        clearTimeout(timer);
+        resolve();
+      }
+      this.notify = done;
+      off = this.onAbort(done);
+    });
+    off();
+    this.notify = null;
+  }
+  async finish(download) {
+    const suggestedFilename = download.suggestedFilename();
+    const base = {
+      suggestedFilename,
+      extension: extname(suggestedFilename)
+    };
+    let timer;
+    let off = () => void 0;
+    const outcome = await Promise.race([
+      download.failure().catch((error) => error instanceof Error ? error.message : String(error)),
+      new Promise((resolve) => {
+        const end = () => {
+          resolve(UNFINISHED);
+        };
+        timer = setTimeout(end, Math.max(0, this.timeLeft()));
+        off = this.onAbort(end);
+      })
+    ]);
+    clearTimeout(timer);
+    off();
+    if (outcome === UNFINISHED) {
+      await download.cancel().catch(() => void 0);
+      await download.delete().catch(() => void 0);
+      return { ...base, state: "unfinished" };
+    }
+    if (outcome !== null) {
+      await download.delete().catch(() => void 0);
+      return { ...base, state: outcome === "canceled" ? "canceled" : "failed", failure: outcome };
+    }
+    try {
+      const { size, sha256, bytes } = await digest(download);
+      if (bytes !== void 0) this.holdBytes(sha256, bytes);
+      return { ...base, size, sha256, state: "completed" };
+    } catch (error) {
+      return { ...base, state: "failed", failure: error instanceof Error ? error.message : String(error) };
+    } finally {
+      await download.delete().catch(() => void 0);
+    }
+  }
+};
+async function withTimeout(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), ms);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function digest(download) {
+  const stream = await download.createReadStream();
+  const hash = createHash("sha256");
+  let size = 0;
+  let chunks = [];
+  for await (const chunk of stream) {
+    const bytes = chunk;
+    size += bytes.length;
+    hash.update(bytes);
+    if (size > DOWNLOAD_HOLD_FILE_CAP) chunks = void 0;
+    else chunks?.push(bytes);
+  }
+  const sha256 = hash.digest("hex");
+  return chunks === void 0 ? { size, sha256 } : { size, sha256, bytes: new Uint8Array(Buffer.concat(chunks)) };
+}
+
+// src/adapter.ts
+var OBSERVE_SNAPSHOT_TIMEOUT_MS = 5e3;
+var OBSERVE_SNAPSHOT_RETRY_TIMEOUT_MS = 3e4;
+var OBSERVE_SNAPSHOT = {
+  timeoutMs: OBSERVE_SNAPSHOT_TIMEOUT_MS,
+  retryTimeoutMs: OBSERVE_SNAPSHOT_RETRY_TIMEOUT_MS
+};
+var SCREENSHOT_TIMEOUT_MS = 5e3;
+function withOperationMetadata(result, captured) {
+  const download = captured?.downloads?.length ? captured.downloads : void 0;
+  const clipboard = captured?.clipboard?.length ? captured.clipboard : void 0;
+  if (!download && !clipboard) return result;
+  return {
+    ...result,
+    metadata: { ...result.metadata, ...download ? { download } : {}, ...clipboard ? { clipboard } : {} }
+  };
+}
+function clickDelayOption(clickDelay) {
+  return clickDelay !== void 0 && clickDelay > 0 ? { delay: clickDelay } : {};
+}
+function readSeamStorageState(action) {
+  return action.state;
+}
+var SCREENCAST_PARAMS = {
+  format: "jpeg",
+  quality: 60,
+  maxWidth: 1280,
+  maxHeight: 720,
+  everyNthFrame: 1
+};
+var SCREENCAST_ACK_WINDOW = 64;
+var KEEPALIVE_ECHO_WINDOW_MS = 250;
+var SCREENCAST_RECOVERY_MS = 1e4;
+function decodeBase64(data) {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+var WebPlatformAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  platform = "web";
+  browser = null;
+  context = null;
+  page = null;
+  // The native binding of the last observation and its document (438 D-06). Neither crosses the
+  // port (observe returns only the ScreenState).
   lastRefs = {};
+  epoch;
   pageLogBuffers = /* @__PURE__ */ new Map();
   logCaptureConfig = { console: true, network: true };
   disconnected = false;
   intentionalClose = false;
+  // Persistent route interception + one-shot dialog arms live until an explicit unroute or
+  // test teardown (D-12/D-18); cleanup() drains both so nothing bleeds across tests (Pitfall 7).
+  armedRoutes = /* @__PURE__ */ new Set();
+  pendingDialogArm = null;
+  // 403 D-05: the live screencast's CDP session, owned here and never handed out.
+  browserName = "chromium";
+  screencast = null;
+  screencastCapability = null;
+  recordingCapability;
+  recordingPageRevision = 0;
+  recordingConfig;
+  // 403-02: the PRODUCT's frame identity, and the CDP ack token it maps to. See `liveStream`.
+  screencastFrameSeq = 0;
+  screencastAckTokens = /* @__PURE__ */ new Map();
+  // 428 D-15: the running screencast's consumer, its quiet-page keepalive, and the size a keepalive
+  // frame reports (the last screencast frame's device size).
+  screencastOnFrame = null;
+  keepaliveTimer = null;
+  lastScreencastSize = null;
+  keepaliveEchoDeadline = null;
+  screencastChain = Promise.resolve();
+  // 428 D-12: the labelled snapshot preview standing in for a screencast withdrawn mid-stream.
+  withdrawnSnapshot = null;
+  screencastRecoveryTimer = null;
+  // 436 D-19, D-21: download and app-clipboard capture, Chromium only; armed around each execute().
+  operationCapture = null;
+  // 436 D-23: Firefox and WebKit run no capture and name themselves as the reason.
+  operationCaptureSupport;
   async setup(config) {
+    this.recordingConfig = config.recording;
     const { chromium, firefox, webkit } = await import("playwright-core");
     const launchers = { chromium, firefox, webkit };
     const browserName = config.browser?.name ?? "chromium";
+    this.browserName = browserName;
     const launcher = launchers[browserName];
+    const headless = config.browser?.headless ?? true;
     try {
       this.browser = await launcher.launch({
-        headless: config.browser?.headless ?? true,
-        ...browserName === "chromium" ? { args: ["--disable-blink-features=AutomationControlled"] } : {}
+        headless,
+        ...browserName === "chromium" ? { args: ["--disable-blink-features=AutomationControlled"] } : {},
+        ...this.options.hostOwnsSignals === true ? { handleSIGINT: false, handleSIGTERM: false, handleSIGHUP: false } : {}
       });
     } catch (error) {
       if (isPlaywrightMissingBrowserError(error)) {
@@ -733,12 +2107,6 @@ var WebPlatformAdapter = class {
     const contextOptions = {
       viewport: config.browser?.viewport ?? { width: 1280, height: 720 }
     };
-    if (config.recording?.enabled) {
-      contextOptions.recordVideo = {
-        dir: config.recording.videoDir,
-        size: config.recording.videoSize ?? config.browser?.viewport ?? { width: 1280, height: 720 }
-      };
-    }
     if (config.authState?.storageStatePath) {
       contextOptions.storageState = config.authState.storageStatePath;
     }
@@ -752,19 +2120,367 @@ var WebPlatformAdapter = class {
     });
     this.page = await this.context.newPage();
     this.attachLogListeners(this.page);
+    if (browserName === "chromium") {
+      this.operationCapture = new OperationCapture({ headless: isHeadlessLaunch({ headless }, process.env) });
+      await this.operationCapture.attach(this.context);
+      this.operationCaptureSupport = { download: true, clipboard: true };
+    } else {
+      this.operationCaptureSupport = { download: false, clipboard: false, reason: browserName };
+    }
+  }
+  /**
+   * 403 D-05/LIVE-01: the Chromium screencast producer, or ABSENT when this adapter cannot stream.
+   *
+   * Absence means "no continuous stream", not "no preview": since 428-05 the composition's
+   * `liveStreamFor` wraps this adapter's `screenshot()` in the labelled 1 s snapshot producer, both
+   * as the fallback behind a screencast that fails to start and as the whole preview on a
+   * non-Chromium target. The two gates here (Chromium only, and a page to stream) stay exactly as
+   * they are, so the absence stays honest.
+   *
+   * SCOPE (428 D-18, closes WIN #273): the screencast shows the page the test is acting on. Both
+   * page-switch sites (`tab new`, `tab switch`) go through `setActivePage`, which re-binds the
+   * running screencast to the new page INSIDE this same capability object: no stop, no re-register,
+   * no stream end, so a subscriber only sees the picture change. Start, stop and re-bind run on one
+   * serialised chain. A popup or a closing tab never changes `this.page` in this adapter, so the
+   * preview already shows the acting page in those cases.
+   */
+  get liveStream() {
+    if (this.browserName !== "chromium") return void 0;
+    if (!this.page || !this.context) return void 0;
+    if (this.screencastCapability) return this.screencastCapability;
+    const capability = {
+      kind: "cdp-screencast",
+      start: (onFrame) => this.onScreencastChain(async () => {
+        if (this.screencastOnFrame !== null) return;
+        const page = this.page;
+        const context = this.context;
+        if (!page || !context) return;
+        const cdp = await context.newCDPSession(page);
+        this.screencast = cdp;
+        this.screencastOnFrame = onFrame;
+        this.screencastAckTokens.clear();
+        this.attachScreencast(cdp, onFrame);
+        try {
+          await cdp.send("Page.startScreencast", { ...SCREENCAST_PARAMS });
+        } catch (error) {
+          this.screencast = null;
+          this.screencastOnFrame = null;
+          try {
+            await cdp.detach();
+          } catch {
+          }
+          throw error;
+        }
+        if (this.screencast === cdp) this.armKeepalive(cdp);
+      }),
+      ack: async (frameId) => {
+        const cdp = this.screencast;
+        if (!cdp) return;
+        const sessionId = this.screencastAckTokens.get(frameId);
+        this.screencastAckTokens.delete(frameId);
+        if (sessionId === void 0) return;
+        try {
+          await cdp.send("Page.screencastFrameAck", { sessionId });
+        } catch {
+        }
+      },
+      stop: () => this.onScreencastChain(async () => {
+        this.screencastOnFrame = null;
+        await this.stopWithdrawnSnapshot();
+        await this.detachScreencast();
+      })
+    };
+    this.screencastCapability = capability;
+    return capability;
+  }
+  /** Run `step` after every earlier start, stop and re-bind has settled (428 D-18). */
+  onScreencastChain(step) {
+    const run = this.screencastChain.then(step);
+    this.screencastChain = run.catch(() => void 0);
+    return run;
+  }
+  /** Stop and detach the current CDP session, best-effort, and forget its tokens and keepalive. */
+  async detachScreencast() {
+    const cdp = this.screencast;
+    this.screencast = null;
+    this.clearKeepalive();
+    this.keepaliveEchoDeadline = null;
+    this.screencastAckTokens.clear();
+    if (!cdp) return;
+    try {
+      await cdp.send("Page.stopScreencast");
+    } catch {
+    }
+    try {
+      await cdp.detach();
+    } catch {
+    }
+  }
+  /** Wire `cdp`'s screencast frames to `onFrame`; shared by `start` and `rebindScreencast`. */
+  attachScreencast(cdp, onFrame) {
+    cdp.on("Page.screencastFrame", (event) => {
+      if (this.screencast !== cdp) return;
+      const metadata = event.metadata;
+      this.lastScreencastSize = { width: metadata.deviceWidth, height: metadata.deviceHeight };
+      this.armKeepalive(cdp);
+      const echoDeadline = this.keepaliveEchoDeadline;
+      this.keepaliveEchoDeadline = null;
+      if (echoDeadline !== null && Date.now() <= echoDeadline) {
+        void cdp.send("Page.screencastFrameAck", { sessionId: event.sessionId }).catch(() => void 0);
+        return;
+      }
+      const id = ++this.screencastFrameSeq;
+      this.screencastAckTokens.set(id, event.sessionId);
+      while (this.screencastAckTokens.size > SCREENCAST_ACK_WINDOW) {
+        const oldest = this.screencastAckTokens.keys().next();
+        if (oldest.done === true) break;
+        const token = this.screencastAckTokens.get(oldest.value);
+        this.screencastAckTokens.delete(oldest.value);
+        if (token !== void 0) {
+          void cdp.send("Page.screencastFrameAck", { sessionId: token }).catch(() => void 0);
+        }
+      }
+      onFrame({
+        id,
+        bytes: decodeBase64(event.data),
+        metadata: {
+          width: metadata.deviceWidth,
+          height: metadata.deviceHeight,
+          // CDP's `TimeSinceEpoch` is SECONDS; every other layer reads epoch ms (428 D-15).
+          ...metadata.timestamp === void 0 ? {} : { timestamp: Math.round(metadata.timestamp * 1e3) },
+          scrollOffsetX: metadata.scrollOffsetX,
+          scrollOffsetY: metadata.scrollOffsetY
+        }
+      });
+    });
+  }
+  /**
+   * The one place the page the test acts on changes (428 D-18). Recording keeps following its
+   * starting page through the revision counter (424 reconciliation 25(d)); the live screencast,
+   * when running, re-binds to the new page on the serialised chain.
+   */
+  setActivePage(page) {
+    this.page = page;
+    this.recordingPageRevision++;
+    if (this.screencastOnFrame !== null) {
+      void this.onScreencastChain(() => this.rebindScreencast());
+    }
+  }
+  /**
+   * Move the running screencast onto `this.page` without its subscribers noticing: the old session
+   * is stopped and detached, a new one is started with the stored `onFrame`, and the id sequence
+   * continues. Ids still pending in the hub settle through its ack bound and are dropped here as
+   * unknown. Best-effort throughout; it never throws into a step.
+   */
+  async rebindScreencast(options = {}) {
+    const onFrame = this.screencastOnFrame;
+    const page = this.page;
+    const context = this.context;
+    if (onFrame === null || !page || !context) return;
+    await this.detachScreencast();
+    this.lastScreencastSize = null;
+    if (options.focus !== false) {
+      try {
+        await page.bringToFront();
+      } catch {
+      }
+    }
+    let cdp;
+    try {
+      cdp = await context.newCDPSession(page);
+    } catch {
+      this.handleScreencastWithdrawn(null);
+      return;
+    }
+    this.screencast = cdp;
+    this.attachScreencast(cdp, onFrame);
+    try {
+      await cdp.send("Page.startScreencast", { ...SCREENCAST_PARAMS });
+    } catch {
+      this.handleScreencastWithdrawn(cdp);
+      return;
+    }
+    if (this.screencast !== cdp) return;
+    this.armKeepalive(cdp);
+    await this.stopWithdrawnSnapshot();
+  }
+  /**
+   * 428 D-12's second half: the screencast was withdrawn while the browser is still up (its CDP
+   * session detached or unusable), which only this capability can see. Detected when a keepalive
+   * capture or a re-bind's start rejects on the active session; the capability then serves the
+   * labelled 1 s snapshot preview of the current page through the same `onFrame`, until `stop()`,
+   * `cleanup()` or a successful re-bind. The declared kind stays `cdp-screencast`; the frames carry
+   * `kind: 'snapshot'`, which is what labels the preview. Runs on the serialised chain.
+   */
+  handleScreencastWithdrawn(cdp) {
+    void this.onScreencastChain(async () => {
+      if (this.screencast !== cdp) return;
+      const onFrame = this.screencastOnFrame;
+      if (onFrame === null || this.withdrawnSnapshot !== null || !this.browserIsLive()) return;
+      await this.detachScreencast();
+      const snapshot = createSnapshotLiveStream({ capture: () => this.screenshot() });
+      this.withdrawnSnapshot = snapshot;
+      await snapshot.start((frame) => {
+        if (this.withdrawnSnapshot !== snapshot) return;
+        onFrame({ ...frame, id: ++this.screencastFrameSeq });
+      });
+      this.armScreencastRecovery();
+    });
+  }
+  /** While the snapshot fallback runs, try the screencast again every SCREENCAST_RECOVERY_MS (428 WR-08). */
+  armScreencastRecovery() {
+    this.clearScreencastRecovery();
+    const timer = setTimeout(() => {
+      this.screencastRecoveryTimer = null;
+      void this.onScreencastChain(async () => {
+        if (this.withdrawnSnapshot === null || this.screencastOnFrame === null || !this.browserIsLive()) return;
+        await this.rebindScreencast({ focus: false });
+        if (this.withdrawnSnapshot !== null) this.armScreencastRecovery();
+      });
+    }, SCREENCAST_RECOVERY_MS);
+    timer.unref?.();
+    this.screencastRecoveryTimer = timer;
+  }
+  clearScreencastRecovery() {
+    if (this.screencastRecoveryTimer !== null) clearTimeout(this.screencastRecoveryTimer);
+    this.screencastRecoveryTimer = null;
+  }
+  browserIsLive() {
+    return !this.intentionalClose && !this.disconnected && this.browser?.isConnected() === true;
+  }
+  async stopWithdrawnSnapshot() {
+    this.clearScreencastRecovery();
+    const snapshot = this.withdrawnSnapshot;
+    this.withdrawnSnapshot = null;
+    try {
+      await snapshot?.stop();
+    } catch {
+    }
+  }
+  clearKeepalive() {
+    if (this.keepaliveTimer !== null) clearTimeout(this.keepaliveTimer);
+    this.keepaliveTimer = null;
+  }
+  /** (Re-)arm the quiet-page keepalive for `cdp`; every screencast frame pushes it back. */
+  armKeepalive(cdp) {
+    this.clearKeepalive();
+    const timer = setTimeout(() => {
+      void this.fireKeepalive(cdp);
+    }, LIVE_KEEPALIVE_QUIET_MS);
+    timer.unref?.();
+    this.keepaliveTimer = timer;
+  }
+  /**
+   * 428 D-15: a fresh capture on the same CDP session, emitted as a frame with no ack token (the ack
+   * path drops ids it never minted a token for). A capture that rejects emits nothing. While the
+   * capability is started under a live browser, a session that then fails a trivial probe too is a
+   * withdrawn screencast (D-12, see `handleScreencastWithdrawn`); one that still answers only had a
+   * bad moment, such as a cross-process navigation, and re-arms (428 WR-08). One that never settles
+   * emits nothing and arms nothing, which is the honest amber.
+   */
+  async fireKeepalive(cdp) {
+    this.keepaliveTimer = null;
+    if (this.screencast !== cdp) return;
+    const framesBefore = this.screencastFrameSeq;
+    let data;
+    try {
+      const result = await cdp.send("Page.captureScreenshot", { format: "jpeg", quality: 60 });
+      data = result.data;
+    } catch {
+      if (this.screencast !== cdp) return;
+      const withdrawn = this.screencastOnFrame !== null && this.browserIsLive() && !await this.sessionAnswers(cdp);
+      if (this.screencast !== cdp) return;
+      if (withdrawn) this.handleScreencastWithdrawn(cdp);
+      else this.armKeepalive(cdp);
+      return;
+    }
+    if (this.screencast !== cdp) return;
+    const onFrame = this.screencastOnFrame;
+    if (onFrame === null) return;
+    if (this.screencastFrameSeq !== framesBefore) return;
+    const size = this.lastScreencastSize ?? this.page?.viewportSize() ?? { width: 0, height: 0 };
+    onFrame({
+      id: ++this.screencastFrameSeq,
+      bytes: decodeBase64(data),
+      metadata: { width: size.width, height: size.height, timestamp: Date.now() }
+    });
+    this.keepaliveEchoDeadline = Date.now() + KEEPALIVE_ECHO_WINDOW_MS;
+    this.armKeepalive(cdp);
+  }
+  /** Whether `cdp` still answers a command that cannot fail on a usable session. */
+  async sessionAnswers(cdp) {
+    try {
+      await cdp.send("Runtime.evaluate", { expression: "1" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  get recording() {
+    if (!this.page || !this.context || !this.recordingConfig) return void 0;
+    return this.recordingCapability ??= createScreencastRecording(
+      () => this.page,
+      this.recordingConfig,
+      () => this.recordingPageRevision
+    );
   }
   async cleanup() {
     this.intentionalClose = true;
+    try {
+      await this.recordingCapability?.stop();
+    } catch {
+    }
+    this.recordingCapability = void 0;
+    this.recordingConfig = void 0;
+    this.screencastOnFrame = null;
+    await this.stopWithdrawnSnapshot();
+    try {
+      await this.screencastCapability?.stop();
+    } catch {
+    }
+    this.screencastCapability = null;
+    try {
+      await this.operationCapture?.dispose();
+    } catch {
+    }
+    if (this.context) {
+      try {
+        await this.context.unrouteAll({ behavior: "ignoreErrors" });
+      } catch {
+      }
+      try {
+        await this.context.setOffline(false);
+      } catch {
+      }
+    }
+    if (this.page && this.pendingDialogArm) {
+      try {
+        this.page.off("dialog", this.pendingDialogArm);
+      } catch {
+      }
+    }
+    this.armedRoutes.clear();
+    this.pendingDialogArm = null;
+    await disposeEpoch(this.epoch);
+    this.epoch = void 0;
     if (this.browser) {
       await this.browser.close();
     }
     this.browser = null;
     this.context = null;
     this.page = null;
+    this.operationCapture = null;
+    this.operationCaptureSupport = void 0;
     this.lastRefs = {};
     this.pageLogBuffers.clear();
     this.disconnected = false;
     this.intentionalClose = false;
+    this.screencast = null;
+    this.screencastOnFrame = null;
+    this.clearKeepalive();
+    this.lastScreencastSize = null;
+    this.screencastAckTokens.clear();
+    this.screencastChain = Promise.resolve();
   }
   get isBrowserDisconnected() {
     return this.disconnected;
@@ -773,14 +2489,63 @@ var WebPlatformAdapter = class {
     if (!this.page) {
       throw new Error("WebPlatformAdapter not initialized \u2014 call setup() first");
     }
-    await waitForPageReady(this.page);
-    const state = await observePage(this.page, {
-      extractDom: options?.extractDom
+    const page = this.page;
+    await waitForPageReady(page);
+    const epoch = await captureEpoch(page);
+    try {
+      const state = await this.observeDocument(page, options);
+      await disposeEpoch(this.epoch);
+      this.epoch = epoch;
+      return state;
+    } catch (error) {
+      await disposeEpoch(epoch);
+      throw error;
+    }
+  }
+  async observeDocument(page, options) {
+    const ariaTree = await snapshotRoot(page, OBSERVE_SNAPSHOT);
+    const { nodes, nativeRefs } = parseAriaSnapshot(ariaTree);
+    if (nodes.length > 0) {
+      await enrichWebNodes(page, nodes, nativeRefs);
+    }
+    const { viewport, scroll } = await captureWebScroll(page);
+    let domContext;
+    if (options?.extractDom) {
+      try {
+        domContext = await extractDom(page);
+      } catch {
+      }
+    }
+    const { state, binding } = buildScreenState3({
+      platform: "web",
+      nodes,
+      viewport,
+      scroll,
+      coordSpace: "viewport",
+      timestamp: Date.now(),
+      url: page.url(),
+      ...domContext !== void 0 ? { domContext } : {}
     });
-    this.lastRefs = state.metadata.refMap ?? {};
+    this.lastRefs = buildRefMap(binding, nodes, nativeRefs, state.elements);
     return state;
   }
-  async execute(action) {
+  async execute(action, options) {
+    if (!this.page) {
+      throw new Error("WebPlatformAdapter not initialized \u2014 call setup() first");
+    }
+    const capture = this.operationCapture;
+    await capture?.arm(action, options, this.page);
+    const result = await this.executeWithErrorResult(action);
+    this.recordingCapability?.endAction();
+    let captured;
+    try {
+      captured = await capture?.collect();
+    } catch {
+      captured = void 0;
+    }
+    return withOperationMetadata(result, captured);
+  }
+  async executeWithErrorResult(action) {
     if (!this.page) {
       throw new Error("WebPlatformAdapter not initialized \u2014 call setup() first");
     }
@@ -812,7 +2577,7 @@ var WebPlatformAdapter = class {
   async screenshot() {
     try {
       if (this.page) {
-        return await this.page.screenshot({ scale: "css" });
+        return await this.page.screenshot({ scale: "css", timeout: SCREENSHOT_TIMEOUT_MS });
       }
       return void 0;
     } catch {
@@ -822,15 +2587,6 @@ var WebPlatformAdapter = class {
   getPage() {
     return this.page;
   }
-  async getVideoPath() {
-    try {
-      const video = this.page?.video();
-      if (!video) return null;
-      return await video.path();
-    } catch {
-      return null;
-    }
-  }
   drainConsoleLogs(level) {
     const all = [];
     for (const buffers of this.pageLogBuffers.values()) {
@@ -851,6 +2607,18 @@ var WebPlatformAdapter = class {
     if (!urlPattern) return all;
     return all.filter((e) => e.url.includes(urlPattern));
   }
+  /** 439 D-04: a completed download's bytes held in memory, by its sha256. */
+  readDownloadBytes(sha256) {
+    return this.operationCapture?.readDownloadBytes(sha256);
+  }
+  peekNetworkLogs(urlPattern) {
+    const all = [];
+    for (const buffers of this.pageLogBuffers.values()) {
+      all.push(...buffers.networkLogs.slice(buffers.networkDrainIndex));
+    }
+    if (!urlPattern) return all;
+    return all.filter((e) => e.url.includes(urlPattern));
+  }
   attachLogListeners(page) {
     const buffers = {
       consoleLogs: [],
@@ -938,6 +2706,12 @@ var WebPlatformAdapter = class {
   async executeAction(action) {
     const page = this.page;
     const resolver = new ElementResolver(page, this.lastRefs);
+    for (const ref of laneRefs(action)) {
+      const entry = this.lastRefs[ref];
+      if (entry === void 0) continue;
+      const check = action.type === "scroll" ? await checkDocument(page, this.epoch) : await checkBinding(page, this.epoch, entry, OBSERVE_SNAPSHOT);
+      if (check.outcome !== "ok") return bindingRefusal(check.outcome, ref);
+    }
     if ("ref" in action && typeof action.ref === "string") {
       const refData = this.lastRefs[action.ref];
       const role = refData?.role;
@@ -952,15 +2726,18 @@ var WebPlatformAdapter = class {
         const box = await resolver.getBoundingBox(action.ref);
         const coordinates = box ? { x: box.x + box.width / 2, y: box.y + box.height / 2 } : void 0;
         await locator.click({
-          ...clickDelayOption(action.clickDelay)
+          ...clickDelayOption(action.clickDelay),
+          ...this.operationCapture ? { noWaitAfter: true } : {}
         });
         return { success: true, coordinates, boundingBox: box ?? void 0 };
       }
       case "fill": {
         const locator = resolver.resolve(action.ref);
         const box = await resolver.getBoundingBox(action.ref);
-        await locator.fill(action.value);
-        return { success: true, boundingBox: box ?? void 0 };
+        return runWebFillCompound(locator, box ?? void 0, action);
+      }
+      case "openApp": {
+        return webOpenAppError();
       }
       case "select": {
         const locator = resolver.resolve(action.ref);
@@ -969,53 +2746,44 @@ var WebPlatformAdapter = class {
         return { success: true, boundingBox: box ?? void 0 };
       }
       case "navigate": {
-        await page.goto(action.url, { waitUntil: "domcontentloaded" });
+        switch (action.to) {
+          case "url":
+            await page.goto(action.url, { waitUntil: "domcontentloaded" });
+            break;
+          case "back":
+            await page.goBack({ waitUntil: "domcontentloaded" });
+            break;
+          case "forward":
+            await page.goForward({ waitUntil: "domcontentloaded" });
+            break;
+          case "reload":
+            await page.reload({ waitUntil: "domcontentloaded" });
+            break;
+        }
         await waitForPageReady(page);
         return { success: true };
       }
       case "scroll": {
-        const deltaX = action.scrollType === "horizontal" ? action.value : 0;
-        const deltaY = action.scrollType === "vertical" ? action.value : 0;
-        let coordinates;
-        let boundingBox;
-        let scrollData;
-        if (action.ref) {
-          const refData = this.lastRefs[action.ref];
-          if (refData) {
-            const scrollAxis = action.scrollType === "horizontal" ? "horizontal" : "vertical";
-            const result = await scrollWithRef(page, refData, deltaX, deltaY, scrollAxis);
-            if (result.bounds) {
-              coordinates = { x: result.bounds.x + result.bounds.width / 2, y: result.bounds.y + result.bounds.height / 2 };
-              boundingBox = result.bounds;
-            }
-            scrollData = { scrolled: result.scrolled, scrolledContainer: result.scrolledContainer };
-          } else {
-            await page.mouse.wheel(deltaX, deltaY);
-          }
-        } else {
-          await page.mouse.wheel(deltaX, deltaY);
-        }
-        await page.evaluate(`new Promise(resolve => {
-          const t = setTimeout(() => resolve('timeout'), 500);
-          requestAnimationFrame(() => requestAnimationFrame(() => {
-            clearTimeout(t);
-            resolve('raf');
-          }));
-        })`);
-        return { success: true, coordinates, boundingBox, data: scrollData };
+        return runWebScrollCompound(page, this.lastRefs, action);
       }
       case "waitFor": {
-        const timeout = action.timeout ?? 5e3;
+        const timeout = action.timeoutMs;
         try {
-          await page.waitForFunction(
-            `document.body && document.body.innerText.includes(${JSON.stringify(action.condition)})`,
-            { timeout }
-          );
-        } catch {
-          try {
-            await page.waitForSelector(action.condition, { timeout });
-          } catch {
+          switch (action.on) {
+            case "text":
+              await page.getByText(action.text).first().waitFor({ state: "visible", timeout });
+              break;
+            case "gone":
+              await page.getByText(action.text).first().waitFor({ state: "hidden", timeout });
+              break;
+            case "selector":
+              await page.waitForSelector(action.selector, { timeout });
+              break;
           }
+        } catch {
+          const what = action.on === "selector" ? `selector "${action.selector}"` : `text "${action.text}"`;
+          const how = action.on === "gone" ? "was still present after" : "did not appear within";
+          return { success: false, error: `waitFor: ${what} ${how} ${timeout}ms.` };
         }
         return { success: true };
       }
@@ -1040,7 +2808,13 @@ var WebPlatformAdapter = class {
           isMac: isMacPlatform()
         });
         for (const key of effectiveKeys) {
-          await page.keyboard.press(key);
+          if (action.mode === "down") {
+            await page.keyboard.down(key);
+          } else if (action.mode === "up") {
+            await page.keyboard.up(key);
+          } else {
+            await page.keyboard.press(key);
+          }
         }
         return { success: true };
       }
@@ -1086,75 +2860,110 @@ var WebPlatformAdapter = class {
         await page.evaluate(`navigator.clipboard.writeText(${JSON.stringify(text)})`);
         return { success: true, boundingBox: box ?? void 0, data: { copied: text } };
       }
-      case "keyDown": {
-        await page.keyboard.down(action.key);
-        return { success: true };
-      }
-      case "keyUp": {
-        await page.keyboard.up(action.key);
-        return { success: true };
-      }
-      case "refresh": {
-        await page.reload({ waitUntil: "domcontentloaded" });
-        await waitForPageReady(page);
-        return { success: true };
-      }
-      case "navigateHistory": {
-        if (action.direction === "back") {
-          await page.goBack({ waitUntil: "domcontentloaded" });
-        } else {
-          await page.goForward({ waitUntil: "domcontentloaded" });
+      case "tab": {
+        if (action.action === "new") {
+          const newPage = await this.context.newPage();
+          this.attachLogListeners(newPage);
+          await newPage.goto(action.url, { waitUntil: "domcontentloaded" });
+          await waitForPageReady(newPage);
+          this.setActivePage(newPage);
+          return { success: true };
+        }
+        const pages = this.context.pages();
+        let target;
+        if (action.index !== void 0) {
+          if (action.index < 0 || action.index >= pages.length) {
+            return { success: false, error: `Tab index ${action.index} out of range (${pages.length} tabs open)` };
+          }
+          target = pages[action.index];
+        } else if (action.title !== void 0) {
+          for (const p of pages) {
+            const t = await p.title();
+            if (t.includes(action.title)) {
+              target = p;
+              break;
+            }
+          }
+        } else if (action.url !== void 0) {
+          target = pages.find((p) => p.url().includes(action.url));
         }
-        await waitForPageReady(page);
+        if (!target) {
+          return { success: false, error: `No tab found matching ${JSON.stringify({ index: action.index, title: action.title, url: action.url })}` };
+        }
+        this.setActivePage(target);
         return { success: true };
       }
-      case "readConsoleLogs": {
-        let entries;
-        if (action.tab) {
-          const targetPage = await this.resolveTabTargetAsync(action.tab);
-          if (!targetPage) {
-            return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+      case "inspect": {
+        switch (action.what) {
+          case "console": {
+            let entries;
+            if (action.tab) {
+              const targetPage = await this.resolveTabTargetAsync(action.tab);
+              if (!targetPage) {
+                return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+              }
+              const buffers = this.pageLogBuffers.get(targetPage);
+              entries = buffers ? [...buffers.consoleLogs] : [];
+            } else {
+              entries = [];
+              for (const buffers of this.pageLogBuffers.values()) {
+                entries.push(...buffers.consoleLogs);
+              }
+            }
+            if (action.level) {
+              entries = entries.filter((e) => e.level === action.level);
+            }
+            return { success: true, data: entries };
           }
-          const buffers = this.pageLogBuffers.get(targetPage);
-          entries = buffers ? [...buffers.consoleLogs] : [];
-        } else {
-          entries = [];
-          for (const buffers of this.pageLogBuffers.values()) {
-            entries.push(...buffers.consoleLogs);
+          case "network": {
+            let entries;
+            if (action.tab) {
+              const targetPage = await this.resolveTabTargetAsync(action.tab);
+              if (!targetPage) {
+                return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+              }
+              const buffers = this.pageLogBuffers.get(targetPage);
+              entries = buffers ? [...buffers.networkLogs] : [];
+            } else {
+              entries = [];
+              for (const buffers of this.pageLogBuffers.values()) {
+                entries.push(...buffers.networkLogs);
+              }
+            }
+            if (action.urlPattern) {
+              entries = entries.filter((e) => e.url.includes(action.urlPattern));
+            }
+            return { success: true, data: entries };
           }
-        }
-        if (action.level) {
-          entries = entries.filter((e) => e.level === action.level);
-        }
-        return { success: true, data: entries };
-      }
-      case "readNetworkLogs": {
-        let entries;
-        if (action.tab) {
-          const targetPage = await this.resolveTabTargetAsync(action.tab);
-          if (!targetPage) {
-            return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+          case "cookies": {
+            const cookies = await this.context.cookies();
+            if (action.name) {
+              const cookie = cookies.find((c) => c.name === action.name) ?? null;
+              return { success: true, data: cookie };
+            }
+            return { success: true, data: cookies };
           }
-          const buffers = this.pageLogBuffers.get(targetPage);
-          entries = buffers ? [...buffers.networkLogs] : [];
-        } else {
-          entries = [];
-          for (const buffers of this.pageLogBuffers.values()) {
-            entries.push(...buffers.networkLogs);
+          case "localStorage": {
+            const pageUrl = page.url();
+            if (pageUrl === "about:blank") {
+              return { success: true, data: action.key ? null : {} };
+            }
+            if (action.key) {
+              const value = await page.evaluate(
+                (k) => localStorage.getItem(k),
+                action.key
+              );
+              return { success: true, data: value };
+            }
+            const all = await page.evaluate(
+              () => Object.fromEntries(
+                Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
+              )
+            );
+            return { success: true, data: all };
           }
         }
-        if (action.urlPattern) {
-          entries = entries.filter((e) => e.url.includes(action.urlPattern));
-        }
-        return { success: true, data: entries };
-      }
-      case "readCookies": {
-        const cookies = await this.context.cookies();
-        if (action.name) {
-          const cookie = cookies.find((c) => c.name === action.name) ?? null;
-          return { success: true, data: cookie };
-        }
-        return { success: true, data: cookies };
+        return { success: true };
       }
       case "setCookies": {
         const cookiesWithDefaults = action.cookies.map((c) => ({
@@ -1164,25 +2973,6 @@ var WebPlatformAdapter = class {
         await this.context.addCookies(cookiesWithDefaults);
         return { success: true };
       }
-      case "readLocalStorage": {
-        const pageUrl = page.url();
-        if (pageUrl === "about:blank") {
-          return { success: true, data: action.key ? null : {} };
-        }
-        if (action.key) {
-          const value = await page.evaluate(
-            (k) => localStorage.getItem(k),
-            action.key
-          );
-          return { success: true, data: value };
-        }
-        const all = await page.evaluate(
-          () => Object.fromEntries(
-            Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
-          )
-        );
-        return { success: true, data: all };
-      }
       case "setLocalStorage": {
         await page.evaluate((entries) => {
           for (const { key, value } of entries) {
@@ -1191,8 +2981,37 @@ var WebPlatformAdapter = class {
         }, action.entries);
         return { success: true };
       }
-      case "assert": {
-        return { success: true };
+      case "focus": {
+        const locator = resolver.resolve(action.ref);
+        const box = await resolver.getBoundingBox(action.ref);
+        await locator.focus();
+        return { success: true, boundingBox: box ?? void 0 };
+      }
+      case "assertValue": {
+        let value;
+        if ("expr" in action) {
+          value = await page.evaluate(action.expr);
+        } else {
+          switch (action.source) {
+            case "url":
+              value = page.url();
+              break;
+            case "storage":
+              value = page.url() === "about:blank" ? {} : await page.evaluate(
+                () => Object.fromEntries(
+                  Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
+                )
+              );
+              break;
+            case "network":
+              value = this.peekNetworkLogs();
+              break;
+            case "expr-result":
+              value = void 0;
+              break;
+          }
+        }
+        return { success: true, data: value };
       }
       case "clearText": {
         const loc = resolver.resolve(action.ref);
@@ -1200,18 +3019,6 @@ var WebPlatformAdapter = class {
         await loc.clear();
         return { success: true, boundingBox: clearBox ?? void 0 };
       }
-      case "drag": {
-        const fromLoc = resolver.resolve(action.fromRef);
-        const toLoc = resolver.resolve(action.toRef);
-        await fromLoc.dragTo(toLoc);
-        return { success: true };
-      }
-      case "doubleTap": {
-        const dblLoc = resolver.resolve(action.ref);
-        const dblBox = await resolver.getBoundingBox(action.ref);
-        await dblLoc.dblclick();
-        return { success: true, boundingBox: dblBox ?? void 0 };
-      }
       case "doubleClick": {
         const locator = resolver.resolve(action.ref);
         const box = await resolver.getBoundingBox(action.ref);
@@ -1233,90 +3040,116 @@ var WebPlatformAdapter = class {
         });
         return { success: true, coordinates, boundingBox: box ?? void 0 };
       }
-      case "openLink": {
-        await page.goto(action.url, { waitUntil: "domcontentloaded" });
-        await waitForPageReady(page);
+      case "route": {
+        await this.context.route(action.urlPattern, async (route) => {
+          await route.fulfill({
+            status: 200,
+            ...action.contentType !== void 0 ? { contentType: action.contentType } : {},
+            ...action.headers !== void 0 ? { headers: action.headers } : {},
+            ...action.body !== void 0 ? { body: action.body } : {}
+          });
+        });
+        this.armedRoutes.add(action.urlPattern);
         return { success: true };
       }
-      case "newTab": {
-        const newPage = await this.context.newPage();
-        this.attachLogListeners(newPage);
-        await newPage.goto(action.url, { waitUntil: "domcontentloaded" });
-        await waitForPageReady(newPage);
-        this.page = newPage;
+      case "unroute": {
+        if (action.urlPattern !== void 0) {
+          await this.context.unroute(action.urlPattern);
+          this.armedRoutes.delete(action.urlPattern);
+        } else {
+          await this.context.unrouteAll({ behavior: "ignoreErrors" });
+          this.armedRoutes.clear();
+        }
         return { success: true };
       }
-      case "switchTab": {
-        const pages = this.context.pages();
-        let target;
-        if (action.index !== void 0) {
-          if (action.index < 0 || action.index >= pages.length) {
-            return { success: false, error: `Tab index ${action.index} out of range (${pages.length} tabs open)` };
-          }
-          target = pages[action.index];
-        } else if (action.title) {
-          for (const p of pages) {
-            const t = await p.title();
-            if (t.includes(action.title)) {
-              target = p;
-              break;
-            }
-          }
-        } else if (action.url) {
-          target = pages.find((p) => p.url().includes(action.url));
-        } else {
-          return { success: false, error: "switchTab requires at least one of: index, title, or url" };
+      case "networkState": {
+        if (action.mode === "offline") {
+          await this.context.setOffline(true);
+          return { success: true };
         }
-        if (!target) {
-          return { success: false, error: `No tab found matching ${JSON.stringify({ index: action.index, title: action.title, url: action.url })}` };
+        try {
+          const cdp = await this.context.newCDPSession(page);
+          await cdp.send("Network.emulateNetworkConditions", {
+            offline: false,
+            latency: action.latencyMs,
+            downloadThroughput: action.downloadKbps * 1e3 / 8,
+            uploadThroughput: action.uploadKbps * 1e3 / 8
+          });
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: `Network throttling is only available on Chromium (via CDP); this context does not support it. ${err instanceof Error ? err.message : String(err)}`
+          };
         }
-        this.page = target;
+      }
+      case "storageState": {
+        if (action.op === "save") {
+          const state = await this.context.storageState();
+          return { success: true, data: { name: action.name, state } };
+        }
+        await this.context.setStorageState(readSeamStorageState(action));
         return { success: true };
       }
-      // Mobile-only actions — graceful unsupported messages
-      case "tap":
-      case "swipe":
-      case "longpress":
-      case "pinch":
-      case "multiTap": {
-        return { success: false, error: `${action.type} is a mobile-only gesture` };
-      }
-      case "tapCoordinate": {
-        const vp = page.viewportSize();
-        if (vp) {
-          warnIfOutOfBounds({ x: action.x, y: action.y }, { width: vp.width, height: vp.height }, "tapCoordinate");
+      case "handleDialog": {
+        if (this.pendingDialogArm) {
+          page.off("dialog", this.pendingDialogArm);
+          this.pendingDialogArm = null;
         }
-        await page.mouse.click(action.x, action.y);
-        return { success: true, coordinates: { x: action.x, y: action.y } };
+        const accept = action.accept;
+        const promptText = action.promptText;
+        const handler = (dialog) => {
+          this.pendingDialogArm = null;
+          if (accept) {
+            void dialog.accept(promptText);
+          } else {
+            void dialog.dismiss();
+          }
+        };
+        this.pendingDialogArm = handler;
+        page.once("dialog", handler);
+        return { success: true };
       }
       case "executeScript": {
         return { success: false, error: "executeScript is a mobile-only action" };
       }
-      case "hideKeyboard":
-      case "launchApp":
-      case "stopApp":
-      case "setOrientation": {
-        return { success: true };
-      }
-      default: {
-        return { success: false, error: `Unknown action type: ${action.type}` };
-      }
+      // Runner-minted / author-channel verbs (D-01/D-15/D-16): reportValue, uniqueValue, assertAI,
+      // extractAI, and setVariable are intercepted at the dispatch seam and never reach the adapter.
+      // A grouped §7.1 defensive case surfaces a dispatch-routing error if one arrives here;
+      // assertNever remains the backstop for a genuinely unknown schema verb.
+      case "reportValue":
+      case "uniqueValue":
+      case "assertAI":
+      case "extractAI":
+      case "setVariable":
+        return {
+          success: false,
+          error: `Action "${action.type}" is handled by the runner dispatch seam and must not reach the web adapter (runner-minted/author-channel verb). This indicates a dispatch routing error.`
+        };
+      default:
+        return assertNever(action);
     }
   }
 };
 
 // src/farm-adapter.ts
+import { assertNever as assertNever2, buildScreenState as buildScreenState4 } from "@vostride/agent-qa-runner";
 import { getProvider, registerAllProviders } from "@vostride/agent-qa-core";
-import { convertKeysForPlatform as convertKeysForPlatform2, isMacPlatform as isMacPlatform2 } from "@vostride/agent-qa-core";
+import { convertKeysForPlatform as convertKeysForPlatform2, isMacPlatform as isMacPlatform2 } from "@vostride/agent-qa-runner";
 function clickDelayOption2(clickDelay) {
   return clickDelay !== void 0 && clickDelay > 0 ? { delay: clickDelay } : {};
 }
+function readSeamStorageState2(action) {
+  return action.state;
+}
 var FarmWebAdapter = class {
   platform = "web";
   browser = null;
   context = null;
   page = null;
+  // The native binding of the last observation and its document (438 D-06).
   lastRefs = {};
+  epoch;
   sessionUrl;
   sessionId;
   testFailed = false;
@@ -1324,7 +3157,14 @@ var FarmWebAdapter = class {
   credentials = null;
   pageLogBuffers = /* @__PURE__ */ new Map();
   logCaptureConfig = { console: true, network: true };
+  // Persistent route interception + one-shot dialog arms live until an explicit unroute or
+  // test teardown (D-12/D-18); cleanup() drains both so nothing bleeds across tests (Pitfall 7).
+  armedRoutes = /* @__PURE__ */ new Set();
+  pendingDialogArm = null;
+  recordingCapability;
+  recordingConfig;
   async setup(config) {
+    this.recordingConfig = config.recording;
     if (!config.farmSession) {
       throw new Error("FarmWebAdapter requires config.farmSession to be set");
     }
@@ -1349,12 +3189,6 @@ var FarmWebAdapter = class {
     const contextOptions = {
       viewport: config.browser?.viewport ?? { width: 1280, height: 720 }
     };
-    if (config.recording?.enabled) {
-      contextOptions.recordVideo = {
-        dir: config.recording.videoDir,
-        size: config.recording.videoSize ?? config.browser?.viewport ?? { width: 1280, height: 720 }
-      };
-    }
     if (config.authState?.storageStatePath) {
       contextOptions.storageState = config.authState.storageStatePath;
     }
@@ -1397,7 +3231,40 @@ var FarmWebAdapter = class {
     this.logCaptureConfig = { console: config.logCapture?.console !== false, network: config.logCapture?.network !== false };
     this.attachLogListeners(this.page);
   }
+  get recording() {
+    if (!this.page || !this.context || !this.recordingConfig) return void 0;
+    return this.recordingCapability ??= createScreencastRecording(
+      () => this.page,
+      this.recordingConfig
+    );
+  }
   async cleanup() {
+    try {
+      await this.recordingCapability?.stop();
+    } catch {
+    }
+    this.recordingCapability = void 0;
+    this.recordingConfig = void 0;
+    if (this.context) {
+      try {
+        await this.context.unrouteAll({ behavior: "ignoreErrors" });
+      } catch {
+      }
+      try {
+        await this.context.setOffline(false);
+      } catch {
+      }
+    }
+    if (this.page && this.pendingDialogArm) {
+      try {
+        this.page.off("dialog", this.pendingDialogArm);
+      } catch {
+      }
+    }
+    this.armedRoutes.clear();
+    this.pendingDialogArm = null;
+    await disposeEpoch(this.epoch);
+    this.epoch = void 0;
     if (this.browser) {
       await this.browser.close();
     }
@@ -1428,11 +3295,44 @@ var FarmWebAdapter = class {
     if (!this.page) {
       throw new Error("FarmWebAdapter not initialized \u2014 call setup() first");
     }
-    await waitForPageReady(this.page);
-    const state = await observePage(this.page, {
-      extractDom: options?.extractDom
+    const page = this.page;
+    await waitForPageReady(page);
+    const epoch = await captureEpoch(page);
+    try {
+      const state = await this.observeDocument(page, options);
+      await disposeEpoch(this.epoch);
+      this.epoch = epoch;
+      return state;
+    } catch (error) {
+      await disposeEpoch(epoch);
+      throw error;
+    }
+  }
+  async observeDocument(page, options) {
+    const ariaTree = await snapshotRoot(page);
+    const { nodes, nativeRefs } = parseAriaSnapshot(ariaTree);
+    if (nodes.length > 0) {
+      await enrichWebNodes(page, nodes, nativeRefs);
+    }
+    const { viewport, scroll } = await captureWebScroll(page);
+    let domContext;
+    if (options?.extractDom) {
+      try {
+        domContext = await extractDom(page);
+      } catch {
+      }
+    }
+    const { state, binding } = buildScreenState4({
+      platform: "web",
+      nodes,
+      viewport,
+      scroll,
+      coordSpace: "viewport",
+      timestamp: Date.now(),
+      url: page.url(),
+      ...domContext !== void 0 ? { domContext } : {}
     });
-    this.lastRefs = state.metadata.refMap ?? {};
+    this.lastRefs = buildRefMap(binding, nodes, nativeRefs, state.elements);
     return state;
   }
   async execute(action) {
@@ -1477,15 +3377,6 @@ var FarmWebAdapter = class {
   getPage() {
     return this.page;
   }
-  async getVideoPath() {
-    try {
-      const video = this.page?.video();
-      if (!video) return null;
-      return await video.path();
-    } catch {
-      return null;
-    }
-  }
   markFailed() {
     this.testFailed = true;
   }
@@ -1515,6 +3406,14 @@ var FarmWebAdapter = class {
     if (!urlPattern) return all;
     return all.filter((e) => e.url.includes(urlPattern));
   }
+  peekNetworkLogs(urlPattern) {
+    const all = [];
+    for (const buffers of this.pageLogBuffers.values()) {
+      all.push(...buffers.networkLogs.slice(buffers.networkDrainIndex));
+    }
+    if (!urlPattern) return all;
+    return all.filter((e) => e.url.includes(urlPattern));
+  }
   attachLogListeners(page) {
     const buffers = {
       consoleLogs: [],
@@ -1602,6 +3501,12 @@ var FarmWebAdapter = class {
   async executeAction(action) {
     const page = this.page;
     const resolver = new ElementResolver(page, this.lastRefs);
+    for (const ref of laneRefs(action)) {
+      const entry = this.lastRefs[ref];
+      if (entry === void 0) continue;
+      const check = action.type === "scroll" ? await checkDocument(page, this.epoch) : await checkBinding(page, this.epoch, entry);
+      if (check.outcome !== "ok") return bindingRefusal(check.outcome, ref);
+    }
     if ("ref" in action && typeof action.ref === "string") {
       const refData = this.lastRefs[action.ref];
       const role = refData?.role;
@@ -1623,8 +3528,10 @@ var FarmWebAdapter = class {
       case "fill": {
         const locator = resolver.resolve(action.ref);
         const box = await resolver.getBoundingBox(action.ref);
-        await locator.fill(action.value);
-        return { success: true, boundingBox: box ?? void 0 };
+        return runWebFillCompound(locator, box ?? void 0, action);
+      }
+      case "openApp": {
+        return webOpenAppError();
       }
       case "select": {
         const locator = resolver.resolve(action.ref);
@@ -1633,53 +3540,44 @@ var FarmWebAdapter = class {
         return { success: true, boundingBox: box ?? void 0 };
       }
       case "navigate": {
-        await page.goto(action.url, { waitUntil: "domcontentloaded" });
+        switch (action.to) {
+          case "url":
+            await page.goto(action.url, { waitUntil: "domcontentloaded" });
+            break;
+          case "back":
+            await page.goBack({ waitUntil: "domcontentloaded" });
+            break;
+          case "forward":
+            await page.goForward({ waitUntil: "domcontentloaded" });
+            break;
+          case "reload":
+            await page.reload({ waitUntil: "domcontentloaded" });
+            break;
+        }
         await waitForPageReady(page);
         return { success: true };
       }
       case "scroll": {
-        const deltaX = action.scrollType === "horizontal" ? action.value : 0;
-        const deltaY = action.scrollType === "vertical" ? action.value : 0;
-        let coordinates;
-        let boundingBox;
-        let scrollData;
-        if (action.ref) {
-          const refData = this.lastRefs[action.ref];
-          if (refData) {
-            const scrollAxis = action.scrollType === "horizontal" ? "horizontal" : "vertical";
-            const result = await scrollWithRef(page, refData, deltaX, deltaY, scrollAxis);
-            if (result.bounds) {
-              coordinates = { x: result.bounds.x + result.bounds.width / 2, y: result.bounds.y + result.bounds.height / 2 };
-              boundingBox = result.bounds;
-            }
-            scrollData = { scrolled: result.scrolled, scrolledContainer: result.scrolledContainer };
-          } else {
-            await page.mouse.wheel(deltaX, deltaY);
-          }
-        } else {
-          await page.mouse.wheel(deltaX, deltaY);
-        }
-        await page.evaluate(`new Promise(resolve => {
-          const t = setTimeout(() => resolve('timeout'), 500);
-          requestAnimationFrame(() => requestAnimationFrame(() => {
-            clearTimeout(t);
-            resolve('raf');
-          }));
-        })`);
-        return { success: true, coordinates, boundingBox, data: scrollData };
+        return runWebScrollCompound(page, this.lastRefs, action);
       }
       case "waitFor": {
-        const timeout = action.timeout ?? 5e3;
+        const timeout = action.timeoutMs;
         try {
-          await page.waitForFunction(
-            `document.body && document.body.innerText.includes(${JSON.stringify(action.condition)})`,
-            { timeout }
-          );
-        } catch {
-          try {
-            await page.waitForSelector(action.condition, { timeout });
-          } catch {
+          switch (action.on) {
+            case "text":
+              await page.getByText(action.text).first().waitFor({ state: "visible", timeout });
+              break;
+            case "gone":
+              await page.getByText(action.text).first().waitFor({ state: "hidden", timeout });
+              break;
+            case "selector":
+              await page.waitForSelector(action.selector, { timeout });
+              break;
           }
+        } catch {
+          const what = action.on === "selector" ? `selector "${action.selector}"` : `text "${action.text}"`;
+          const how = action.on === "gone" ? "was still present after" : "did not appear within";
+          return { success: false, error: `waitFor: ${what} ${how} ${timeout}ms.` };
         }
         return { success: true };
       }
@@ -1704,7 +3602,13 @@ var FarmWebAdapter = class {
           isMac: isMacPlatform2()
         });
         for (const key of effectiveKeys) {
-          await page.keyboard.press(key);
+          if (action.mode === "down") {
+            await page.keyboard.down(key);
+          } else if (action.mode === "up") {
+            await page.keyboard.up(key);
+          } else {
+            await page.keyboard.press(key);
+          }
         }
         return { success: true };
       }
@@ -1750,75 +3654,110 @@ var FarmWebAdapter = class {
         await page.evaluate(`navigator.clipboard.writeText(${JSON.stringify(text)})`);
         return { success: true, boundingBox: box ?? void 0, data: { copied: text } };
       }
-      case "keyDown": {
-        await page.keyboard.down(action.key);
-        return { success: true };
-      }
-      case "keyUp": {
-        await page.keyboard.up(action.key);
-        return { success: true };
-      }
-      case "refresh": {
-        await page.reload({ waitUntil: "domcontentloaded" });
-        await waitForPageReady(page);
-        return { success: true };
-      }
-      case "navigateHistory": {
-        if (action.direction === "back") {
-          await page.goBack({ waitUntil: "domcontentloaded" });
-        } else {
-          await page.goForward({ waitUntil: "domcontentloaded" });
+      case "tab": {
+        if (action.action === "new") {
+          const newPage = await this.context.newPage();
+          this.attachLogListeners(newPage);
+          await newPage.goto(action.url, { waitUntil: "domcontentloaded" });
+          await waitForPageReady(newPage);
+          this.page = newPage;
+          return { success: true };
         }
-        await waitForPageReady(page);
-        return { success: true };
-      }
-      case "readConsoleLogs": {
-        let entries;
-        if (action.tab) {
-          const targetPage = await this.resolveTabTargetAsync(action.tab);
-          if (!targetPage) {
-            return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+        const pages = this.context.pages();
+        let target;
+        if (action.index !== void 0) {
+          if (action.index < 0 || action.index >= pages.length) {
+            return { success: false, error: `Tab index ${action.index} out of range (${pages.length} tabs open)` };
           }
-          const buffers = this.pageLogBuffers.get(targetPage);
-          entries = buffers ? [...buffers.consoleLogs] : [];
-        } else {
-          entries = [];
-          for (const buffers of this.pageLogBuffers.values()) {
-            entries.push(...buffers.consoleLogs);
+          target = pages[action.index];
+        } else if (action.title !== void 0) {
+          for (const p of pages) {
+            const t = await p.title();
+            if (t.includes(action.title)) {
+              target = p;
+              break;
+            }
           }
+        } else if (action.url !== void 0) {
+          target = pages.find((p) => p.url().includes(action.url));
         }
-        if (action.level) {
-          entries = entries.filter((e) => e.level === action.level);
+        if (!target) {
+          return { success: false, error: `No tab found matching ${JSON.stringify({ index: action.index, title: action.title, url: action.url })}` };
         }
-        return { success: true, data: entries };
-      }
-      case "readNetworkLogs": {
-        let entries;
-        if (action.tab) {
-          const targetPage = await this.resolveTabTargetAsync(action.tab);
-          if (!targetPage) {
-            return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+        this.page = target;
+        return { success: true };
+      }
+      case "inspect": {
+        switch (action.what) {
+          case "console": {
+            let entries;
+            if (action.tab) {
+              const targetPage = await this.resolveTabTargetAsync(action.tab);
+              if (!targetPage) {
+                return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+              }
+              const buffers = this.pageLogBuffers.get(targetPage);
+              entries = buffers ? [...buffers.consoleLogs] : [];
+            } else {
+              entries = [];
+              for (const buffers of this.pageLogBuffers.values()) {
+                entries.push(...buffers.consoleLogs);
+              }
+            }
+            if (action.level) {
+              entries = entries.filter((e) => e.level === action.level);
+            }
+            return { success: true, data: entries };
           }
-          const buffers = this.pageLogBuffers.get(targetPage);
-          entries = buffers ? [...buffers.networkLogs] : [];
-        } else {
-          entries = [];
-          for (const buffers of this.pageLogBuffers.values()) {
-            entries.push(...buffers.networkLogs);
+          case "network": {
+            let entries;
+            if (action.tab) {
+              const targetPage = await this.resolveTabTargetAsync(action.tab);
+              if (!targetPage) {
+                return { success: false, error: `No tab found matching ${JSON.stringify(action.tab)}` };
+              }
+              const buffers = this.pageLogBuffers.get(targetPage);
+              entries = buffers ? [...buffers.networkLogs] : [];
+            } else {
+              entries = [];
+              for (const buffers of this.pageLogBuffers.values()) {
+                entries.push(...buffers.networkLogs);
+              }
+            }
+            if (action.urlPattern) {
+              entries = entries.filter((e) => e.url.includes(action.urlPattern));
+            }
+            return { success: true, data: entries };
+          }
+          case "cookies": {
+            const cookies = await this.context.cookies();
+            if (action.name) {
+              const cookie = cookies.find((c) => c.name === action.name) ?? null;
+              return { success: true, data: cookie };
+            }
+            return { success: true, data: cookies };
+          }
+          case "localStorage": {
+            const pageUrl = page.url();
+            if (pageUrl === "about:blank") {
+              return { success: true, data: action.key ? null : {} };
+            }
+            if (action.key) {
+              const value = await page.evaluate(
+                (k) => localStorage.getItem(k),
+                action.key
+              );
+              return { success: true, data: value };
+            }
+            const all = await page.evaluate(
+              () => Object.fromEntries(
+                Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
+              )
+            );
+            return { success: true, data: all };
           }
         }
-        if (action.urlPattern) {
-          entries = entries.filter((e) => e.url.includes(action.urlPattern));
-        }
-        return { success: true, data: entries };
-      }
-      case "readCookies": {
-        const cookies = await this.context.cookies();
-        if (action.name) {
-          const cookie = cookies.find((c) => c.name === action.name) ?? null;
-          return { success: true, data: cookie };
-        }
-        return { success: true, data: cookies };
+        return { success: true };
       }
       case "setCookies": {
         const cookiesWithDefaults = action.cookies.map((c) => ({
@@ -1828,25 +3767,6 @@ var FarmWebAdapter = class {
         await this.context.addCookies(cookiesWithDefaults);
         return { success: true };
       }
-      case "readLocalStorage": {
-        const pageUrl = page.url();
-        if (pageUrl === "about:blank") {
-          return { success: true, data: action.key ? null : {} };
-        }
-        if (action.key) {
-          const value = await page.evaluate(
-            (k) => localStorage.getItem(k),
-            action.key
-          );
-          return { success: true, data: value };
-        }
-        const all = await page.evaluate(
-          () => Object.fromEntries(
-            Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
-          )
-        );
-        return { success: true, data: all };
-      }
       case "setLocalStorage": {
         await page.evaluate((entries) => {
           for (const { key, value } of entries) {
@@ -1855,8 +3775,37 @@ var FarmWebAdapter = class {
         }, action.entries);
         return { success: true };
       }
-      case "assert": {
-        return { success: true };
+      case "focus": {
+        const locator = resolver.resolve(action.ref);
+        const box = await resolver.getBoundingBox(action.ref);
+        await locator.focus();
+        return { success: true, boundingBox: box ?? void 0 };
+      }
+      case "assertValue": {
+        let value;
+        if ("expr" in action) {
+          value = await page.evaluate(action.expr);
+        } else {
+          switch (action.source) {
+            case "url":
+              value = page.url();
+              break;
+            case "storage":
+              value = page.url() === "about:blank" ? {} : await page.evaluate(
+                () => Object.fromEntries(
+                  Object.keys(localStorage).map((k) => [k, localStorage.getItem(k)])
+                )
+              );
+              break;
+            case "network":
+              value = this.peekNetworkLogs();
+              break;
+            case "expr-result":
+              value = void 0;
+              break;
+          }
+        }
+        return { success: true, data: value };
       }
       case "clearText": {
         const loc = resolver.resolve(action.ref);
@@ -1864,18 +3813,6 @@ var FarmWebAdapter = class {
         await loc.clear();
         return { success: true, boundingBox: clearBox ?? void 0 };
       }
-      case "drag": {
-        const fromLoc = resolver.resolve(action.fromRef);
-        const toLoc = resolver.resolve(action.toRef);
-        await fromLoc.dragTo(toLoc);
-        return { success: true };
-      }
-      case "doubleTap": {
-        const dblLoc = resolver.resolve(action.ref);
-        const dblBox = await resolver.getBoundingBox(action.ref);
-        await dblLoc.dblclick();
-        return { success: true, boundingBox: dblBox ?? void 0 };
-      }
       case "doubleClick": {
         const locator = resolver.resolve(action.ref);
         const box = await resolver.getBoundingBox(action.ref);
@@ -1897,66 +3834,94 @@ var FarmWebAdapter = class {
         });
         return { success: true, coordinates, boundingBox: box ?? void 0 };
       }
-      case "openLink": {
-        await page.goto(action.url, { waitUntil: "domcontentloaded" });
-        await waitForPageReady(page);
+      case "route": {
+        await this.context.route(action.urlPattern, async (route) => {
+          await route.fulfill({
+            status: 200,
+            ...action.contentType !== void 0 ? { contentType: action.contentType } : {},
+            ...action.headers !== void 0 ? { headers: action.headers } : {},
+            ...action.body !== void 0 ? { body: action.body } : {}
+          });
+        });
+        this.armedRoutes.add(action.urlPattern);
         return { success: true };
       }
-      case "newTab": {
-        const newPage = await this.context.newPage();
-        this.attachLogListeners(newPage);
-        await newPage.goto(action.url, { waitUntil: "domcontentloaded" });
-        await waitForPageReady(newPage);
-        this.page = newPage;
+      case "unroute": {
+        if (action.urlPattern !== void 0) {
+          await this.context.unroute(action.urlPattern);
+          this.armedRoutes.delete(action.urlPattern);
+        } else {
+          await this.context.unrouteAll({ behavior: "ignoreErrors" });
+          this.armedRoutes.clear();
+        }
         return { success: true };
       }
-      case "switchTab": {
-        const pages = this.context.pages();
-        let target;
-        if (action.index !== void 0) {
-          if (action.index < 0 || action.index >= pages.length) {
-            return { success: false, error: `Tab index ${action.index} out of range (${pages.length} tabs open)` };
-          }
-          target = pages[action.index];
-        } else if (action.title) {
-          for (const p of pages) {
-            const t = await p.title();
-            if (t.includes(action.title)) {
-              target = p;
-              break;
-            }
-          }
-        } else if (action.url) {
-          target = pages.find((p) => p.url().includes(action.url));
-        } else {
-          return { success: false, error: "switchTab requires at least one of: index, title, or url" };
+      case "networkState": {
+        if (action.mode === "offline") {
+          await this.context.setOffline(true);
+          return { success: true };
         }
-        if (!target) {
-          return { success: false, error: `No tab found matching ${JSON.stringify({ index: action.index, title: action.title, url: action.url })}` };
+        try {
+          const cdp = await this.context.newCDPSession(page);
+          await cdp.send("Network.emulateNetworkConditions", {
+            offline: false,
+            latency: action.latencyMs,
+            downloadThroughput: action.downloadKbps * 1e3 / 8,
+            uploadThroughput: action.uploadKbps * 1e3 / 8
+          });
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: `Network throttling is only available on Chromium (via CDP); this context does not support it. ${err instanceof Error ? err.message : String(err)}`
+          };
         }
-        this.page = target;
-        return { success: true };
       }
-      case "tap":
-      case "swipe":
-      case "longpress":
-      case "pinch":
-      case "multiTap": {
-        return { success: false, error: `${action.type} is a mobile-only gesture` };
-      }
-      case "tapCoordinate": {
-        await page.mouse.click(action.x, action.y);
-        return { success: true, coordinates: { x: action.x, y: action.y } };
-      }
-      case "hideKeyboard":
-      case "launchApp":
-      case "stopApp":
-      case "setOrientation": {
+      case "storageState": {
+        if (action.op === "save") {
+          const state = await this.context.storageState();
+          return { success: true, data: { name: action.name, state } };
+        }
+        await this.context.setStorageState(readSeamStorageState2(action));
         return { success: true };
       }
-      default: {
-        return { success: false, error: `Unknown action type: ${action.type}` };
+      case "handleDialog": {
+        if (this.pendingDialogArm) {
+          page.off("dialog", this.pendingDialogArm);
+          this.pendingDialogArm = null;
+        }
+        const accept = action.accept;
+        const promptText = action.promptText;
+        const handler = (dialog) => {
+          this.pendingDialogArm = null;
+          if (accept) {
+            void dialog.accept(promptText);
+          } else {
+            void dialog.dismiss();
+          }
+        };
+        this.pendingDialogArm = handler;
+        page.once("dialog", handler);
+        return { success: true };
       }
+      case "executeScript": {
+        return { success: false, error: "executeScript not supported on farm adapter" };
+      }
+      // Runner-minted / author-channel verbs (D-01/D-15/D-16): reportValue, uniqueValue, assertAI,
+      // extractAI, and setVariable are intercepted at the dispatch seam and never reach the adapter.
+      // A grouped §7.1 defensive case surfaces a dispatch-routing error if one arrives here;
+      // assertNever remains the backstop for a genuinely unknown schema verb.
+      case "reportValue":
+      case "uniqueValue":
+      case "assertAI":
+      case "extractAI":
+      case "setVariable":
+        return {
+          success: false,
+          error: `Action "${action.type}" is handled by the runner dispatch seam and must not reach the web adapter (runner-minted/author-channel verb). This indicates a dispatch routing error.`
+        };
+      default:
+        return assertNever2(action);
     }
   }
 };