replicas-computer 0.3.22 → 0.3.24

package/dist/index.js

@@ -191,21 +191,18 @@ import { dirname as dirname4 } from "path";
 // src/commands/capture.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
-import { closeSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync as readFileSync2, readSync, rmSync, writeFileSync } from "fs";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { dirname as dirname2 } from "path";
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-function readPngDimensions(filePath) {
-  const fd = openSync(filePath, "r");
-  try {
-    const buf = Buffer.alloc(24);
-    const bytesRead = readSync(fd, buf, 0, 24, 0);
-    if (bytesRead < 24 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) {
-      fail(`${filePath} is not a valid PNG (read ${bytesRead}/24 bytes)`);
+function readImageDimensions(filePath) {
+  const data = readFileSync2(filePath);
+  if (data.length >= 24 && data.subarray(0, 8).equals(PNG_SIGNATURE)) return { width: data.readUInt32BE(16), height: data.readUInt32BE(20) };
+  if (data[0] === 255 && data[1] === 216) {
+    for (let offset = 2; offset + 9 < data.length && data[offset] === 255; offset += 2 + data.readUInt16BE(offset + 2)) {
+      if (data[offset + 1] >= 192 && data[offset + 1] <= 195) return { width: data.readUInt16BE(offset + 7), height: data.readUInt16BE(offset + 5) };
     }
-    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
-  } finally {
-    closeSync(fd);
   }
+  fail(`${filePath} is not a valid PNG or JPEG image`);
 }
 function currentWallpaper() {
   const recorded = `${STATE_DIR}/wallpaper-path`;
@@ -225,6 +222,12 @@ var SHADOW_OFFSET_Y_FRACTION = 0.013;
 var SHADOW_ALPHA = 0.6;
 var SCREENSHOT_MASK_TEMPLATE = `<svg width="__W__" height="__H__" xmlns="http://www.w3.org/2000/svg"><rect width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
 var SHADOW_MASK_TEMPLATE = `<svg width="__SW__" height="__SH__" xmlns="http://www.w3.org/2000/svg"><rect x="__M__" y="__M__" width="__W__" height="__H__" rx="__R__" ry="__R__" fill="white"/></svg>`;
+var isJpeg = (path) => /\.jpe?g$/i.test(path);
+var imageExtension = (path) => isJpeg(path) ? "jpg" : "png";
+var jpegQuality = (path) => isJpeg(path) ? ["-q:v", "2"] : [];
+function captureScreen(path) {
+  runDisplayCmd("scrot", ["-o", ...isJpeg(path) ? ["-q", "90"] : [], path]);
+}
 function parseGridSize(value) {
   if (value === void 0 || value === false) return null;
   const size = value === true ? 100 : parseCoord(value, "--grid");
@@ -269,6 +272,7 @@ function overlayGrid(rawPath, target, width2, height2, gridSize, gridPath) {
       "1",
       "-update",
       "1",
+      ...jpegQuality(target),
       target
     ],
     { stdio: "pipe" }
@@ -281,13 +285,13 @@ async function computerScreenshotCommand(path, options = {}) {
   const target = resolvePath(path);
   mkdirSync2(dirname2(target), { recursive: true });
   const stamp = `${process.pid}-${Date.now()}`;
-  const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.png`;
+  const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.${imageExtension(target)}`;
   const maskPath = `/tmp/replicas-screenshot-${stamp}.mask.svg`;
   const shadowPath = `/tmp/replicas-screenshot-${stamp}.shadow.svg`;
   const gridPath = `/tmp/replicas-screenshot-${stamp}.grid.svg`;
   try {
-    runDisplayCmd("scrot", ["-o", rawPath]);
-    const { width: width2, height: height2 } = readPngDimensions(rawPath);
+    captureScreen(rawPath);
+    const { width: width2, height: height2 } = getDisplayDimensions();
     const gridSize = parseGridSize(options.grid);
     if (options.raw && gridSize === null) {
       copyFileSync(rawPath, target);
@@ -339,6 +343,7 @@ async function computerScreenshotCommand(path, options = {}) {
         "1",
         "-update",
         "1",
+        ...jpegQuality(target),
         target
       ],
       { stdio: "pipe" }
@@ -357,22 +362,18 @@ async function computerScreenshotCommand(path, options = {}) {
 function hashFile(path) {
   return createHash("sha256").update(readFileSync2(path)).digest("hex");
 }
-async function captureStableRawScreenshot(target, options) {
+async function captureStableScreenshot(target, options) {
   const start = Date.now();
-  const framePath = `${target}.frame.png`;
+  const framePath = `${target}.frame.jpg`;
   let lastHash = null;
   let lastChangeAt = start;
   let frames = 0;
   let changes = 0;
-  let width2 = 0;
-  let height2 = 0;
+  let stable = false;
   try {
     while (Date.now() - start <= options.timeoutMs) {
-      runDisplayCmd("scrot", ["-o", framePath]);
+      captureScreen(framePath);
       frames++;
-      const dimensions = readPngDimensions(framePath);
-      width2 = dimensions.width;
-      height2 = dimensions.height;
       const hash = hashFile(framePath);
       const now = Date.now();
       if (lastHash === null) {
@@ -382,13 +383,16 @@ async function captureStableRawScreenshot(target, options) {
         lastChangeAt = now;
       }
       lastHash = hash;
-      copyFileSync(framePath, target);
       if (frames > 1 && now - lastChangeAt >= options.stableMs) {
-        return { width: width2, height: height2, stable: true, elapsedMs: now - start, frames, changes };
+        stable = true;
+        break;
       }
       await sleep(options.pollMs);
     }
-    return { width: width2, height: height2, stable: false, elapsedMs: Date.now() - start, frames, changes };
+    const elapsedMs = Date.now() - start;
+    if (isJpeg(target)) copyFileSync(framePath, target);
+    else captureScreen(target);
+    return { stable, elapsedMs, frames, changes };
   } finally {
     rmSync(framePath, { force: true });
   }
@@ -405,26 +409,27 @@ async function computerObserveCommand(path, options = {}) {
   mkdirSync2(dirname2(target), { recursive: true });
   const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 3e3;
   const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 600;
-  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 200;
+  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 100;
   if (timeoutMs < 0) fail("--timeout must be >= 0");
   if (stableMs < 0) fail("--stable-ms must be >= 0");
   if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
   const stamp = `${process.pid}-${Date.now()}`;
-  const rawPath = `/tmp/replicas-observe-${stamp}.raw.png`;
+  const rawPath = `/tmp/replicas-observe-${stamp}.raw.${imageExtension(target)}`;
   const gridPath = `/tmp/replicas-observe-${stamp}.grid.svg`;
   try {
     ensureServicesRunning();
-    const capture = await captureStableRawScreenshot(rawPath, { timeoutMs, stableMs, pollMs });
-    const gridSize = options.raw ? null : parseGridSize(options.grid ?? true);
+    const capture = await captureStableScreenshot(rawPath, { timeoutMs, stableMs, pollMs });
+    const { width: width2, height: height2 } = getDisplayDimensions();
+    const gridSize = options.raw ? null : parseGridSize(options.grid);
     if (gridSize === null) {
       copyFileSync(rawPath, target);
     } else {
-      overlayGrid(rawPath, target, capture.width, capture.height, gridSize, gridPath);
+      overlayGrid(rawPath, target, width2, height2, gridSize, gridPath);
     }
     console.log(JSON.stringify({
       screenshot: target,
-      width: capture.width,
-      height: capture.height,
+      width: width2,
+      height: height2,
       stable: capture.stable,
       elapsedMs: capture.elapsedMs,
       frames: capture.frames,
@@ -1115,6 +1120,7 @@ function isRecord(value) {
 async function openChromeSession(webSocketDebuggerUrl) {
   const socket = new WebSocket(webSocketDebuggerUrl);
   const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
   let nextId = 1;
   let closed = false;
   const fail2 = (error) => {
@@ -1137,6 +1143,7 @@ async function openChromeSession(webSocketDebuggerUrl) {
       return;
     }
     if (!isRecord(message)) return;
+    if (typeof message.method === "string" && isRecord(message.params)) listeners.get(message.method)?.(message.params);
     if (typeof message.id !== "number") return;
     const request = pending.get(message.id);
     if (!request) return;
@@ -1175,6 +1182,7 @@ async function openChromeSession(webSocketDebuggerUrl) {
       pending.set(id, { resolve: resolve5, reject, timeout });
       socket.send(JSON.stringify({ id, method, params }));
     }),
+    on: (method, listener) => listeners.set(method, listener),
     close: () => fail2(new Error("Chrome DevTools connection closed"))
   };
 }
@@ -1233,7 +1241,11 @@ async function selectChromePage(options = {}) {
       `No matching debuggable Chrome page found (${matches.length} match${matches.length === 1 ? "" : "es"}, index ${index}). Use \`replicas computer browser\` to list pages.`
     );
   }
-  await sendChromeCommand(webSocketDebuggerUrl, "Page.bringToFront", {});
+  const [front] = await sendChromeCommands(webSocketDebuggerUrl, [
+    { method: "Page.bringToFront", params: {} },
+    { method: "Runtime.evaluate", params: { expression: BROWSER_QUIET_JS, returnByValue: true } }
+  ]);
+  chromeResult(front, "Page.bringToFront");
   return { ...page, webSocketDebuggerUrl };
 }
 var VISIBLE_JS = `
@@ -1332,7 +1344,9 @@ function readBrowserStateCache(path) {
   return {
     url: typeof value.url === "string" ? value.url : void 0,
     documentId: typeof value.documentId === "string" || value.documentId === null ? value.documentId : void 0,
-    entries
+    entries,
+    textLimit: typeof value.textLimit === "number" ? value.textLimit : void 0,
+    elementLimit: typeof value.elementLimit === "number" ? value.elementLimit : void 0
   };
 }
 function chromeResult(response, method) {
@@ -1385,6 +1399,22 @@ function browserContentQuadRects(quads, viewportRect) {
 function buildBrowserBounds(result, viewport, targetId) {
   const strings = Array.isArray(result.strings) ? result.strings : [];
   const documents = Array.isArray(result.documents) ? result.documents.filter(isDOMSnapshotDocument) : [];
+  const pointerNodes = documents.map((document) => {
+    const cursors = /* @__PURE__ */ new Map();
+    document.layout?.nodeIndex?.forEach((nodeIndex, index) => {
+      const cursor = strings[document.layout?.styles?.[index]?.[0] ?? -1];
+      if (typeof cursor === "string") cursors.set(nodeIndex, cursor);
+    });
+    const parentIndex = document.nodes?.parentIndex ?? [];
+    const starts = /* @__PURE__ */ new Set();
+    for (const [nodeIndex, cursor] of cursors) {
+      if (!BROWSER_POINTER_CURSORS.has(cursor)) continue;
+      let parent = parentIndex[nodeIndex] ?? -1;
+      while (parent >= 0 && !cursors.has(parent)) parent = parentIndex[parent] ?? -1;
+      if (cursors.get(parent) !== cursor) starts.add(nodeIndex);
+    }
+    return starts;
+  });
   const localRects = documents.map((document) => {
     const rects = /* @__PURE__ */ new Map();
     const nodeIndexes = document.layout?.nodeIndex ?? [];
@@ -1475,7 +1505,7 @@ function buildBrowserBounds(result, viewport, targetId) {
         centerX: origin.x + local.centerX,
         centerY: origin.y + local.centerY
       };
-      if (intersectRects(rect, origin.clip)) byBackendNodeId.set(backendNodeId, { rect, clip: origin.clip });
+      if (intersectRects(rect, origin.clip)) byBackendNodeId.set(backendNodeId, { rect, clip: origin.clip, pointer: pointerNodes[documentIndex].has(nodeIndex) });
     }
   });
   return byBackendNodeId;
@@ -1518,6 +1548,10 @@ var BROWSER_STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
   "status",
   "StaticText"
 ]);
+var BROWSER_HIDDEN_STATES = /* @__PURE__ */ new Set(["focusable", "url"]);
+var BROWSER_POINTER_CURSORS = /* @__PURE__ */ new Set(["pointer", "grab", "move"]);
+var BROWSER_UNREFERENCED_ROLES = /* @__PURE__ */ new Set(["ListMarker", "RootWebArea", "StaticText"]);
+var BROWSER_TOGGLE_STATES = /* @__PURE__ */ new Set(["checked", "expanded", "pressed", "selected"]);
 var BROWSER_STATE_PROPERTIES = /* @__PURE__ */ new Set([
   "autocomplete",
   "checked",
@@ -1541,34 +1575,23 @@ var BROWSER_STATE_PROPERTIES = /* @__PURE__ */ new Set([
 function clippedText(value, limit = 240) {
   return String(value ?? "").replace(/\s+/g, " ").trim().slice(0, limit);
 }
-function browserTargetOutput(page) {
-  return {
-    targetId: page.id ?? null,
-    title: (page.title ?? "").slice(0, 1e3),
-    url: (page.url ?? "").slice(0, 2e3)
-  };
-}
 function browserNodeActionable(role, states) {
   return BROWSER_INTERACTIVE_ROLES.has(role) || states.editable === true || states.focusable === true && role !== "RootWebArea";
 }
-async function captureBrowserSnapshot(page, options) {
-  const initialCommands = [
-    { method: "Page.getFrameTree", params: {} },
-    { method: "Page.getLayoutMetrics", params: {} },
-    { method: "DOMSnapshot.captureSnapshot", params: { computedStyles: [], includeDOMRects: true, includePaintOrder: true } }
-  ];
-  const initial = await sendChromeCommands(page.webSocketDebuggerUrl, initialCommands);
-  const frameTree = chromeResult(initial[0], initialCommands[0].method).frameTree;
-  const layout = chromeResult(initial[1], initialCommands[1].method);
-  const domSnapshot = chromeResult(initial[2], initialCommands[2].method);
+async function captureBrowserSnapshot(session, page, options) {
+  const [frameTreeResult, layoutResult, domSnapshotResult, mainAxResult] = await Promise.all([
+    session.send({ method: "Page.getFrameTree", params: {} }),
+    session.send({ method: "Page.getLayoutMetrics", params: {} }),
+    session.send({ method: "DOMSnapshot.captureSnapshot", params: { computedStyles: ["cursor"] } }),
+    session.send({ method: "Accessibility.getFullAXTree", params: {} })
+  ]);
+  const frameTree = chromeResult(frameTreeResult, "Page.getFrameTree").frameTree;
+  const layout = chromeResult(layoutResult, "Page.getLayoutMetrics");
+  const domSnapshot = chromeResult(domSnapshotResult, "DOMSnapshot.captureSnapshot");
   const viewport = chromeVisualViewport(layout);
   const frameIds = collectFrameIds(frameTree);
   if (frameIds.length === 0 && page.id) frameIds.push(page.id);
-  const axCommands = frameIds.map((frameId) => ({
-    method: "Accessibility.getFullAXTree",
-    params: { frameId }
-  }));
-  const axResults = await sendChromeCommands(page.webSocketDebuggerUrl, axCommands);
+  const axResults = [mainAxResult, ...await Promise.all(frameIds.slice(1).map((frameId) => session.send({ method: "Accessibility.getFullAXTree", params: { frameId } })))];
   const nodes = [];
   axResults.forEach((response, index) => {
     if (response.error) return;
@@ -1584,6 +1607,8 @@ async function captureBrowserSnapshot(page, options) {
   const propertyMap = browserStateProperties;
   const roleOf = (node) => clippedText(node.role?.value, 80);
   const nameOf = (node) => clippedText(node.name?.value);
+  const textOf = (node, depth = 0) => depth > 6 ? "" : (node.childIds ?? []).map((id) => nodesByKey.get(`${node.sourceFrameId}:${id}`)).map((child) => !child ? "" : roleOf(child) === "StaticText" ? nameOf(child) : textOf(child, depth + 1)).filter(Boolean).join(" ");
+  const displayNameOf = (node) => nameOf(node) || (bounds.get(node.backendDOMNodeId ?? -1)?.pointer ? clippedText(textOf(node), 120) : "");
   const valueOf = (node) => {
     if (propertyMap(node).protected === true) return null;
     const value = node.value?.value;
@@ -1592,20 +1617,20 @@ async function captureBrowserSnapshot(page, options) {
     if (/^[•●*]+$/.test(text)) return "[protected]";
     return text || null;
   };
-  const meaningful = nodes.filter((node) => !node.ignored && Number.isInteger(node.backendDOMNodeId)).map((node) => ({
-    node,
-    role: roleOf(node),
-    bound: typeof node.backendDOMNodeId === "number" ? bounds.get(node.backendDOMNodeId) : void 0
-  })).filter((entry) => {
+  const meaningful = nodes.filter((node) => !node.ignored && Number.isInteger(node.backendDOMNodeId)).map((node) => {
+    const bound = typeof node.backendDOMNodeId === "number" ? bounds.get(node.backendDOMNodeId) : void 0;
+    const role = roleOf(node);
+    return { node, role: role === "generic" && bound?.pointer ? "clickable" : role, bound };
+  }).filter((entry) => {
     const { node, role, bound } = entry;
     if (!bound || bound.rect.width <= 0 || bound.rect.height <= 0) return false;
     if (role === "InlineTextBox" || role === "none" || role === "generic") return false;
-    if (BROWSER_INTERACTIVE_ROLES.has(role) || BROWSER_STRUCTURAL_ROLES.has(role)) return true;
+    if (bound.pointer || BROWSER_INTERACTIVE_ROLES.has(role) || BROWSER_STRUCTURAL_ROLES.has(role)) return true;
     return !!nameOf(node) || valueOf(node) !== null || propertyMap(node).focusable === true;
   }).filter(({ node, role }) => {
     if (role !== "StaticText") return true;
     const parent = node.parentId ? nodesByKey.get(`${node.sourceFrameId}:${node.parentId}`) : void 0;
-    return !parent || nameOf(parent) !== nameOf(node);
+    return !parent || displayNameOf(parent) !== nameOf(node);
   }).sort((a, b) => a.bound.rect.y - b.bound.rect.y || a.bound.rect.x - b.bound.rect.x);
   const elements = [];
   const entries = [];
@@ -1615,12 +1640,12 @@ async function captureBrowserSnapshot(page, options) {
   let treeLength = 0;
   const treeLimit = Math.min(5e4, Math.max(4e3, options.textLimit * 2));
   for (const { node, role, bound } of meaningful) {
-    const name = nameOf(node);
+    const name = displayNameOf(node);
     const description = clippedText(node.description?.value) || null;
     const value = valueOf(node);
     const states = propertyMap(node);
-    const actionable = browserNodeActionable(role, states);
-    const ref = actionable && elements.length < options.elementLimit ? String(node.backendDOMNodeId) : null;
+    const actionable = browserNodeActionable(role, states) || bound.pointer;
+    const ref = (actionable ? elements.length < options.elementLimit : !BROWSER_UNREFERENCED_ROLES.has(role)) ? String(node.backendDOMNodeId) : null;
     const visibleRect = role === "RootWebArea" && node.sourceFrameId === page.id ? { x: 0, y: 0, width: viewport.width, height: viewport.height, centerX: viewport.width / 2, centerY: viewport.height / 2 } : intersectRects(bound.rect, bound.clip) ?? bound.rect;
     const rect = roundBrowserRect(visibleRect);
     const actions = [
@@ -1628,7 +1653,7 @@ async function captureBrowserSnapshot(page, options) {
       ...["textbox", "searchbox", "combobox", "spinbutton", "slider"].includes(role) || states.editable === true ? ["set_value"] : [],
       "scroll"
     ];
-    if (ref) {
+    if (ref && actionable) {
       elements.push({
         ref,
         role,
@@ -1641,7 +1666,7 @@ async function captureBrowserSnapshot(page, options) {
         frameId: node.sourceFrameId
       });
     }
-    const stateText = Object.entries(states).filter(([key]) => key !== "url" && key !== "focusable").map(([key, state]) => `${key}=${JSON.stringify(state)}`);
+    const stateText = Object.entries(states).filter(([key, state]) => !BROWSER_HIDDEN_STATES.has(key) && (BROWSER_TOGGLE_STATES.has(key) || state !== false && state !== "false")).filter(([key]) => key !== "editable" || !["textbox", "searchbox"].includes(role)).map(([key, state]) => `${key}=${JSON.stringify(state)}`);
     const url = typeof states.url === "string" ? clippedText(states.url, 300) : "";
     const semantic = [role, name && JSON.stringify(name), value !== null && `value=${JSON.stringify(value)}`, description && `description=${JSON.stringify(description)}`, url && `url=${JSON.stringify(url)}`, ...stateText].filter(Boolean).join(" ");
     let depth = 0;
@@ -1667,9 +1692,11 @@ async function captureBrowserSnapshot(page, options) {
     }
   }
   const revision = createHash2("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
+  const mainFrame = isRecord(frameTree) && isRecord(frameTree.frame) ? frameTree.frame : {};
+  const frameUrl = typeof mainFrame.url === "string" ? `${mainFrame.url}${typeof mainFrame.urlFragment === "string" ? mainFrame.urlFragment : ""}` : page.url;
   const snapshot = {
-    title: (page.title ?? "").slice(0, 1e3),
-    url: (page.url ?? "").slice(0, 2e3),
+    title: page.title.slice(0, 1e3),
+    url: frameUrl.slice(0, 2e3),
     documentId: browserDocumentId(frameTree),
     revision,
     viewport,
@@ -1679,7 +1706,7 @@ async function captureBrowserSnapshot(page, options) {
     controls: elements,
     nodeCount: entries.length,
     elementCount: elements.length,
-    truncated: entries.length < meaningful.length || elements.length < meaningful.filter(({ node, role }) => browserNodeActionable(role, propertyMap(node))).length
+    truncated: entries.length < meaningful.length || elements.length < meaningful.filter(({ node, role, bound }) => browserNodeActionable(role, propertyMap(node)) || bound.pointer).length
   };
   return { snapshot, entries };
 }
@@ -1702,10 +1729,11 @@ async function computerBrowserCommand(options = {}) {
   for (const { target, page } of pages) {
     if (options.snapshot && target.webSocketDebuggerUrl) {
       try {
-        const { snapshot } = await captureBrowserSnapshot(
-          { ...target, webSocketDebuggerUrl: target.webSocketDebuggerUrl },
+        const { snapshot } = await withChromeSession(target.webSocketDebuggerUrl, async (session) => await captureBrowserSnapshot(
+          session,
+          { id: target.id, url: target.url ?? "", title: target.title ?? "" },
           { textLimit, elementLimit }
-        );
+        ));
         pageResults.push({ ...page, snapshot });
       } catch (error) {
         pageResults.push({ ...page, snapshotError: error instanceof Error ? error.message : "snapshot failed" });
@@ -1720,89 +1748,36 @@ async function computerBrowserCommand(options = {}) {
     pages: pageResults
   }, null, 2));
 }
-function buildBrowserStabilityExpression() {
-  return `(() => {
-    const key = '__replicasComputerUseObserver';
-    if (!globalThis[key]) {
-      const state = { revision: 0 };
-      const observer = new MutationObserver(() => state.revision++);
-      globalThis[key] = { state, observer, observing: false };
-    }
-    if (document.documentElement && !globalThis[key].observing) {
-      globalThis[key].observer.observe(document.documentElement, {
-        subtree: true,
-        childList: true,
-        attributes: true,
-        characterData: true,
-      });
-      globalThis[key].observing = true;
-    }
-    const controls = Array.from(document.querySelectorAll('input,textarea,select,[contenteditable="true"],[role="checkbox"],[role="combobox"],[role="slider"],[role="switch"],[role="textbox"]')).slice(0, 200);
-    const active = document.activeElement;
-    const controlState = controls.map((element, index) => {
-      const value = 'value' in element
-        ? element instanceof HTMLInputElement && element.type === 'password'
-          ? String(element.value).length
-          : String(element.value)
-        : element.textContent;
-      return [
-        index,
-        element === active,
-        value,
-        'checked' in element ? element.checked : null,
-        'selectedIndex' in element ? element.selectedIndex : null,
-        'disabled' in element ? element.disabled : null,
-        element.getAttribute('aria-checked'),
-        element.getAttribute('aria-expanded'),
-        element.getAttribute('aria-selected'),
-      ].join('|');
-    }).join('\\u001f');
-    let controlRevision = 2166136261;
-    for (let index = 0; index < controlState.length; index++) {
-      controlRevision ^= controlState.charCodeAt(index);
-      controlRevision = Math.imul(controlRevision, 16777619);
-    }
-    return {
-      revision: globalThis[key].state.revision,
-      controlRevision: (controlRevision >>> 0).toString(16),
-      readyState: document.readyState,
-      busy: !!document.querySelector('[aria-busy="true"]'),
-      url: location.href.slice(0, 2000),
-      scrollX: Math.round(scrollX),
-      scrollY: Math.round(scrollY),
-      innerWidth,
-      innerHeight,
-      devicePixelRatio,
-    };
-  })()`;
-}
-async function waitForBrowserStability(page, options) {
+var BROWSER_QUIET_JS = `(() => {
+  const key = '__replicasComputerUseQuiet';
+  if (!globalThis[key]) {
+    const tracker = { lastChange: performance.now() };
+    const touch = () => { tracker.lastChange = performance.now(); };
+    new MutationObserver(touch).observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+    for (const type of ['input', 'change', 'scroll']) addEventListener(type, touch, { capture: true, passive: true });
+    globalThis[key] = tracker;
+  }
+  return {
+    quietMs: Math.round(performance.now() - globalThis[key].lastChange),
+    readyState: document.readyState,
+    busy: !!document.querySelector('[aria-busy="true"]'),
+    animating: document.getAnimations().some((animation) => animation.playState === 'running' && animation.effect?.getTiming().iterations !== Infinity),
+    url: location.href.slice(0, 2000),
+    title: document.title.slice(0, 1000),
+    devicePixelRatio,
+  };
+})()`;
+async function waitForBrowserQuiet(session, options) {
   const startedAt = Date.now();
-  let lastSignature = null;
-  let lastChangeAt = startedAt;
-  let samples = 0;
-  let changes = 0;
-  let state = null;
-  while (Date.now() - startedAt <= options.timeoutMs) {
-    try {
-      state = await evaluateChromeTarget(page.webSocketDebuggerUrl, buildBrowserStabilityExpression());
-      samples++;
-      const signature = JSON.stringify(state);
-      const now = Date.now();
-      if (lastSignature === null || signature !== lastSignature) {
-        if (lastSignature !== null) changes++;
-        lastSignature = signature;
-        lastChangeAt = now;
-      }
-      const ready = typeof state === "object" && state !== null && "readyState" in state && state.readyState !== "loading" && "busy" in state && state.busy !== true;
-      if (samples > 1 && ready && now - lastChangeAt >= options.stableMs) {
-        return { stable: true, elapsedMs: now - startedAt, samples, changes, state };
-      }
-    } catch {
-    }
+  let state;
+  while (true) {
+    const value = await evaluateChromeSession(session, BROWSER_QUIET_JS).catch(() => null);
+    state = isRecord(value) ? value : {};
+    const now = Date.now();
+    const quiet = isRecord(value) && typeof value.quietMs === "number" && value.quietMs >= options.stableMs && value.readyState !== "loading" && value.busy !== true && value.animating !== true && now - (options.actedAt ?? 0) >= options.stableMs;
+    if (quiet || now - startedAt >= options.timeoutMs) return { stable: quiet, elapsedMs: now - startedAt, state };
     await sleep(options.pollMs);
   }
-  return { stable: false, elapsedMs: Date.now() - startedAt, samples, changes, state };
 }
 function browserStateCachePath(targetId) {
   return `${STATE_DIR}/browser-state-${targetId.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`;
@@ -1832,35 +1807,30 @@ function browserStateDiff(previous, current) {
   }
   return { tree: lines.join("\n") || "No accessibility changes.", added, changed, removed };
 }
-async function computerBrowserStateCommand(path, options = {}) {
-  const textLimit = options.limit ? parseCoord(options.limit, "--limit") : 8e3;
-  const elementLimit = options.elementLimit ? parseCoord(options.elementLimit, "--element-limit") : 120;
-  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 5e3;
-  const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 500;
-  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 100;
-  if (textLimit < 0 || textLimit > 5e4) fail("--limit must be between 0 and 50000");
-  if (elementLimit < 0 || elementLimit > 500) fail("--element-limit must be between 0 and 500");
-  if (timeoutMs < 0) fail("--timeout must be >= 0");
-  if (stableMs < 0) fail("--stable-ms must be >= 0");
-  if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
-  const page = await selectChromePage(options);
-  const stability = await waitForBrowserStability(page, { timeoutMs, stableMs, pollMs });
-  const target = resolvePath(path);
-  mkdirSync4(dirname4(target), { recursive: true });
-  const [{ snapshot, entries }, screenshotResult] = await Promise.all([
-    captureBrowserSnapshot(page, { textLimit, elementLimit }),
-    sendChromeCommand(page.webSocketDebuggerUrl, "Page.captureScreenshot", {
-      format: "png",
-      fromSurface: true,
-      captureBeyondViewport: false
-    })
+var BROWSER_ACTION_OBSERVATION = { textLimit: 8e3, elementLimit: 120, timeoutMs: 2e3, stableMs: 300, pollMs: 50 };
+async function observeBrowserPage(session, page, options) {
+  const settled = await waitForBrowserQuiet(session, options);
+  const live = {
+    id: page.id,
+    url: typeof settled.state.url === "string" ? settled.state.url : page.url ?? "",
+    title: typeof settled.state.title === "string" ? settled.state.title : page.title ?? ""
+  };
+  const [{ snapshot, entries }, capture] = await Promise.all([
+    captureBrowserSnapshot(session, live, options),
+    options.screenshotPath ? sendChromeSessionCommand(session, "Page.captureScreenshot", { format: isJpeg(options.screenshotPath) ? "jpeg" : "png", fromSurface: true, captureBeyondViewport: false }) : null
   ]);
-  const data = screenshotResult.data;
-  if (typeof data !== "string") fail("Chrome did not return screenshot data");
-  writeFileSync4(target, Buffer.from(data, "base64"));
-  const screenshot = readPngDimensions(target);
-  const targetId = page.id ?? "unknown";
-  const cachePath = browserStateCachePath(targetId);
+  let screenshot = null;
+  if (options.screenshotPath && capture) {
+    if (typeof capture.data !== "string") fail("Chrome did not return screenshot data");
+    mkdirSync4(dirname4(options.screenshotPath), { recursive: true });
+    writeFileSync4(options.screenshotPath, Buffer.from(capture.data, "base64"));
+    screenshot = {
+      path: options.screenshotPath,
+      ...readImageDimensions(options.screenshotPath),
+      devicePixelRatio: typeof settled.state.devicePixelRatio === "number" ? settled.state.devicePixelRatio : 1
+    };
+  }
+  const cachePath = browserStateCachePath(page.id ?? "unknown");
   let mode = "full";
   let tree = snapshot.tree;
   let changes = { added: snapshot.nodeCount, changed: 0, removed: 0 };
@@ -1874,33 +1844,62 @@ async function computerBrowserStateCommand(path, options = {}) {
     }
   }
   mkdirSync4(STATE_DIR, { recursive: true });
-  writeFileSync4(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries }));
-  const stableState = isRecord(stability.state) ? stability.state : {};
-  const state = {
-    title: snapshot.title,
-    url: snapshot.url,
-    documentId: snapshot.documentId,
-    revision: snapshot.revision,
-    viewport: snapshot.viewport,
-    text: snapshot.text,
-    tree,
-    nodeCount: snapshot.nodeCount,
-    elementCount: snapshot.elementCount,
-    truncated: snapshot.truncated,
-    mode,
-    changes
+  writeFileSync4(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries, textLimit: options.textLimit, elementLimit: options.elementLimit }));
+  return {
+    screenshot,
+    stability: { stable: settled.stable, elapsedMs: settled.elapsedMs },
+    state: {
+      title: snapshot.title,
+      url: snapshot.url,
+      documentId: snapshot.documentId,
+      revision: snapshot.revision,
+      viewport: snapshot.viewport,
+      tree,
+      nodeCount: snapshot.nodeCount,
+      elementCount: snapshot.elementCount,
+      truncated: snapshot.truncated,
+      mode,
+      changes
+    }
   };
-  console.log(JSON.stringify({
-    targetId,
-    screenshot: {
-      path: target,
-      width: screenshot.width,
-      height: screenshot.height,
-      devicePixelRatio: typeof stableState.devicePixelRatio === "number" ? stableState.devicePixelRatio : 1
-    },
-    stability,
-    state
-  }, null, 2));
+}
+async function observeAfterBrowserAction(page, actedAt) {
+  const cachePath = browserStateCachePath(page.id ?? "unknown");
+  const cached = existsSync4(cachePath) ? readBrowserStateCache(cachePath) : null;
+  try {
+    const { stability, state } = await withChromeSession(page.webSocketDebuggerUrl, async (session) => await observeBrowserPage(session, page, {
+      ...BROWSER_ACTION_OBSERVATION,
+      textLimit: cached?.textLimit ?? BROWSER_ACTION_OBSERVATION.textLimit,
+      elementLimit: cached?.elementLimit ?? BROWSER_ACTION_OBSERVATION.elementLimit,
+      actedAt
+    }));
+    return { stability, state };
+  } catch (error) {
+    return { error: `Action completed but the page could not be observed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+async function computerBrowserStateCommand(path, options = {}) {
+  const textLimit = options.limit ? parseCoord(options.limit, "--limit") : 8e3;
+  const elementLimit = options.elementLimit ? parseCoord(options.elementLimit, "--element-limit") : 120;
+  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 5e3;
+  const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 500;
+  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 100;
+  if (textLimit < 0 || textLimit > 5e4) fail("--limit must be between 0 and 50000");
+  if (elementLimit < 0 || elementLimit > 500) fail("--element-limit must be between 0 and 500");
+  if (timeoutMs < 0) fail("--timeout must be >= 0");
+  if (stableMs < 0) fail("--stable-ms must be >= 0");
+  if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
+  const page = await selectChromePage(options);
+  const observation = await withChromeSession(page.webSocketDebuggerUrl, async (session) => await observeBrowserPage(session, page, {
+    full: options.full,
+    textLimit,
+    elementLimit,
+    timeoutMs,
+    stableMs,
+    pollMs,
+    screenshotPath: path === void 0 ? void 0 : resolvePath(path)
+  }));
+  console.log(JSON.stringify({ targetId: page.id ?? "unknown", ...observation }, null, 2));
 }
 var DESKTOP_POINT_JS = `
     const desktopPoint = (rect) => {
@@ -1920,10 +1919,9 @@ function readBrowserRefCache(page) {
   const targetId = page.id;
   if (!targetId) fail("Chrome target has no stable ID. Capture fresh browser state and retry.");
   const cachePath = browserStateCachePath(targetId);
-  if (!existsSync4(cachePath)) fail(`No browser state is cached for target ${targetId}. Run replicas computer browser-state <path> --target-id ${targetId} first.`);
+  if (!existsSync4(cachePath)) fail(`No browser state is cached for target ${targetId}. Run replicas computer browser-state --target-id ${targetId} first.`);
   const cached = readBrowserStateCache(cachePath);
   if (!cached) fail(`Browser state for target ${targetId} is invalid. Capture fresh browser state and retry.`);
-  if (cached.url !== (page.url ?? "").slice(0, 2e3)) fail("Cached browser state belongs to a different URL. Capture fresh browser state and retry.");
   return { targetId, cached };
 }
 function browserViewportRect(layout) {
@@ -1938,11 +1936,10 @@ function browserViewportRect(layout) {
   };
 }
 async function prepareBrowserElement(page, refValue) {
-  const backendNodeId = parseBrowserRef(refValue);
   const { cached } = readBrowserRefCache(page);
   return await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
     const layout = await sendChromeSessionCommand(session, "Page.getLayoutMetrics", {});
-    const rect = await prepareBrowserRefInSession(session, backendNodeId, cached, browserViewportRect(layout));
+    const { backendNodeId, rect } = await prepareBrowserRefInSession(session, parseBrowserRef(refValue), cached, browserViewportRect(layout));
     const axNodes = (await sendChromeSessionCommand(session, "Accessibility.getPartialAXTree", {
       backendNodeId,
       fetchRelatives: false
@@ -1975,23 +1972,35 @@ ${DESKTOP_POINT_JS}
     };
   });
 }
-async function prepareBrowserRefInSession(session, backendNodeId, cached, viewportRect) {
-  if (!cached.entries.some(({ line }) => line.trimStart().startsWith(`[ref=${backendNodeId}]`))) {
-    fail(`Browser element ref ${backendNodeId} is not in the latest state. Capture fresh browser state and retry.`);
-  }
+var browserRefIdentity = (semantic) => semantic.match(/^\S+ "(?:[^"\\]|\\.)+"/)?.[0] ?? null;
+async function findReplacedBrowserRef(session, semantic, cached) {
+  const identity = browserRefIdentity(semantic);
+  if (!identity || cached.entries.filter((entry) => browserRefIdentity(entry.semantic) === identity).length !== 1) return null;
+  const { entries } = await captureBrowserSnapshot(session, { url: "", title: "" }, { textLimit: 5e4, elementLimit: 500 });
+  const matches = entries.filter((entry) => entry.line.trimStart().startsWith("[ref=") && browserRefIdentity(entry.semantic) === identity);
+  return matches.length === 1 ? Number(matches[0].key.split(":").pop()) : null;
+}
+async function prepareBrowserRefInSession(session, ref, cached, viewportRect) {
+  const entry = cached.entries.find(({ line }) => line.trimStart().startsWith(`[ref=${ref}]`));
+  if (!entry) fail(`Browser element ref ${ref} is not in the latest state. Capture fresh browser state and retry.`);
   const frameTree = (await sendChromeSessionCommand(session, "Page.getFrameTree", {})).frameTree;
   if (cached.documentId !== browserDocumentId(frameTree)) {
-    fail(`Browser element ref ${backendNodeId} belongs to a previous document. Capture fresh browser state and retry.`);
-  }
-  try {
-    await sendChromeSessionCommand(session, "DOM.scrollIntoViewIfNeeded", { backendNodeId });
-  } catch (error) {
-    fail(`Browser element ref ${backendNodeId} is stale or cannot be scrolled into view: ${error instanceof Error ? error.message : String(error)}`);
+    fail(`Browser element ref ${ref} belongs to a previous document. Capture fresh browser state and retry.`);
   }
+  const backendNodeId = await sendChromeSessionCommand(session, "DOM.scrollIntoViewIfNeeded", { backendNodeId: ref }).then(
+    () => ref,
+    async (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      const replacement = /detached|No node/i.test(message) ? await findReplacedBrowserRef(session, entry.semantic, cached) : null;
+      if (replacement === null) fail(`Browser element ref ${ref} is stale or cannot be scrolled into view: ${message}`);
+      await sendChromeSessionCommand(session, "DOM.scrollIntoViewIfNeeded", { backendNodeId: replacement });
+      return replacement;
+    }
+  );
   const quads = (await sendChromeSessionCommand(session, "DOM.getContentQuads", { backendNodeId })).quads;
   const candidates = browserContentQuadRects(quads, viewportRect);
-  if (!candidates[0]) fail(`Browser element ref ${backendNodeId} has no visible content quad. Fetch fresh browser state and retry.`);
-  return roundBrowserRect(candidates[0]);
+  if (!candidates[0]) fail(`Browser element ref ${ref} has no visible content quad. Fetch fresh browser state and retry.`);
+  return { backendNodeId, rect: roundBrowserRect(candidates[0]) };
 }
 function buildBrowserClickExpression(query, options) {
   return `(() => {
@@ -2094,6 +2103,62 @@ async function dispatchChromeClickInSession(session, x, y, button, clicks) {
     });
   }
 }
+async function dragChromeInSession(session, from, to) {
+  const intercepted = new Promise((resolve5) => session.on("Input.dragIntercepted", (params) => resolve5(params.data)));
+  await sendChromeSessionCommand(session, "Input.setInterceptDrags", { enabled: true });
+  let released = false;
+  try {
+    await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mouseMoved", x: from.centerX, y: from.centerY });
+    await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mousePressed", x: from.centerX, y: from.centerY, button: "left", buttons: 1, clickCount: 1 });
+    const steps = 10;
+    for (let step = 1; step <= steps; step++) {
+      await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", {
+        type: "mouseMoved",
+        x: from.centerX + (to.centerX - from.centerX) * step / steps,
+        y: from.centerY + (to.centerY - from.centerY) * step / steps,
+        button: "left",
+        buttons: 1
+      });
+    }
+    const dragData = await Promise.race([intercepted, sleep(100).then(() => void 0)]);
+    if (dragData) {
+      for (const type of ["dragEnter", "dragOver", "drop"]) {
+        await sendChromeSessionCommand(session, "Input.dispatchDragEvent", { type, x: to.centerX, y: to.centerY, data: dragData });
+      }
+    }
+    await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mouseReleased", x: to.centerX, y: to.centerY, button: "left", buttons: 0, clickCount: 1 });
+    released = true;
+  } finally {
+    if (!released) {
+      await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mouseReleased", x: to.centerX, y: to.centerY, button: "left", buttons: 0, clickCount: 1 }).catch(() => void 0);
+    }
+    await sendChromeSessionCommand(session, "Input.setInterceptDrags", { enabled: false }).catch(() => void 0);
+  }
+}
+async function prepareBrowserDragInSession(session, refs, cached, viewportRect) {
+  const to = await prepareBrowserRefInSession(session, refs.to, cached, viewportRect);
+  const from = await prepareBrowserRefInSession(session, refs.from, cached, viewportRect);
+  const [fromQuad, toQuad] = await Promise.all([from, to].map(async ({ backendNodeId }) => browserContentQuadRects((await sendChromeSessionCommand(session, "DOM.getContentQuads", { backendNodeId })).quads, viewportRect)[0]));
+  if (!fromQuad || !toQuad) fail(`Browser element refs ${refs.from} and ${refs.to} are not visible together. Scroll so both are in view and retry.`);
+  return { from: roundBrowserRect(fromQuad), to: roundBrowserRect(toQuad), refs: { from: from.backendNodeId, to: to.backendNodeId } };
+}
+async function computerBrowserDragCommand(options) {
+  const page = await selectChromePage(options);
+  const { cached } = readBrowserRefCache(page);
+  const refs = { from: parseBrowserRef(options.ref), to: parseBrowserRef(options.toRef) };
+  const rects = await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+    const layout = await sendChromeSessionCommand(session, "Page.getLayoutMetrics", {});
+    const prepared = await prepareBrowserDragInSession(session, refs, cached, browserViewportRect(layout));
+    await dragChromeInSession(session, prepared.from, prepared.to);
+    return prepared;
+  });
+  logRecordingAction({ type: "drag" });
+  console.log(JSON.stringify({
+    targetId: page.id ?? null,
+    result: { dragged: true, ref: String(rects.refs.from), toRef: String(rects.refs.to), from: rects.from, to: rects.to },
+    observation: await observeAfterBrowserAction(page, Date.now())
+  }, null, 2));
+}
 async function replaceChromeText(page, text) {
   await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
     await replaceChromeTextInSession(session, text);
@@ -2129,8 +2194,14 @@ function browserFillInvalid(actual, expected, fieldType, semanticSelection = fal
   if (fieldType === "color") return String(actual).toLowerCase() !== expected.toLowerCase();
   return actual !== expected;
 }
-async function fillChromeNodeInSession(session, backendNodeId, value) {
+async function fillBrowserRefInSession(session, ref, cached, viewportRect, value) {
+  let { backendNodeId } = await prepareBrowserRefInSession(session, ref, cached, viewportRect);
   await sendChromeSessionCommand(session, "DOM.focus", { backendNodeId });
+  const connected = await callFunctionOnChromeNodeInSession(session, backendNodeId, "function() { return this.isConnected; }").then(chromeCallValue, () => false);
+  if (connected !== true) {
+    ({ backendNodeId } = await prepareBrowserRefInSession(session, ref, cached, viewportRect));
+    await sendChromeSessionCommand(session, "DOM.focus", { backendNodeId });
+  }
   const directResult = await callFunctionOnChromeNodeInSession(
     session,
     backendNodeId,
@@ -2183,7 +2254,7 @@ async function fillChromeNodeInSession(session, backendNodeId, value) {
   if (browserFillInvalid(actual.value, value, fieldType, semanticSelection, selectionMatched)) {
     fail(`Chrome reported that ref ${backendNodeId} contains ${JSON.stringify(actual.value)} after filling, expected ${JSON.stringify(value)}.`);
   }
-  return { value: actual.value, valueLength: actual.valueLength, type: fieldType };
+  return { backendNodeId, value: actual.value, valueLength: actual.valueLength, type: fieldType };
 }
 async function computerBrowserClickCommand(query, options = {}) {
   const page = await selectChromePage(options);
@@ -2196,8 +2267,9 @@ async function computerBrowserClickCommand(query, options = {}) {
     await dispatchChromeClick(page, target.rect.centerX, target.rect.centerY, button, clicks);
     if (target.desktopPoint) logRecordingAction({ type: "click", ...target.desktopPoint });
     console.log(JSON.stringify({
-      ...browserTargetOutput(page),
-      result: { clicked: true, ref: target.ref, button, clickCount: clicks, rect: target.rect, element: target.element }
+      targetId: page.id ?? null,
+      result: { clicked: true, ref: target.ref, button, clickCount: clicks, rect: target.rect, element: target.element },
+      observation: await observeAfterBrowserAction(page, Date.now())
     }, null, 2));
     return;
   }
@@ -2213,8 +2285,9 @@ async function computerBrowserClickCommand(query, options = {}) {
   const point = browserActionPoint(result);
   if (point) logRecordingAction({ type: "click", ...point });
   console.log(JSON.stringify({
-    ...browserTargetOutput(page),
-    result
+    targetId: page.id ?? null,
+    result,
+    observation: await observeAfterBrowserAction(page, Date.now())
   }, null, 2));
 }
 function buildBrowserFillExpression(query, value, options) {
@@ -2336,13 +2409,18 @@ ${DESKTOP_POINT_JS}
 async function computerBrowserFillCommand(query, value, options = {}) {
   const page = await selectChromePage(options);
   if (options.ref) {
+    const ref = parseBrowserRef(options.ref);
     const target = await prepareBrowserElement(page, options.ref);
-    const backendNodeId = parseBrowserRef(options.ref);
-    const actual = await withChromeSession(page.webSocketDebuggerUrl, async (session) => await fillChromeNodeInSession(session, backendNodeId, value));
+    const { cached } = readBrowserRefCache(page);
+    const actual = await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+      const layout = await sendChromeSessionCommand(session, "Page.getLayoutMetrics", {});
+      return await fillBrowserRefInSession(session, ref, cached, browserViewportRect(layout), value);
+    });
     if (target.desktopPoint) logRecordingAction({ type: "type", ...target.desktopPoint });
     console.log(JSON.stringify({
-      ...browserTargetOutput(page),
-      result: { filled: true, ref: target.ref, valueLength: actual.valueLength, rect: target.rect, element: target.element }
+      targetId: page.id ?? null,
+      result: { filled: true, ref: String(actual.backendNodeId), valueLength: actual.valueLength, rect: target.rect, element: target.element },
+      observation: await observeAfterBrowserAction(page, Date.now())
     }, null, 2));
     return;
   }
@@ -2375,8 +2453,9 @@ async function computerBrowserFillCommand(query, value, options = {}) {
   }
   if (point) logRecordingAction({ type: "type", ...point });
   console.log(JSON.stringify({
-    ...browserTargetOutput(page),
-    result
+    targetId: page.id ?? null,
+    result,
+    observation: await observeAfterBrowserAction(page, Date.now())
   }, null, 2));
 }
 function buildBrowserWaitExpression(query, options) {
@@ -2438,7 +2517,34 @@ async function computerBrowserWaitCommand(query, options = {}) {
     await sleep(pollMs);
   }
   console.log(JSON.stringify({ ok: false, elapsedMs: Date.now() - start, attempts, result: lastResult }, null, 2));
-  process.exitCode = 1;
+  fail(`Timed out after ${timeoutMs}ms waiting for ${JSON.stringify(query)}`);
+}
+async function browserScrollPointInSession(session, viewportRect, deltaX, deltaY) {
+  const point = await evaluateChromeSession(session, `(() => {
+    const vertical = ${deltaY !== 0};
+    const root = document.scrollingElement || document.documentElement;
+    if (vertical ? root.scrollHeight > innerHeight : root.scrollWidth > innerWidth) return null;
+    let best = null;
+    let bestArea = 0;
+    for (const el of document.querySelectorAll('*')) {
+      const style = getComputedStyle(el);
+      const scrollable = vertical
+        ? /(auto|scroll)/.test(style.overflowY) && el.scrollHeight > el.clientHeight
+        : /(auto|scroll)/.test(style.overflowX) && el.scrollWidth > el.clientWidth;
+      if (!scrollable) continue;
+      const rect = el.getBoundingClientRect();
+      const left = Math.max(rect.left, 0);
+      const top = Math.max(rect.top, 0);
+      const width = Math.min(rect.right, innerWidth) - left;
+      const height = Math.min(rect.bottom, innerHeight) - top;
+      if (width > 0 && height > 0 && width * height > bestArea) {
+        bestArea = width * height;
+        best = { x: left + width / 2, y: top + height / 2 };
+      }
+    }
+    return best;
+  })()`);
+  return isRecord(point) && typeof point.x === "number" && typeof point.y === "number" ? { x: point.x, y: point.y } : { x: viewportRect.centerX, y: viewportRect.centerY };
 }
 async function computerBrowserScrollCommand(direction, options = {}) {
   const page = await selectChromePage(options);
@@ -2446,25 +2552,54 @@ async function computerBrowserScrollCommand(direction, options = {}) {
   if (!["up", "down", "left", "right"].includes(normalized)) fail("direction must be one of up|down|left|right");
   const amount = options.amount ? parseCoord(options.amount, "--amount") : 600;
   if (amount <= 0 || amount > 1e4) fail("--amount must be between 1 and 10000 CSS pixels");
-  const layout = await sendChromeCommand(page.webSocketDebuggerUrl, "Page.getLayoutMetrics", {});
-  const viewport = chromeVisualViewport(layout);
+  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 1e4;
   const target = options.ref ? await prepareBrowserElement(page, options.ref) : null;
-  const x = target?.rect.centerX ?? viewport.width / 2;
-  const y = target?.rect.centerY ?? viewport.height / 2;
   const deltaX = normalized === "left" ? -amount : normalized === "right" ? amount : 0;
   const deltaY = normalized === "up" ? -amount : normalized === "down" ? amount : 0;
-  await sendChromeCommand(page.webSocketDebuggerUrl, "Input.dispatchMouseEvent", {
-    type: "mouseWheel",
-    x,
-    y,
-    deltaX,
-    deltaY
+  const startedAt = Date.now();
+  const { point, scrolls, search } = await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+    const point2 = target ? { x: target.rect.centerX, y: target.rect.centerY } : await browserScrollPointInSession(session, browserViewportRect(await sendChromeSessionCommand(session, "Page.getLayoutMetrics", {})), deltaX, deltaY);
+    const wheel = () => sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mouseWheel", ...point2, deltaX, deltaY });
+    if (options.until === void 0) {
+      await wheel();
+      return { point: point2, scrolls: 1, search: null };
+    }
+    const expression = `(() => {
+      const needle = ${JSON.stringify(options.until)}.replace(/\\s+/g, ' ').trim().toLowerCase();
+      const normalize = (text) => String(text || '').replace(/\\s+/g, ' ').trim();
+      const has = (el) => normalize(el.innerText).toLowerCase().includes(needle);
+${VISIBLE_JS}
+      const offsets = [scrollX, scrollY, document.getElementsByTagName('*').length];
+      for (let el = document.elementFromPoint(${point2.x}, ${point2.y}); el; el = el.parentElement) offsets.push(el.scrollLeft, el.scrollTop);
+      if (!document.body || !has(document.body)) return { match: null, signature: offsets.join(',') };
+      let el = document.body;
+      for (let child = el; child; child = Array.from(el.children).find((item) => visible(item) && has(item))) el = child;
+      el.scrollIntoView({ block: 'center', inline: 'nearest' });
+      return { match: normalize(el.innerText).slice(0, 300), signature: null };
+    })()`;
+    let scrolls2 = 0;
+    let unchanged = 0;
+    let previous = null;
+    while (true) {
+      const found = await evaluateChromeSession(session, expression);
+      if (!isRecord(found)) fail("Chrome did not return a text search result");
+      if (typeof found.match === "string") return { point: point2, scrolls: scrolls2, search: { found: true, match: found.match } };
+      unchanged = found.signature === previous ? unchanged + 1 : 0;
+      previous = found.signature;
+      if (unchanged >= 2) return { point: point2, scrolls: scrolls2, search: { found: false, reason: "Reached the end of the scrollable content" } };
+      if (Date.now() - startedAt >= timeoutMs) return { point: point2, scrolls: scrolls2, search: { found: false, reason: `Timed out after ${timeoutMs}ms` } };
+      await wheel();
+      scrolls2++;
+      await waitForBrowserQuiet(session, { timeoutMs: 2e3, stableMs: 300, pollMs: 50, actedAt: Date.now() });
+    }
   });
   logRecordingAction({ type: "scroll", ...target?.desktopPoint ?? {} });
   console.log(JSON.stringify({
-    ...browserTargetOutput(page),
-    result: { scrolled: true, direction: normalized, amount, ref: target?.ref ?? null, x: Math.round(x), y: Math.round(y) }
+    targetId: page.id ?? null,
+    result: { scrolled: true, direction: normalized, amount, scrolls, ref: target?.ref ?? null, x: Math.round(point.x), y: Math.round(point.y), ...search && { until: options.until, ...search } },
+    observation: await observeAfterBrowserAction(page, Date.now())
   }, null, 2));
+  if (search?.found === false) fail(`${search.reason} without finding ${JSON.stringify(options.until)}`);
 }
 function browserKeyDetails(combo) {
   const tokens = combo.split("+").map((token) => token.trim()).filter(Boolean);
@@ -2521,7 +2656,7 @@ async function computerBrowserKeyCommand(combo, options = {}) {
     await dispatchChromeKeyInSession(session, key);
   });
   logRecordingAction({ type: "key" });
-  console.log(JSON.stringify({ targetId: page.id ?? null, result: { pressed: combo } }, null, 2));
+  console.log(JSON.stringify({ targetId: page.id ?? null, result: { pressed: combo }, observation: await observeAfterBrowserAction(page, Date.now()) }, null, 2));
 }
 async function dispatchChromeKeyInSession(session, key) {
   await sendChromeSessionCommand(session, "Input.dispatchKeyEvent", {
@@ -2542,7 +2677,7 @@ async function computerBrowserTypeCommand(text, options = {}) {
   const page = await selectChromePage(options);
   await sendChromeCommand(page.webSocketDebuggerUrl, "Input.insertText", { text });
   logRecordingAction({ type: "type" });
-  console.log(JSON.stringify({ targetId: page.id ?? null, result: { typed: true, length: text.length } }, null, 2));
+  console.log(JSON.stringify({ targetId: page.id ?? null, result: { typed: true, length: text.length }, observation: await observeAfterBrowserAction(page, Date.now()) }, null, 2));
 }
 function parseBrowserBatchActions(value) {
   let input;
@@ -2570,6 +2705,12 @@ function parseBrowserBatchActions(value) {
       }
       return { action: "fill", ref: String(item.ref), value: item.value };
     }
+    if (item.action === "drag") {
+      if (typeof item.ref !== "string" && typeof item.ref !== "number" || typeof item.toRef !== "string" && typeof item.toRef !== "number") {
+        fail(`Batch drag ${index} requires ref and toRef`);
+      }
+      return { action: "drag", ref: String(item.ref), toRef: String(item.toRef) };
+    }
     if (item.action === "key") {
       if (typeof item.combo !== "string") fail(`Batch key ${index} requires combo`);
       return { action: "key", combo: item.combo };
@@ -2621,16 +2762,20 @@ async function computerBrowserBatchCommand(actionsJson, options = {}) {
         const actionStartedAt = Date.now();
         if (action.action === "click") {
           const ref = parseBrowserRef(action.ref);
-          const rect = await prepareBrowserRefInSession(session, ref, cached, viewportRect);
+          const { backendNodeId, rect } = await prepareBrowserRefInSession(session, ref, cached, viewportRect);
           await dispatchChromeClickInSession(session, rect.centerX, rect.centerY, action.button, action.clicks);
           logRecordingAction({ type: "click" });
-          completed.push({ index, action: action.action, ref: String(ref), elapsedMs: Date.now() - actionStartedAt });
+          completed.push({ index, action: action.action, ref: String(backendNodeId), elapsedMs: Date.now() - actionStartedAt });
         } else if (action.action === "fill") {
-          const ref = parseBrowserRef(action.ref);
-          await prepareBrowserRefInSession(session, ref, cached, viewportRect);
-          const result = await fillChromeNodeInSession(session, ref, action.value);
+          const result = await fillBrowserRefInSession(session, parseBrowserRef(action.ref), cached, viewportRect, action.value);
           logRecordingAction({ type: "type" });
-          completed.push({ index, action: action.action, ref: String(ref), valueLength: result.valueLength, elapsedMs: Date.now() - actionStartedAt });
+          completed.push({ index, action: action.action, ref: String(result.backendNodeId), valueLength: result.valueLength, elapsedMs: Date.now() - actionStartedAt });
+        } else if (action.action === "drag") {
+          const refs = { from: parseBrowserRef(action.ref), to: parseBrowserRef(action.toRef) };
+          const rects = await prepareBrowserDragInSession(session, refs, cached, viewportRect);
+          await dragChromeInSession(session, rects.from, rects.to);
+          logRecordingAction({ type: "drag" });
+          completed.push({ index, action: action.action, ref: String(rects.refs.from), toRef: String(rects.refs.to), elapsedMs: Date.now() - actionStartedAt });
         } else if (action.action === "key") {
           await dispatchChromeKeyInSession(session, browserKeyDetails(action.combo));
           logRecordingAction({ type: "key" });
@@ -2641,16 +2786,11 @@ async function computerBrowserBatchCommand(actionsJson, options = {}) {
           completed.push({ index, action: action.action, length: action.text.length, elapsedMs: Date.now() - actionStartedAt });
         } else if (action.action === "scroll") {
           const ref = action.ref ? parseBrowserRef(action.ref) : null;
-          const rect = ref ? await prepareBrowserRefInSession(session, ref, cached, viewportRect) : viewportRect;
           const deltaX = action.direction === "left" ? -action.amount : action.direction === "right" ? action.amount : 0;
           const deltaY = action.direction === "up" ? -action.amount : action.direction === "down" ? action.amount : 0;
-          await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", {
-            type: "mouseWheel",
-            x: rect.centerX,
-            y: rect.centerY,
-            deltaX,
-            deltaY
-          });
+          const rect = ref ? (await prepareBrowserRefInSession(session, ref, cached, viewportRect)).rect : null;
+          const point = rect ? { x: rect.centerX, y: rect.centerY } : await browserScrollPointInSession(session, viewportRect, deltaX, deltaY);
+          await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", { type: "mouseWheel", ...point, deltaX, deltaY });
           logRecordingAction({ type: "scroll" });
           completed.push({ index, action: action.action, direction: action.direction, amount: action.amount, elapsedMs: Date.now() - actionStartedAt });
         } else {
@@ -2670,10 +2810,11 @@ async function computerBrowserBatchCommand(actionsJson, options = {}) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(JSON.stringify({ ok: false, targetId, elapsedMs: Date.now() - startedAt, completed, failedIndex: completed.length, error: message }, null, 2));
+    const observation = await observeAfterBrowserAction(page, Date.now());
+    console.log(JSON.stringify({ ok: false, targetId, elapsedMs: Date.now() - startedAt, completed, failedIndex: completed.length, error: message, observation }, null, 2));
     throw error;
   }
-  console.log(JSON.stringify({ ok: true, targetId, elapsedMs: Date.now() - startedAt, completed }, null, 2));
+  console.log(JSON.stringify({ ok: true, targetId, elapsedMs: Date.now() - startedAt, completed, observation: await observeAfterBrowserAction(page, Date.now()) }, null, 2));
 }
 var APP_ALIASES = {
   chrome: [CHROME_WRAPPER],
@@ -2730,8 +2871,8 @@ async function computerLaunchCommand(app, args) {
       const candidates = expectsNewChromePage && existingChromePageIds.size > 0 ? pages.filter((page) => page.id && !existingChromePageIds.has(page.id)) : pages;
       for (const page of candidates) {
         if (!page.webSocketDebuggerUrl || !page.url || page.url === "about:blank") continue;
-        const readyState = await evaluateChromeTarget(page.webSocketDebuggerUrl, "document.readyState");
-        if (readyState === "interactive" || readyState === "complete") {
+        const quiet = await evaluateChromeTarget(page.webSocketDebuggerUrl, BROWSER_QUIET_JS);
+        if (isRecord(quiet) && (quiet.readyState === "interactive" || quiet.readyState === "complete")) {
           readyPage = page;
           break;
         }
@@ -2764,7 +2905,7 @@ async function computerClickCommand(xStr, yStr, options) {
   const x = parseScreenCoord(xStr, "x", dimensions.width);
   const y = parseScreenCoord(yStr, "y", dimensions.height);
   const button = options.button ?? "1";
-  const args = ["mousemove", "--sync", String(x), String(y)];
+  const args = ["mousemove", String(x), String(y)];
   if (options.modifiers) {
     for (const mod of options.modifiers.split("+")) {
       args.push("keydown", mod);
@@ -2788,7 +2929,7 @@ async function computerMoveCommand(xStr, yStr) {
   const dimensions = getDisplayDimensions();
   const x = parseScreenCoord(xStr, "x", dimensions.width);
   const y = parseScreenCoord(yStr, "y", dimensions.height);
-  runDesktopInputCmd(["mousemove", "--sync", String(x), String(y)]);
+  runDesktopInputCmd(["mousemove", String(x), String(y)]);
   logRecordingAction({ type: "move", x, y });
   console.log(`moved to (${x},${y})`);
 }
@@ -2819,12 +2960,7 @@ async function computerScrollCommand(direction, options) {
       x: parseScreenCoord(options.x, "--x", dimensions.width),
       y: parseScreenCoord(options.y, "--y", dimensions.height)
     };
-    args.push(
-      "mousemove",
-      "--sync",
-      String(hoverPosition.x),
-      String(hoverPosition.y)
-    );
+    args.push("mousemove", String(hoverPosition.x), String(hoverPosition.y));
   }
   args.push("click", "--repeat", String(amount), "--delay", "30", button);
   runDesktopInputCmd(args);
@@ -2842,7 +2978,6 @@ async function computerDragCommand(fx, fy, tx, ty) {
   const steps = clamp(Math.ceil(distance / 70), 8, 24);
   const args = [
     "mousemove",
-    "--sync",
     String(fromX),
     String(fromY),
     "mousedown",
@@ -2851,8 +2986,10 @@ async function computerDragCommand(fx, fy, tx, ty) {
   for (let i = 1; i <= steps; i++) {
     const x = Math.round(fromX + (toX - fromX) * i / steps);
     const y = Math.round(fromY + (toY - fromY) * i / steps);
-    args.push("mousemove", "--sync", String(x), String(y), "sleep", "0.018");
+    args.push("mousemove", String(x), String(y), "sleep", "0.018");
   }
+  const nudgeX = toX > 0 ? toX - 1 : toX + 1;
+  for (const x of [nudgeX, toX, nudgeX, toX]) args.push("mousemove", String(x), String(toY), "sleep", "0.018");
   args.push("mouseup", "1");
   runDesktopInputCmd(args);
   logRecordingAction({ type: "drag", x: fromX, y: fromY, toX, toY });
@@ -2932,7 +3069,7 @@ async function computerStatusCommand() {
 }
 
 // src/version.ts
-var COMPUTER_USE_VERSION = "0.3.22";
+var COMPUTER_USE_VERSION = "0.3.23";
 var COMPUTER_USE_PROTOCOL_VERSION = 1;
 
 // src/program.ts
@@ -2947,9 +3084,9 @@ function createProgram() {
   program.command("info").description("Print the live noVNC viewer URL").action(() => computerInfoCommand());
   program.command("status").description("Show desktop services and the active preview URL").action(() => computerStatusCommand());
   program.command("screenshot <path>").description("Capture the current desktop to a PNG file").option("--raw", "Save a 1:1 desktop capture").option("--grid [px]", "Overlay a coordinate grid. Default 100px.").action((path, options) => computerScreenshotCommand(path, options));
-  program.command("observe <path>").description("Wait for the desktop to settle and capture screen context").option("--raw", "Save a 1:1 desktop capture without a grid").option("--grid [px]", "Overlay a coordinate grid. Default 100px.").option("--timeout <ms>", "Maximum stability wait. Default 3000.").option("--stable-ms <ms>", "Required unchanged time. Default 600.").option("--poll-ms <ms>", "Polling interval. Default 200.").action((path, options) => computerObserveCommand(path, options));
+  program.command("observe <path>").description("Wait for the desktop to settle and capture screen context").option("--raw", "Save a 1:1 desktop capture without a grid (default)").option("--grid [px]", "Overlay a coordinate grid. Default 100px.").option("--timeout <ms>", "Maximum stability wait. Default 3000.").option("--stable-ms <ms>", "Required unchanged time. Default 600.").option("--poll-ms <ms>", "Polling interval. Default 100.").action((path, options) => computerObserveCommand(path, options));
   program.command("browser").description("Print JSON for controllable Chrome pages").option("--snapshot", "Include visible text and controls").option("--limit <chars>", "Maximum body text characters. Default 4000.").option("--element-limit <n>", "Maximum controls. Default 80.").option("--target-id <id>", "Only include this Chrome target").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((options) => computerBrowserCommand(options));
-  program.command("browser-state <path>").description("Capture a Chrome screenshot and accessibility state").option("--full", "Return the full tree instead of a diff").option("--limit <chars>", "Maximum visible text characters. Default 8000.").option("--element-limit <n>", "Maximum actionable elements. Default 120.").option("--timeout <ms>", "Maximum stability wait. Default 5000.").option("--stable-ms <ms>", "Required unchanged time. Default 500.").option("--poll-ms <ms>", "Polling interval. Default 100.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((path, options) => computerBrowserStateCommand(path, options));
+  program.command("browser-state [path]").description("Capture Chrome accessibility state, and a viewport screenshot when a path is given").option("--full", "Return the full tree instead of a diff").option("--limit <chars>", "Maximum visible text characters. Default 8000.").option("--element-limit <n>", "Maximum actionable elements. Default 120.").option("--timeout <ms>", "Maximum stability wait. Default 5000.").option("--stable-ms <ms>", "Required unchanged time. Default 500.").option("--poll-ms <ms>", "Polling interval. Default 100.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((path, options) => computerBrowserStateCommand(path, options));
   program.command("browser-batch <actions>").description("Run an ordered, fail-fast JSON array of browser actions").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((actions, options) => computerBrowserBatchCommand(actions, options));
   program.command("browser-click [text]").description("Click a Chrome element by ref or visible text").option("--ref <id>", "Backend DOM node ref from browser-state").option("--exact", "Require an exact text match").option("--index <n>", "Select the nth match. Default 0.").option("--button <button>", "left, middle, or right").option("--double", "Double-click").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((text, options) => computerBrowserClickCommand(text, options));
   program.command("browser-fill [field] [value]").description("Fill a Chrome field by ref or visible text").option("--ref <id>", "Backend DOM node ref from browser-state").option("--exact", "Require an exact field match").option("--index <n>", "Select the nth match. Default 0.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((field, value, options) => {
@@ -2958,7 +3095,8 @@ function createProgram() {
     if (resolvedValue === void 0) throw new Error("Provide <field> <value>, or --ref <id> <value>");
     return computerBrowserFillCommand(resolvedField, resolvedValue, options);
   });
-  program.command("browser-scroll <direction>").description("Send trusted wheel input to Chrome").option("--ref <id>", "Scroll from a backend DOM node ref").option("--amount <px>", "Scroll distance. Default 600.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((direction, options) => computerBrowserScrollCommand(direction, options));
+  program.command("browser-drag").description("Drag a Chrome element onto another by ref").requiredOption("--ref <id>", "Element to drag, from the latest browser state").requiredOption("--to-ref <id>", "Element to drop it on").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((options) => computerBrowserDragCommand(options));
+  program.command("browser-scroll <direction>").description("Send trusted wheel input to Chrome").option("--ref <id>", "Scroll from a backend DOM node ref").option("--amount <px>", "Scroll distance. Default 600.").option("--until <text>", "Keep scrolling until this text is on the page, then center it").option("--timeout <ms>", "Give up on --until after this long. Default 10000.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((direction, options) => computerBrowserScrollCommand(direction, options));
   program.command("browser-key <combo>").description("Press a key chord in Chrome").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((combo, options) => computerBrowserKeyCommand(combo, options));
   program.command("browser-type <text>").description("Type literal text in Chrome").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((text, options) => computerBrowserTypeCommand(text, options));
   program.command("browser-wait <text>").description("Wait for Chrome title, URL, text, or controls").option("--mode <mode>", "any, text, title, url, or control").option("--exact", "Require an exact match").option("--timeout <ms>", "Maximum wait. Default 10000.").option("--poll-ms <ms>", "Polling interval. Default 250.").option("--target-id <id>", "Target this Chrome page").option("--page <n>", "Select the nth matching page. Default 0.").option("--title <text>", "Filter by title").option("--url <text>", "Filter by URL").action((text, options) => computerBrowserWaitCommand(text, options));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-computer",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "Replicas workspace computer-use runtime",
   "type": "module",
   "main": "dist/index.js",