replicas-computer 0.1.0

package/dist/index.js

@@ -0,0 +1,3287 @@
+#!/usr/bin/env node
+
+// src/client.ts
+import { createConnection as createConnection2 } from "net";
+
+// src/daemon.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
+import { createConnection, createServer } from "net";
+import { dirname as dirname4 } from "path";
+
+// src/commands/desktop.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+var DESKTOP_NOVNC_PORT = 6080;
+var DESKTOP_VIEWER_WIDTH = 1920;
+var DESKTOP_VIEWER_HEIGHT = 1080;
+var STATE_DIR = process.env.REPLICAS_DESKTOP_STATE_DIR || "/tmp/replicas-computer";
+var DEFAULT_DISPLAY = process.env.REPLICAS_DESKTOP_DISPLAY || ":99";
+var NOVNC_PORT = process.env.REPLICAS_DESKTOP_NOVNC_PORT ? parseInt(process.env.REPLICAS_DESKTOP_NOVNC_PORT, 10) : DESKTOP_NOVNC_PORT;
+var SERVICES_SCRIPT = process.env.REPLICAS_COMPUTER_SERVICES_SCRIPT || "/usr/local/bin/replicas-start-desktop-services";
+var INPUT_LOCK_FILE = process.env.REPLICAS_DESKTOP_INPUT_LOCK_FILE || `${STATE_DIR}/input.lock`;
+var CHROME_WRAPPER = "/usr/local/bin/replicas-chrome";
+var INFO_WAIT_TIMEOUT_MS = 1e4;
+var INFO_WAIT_INTERVAL_MS = 500;
+var lastDesktopHealthAt = 0;
+var CHROME_DEBUG_PORT = (() => {
+  const value = process.env.REPLICAS_DESKTOP_CHROME_DEBUG_PORT;
+  if (!value) return 9222;
+  const port = parseInt(value, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    fail(`REPLICAS_DESKTOP_CHROME_DEBUG_PORT must be a valid TCP port, got ${JSON.stringify(value)}`);
+  }
+  return port;
+})();
+function fail(msg) {
+  throw new Error(msg);
+}
+function getDesktopBridgeStatus() {
+  const r = spawnSync("bash", [SERVICES_SCRIPT, "--status-json"], { stdio: "pipe" });
+  if (r.status !== 0) return null;
+  try {
+    return JSON.parse(r.stdout.toString());
+  } catch {
+    return null;
+  }
+}
+function desktopStackHealthy() {
+  const pids = {};
+  for (const name of ["openbox", "tint2", "x11vnc", "novnc"]) {
+    try {
+      const pid = Number.parseInt(readFileSync(`${STATE_DIR}/${name}.pid`, "utf8").trim(), 10);
+      if (!Number.isFinite(pid)) return false;
+      process.kill(pid, 0);
+      pids[name] = pid;
+    } catch {
+      return false;
+    }
+  }
+  if (spawnSync("xdpyinfo", [], { env: withDisplay(), stdio: "ignore" }).status !== 0) return false;
+  const wm = spawnSync("xprop", ["-root", "_NET_SUPPORTING_WM_CHECK"], { env: withDisplay(), stdio: "pipe" });
+  if (wm.status !== 0 || !wm.stdout?.toString().includes("window id")) return false;
+  const bridge = getDesktopBridgeStatus();
+  return !!bridge?.x11vnc.listenerPids?.includes(pids.x11vnc) && !!bridge.websockify.listenerPids?.includes(pids.novnc);
+}
+function ensureServicesRunning() {
+  if (!existsSync(SERVICES_SCRIPT)) {
+    fail(
+      `Desktop services script missing at ${SERVICES_SCRIPT}. The workspace image is out of date \u2014 Xvfb / openbox / x11vnc / websockify must be installed and \`replicas-computer setup\` must install the desktop runtime.`
+    );
+  }
+  if (Date.now() - lastDesktopHealthAt < 1e3) return;
+  if (desktopStackHealthy()) {
+    lastDesktopHealthAt = Date.now();
+    return;
+  }
+  const r = spawnSync("bash", [SERVICES_SCRIPT], { stdio: "pipe" });
+  if (r.status !== 0) {
+    fail(`Failed to start desktop services: ${r.stderr?.toString() || "unknown error"}`);
+  }
+  lastDesktopHealthAt = Date.now();
+}
+function withDisplay(env = process.env) {
+  return { ...env, DISPLAY: DEFAULT_DISPLAY };
+}
+function runDisplayCmd(bin, args) {
+  ensureServicesRunning();
+  const r = spawnSync(bin, args, { env: withDisplay(), stdio: "pipe" });
+  if (r.status !== 0) {
+    fail(`${bin} ${args.join(" ")} failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+  }
+  return r.stdout?.toString() ?? "";
+}
+function runDesktopInputCmd(args) {
+  mkdirSync(dirname(INPUT_LOCK_FILE), { recursive: true });
+  return runDisplayCmd("flock", [
+    "--exclusive",
+    "--wait",
+    process.env.REPLICAS_DESKTOP_INPUT_LOCK_WAIT_SECONDS || "60",
+    INPUT_LOCK_FILE,
+    "xdotool",
+    ...args
+  ]);
+}
+function tryDisplayCmd(bin, args) {
+  ensureServicesRunning();
+  const r = spawnSync(bin, args, { env: withDisplay(), stdio: "pipe" });
+  if (r.status !== 0) return null;
+  const out = r.stdout?.toString().trim();
+  return out || null;
+}
+function parseCoord(value, label) {
+  if (!/^-?\d+$/.test(value)) fail(`${label} must be an integer (got "${value}")`);
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n)) fail(`${label} must be an integer (got "${value}")`);
+  return n;
+}
+function getDisplayDimensions() {
+  const out = runDisplayCmd("xdpyinfo", []);
+  const match = out.match(/dimensions:\s+(\d+)x(\d+)\s+pixels/);
+  if (!match) fail("could not read display dimensions from xdpyinfo");
+  return { width: Number.parseInt(match[1], 10), height: Number.parseInt(match[2], 10) };
+}
+function getMouseLocation() {
+  const out = tryDisplayCmd("xdotool", ["getmouselocation", "--shell"]);
+  if (!out) return null;
+  const values = Object.fromEntries(
+    out.split("\n").map((line) => {
+      const [key, value] = line.split("=");
+      return [key.toLowerCase(), Number.parseInt(value, 10)];
+    })
+  );
+  if (!Number.isFinite(values.x) || !Number.isFinite(values.y)) return null;
+  return {
+    x: values.x,
+    y: values.y,
+    screen: Number.isFinite(values.screen) ? values.screen : 0,
+    window: Number.isFinite(values.window) ? values.window : 0
+  };
+}
+function parseScreenCoord(value, label, size) {
+  if (value.endsWith("%")) {
+    const rawPct = value.slice(0, -1);
+    if (!/^(?:\d+(?:\.\d+)?|\.\d+)$/.test(rawPct)) fail(`${label} percent must be a number between 0% and 100% (got "${value}")`);
+    const pct = Number.parseFloat(rawPct);
+    if (!Number.isFinite(pct) || pct < 0 || pct > 100) fail(`${label} percent must be between 0% and 100% (got "${value}")`);
+    return Math.round(pct / 100 * (size - 1));
+  }
+  const n = parseCoord(value, label);
+  if (n < 0 || n >= size) fail(`${label} must be between 0 and ${size - 1} pixels, or 0%-100% (got "${value}")`);
+  return n;
+}
+function resolvePath(p) {
+  return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+function configuredDesktopDimensions() {
+  const resolution = process.env.REPLICAS_DESKTOP_RESOLUTION?.match(/^(\d+)x(\d+)$/);
+  const width = parseInt(resolution?.[1] || process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
+  const height = parseInt(resolution?.[2] || process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT), 10);
+  if (!Number.isFinite(width) || width <= 0) fail(`REPLICAS_DESKTOP_WIDTH must be a positive integer`);
+  if (!Number.isFinite(height) || height <= 0) fail(`REPLICAS_DESKTOP_HEIGHT must be a positive integer`);
+  return { width, height };
+}
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+
+// src/program.ts
+import { format } from "util";
+import { Command, CommanderError } from "commander";
+
+// src/commands/index.ts
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import { createHash } from "crypto";
+import { closeSync, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync3, readSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join } from "path";
+import chalk from "chalk";
+
+// src/commands/recording.ts
+import { spawn } from "child_process";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/commands/recording/render.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { copyFileSync, rmSync, writeFileSync } from "fs";
+
+// src/commands/recording/config.ts
+var cameraMotion = {
+  clickLeadSeconds: 1.2,
+  clickTailSeconds: 0.5,
+  actionLeadSeconds: 0.9,
+  clickZoom: 1.24,
+  closeClickOutputGapSeconds: 6,
+  clickMoveSeconds: 1.2,
+  returnSeconds: 1,
+  minSegmentSeconds: 0.05
+};
+var cursorMotion = {
+  minMoveSeconds: 0.38,
+  maxMoveSeconds: 1.7,
+  speedPxPerSecond: 700,
+  defaultLeadSeconds: 0.16,
+  clickShrinkSeconds: 0.08,
+  clickGrowSeconds: 0.14,
+  clickDwellGapStartSeconds: 0.75,
+  clickDwellFullGapSeconds: 3.2,
+  clickMinDwellSeconds: 0.12,
+  clickMaxDwellSeconds: 1.15,
+  maxDwellGapShare: 0.45,
+  dragLeadSeconds: 0.55,
+  maxKeyframes: 120
+};
+var cursorStyle = {
+  size: 30,
+  clickSize: 24
+};
+
+// src/commands/recording/ffmpeg-expressions.ts
+function expressionNumber(n) {
+  return Number.isInteger(n) ? String(n) : n.toFixed(3);
+}
+function mixNumber(from, to, progress) {
+  return from + (to - from) * progress;
+}
+function easeInOutSmootherNumber(progress) {
+  const p = clamp(progress, 0, 1);
+  return p * p * p * (p * (p * 6 - 15) + 10);
+}
+function easeInOutSmootherExpression(progress) {
+  const p = `(${progress})`;
+  return `${p}*${p}*${p}*(${p}*(${p}*6-15)+10)`;
+}
+function progressOverTime(timeExpression, seconds) {
+  return easeInOutSmootherExpression(`min(max((${timeExpression})/${seconds.toFixed(3)}\\,0)\\,1)`);
+}
+function progressBetween(start, duration) {
+  return easeInOutSmootherExpression(`min(max((t-${start.toFixed(3)})/${duration.toFixed(3)}\\,0)\\,1)`);
+}
+function mixExpression(from, to, progress) {
+  return `${expressionNumber(from)}+(${expressionNumber(to - from)})*${progress}`;
+}
+function cropOrigin(point, zoom, size) {
+  return clamp(point * zoom - size / 2, 0, size * zoom - size);
+}
+function easedCropOrigin(fromPoint, toPoint, fromZoom, toZoom, size, progress) {
+  return mixExpression(
+    cropOrigin(fromPoint, fromZoom, size),
+    cropOrigin(toPoint, toZoom, size),
+    progress
+  );
+}
+function betweenExpression(start, end) {
+  return `between(t\\,${start.toFixed(3)}\\,${end.toFixed(3)})`;
+}
+
+// src/commands/recording/timeline.ts
+function centerOf(size) {
+  return { x: size.width / 2, y: size.height / 2 };
+}
+function actionPoint(action, size) {
+  const x = action.toX ?? action.x ?? size.width / 2;
+  const y = action.toY ?? action.y ?? size.height / 2;
+  return { x: clamp(x, 0, size.width), y: clamp(y, 0, size.height) };
+}
+function idleSpeed(duration) {
+  if (duration < 1.2) return 1;
+  return clamp(1 + Math.log1p(duration - 0.8) * 1.8, 1.5, 5);
+}
+function renderedGapSeconds(duration) {
+  return duration / idleSpeed(duration);
+}
+function timelineActions(actions) {
+  return actions.filter((action) => action.type !== "key" && action.type !== "move");
+}
+function actionWindow(action, duration) {
+  const shouldZoom = action.type === "click";
+  const at = clamp(action.atMs / 1e3, 0, duration);
+  const start = clamp(at - (shouldZoom ? cameraMotion.clickLeadSeconds : cameraMotion.actionLeadSeconds), 0, duration);
+  const tail = shouldZoom ? cameraMotion.clickTailSeconds : action.type === "type" ? 1.5 : 0.9;
+  return { start, end: clamp(at + tail, start, duration), shouldZoom };
+}
+function nextClickStart(actions, index, duration) {
+  const nextClick = actions.slice(index + 1).find((candidate) => candidate.type === "click");
+  return nextClick ? clamp(nextClick.atMs / 1e3 - cameraMotion.clickLeadSeconds, 0, duration) : null;
+}
+function shouldPreserveZoom(nextStart, cursor, lastZoom) {
+  return lastZoom > 1 && nextStart !== null && nextStart > cursor && renderedGapSeconds(nextStart - cursor) <= cameraMotion.closeClickOutputGapSeconds;
+}
+function fullFrameSegment(duration, size) {
+  const center = centerOf(size);
+  return {
+    start: 0,
+    end: duration,
+    speed: 1,
+    motionSeconds: cameraMotion.returnSeconds,
+    fromZoom: 1,
+    zoom: 1,
+    fromX: center.x,
+    fromY: center.y,
+    ...center
+  };
+}
+function buildRecordingSegments(actions, duration, size) {
+  const actionsForTimeline = timelineActions(actions);
+  if (actionsForTimeline.length === 0) return [fullFrameSegment(duration, size)];
+  const center = centerOf(size);
+  const segments = [];
+  let cursor = 0;
+  let lastPoint = center;
+  let lastZoom = 1;
+  for (let i = 0; i < actionsForTimeline.length; i++) {
+    const action = actionsForTimeline[i];
+    const { start, end, shouldZoom } = actionWindow(action, duration);
+    const preserveZoom = !shouldZoom && shouldPreserveZoom(nextClickStart(actionsForTimeline, i, duration), cursor, lastZoom);
+    const point = shouldZoom ? actionPoint(action, size) : preserveZoom ? lastPoint : center;
+    const zoom = shouldZoom ? cameraMotion.clickZoom : preserveZoom ? lastZoom : 1;
+    if (start > cursor + cameraMotion.minSegmentSeconds) {
+      const gap = start - cursor;
+      const speed = idleSpeed(gap);
+      const bridgeZoom = shouldZoom && lastZoom > 1 && renderedGapSeconds(gap) <= cameraMotion.closeClickOutputGapSeconds;
+      segments.push({
+        start: cursor,
+        end: start,
+        speed,
+        motionSeconds: bridgeZoom ? Math.min(cameraMotion.clickMoveSeconds, Math.max(0.18, gap / speed)) : cameraMotion.returnSeconds,
+        fromZoom: lastZoom,
+        zoom: bridgeZoom ? cameraMotion.clickZoom : zoom,
+        fromX: lastPoint.x,
+        fromY: lastPoint.y,
+        ...point
+      });
+      lastZoom = bridgeZoom ? cameraMotion.clickZoom : zoom;
+      lastPoint = point;
+    }
+    const actionStart = Math.max(cursor, start);
+    if (end > actionStart + cameraMotion.minSegmentSeconds) {
+      segments.push({
+        start: actionStart,
+        end,
+        speed: 1,
+        motionSeconds: shouldZoom ? cameraMotion.clickMoveSeconds : cameraMotion.returnSeconds,
+        fromZoom: lastZoom,
+        zoom,
+        fromX: lastPoint.x,
+        fromY: lastPoint.y,
+        ...point
+      });
+      cursor = end;
+      lastZoom = zoom;
+    }
+    lastPoint = point;
+  }
+  if (duration > cursor + cameraMotion.minSegmentSeconds) {
+    segments.push({
+      start: cursor,
+      end: duration,
+      speed: idleSpeed(duration - cursor),
+      motionSeconds: cameraMotion.returnSeconds,
+      fromZoom: lastZoom,
+      zoom: 1,
+      fromX: lastPoint.x,
+      fromY: lastPoint.y,
+      ...center
+    });
+  }
+  return segments.filter((segment) => segment.end > segment.start + cameraMotion.minSegmentSeconds);
+}
+
+// src/commands/recording/cursor.ts
+var cursorHotspotRatio = { x: 8 / 32, y: 4 / 32 };
+function cursorAssets(stamp) {
+  return {
+    path: `/tmp/replicas-cursor-${stamp}.svg`,
+    size: cursorStyle.size
+  };
+}
+function clickDwellSeconds(gapSeconds) {
+  if (gapSeconds <= cursorMotion.clickDwellGapStartSeconds) return cursorMotion.defaultLeadSeconds;
+  const progress = (gapSeconds - cursorMotion.clickDwellGapStartSeconds) / (cursorMotion.clickDwellFullGapSeconds - cursorMotion.clickDwellGapStartSeconds);
+  const dwell = mixNumber(
+    cursorMotion.clickMinDwellSeconds,
+    cursorMotion.clickMaxDwellSeconds,
+    easeInOutSmootherNumber(progress)
+  );
+  return Math.min(dwell, gapSeconds * cursorMotion.maxDwellGapShare);
+}
+function arrivalLeadSeconds(action, gapSeconds) {
+  return action.type === "click" ? clickDwellSeconds(gapSeconds) : cursorMotion.defaultLeadSeconds;
+}
+function cursorKeyframe(action, at, previousAt, size) {
+  if (typeof action.x !== "number" || typeof action.y !== "number") return null;
+  const point = actionPoint(action, size);
+  const lead = arrivalLeadSeconds(action, at - previousAt);
+  return { ...point, at, arriveAt: clamp(at - lead, previousAt, at) };
+}
+function dedupeKeyframes(points) {
+  return points.sort((a, b) => a.at - b.at).filter(
+    (point, index, all) => index === 0 || point.at - all[index - 1].at > 0.08 || Math.hypot(point.x - all[index - 1].x, point.y - all[index - 1].y) > 24
+  );
+}
+function downsampleKeyframes(points, actions, size) {
+  if (points.length <= cursorMotion.maxKeyframes) return points;
+  const anchors = actions.filter((action) => action.type !== "move").map((action) => actionPoint(action, size));
+  const result = points.filter(
+    (point, index) => index === 0 || index === points.length - 1 || anchors.some((anchor) => Math.hypot(anchor.x - point.x, anchor.y - point.y) < 1)
+  );
+  const step = points.length / Math.max(1, cursorMotion.maxKeyframes - result.length);
+  for (let i = 0; result.length < cursorMotion.maxKeyframes && i < points.length; i += step) {
+    const point = points[Math.floor(i)];
+    if (!result.includes(point)) result.push(point);
+  }
+  return result.sort((a, b) => a.at - b.at);
+}
+function cursorKeyframes(actions, duration, size) {
+  const center = { x: size.width / 2, y: size.height / 2 };
+  const points = [{ at: 0, arriveAt: 0, ...center }];
+  for (const action of actions) {
+    const at = clamp(action.atMs / 1e3, 0, duration);
+    const previousAt = points[points.length - 1].at;
+    if (action.type === "drag" && typeof action.x === "number" && typeof action.y === "number") {
+      const startAt = clamp(at - cursorMotion.dragLeadSeconds, 0, duration);
+      points.push({
+        at: startAt,
+        arriveAt: startAt,
+        x: clamp(action.x, 0, size.width),
+        y: clamp(action.y, 0, size.height)
+      });
+      if (typeof action.toX === "number" && typeof action.toY === "number") {
+        points.push({
+          at,
+          arriveAt: at,
+          x: clamp(action.toX, 0, size.width),
+          y: clamp(action.toY, 0, size.height)
+        });
+      }
+      continue;
+    }
+    const point = cursorKeyframe(action, at, previousAt, size);
+    if (point) points.push(point);
+  }
+  return downsampleKeyframes(dedupeKeyframes(points), actions, size);
+}
+function cursorAxisExpression(points, axis) {
+  if (points.length === 0) return "0";
+  let expression = expressionNumber(points[points.length - 1][axis]);
+  for (let i = points.length - 2; i >= 0; i--) {
+    const from = points[i];
+    const to = points[i + 1];
+    const arriveAt = clamp(to.arriveAt, from.at, to.at);
+    const moveWindow = Math.max(1e-3, arriveAt - from.at);
+    const distance = Math.hypot(to.x - from.x, to.y - from.y);
+    const moveSeconds = Math.min(
+      moveWindow,
+      Math.max(cursorMotion.minMoveSeconds, Math.min(cursorMotion.maxMoveSeconds, distance / cursorMotion.speedPxPerSecond))
+    );
+    const moveStart = Math.max(from.at, arriveAt - moveSeconds);
+    const duration = Math.max(1e-3, arriveAt - moveStart);
+    const interpolated = mixExpression(from[axis], to[axis], progressBetween(moveStart, duration));
+    expression = `if(lte(t\\,${moveStart.toFixed(3)})\\,${expressionNumber(from[axis])}\\,if(lte(t\\,${to.at.toFixed(3)})\\,${interpolated}\\,${expression}))`;
+  }
+  return expression;
+}
+function cursorSizeExpression(actions, normalSize) {
+  let expression = expressionNumber(normalSize);
+  const clicks = actions.filter((action) => action.type === "click").sort((a, b) => b.atMs - a.atMs);
+  for (const action of clicks) {
+    const at = action.atMs / 1e3;
+    const shrinkStart = Math.max(0, at - cursorMotion.clickShrinkSeconds);
+    const shrink = mixExpression(
+      normalSize,
+      cursorStyle.clickSize,
+      progressBetween(shrinkStart, Math.max(1e-3, at - shrinkStart))
+    );
+    const grow = mixExpression(cursorStyle.clickSize, normalSize, progressBetween(at, cursorMotion.clickGrowSeconds));
+    expression = `if(${betweenExpression(shrinkStart, at)}\\,${shrink}\\,if(${betweenExpression(at, at + cursorMotion.clickGrowSeconds)}\\,${grow}\\,${expression}))`;
+  }
+  return expression;
+}
+function cursorOverlayPositionExpression(cursor, size, hotspotRatio, overlaySize) {
+  return `max(0\\,min(${expressionNumber(size)}-${overlaySize}\\,(${cursor})-${hotspotRatio.toFixed(6)}*${overlaySize}))`;
+}
+function cursorSvg(size) {
+  return `<svg width="${size}" height="${size}" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg"><path d="M7.7 3.4c-1.45 0-2.62 1.17-2.62 2.62v19.7c0 2.46 3.02 3.65 4.7 1.85l5.06-5.44a5.42 5.42 0 0 1 3.96-1.73h5.82c2.48 0 3.63-3.08 1.76-4.7L9.42 4.04A2.62 2.62 0 0 0 7.7 3.4Z" fill="white" fill-opacity="0.98" stroke="black" stroke-opacity="0.88" stroke-width="2.9" stroke-linejoin="round"/></svg>`;
+}
+function buildCursorOverlayFilter(actions, duration, size, assets, projectCursor = null, inputLabel = "[screen]", outputLabel = "[v]") {
+  const points = cursorKeyframes(actions, duration, size);
+  const rawCursorX = cursorAxisExpression(points, "x");
+  const rawCursorY = cursorAxisExpression(points, "y");
+  const cursorX = projectCursor ? projectCursor.x(rawCursorX) : rawCursorX;
+  const cursorY = projectCursor ? projectCursor.y(rawCursorY) : rawCursorY;
+  const cursorSize = cursorSizeExpression(actions, assets.size);
+  const cursorOverlayX = cursorOverlayPositionExpression(cursorX, size.width, cursorHotspotRatio.x, "overlay_w");
+  const cursorOverlayY = cursorOverlayPositionExpression(cursorY, size.height, cursorHotspotRatio.y, "overlay_h");
+  return `[1:v]scale=w='${cursorSize}':h='${cursorSize}':eval=frame[cursor];${inputLabel}[cursor]overlay=x='${cursorOverlayX}':y='${cursorOverlayY}':eof_action=repeat:shortest=1:eval=frame${outputLabel}`;
+}
+
+// src/commands/recording/render.ts
+function videoDuration(path) {
+  const r = spawnSync2("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "default=noprint_wrappers=1:nokey=1",
+    path
+  ], { stdio: "pipe" });
+  if (r.status !== 0) fail(`ffprobe failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+  const duration = Number.parseFloat(r.stdout?.toString().trim() ?? "");
+  if (!Number.isFinite(duration) || duration <= 0) fail(`could not read recording duration for ${path}`);
+  return duration;
+}
+function renderedSegmentSpans(segments) {
+  let outputStart = 0;
+  return segments.map((segment) => {
+    const outputEnd = outputStart + (segment.end - segment.start) / segment.speed;
+    const span = {
+      rawStart: segment.start,
+      rawEnd: segment.end,
+      outputStart,
+      outputEnd,
+      speed: segment.speed
+    };
+    outputStart = outputEnd;
+    return span;
+  });
+}
+function outputTimeForRawTime(spans, rawTime) {
+  const span = spans.find((candidate) => rawTime >= candidate.rawStart && rawTime <= candidate.rawEnd);
+  if (span) return span.outputStart + (rawTime - span.rawStart) / span.speed;
+  if (spans.length === 0) return rawTime;
+  if (rawTime <= spans[0].rawStart) return spans[0].outputStart;
+  const lastSpan = spans[spans.length - 1];
+  if (rawTime >= lastSpan.rawEnd) return lastSpan.outputEnd;
+  return spans.find((candidate) => rawTime < candidate.rawStart)?.outputStart ?? lastSpan.outputEnd;
+}
+function actionsOnRenderedTimeline(actions, spans) {
+  return actions.map((action) => ({
+    ...action,
+    atMs: outputTimeForRawTime(spans, action.atMs / 1e3) * 1e3
+  }));
+}
+function segmentMotionSeconds(segment) {
+  return Math.min(segment.motionSeconds, Math.max(0.12, (segment.end - segment.start) / segment.speed));
+}
+function scaledFrameClampExpression(value, zoom, outputSize) {
+  return `max(0\\,min(${outputSize}*(${zoom})-${outputSize}\\,${value}))`;
+}
+function cameraTransformExpressions(segment, size, timeExpression) {
+  const progress = progressOverTime(timeExpression, segmentMotionSeconds(segment));
+  const zoom = mixExpression(segment.fromZoom, segment.zoom, progress);
+  return {
+    zoom,
+    cropX: scaledFrameClampExpression(
+      easedCropOrigin(segment.fromX, segment.x, segment.fromZoom, segment.zoom, size.width, progress),
+      zoom,
+      size.width
+    ),
+    cropY: scaledFrameClampExpression(
+      easedCropOrigin(segment.fromY, segment.y, segment.fromZoom, segment.zoom, size.height, progress),
+      zoom,
+      size.height
+    )
+  };
+}
+function projectedCursorExpression(rawCursor, axis, segments, spans, size) {
+  let expression = rawCursor;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const span = spans[i];
+    const camera = cameraTransformExpressions(segments[i], size, `t-${span.outputStart.toFixed(3)}`);
+    const crop = axis === "x" ? camera.cropX : camera.cropY;
+    const projected = `(${rawCursor})*(${camera.zoom})-(${crop})`;
+    expression = `if(${betweenExpression(span.outputStart, span.outputEnd)}\\,${projected}\\,${expression})`;
+  }
+  return expression;
+}
+function renderRecording(rawPath, target, actions, fps, size) {
+  if (actions.length === 0) {
+    copyFileSync(rawPath, target);
+    return;
+  }
+  const duration = videoDuration(rawPath);
+  const segments = buildRecordingSegments(actions, duration, size);
+  if (segments.length === 0) {
+    copyFileSync(rawPath, target);
+    return;
+  }
+  const stamp = `${process.pid}-${Date.now()}`;
+  const cursor = cursorAssets(stamp);
+  writeFileSync(cursor.path, cursorSvg(cursor.size));
+  const spans = renderedSegmentSpans(segments);
+  const renderedDuration = spans.length ? spans[spans.length - 1].outputEnd : duration;
+  const renderedActions = actionsOnRenderedTimeline(actions, spans);
+  const cursorFilter = buildCursorOverlayFilter(
+    renderedActions,
+    renderedDuration,
+    size,
+    cursor,
+    {
+      x: (cursorX) => projectedCursorExpression(cursorX, "x", segments, spans, size),
+      y: (cursorY) => projectedCursorExpression(cursorY, "y", segments, spans, size)
+    }
+  );
+  const screenLabels = segments.map((_, index) => `[screen${index}]`).join("");
+  const screenSplitFilter = `[0:v]split=${segments.length}${screenLabels}`;
+  const filters = segments.map((segment, index) => {
+    const { zoom, cropX, cropY } = cameraTransformExpressions(segment, size, "t");
+    return `[screen${index}]trim=start=${segment.start.toFixed(3)}:end=${segment.end.toFixed(3)},setpts=(PTS-STARTPTS)/${segment.speed.toFixed(3)},scale=w=${size.width}*(${zoom}):h=${size.height}*(${zoom}):eval=frame,crop=${size.width}:${size.height}:x=${cropX}:y=${cropY},setsar=1[v${index}]`;
+  });
+  const concatInputs = segments.map((_, index) => `[v${index}]`).join("");
+  const filter = `${screenSplitFilter};${filters.join(";")};${concatInputs}concat=n=${segments.length}:v=1:a=0[screen];${cursorFilter}`;
+  const filterPath = `/tmp/replicas-recording-filter-${stamp}.ffgraph`;
+  writeFileSync(filterPath, filter);
+  try {
+    const r = spawnSync2("ffmpeg", [
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-i",
+      rawPath,
+      "-loop",
+      "1",
+      "-i",
+      cursor.path,
+      "-filter_complex_script",
+      filterPath,
+      "-map",
+      "[v]",
+      "-r",
+      String(fps),
+      "-c:v",
+      "libx264",
+      "-preset",
+      "veryfast",
+      "-crf",
+      "23",
+      "-pix_fmt",
+      "yuv420p",
+      "-movflags",
+      "+faststart",
+      target
+    ], { stdio: "pipe", maxBuffer: 20 * 1024 * 1024 });
+    if (r.status !== 0) {
+      fail(`recording post-processing failed: ${r.error?.message || r.stderr?.toString().trim() || `exit ${r.status}`}`);
+    }
+  } finally {
+    rmSync(filterPath, { force: true });
+    rmSync(cursor.path, { force: true });
+  }
+}
+
+// src/commands/recording.ts
+var RECORD_PID_FILE = `${STATE_DIR}/ffmpeg.pid`;
+var RECORD_PATH_FILE = `${STATE_DIR}/recording-path.txt`;
+var RECORD_RAW_PATH_FILE = `${STATE_DIR}/recording-raw-path.txt`;
+var RECORD_STARTED_AT_FILE = `${STATE_DIR}/recording-started-at.txt`;
+var RECORD_FPS_FILE = `${STATE_DIR}/recording-fps.txt`;
+var RECORD_DIMENSIONS_FILE = `${STATE_DIR}/recording-dimensions.json`;
+var RECORD_ACTIONS_FILE = `${STATE_DIR}/recording-actions.jsonl`;
+var RECORD_STATE_FILES = [
+  RECORD_PID_FILE,
+  RECORD_PATH_FILE,
+  RECORD_RAW_PATH_FILE,
+  RECORD_STARTED_AT_FILE,
+  RECORD_FPS_FILE,
+  RECORD_DIMENSIONS_FILE,
+  RECORD_ACTIONS_FILE
+];
+function clearRecordingState() {
+  for (const file of RECORD_STATE_FILES) rmSync2(file, { force: true });
+}
+function recordingStartedAt() {
+  if (!existsSync2(RECORD_STARTED_AT_FILE)) return null;
+  const startedAt = Number.parseInt(readFileSync2(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
+  return Number.isFinite(startedAt) ? startedAt : null;
+}
+function logRecordingAction(action) {
+  const startedAt = recordingStartedAt();
+  if (!startedAt) return;
+  const atMs = Date.now() - startedAt;
+  appendFileSync(RECORD_ACTIONS_FILE, `${JSON.stringify({ ...action, atMs })}
+`);
+}
+function readRecordingDimensions() {
+  if (!existsSync2(RECORD_DIMENSIONS_FILE)) return configuredDesktopDimensions();
+  try {
+    const dimensions = JSON.parse(readFileSync2(RECORD_DIMENSIONS_FILE, "utf8"));
+    const width = dimensions?.width;
+    const height = dimensions?.height;
+    if (typeof width === "number" && Number.isFinite(width) && width > 0 && typeof height === "number" && Number.isFinite(height) && height > 0) {
+      return { width, height };
+    }
+  } catch {
+  }
+  fail("invalid recording dimensions state");
+}
+function isRecordingActionType(value) {
+  return value === "click" || value === "drag" || value === "key" || value === "move" || value === "scroll" || value === "type";
+}
+function isOptionalNumber(value) {
+  return value === void 0 || typeof value === "number";
+}
+function readRecordingActions() {
+  if (!existsSync2(RECORD_ACTIONS_FILE)) return [];
+  return readFileSync2(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      const value = JSON.parse(line);
+      if (typeof value !== "object" || value === null) return [];
+      const type = "type" in value ? value.type : void 0;
+      const atMs = "atMs" in value ? value.atMs : void 0;
+      const x = "x" in value ? value.x : void 0;
+      const y = "y" in value ? value.y : void 0;
+      const toX = "toX" in value ? value.toX : void 0;
+      const toY = "toY" in value ? value.toY : void 0;
+      if (!isRecordingActionType(type) || typeof atMs !== "number" || !Number.isFinite(atMs) || !isOptionalNumber(x) || !isOptionalNumber(y) || !isOptionalNumber(toX) || !isOptionalNumber(toY)) {
+        return [];
+      }
+      return [{ type, atMs, x, y, toX, toY }];
+    } catch {
+      return [];
+    }
+  }).sort((a, b) => a.atMs - b.atMs);
+}
+async function computerRecordStartCommand(path, options) {
+  ensureServicesRunning();
+  if (existsSync2(RECORD_PID_FILE)) {
+    const pid = parseInt(readFileSync2(RECORD_PID_FILE, "utf8").trim(), 10);
+    if (Number.isFinite(pid)) {
+      let alive2 = false;
+      try {
+        process.kill(pid, 0);
+        alive2 = true;
+      } catch {
+      }
+      if (alive2) fail(`recording already in progress (pid ${pid}). run \`replicas computer record stop\` first.`);
+    }
+  }
+  const target = resolvePath(path);
+  mkdirSync2(dirname2(target), { recursive: true });
+  const fps = options.fps ? parseCoord(options.fps, "--fps") : 60;
+  const { width, height } = configuredDesktopDimensions();
+  mkdirSync2(STATE_DIR, { recursive: true });
+  const rawTarget = `${target}.raw-${Date.now()}.mp4`;
+  rmSync2(RECORD_ACTIONS_FILE, { force: true });
+  const child = spawn("ffmpeg", [
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "warning",
+    "-f",
+    "x11grab",
+    "-framerate",
+    String(fps),
+    "-video_size",
+    `${width}x${height}`,
+    "-draw_mouse",
+    "0",
+    "-i",
+    DEFAULT_DISPLAY,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-tune",
+    "zerolatency",
+    "-crf",
+    "23",
+    "-pix_fmt",
+    "yuv420p",
+    "-movflags",
+    "+faststart+frag_keyframe+empty_moov",
+    rawTarget
+  ], { detached: true, stdio: "ignore" });
+  child.unref();
+  if (!child.pid) fail("failed to launch ffmpeg");
+  writeFileSync2(RECORD_PID_FILE, String(child.pid));
+  writeFileSync2(RECORD_PATH_FILE, target);
+  writeFileSync2(RECORD_RAW_PATH_FILE, rawTarget);
+  writeFileSync2(RECORD_STARTED_AT_FILE, String(Date.now()));
+  writeFileSync2(RECORD_FPS_FILE, String(fps));
+  writeFileSync2(RECORD_DIMENSIONS_FILE, JSON.stringify({ width, height }));
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < 5e3) {
+    try {
+      process.kill(child.pid, 0);
+      if (existsSync2(rawTarget) && statSync(rawTarget).size > 0) {
+        console.log(`${target} (recording ready in ${Date.now() - startedAt}ms)`);
+        return;
+      }
+    } catch {
+      break;
+    }
+    await sleep(100);
+  }
+  let alive = false;
+  try {
+    process.kill(child.pid, 0);
+    alive = true;
+  } catch {
+  }
+  if (alive) fail("ffmpeg is running but did not produce recording output within 5 seconds; run `replicas computer record stop` to finalize or retry");
+  clearRecordingState();
+  rmSync2(rawTarget, { force: true });
+  fail("ffmpeg exited before screen recording became ready");
+}
+async function computerRecordStopCommand() {
+  if (!existsSync2(RECORD_PID_FILE) && !existsSync2(RECORD_PATH_FILE)) fail("no recording in progress");
+  if (existsSync2(RECORD_PID_FILE)) {
+    const pid = parseInt(readFileSync2(RECORD_PID_FILE, "utf8").trim(), 10);
+    if (!Number.isFinite(pid)) fail("invalid recording pidfile");
+    try {
+      process.kill(pid, "SIGINT");
+    } catch {
+    }
+    let alive = true;
+    for (let i = 0; i < 150; i++) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        alive = false;
+        break;
+      }
+      await sleep(200);
+    }
+    if (alive) fail(`ffmpeg did not finalize recording within 30 seconds (pid ${pid})`);
+  }
+  if (existsSync2(RECORD_PATH_FILE)) {
+    const target = readFileSync2(RECORD_PATH_FILE, "utf8").trim();
+    const rawPath = existsSync2(RECORD_RAW_PATH_FILE) ? readFileSync2(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
+    const fps = existsSync2(RECORD_FPS_FILE) ? parseInt(readFileSync2(RECORD_FPS_FILE, "utf8").trim(), 10) : 60;
+    const size = readRecordingDimensions();
+    const actions = readRecordingActions();
+    if (rawPath !== target) {
+      renderRecording(rawPath, target, actions, Number.isFinite(fps) ? fps : 60, size);
+      rmSync2(rawPath, { force: true });
+    }
+    console.log(target);
+  }
+  clearRecordingState();
+}
+
+// src/commands/index.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getDesktopViewerUrl(publicUrl) {
+  const url = new URL(`${publicUrl.replace(/\/$/, "")}/`);
+  url.searchParams.set("v", "13");
+  return url.toString();
+}
+function bridgeStatus(details, includeBacklog = false, rootsOnly = false) {
+  const pids = rootsOnly ? details.rootPids ?? [] : details.listenerPids ?? [];
+  const listenerCount = rootsOnly ? details.rootListeners ?? pids.length : details.listeners ?? pids.length;
+  const listenerLabel = rootsOnly ? "root listener" : "listener";
+  const parts = [`${listenerCount} ${listenerLabel}${listenerCount === 1 ? "" : "s"} on ${details.port}`];
+  if (includeBacklog) parts.push(`backlog ${details.backlog ?? 0}`);
+  if (pids.length > 0) parts.push(`pid${pids.length === 1 ? "" : "s"} ${pids.join(",")}`);
+  return ` (${parts.join(", ")})`;
+}
+async function lookupDesktopViewerUrl() {
+  try {
+    const value = JSON.parse(readFileSync3(join(homedir(), ".replicas", "preview-ports.json"), "utf8"));
+    if (!isRecord(value) || !Array.isArray(value.previews)) return null;
+    const preview = value.previews.find(
+      (item) => isRecord(item) && item.port === NOVNC_PORT && typeof item.publicUrl === "string"
+    );
+    return isRecord(preview) && typeof preview.publicUrl === "string" ? getDesktopViewerUrl(preview.publicUrl) : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForDesktopViewerUrl(timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const url = await lookupDesktopViewerUrl();
+    if (url) return url;
+    await new Promise((resolve3) => setTimeout(resolve3, INFO_WAIT_INTERVAL_MS));
+  }
+  return await lookupDesktopViewerUrl();
+}
+async function computerInfoCommand() {
+  const viewerUrl = await waitForDesktopViewerUrl(INFO_WAIT_TIMEOUT_MS);
+  if (!viewerUrl) {
+    fail(
+      `Desktop preview for port ${NOVNC_PORT} is not registered. The engine registers it at startup \u2014 check /tmp/replicas-desktop-stack.log and engine logs for errors.`
+    );
+  }
+  console.log(viewerUrl);
+  console.error(chalk.dim(`Share this URL with the user to let them watch the desktop live.`));
+}
+async function computerStatusCommand() {
+  ensureServicesRunning();
+  const bridge = getDesktopBridgeStatus();
+  const procs = ["Xvfb", "openbox", "tint2", "x11vnc", "websockify"];
+  for (const p of procs) {
+    const r = spawnSync3("pgrep", ["-af", p], { stdio: "pipe" });
+    const running = r.status === 0 && !!r.stdout?.toString().trim();
+    const suffix = p === "x11vnc" && bridge ? bridgeStatus(bridge.x11vnc, true) : p === "websockify" && bridge ? bridgeStatus(bridge.websockify, false, true) : "";
+    console.log(`  ${running ? chalk.green("\u25CF") : chalk.red("\u25CB")} ${p}${suffix}`);
+  }
+  const viewerUrl = await lookupDesktopViewerUrl();
+  if (viewerUrl) {
+    console.log(`  ${chalk.cyan("preview")}: ${viewerUrl}`);
+  } else {
+    console.log(`  ${chalk.dim("preview: not yet registered (engine registers it at startup)")}`);
+  }
+}
+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)`);
+    }
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  } finally {
+    closeSync(fd);
+  }
+}
+function brandSvgPath() {
+  const dir = process.env.REPLICAS_DESKTOP_TEMPLATES || "/usr/local/share/replicas/desktop";
+  return `${dir}/brand-wallpaper.svg`;
+}
+function loadBrandSvg(canvasW, canvasH) {
+  const path = brandSvgPath();
+  if (!existsSync3(path)) {
+    fail(
+      `Brand wallpaper SVG missing at ${path}. The workspace image is out of date \u2014 \`replicas-computer setup\` must install brand-wallpaper.svg at $REPLICAS_DESKTOP_TEMPLATES.`
+    );
+  }
+  return readFileSync3(path, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
+}
+var BRAND_PAD_FRACTION = 0.06;
+var SCREENSHOT_CORNER_FRACTION = 0.022;
+var SHADOW_SIGMA_FRACTION = 0.022;
+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>`;
+function parseGridSize(value) {
+  if (value === void 0 || value === false) return null;
+  const size = value === true ? 100 : parseCoord(value, "--grid");
+  if (size < 25 || size > 500) fail("--grid must be between 25 and 500 pixels");
+  return size;
+}
+function buildGridSvg(width, height, size) {
+  const lines = [];
+  const labels = [];
+  for (let x = 0; x <= width; x += size) {
+    const strokeWidth = x % (size * 5) === 0 ? 2 : 1;
+    lines.push(`<line x1="${x}" y1="0" x2="${x}" y2="${height}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
+    if (x > 0 && x < width) labels.push(`<text x="${x + 4}" y="18">${x}</text>`);
+  }
+  for (let y = 0; y <= height; y += size) {
+    const strokeWidth = y % (size * 5) === 0 ? 2 : 1;
+    lines.push(`<line x1="0" y1="${y}" x2="${width}" y2="${y}" stroke="#00e5ff" stroke-opacity="0.42" stroke-width="${strokeWidth}"/>`);
+    if (y > 0 && y < height) labels.push(`<text x="4" y="${y - 4}">${y}</text>`);
+  }
+  return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+<style>text{font:16px monospace;fill:white;paint-order:stroke;stroke:black;stroke-width:4px;stroke-linejoin:round}</style>
+${lines.join("\n")}
+${labels.join("\n")}
+</svg>`;
+}
+function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
+  writeFileSync3(gridPath, buildGridSvg(width, height, gridSize));
+  const r = spawnSync3(
+    "ffmpeg",
+    [
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      rawPath,
+      "-i",
+      gridPath,
+      "-filter_complex",
+      "[0:v][1:v]overlay=0:0:format=auto",
+      "-frames:v",
+      "1",
+      "-update",
+      "1",
+      target
+    ],
+    { stdio: "pipe" }
+  );
+  if (r.status !== 0) {
+    fail(`ffmpeg grid overlay failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+  }
+}
+async function computerScreenshotCommand(path, options = {}) {
+  const target = resolvePath(path);
+  mkdirSync3(dirname3(target), { recursive: true });
+  const stamp = `${process.pid}-${Date.now()}`;
+  const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.png`;
+  const svgPath = `/tmp/replicas-screenshot-${stamp}.brand.svg`;
+  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, height } = readPngDimensions(rawPath);
+    const gridSize = parseGridSize(options.grid);
+    if (options.raw && gridSize === null) {
+      copyFileSync2(rawPath, target);
+      console.log(`${target} (${width}x${height}, raw 1:1 desktop pixels)`);
+      return;
+    }
+    if (gridSize !== null) {
+      overlayGrid(rawPath, target, width, height, gridSize, gridPath);
+      console.log(`${target} (${width}x${height}, raw 1:1 desktop pixels, ${gridSize}px grid)`);
+      return;
+    }
+    const padX = Math.round(width * BRAND_PAD_FRACTION);
+    const padY = Math.round(height * BRAND_PAD_FRACTION);
+    const canvasW = width + padX * 2;
+    const canvasH = height + padY * 2;
+    const minDim = Math.min(width, height);
+    const cornerR = Math.round(minDim * SCREENSHOT_CORNER_FRACTION);
+    const shadowSigma = Math.max(12, Math.round(minDim * SHADOW_SIGMA_FRACTION));
+    const shadowOffsetY = Math.round(minDim * SHADOW_OFFSET_Y_FRACTION);
+    const shadowMargin = shadowSigma * 3;
+    const shadowW = width + shadowMargin * 2;
+    const shadowH = height + shadowMargin * 2;
+    writeFileSync3(svgPath, loadBrandSvg(canvasW, canvasH));
+    writeFileSync3(
+      maskPath,
+      SCREENSHOT_MASK_TEMPLATE.replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
+    );
+    writeFileSync3(
+      shadowPath,
+      SHADOW_MASK_TEMPLATE.replace(/__SW__/g, String(shadowW)).replace(/__SH__/g, String(shadowH)).replace(/__M__/g, String(shadowMargin)).replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
+    );
+    const r = spawnSync3(
+      "ffmpeg",
+      [
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        svgPath,
+        "-i",
+        rawPath,
+        "-i",
+        maskPath,
+        "-i",
+        shadowPath,
+        "-filter_complex",
+        `[2:v]format=rgba,alphaextract[mask];[3:v]format=rgba,colorchannelmixer=rr=0:gg=0:bb=0:aa=${SHADOW_ALPHA},gblur=sigma=${shadowSigma}[shadow];[1:v]format=rgba[scr];[scr][mask]alphamerge[rounded];[0:v]format=rgba[bg];[bg][shadow]overlay=${padX - shadowMargin}:${padY - shadowMargin + shadowOffsetY}:format=auto[bg_shadow];[bg_shadow][rounded]overlay=${padX}:${padY}:format=auto`,
+        "-frames:v",
+        "1",
+        "-update",
+        "1",
+        target
+      ],
+      { stdio: "pipe" }
+    );
+    if (r.status !== 0) {
+      fail(`ffmpeg branding failed: ${r.stderr?.toString().trim() || `exit ${r.status}`}`);
+    }
+  } finally {
+    rmSync3(rawPath, { force: true });
+    rmSync3(svgPath, { force: true });
+    rmSync3(maskPath, { force: true });
+    rmSync3(shadowPath, { force: true });
+    rmSync3(gridPath, { force: true });
+  }
+  console.log(target);
+}
+function hashFile(path) {
+  return createHash("sha256").update(readFileSync3(path)).digest("hex");
+}
+async function captureStableRawScreenshot(target, options) {
+  const start = Date.now();
+  const framePath = `${target}.frame.png`;
+  let lastHash = null;
+  let lastChangeAt = start;
+  let frames = 0;
+  let changes = 0;
+  let width = 0;
+  let height = 0;
+  try {
+    while (Date.now() - start <= options.timeoutMs) {
+      runDisplayCmd("scrot", ["-o", framePath]);
+      frames++;
+      const dimensions = readPngDimensions(framePath);
+      width = dimensions.width;
+      height = dimensions.height;
+      const hash = hashFile(framePath);
+      const now = Date.now();
+      if (lastHash === null) {
+        lastChangeAt = now;
+      } else if (hash !== lastHash) {
+        changes++;
+        lastChangeAt = now;
+      }
+      lastHash = hash;
+      copyFileSync2(framePath, target);
+      if (frames > 1 && now - lastChangeAt >= options.stableMs) {
+        return { width, height, stable: true, elapsedMs: now - start, frames, changes };
+      }
+      await sleep(options.pollMs);
+    }
+    return { width, height, stable: false, elapsedMs: Date.now() - start, frames, changes };
+  } finally {
+    rmSync3(framePath, { force: true });
+  }
+}
+function getActiveWindowTitle() {
+  return tryDisplayCmd("xdotool", ["getactivewindow", "getwindowname"]);
+}
+function getVisibleWindowTitles() {
+  const out = tryDisplayCmd("xdotool", ["search", "--onlyvisible", "--name", ".", "getwindowname", "%@"]);
+  return out ? out.split("\n").filter(Boolean).slice(0, 20) : [];
+}
+function recordingMousePosition() {
+  const mouse = getMouseLocation();
+  return mouse ? { x: mouse.x, y: mouse.y } : null;
+}
+async function computerObserveCommand(path, options = {}) {
+  const target = resolvePath(path);
+  mkdirSync3(dirname3(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;
+  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 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);
+    if (gridSize === null) {
+      copyFileSync2(rawPath, target);
+    } else {
+      overlayGrid(rawPath, target, capture.width, capture.height, gridSize, gridPath);
+    }
+    console.log(JSON.stringify({
+      screenshot: target,
+      width: capture.width,
+      height: capture.height,
+      stable: capture.stable,
+      elapsedMs: capture.elapsedMs,
+      frames: capture.frames,
+      changes: capture.changes,
+      mouse: getMouseLocation(),
+      activeWindow: getActiveWindowTitle(),
+      visibleWindows: getVisibleWindowTitles(),
+      mode: gridSize === null ? "raw" : "grid",
+      gridSize
+    }, null, 2));
+  } finally {
+    rmSync3(rawPath, { force: true });
+    rmSync3(gridPath, { force: true });
+  }
+}
+async function fetchChromeJson(path) {
+  let res;
+  try {
+    res = await fetch(`http://127.0.0.1:${CHROME_DEBUG_PORT}${path}`);
+  } catch {
+    fail(
+      `Chrome DevTools is not available on localhost:${CHROME_DEBUG_PORT}. Launch Chrome with \`replicas computer launch chrome <url>\` and try again.`
+    );
+  }
+  if (!res.ok) fail(`Chrome DevTools returned HTTP ${res.status}`);
+  try {
+    return await res.json();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    fail(`Chrome DevTools returned invalid JSON from ${path}: ${reason}`);
+  }
+}
+async function getChromePages() {
+  const targets = await fetchChromeJson("/json/list");
+  if (!Array.isArray(targets)) fail("Chrome DevTools returned an unexpected target list");
+  return targets.filter((target) => typeof target === "object" && target !== null).filter((target) => target.type === "page");
+}
+async function selectChromePage(options = {}) {
+  const pages = await getChromePages();
+  let matches = pages;
+  if (options.targetId) {
+    matches = matches.filter((page2) => page2.id === options.targetId);
+  }
+  if (options.title) {
+    const needle = options.title.toLowerCase();
+    matches = matches.filter((page2) => (page2.title ?? "").toLowerCase().includes(needle));
+  }
+  if (options.url) {
+    const needle = options.url.toLowerCase();
+    matches = matches.filter((page2) => (page2.url ?? "").toLowerCase().includes(needle));
+  }
+  const index = options.page ? parseCoord(options.page, "--page") : 0;
+  if (index < 0) fail("--page must be >= 0");
+  const page = matches[index];
+  const webSocketDebuggerUrl = page?.webSocketDebuggerUrl;
+  if (!webSocketDebuggerUrl) {
+    fail(
+      `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", {});
+  return { ...page, webSocketDebuggerUrl };
+}
+var VISIBLE_JS = `
+    const visible = (el) => {
+      const rect = el.getBoundingClientRect();
+      const style = getComputedStyle(el);
+      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+    };`;
+async function sendChromeSessionCommand(session, method, params) {
+  return chromeResult(await session.send({ method, params }), method);
+}
+async function withChromeSession(webSocketDebuggerUrl, callback) {
+  return await new Promise((resolve3, reject) => {
+    const ws = new WebSocket(webSocketDebuggerUrl);
+    const pending = /* @__PURE__ */ new Map();
+    let nextId = 1;
+    let settled = false;
+    const failSession = (error) => {
+      if (settled) return;
+      settled = true;
+      for (const request of pending.values()) {
+        clearTimeout(request.timeout);
+        request.reject(error);
+      }
+      pending.clear();
+      ws.close();
+      reject(error);
+    };
+    const finishSession = (value) => {
+      if (settled) return;
+      settled = true;
+      for (const request of pending.values()) clearTimeout(request.timeout);
+      pending.clear();
+      ws.close();
+      resolve3(value);
+    };
+    const session = {
+      send: ({ method, params }) => new Promise((resolveCommand, rejectCommand) => {
+        const id = nextId++;
+        const timeout = setTimeout(() => {
+          pending.delete(id);
+          rejectCommand(new Error(`Chrome DevTools ${method} timed out`));
+        }, 1e4);
+        pending.set(id, { method, resolve: resolveCommand, reject: rejectCommand, timeout });
+        ws.send(JSON.stringify({ id, method, params }));
+      })
+    };
+    ws.addEventListener("open", async () => {
+      try {
+        finishSession(await callback(session));
+      } catch (error) {
+        failSession(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : Buffer.isBuffer(event.data) ? event.data.toString("utf8") : Buffer.from(event.data).toString("utf8");
+      let message;
+      try {
+        message = JSON.parse(data);
+      } catch (error) {
+        failSession(new Error(`Chrome DevTools returned invalid WebSocket JSON: ${error instanceof Error ? error.message : String(error)}`));
+        return;
+      }
+      if (!isRecord(message) || typeof message.id !== "number") return;
+      const request = pending.get(message.id);
+      if (!request) return;
+      clearTimeout(request.timeout);
+      pending.delete(message.id);
+      const detail = isRecord(message.error) && typeof message.error.message === "string" ? message.error.message : void 0;
+      request.resolve(message.error ? { error: { message: detail } } : { result: isRecord(message.result) ? message.result : {} });
+    });
+    ws.addEventListener("error", () => failSession(new Error("Chrome DevTools WebSocket failed")));
+    ws.addEventListener("close", () => {
+      if (!settled) failSession(new Error("Chrome DevTools WebSocket closed unexpectedly"));
+    });
+  });
+}
+async function sendChromeCommands(webSocketDebuggerUrl, commands) {
+  return await withChromeSession(webSocketDebuggerUrl, async (session) => await Promise.all(commands.map((command) => session.send(command))));
+}
+async function sendChromeCommand(webSocketDebuggerUrl, method, params) {
+  const response = (await sendChromeCommands(webSocketDebuggerUrl, [{ method, params }]))[0];
+  if (response.error) throw new Error(response.error.message || `Chrome DevTools ${method} failed`);
+  return response.result ?? {};
+}
+async function callFunctionOnChromeNodeInSession(session, backendNodeId, functionDeclaration, args = []) {
+  const resolved = await sendChromeSessionCommand(session, "DOM.resolveNode", { backendNodeId });
+  const objectId = isRecord(resolved.object) ? resolved.object.objectId : void 0;
+  if (typeof objectId !== "string") throw new Error(`Could not resolve browser element ref ${backendNodeId}`);
+  return await sendChromeSessionCommand(session, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    arguments: args.map((value) => ({ value })),
+    returnByValue: true
+  });
+}
+function chromeCallValue(response) {
+  return isRecord(response.result) ? response.result.value : void 0;
+}
+async function evaluateChromeTarget(webSocketDebuggerUrl, expression) {
+  return await withChromeSession(webSocketDebuggerUrl, async (session) => await evaluateChromeSession(session, expression));
+}
+async function evaluateChromeSession(session, expression) {
+  const response = await sendChromeSessionCommand(session, "Runtime.evaluate", {
+    expression,
+    awaitPromise: true,
+    returnByValue: true
+  });
+  const exception = response.exceptionDetails;
+  if (exception) {
+    const text = typeof exception === "object" && exception !== null && "text" in exception && typeof exception.text === "string" ? exception.text : "";
+    throw new Error(text || "Chrome DevTools evaluation threw");
+  }
+  const evaluated = response.result;
+  return typeof evaluated === "object" && evaluated !== null && "value" in evaluated ? evaluated.value ?? null : null;
+}
+function isRawAXNode(value) {
+  return isRecord(value);
+}
+function isDOMSnapshotDocument(value) {
+  return isRecord(value);
+}
+function chromeVisualViewport(layout) {
+  const viewport = isRecord(layout.cssVisualViewport) ? layout.cssVisualViewport : {};
+  return {
+    width: typeof viewport.clientWidth === "number" ? viewport.clientWidth : 0,
+    height: typeof viewport.clientHeight === "number" ? viewport.clientHeight : 0
+  };
+}
+function roundBrowserRect(rect) {
+  return {
+    x: Math.round(rect.x),
+    y: Math.round(rect.y),
+    width: Math.round(rect.width),
+    height: Math.round(rect.height),
+    centerX: Math.round(rect.centerX),
+    centerY: Math.round(rect.centerY)
+  };
+}
+function browserStateProperties(node) {
+  const properties = [];
+  for (const { name, value } of node.properties ?? []) {
+    const state = value?.value;
+    if (!name || !BROWSER_STATE_PROPERTIES.has(name) || typeof state !== "string" && typeof state !== "number" && typeof state !== "boolean") continue;
+    properties.push([name, name === "url" ? clippedText(state, 300) : state]);
+  }
+  return Object.fromEntries(properties);
+}
+function readBrowserStateCache(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord(value) || !Array.isArray(value.entries)) return null;
+  const entries = [];
+  for (const entry of value.entries) {
+    if (!isRecord(entry) || typeof entry.key !== "string" || typeof entry.semantic !== "string" || typeof entry.line !== "string") return null;
+    entries.push({ key: entry.key, semantic: entry.semantic, line: entry.line });
+  }
+  return {
+    url: typeof value.url === "string" ? value.url : void 0,
+    documentId: typeof value.documentId === "string" || value.documentId === null ? value.documentId : void 0,
+    entries
+  };
+}
+function chromeResult(response, method) {
+  if (response.error) throw new Error(response.error.message || `Chrome DevTools ${method} failed`);
+  return response.result ?? {};
+}
+function collectFrameIds(frameTree) {
+  const ids = [];
+  const visit = (value) => {
+    if (!isRecord(value)) return;
+    const frame = isRecord(value.frame) ? value.frame : {};
+    if (typeof frame.id === "string") ids.push(frame.id);
+    if (Array.isArray(value.childFrames)) value.childFrames.forEach(visit);
+  };
+  visit(frameTree);
+  return ids;
+}
+function browserDocumentId(frameTree) {
+  if (!isRecord(frameTree) || !isRecord(frameTree.frame)) return null;
+  const loaderId = frameTree.frame.loaderId;
+  return typeof loaderId === "string" ? loaderId : null;
+}
+function intersectRects(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const right = Math.min(a.x + a.width, b.x + b.width);
+  const bottom = Math.min(a.y + a.height, b.y + b.height);
+  if (right <= x || bottom <= y) return null;
+  return {
+    x,
+    y,
+    width: right - x,
+    height: bottom - y,
+    centerX: x + (right - x) / 2,
+    centerY: y + (bottom - y) / 2
+  };
+}
+function browserContentQuadRects(quads, viewportRect) {
+  if (!Array.isArray(quads)) return [];
+  return quads.filter((quad) => Array.isArray(quad) && quad.length >= 8 && quad.every(Number.isFinite)).map((quad) => {
+    const xs = [quad[0], quad[2], quad[4], quad[6]];
+    const ys = [quad[1], quad[3], quad[5], quad[7]];
+    const x = Math.min(...xs);
+    const y = Math.min(...ys);
+    const width = Math.max(...xs) - x;
+    const height = Math.max(...ys) - y;
+    return { x, y, width, height, centerX: x + width / 2, centerY: y + height / 2 };
+  }).map((rect) => intersectRects(rect, viewportRect)).filter((rect) => !!rect).sort((a, b) => b.width * b.height - a.width * a.height);
+}
+function buildBrowserBounds(result, viewport, targetId) {
+  const strings = Array.isArray(result.strings) ? result.strings : [];
+  const documents = Array.isArray(result.documents) ? result.documents.filter(isDOMSnapshotDocument) : [];
+  const localRects = documents.map((document) => {
+    const rects = /* @__PURE__ */ new Map();
+    const nodeIndexes = document.layout?.nodeIndex ?? [];
+    const bounds = document.layout?.bounds ?? [];
+    const scrollX = document.scrollOffsetX ?? 0;
+    const scrollY = document.scrollOffsetY ?? 0;
+    nodeIndexes.forEach((nodeIndex, index) => {
+      const bound = bounds[index];
+      if (!Array.isArray(bound) || bound.length < 4 || !bound.every(Number.isFinite)) return;
+      const [rawX, rawY, width, height] = bound;
+      rects.set(nodeIndex, {
+        x: rawX - scrollX,
+        y: rawY - scrollY,
+        width,
+        height,
+        centerX: rawX - scrollX + width / 2,
+        centerY: rawY - scrollY + height / 2
+      });
+    });
+    return rects;
+  });
+  const parents = /* @__PURE__ */ new Map();
+  documents.forEach((document, documentIndex) => {
+    const sparse = document.nodes?.contentDocumentIndex;
+    sparse?.index?.forEach((nodeIndex, index) => {
+      const childDocumentIndex = sparse.value?.[index];
+      if (typeof childDocumentIndex === "number") parents.set(childDocumentIndex, { documentIndex, nodeIndex });
+    });
+  });
+  const targetDocumentIndex = documents.findIndex(
+    (document) => typeof document.frameId === "number" && strings[document.frameId] === targetId
+  );
+  const rootIndex = targetDocumentIndex >= 0 ? targetDocumentIndex : documents.findIndex((_, index) => !parents.has(index));
+  const viewportRect = {
+    x: 0,
+    y: 0,
+    width: viewport.width,
+    height: viewport.height,
+    centerX: viewport.width / 2,
+    centerY: viewport.height / 2
+  };
+  const origins = /* @__PURE__ */ new Map();
+  origins.set(rootIndex < 0 ? 0 : rootIndex, { x: 0, y: 0, clip: viewportRect });
+  for (let pass = 0; pass < documents.length; pass++) {
+    let changed = false;
+    for (const [childIndex, parent] of parents) {
+      if (origins.has(childIndex)) continue;
+      const parentOrigin = origins.get(parent.documentIndex);
+      const frameRect = localRects[parent.documentIndex]?.get(parent.nodeIndex);
+      if (!parentOrigin || !frameRect) continue;
+      const globalFrameRect = {
+        ...frameRect,
+        x: parentOrigin.x + frameRect.x,
+        y: parentOrigin.y + frameRect.y,
+        centerX: parentOrigin.x + frameRect.centerX,
+        centerY: parentOrigin.y + frameRect.centerY
+      };
+      const childDocument = documents[childIndex];
+      const insetX = Math.max(0, (globalFrameRect.width - (childDocument?.contentWidth ?? globalFrameRect.width)) / 2);
+      const insetY = Math.max(0, (globalFrameRect.height - (childDocument?.contentHeight ?? globalFrameRect.height)) / 2);
+      const contentRect = {
+        x: globalFrameRect.x + insetX,
+        y: globalFrameRect.y + insetY,
+        width: Math.max(0, globalFrameRect.width - insetX * 2),
+        height: Math.max(0, globalFrameRect.height - insetY * 2),
+        centerX: globalFrameRect.centerX,
+        centerY: globalFrameRect.centerY
+      };
+      const clip = intersectRects(parentOrigin.clip, contentRect);
+      if (!clip) continue;
+      origins.set(childIndex, { x: contentRect.x, y: contentRect.y, clip });
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  const byBackendNodeId = /* @__PURE__ */ new Map();
+  documents.forEach((document, documentIndex) => {
+    const origin = origins.get(documentIndex);
+    if (!origin) return;
+    const backendNodeIds = document.nodes?.backendNodeId ?? [];
+    for (const [nodeIndex, local] of localRects[documentIndex] ?? []) {
+      const backendNodeId = backendNodeIds[nodeIndex];
+      if (!Number.isInteger(backendNodeId)) continue;
+      const rect = {
+        ...local,
+        x: origin.x + local.x,
+        y: origin.y + local.y,
+        centerX: origin.x + local.centerX,
+        centerY: origin.y + local.centerY
+      };
+      if (intersectRects(rect, origin.clip)) byBackendNodeId.set(backendNodeId, { rect, clip: origin.clip });
+    }
+  });
+  return byBackendNodeId;
+}
+var BROWSER_INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "checkbox",
+  "combobox",
+  "link",
+  "listbox",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "radio",
+  "scrollbar",
+  "searchbox",
+  "slider",
+  "spinbutton",
+  "switch",
+  "tab",
+  "textbox",
+  "treeitem"
+]);
+var BROWSER_STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "alert",
+  "cell",
+  "columnheader",
+  "dialog",
+  "figure",
+  "gridcell",
+  "heading",
+  "image",
+  "listitem",
+  "main",
+  "paragraph",
+  "region",
+  "row",
+  "rowheader",
+  "status",
+  "StaticText"
+]);
+var BROWSER_STATE_PROPERTIES = /* @__PURE__ */ new Set([
+  "autocomplete",
+  "checked",
+  "disabled",
+  "editable",
+  "expanded",
+  "focusable",
+  "focused",
+  "haspopup",
+  "invalid",
+  "level",
+  "multiselectable",
+  "orientation",
+  "pressed",
+  "readonly",
+  "protected",
+  "required",
+  "selected",
+  "url"
+]);
+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);
+  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 nodes = [];
+  axResults.forEach((response, index) => {
+    if (response.error) return;
+    const responseNodes = response.result?.nodes;
+    if (!Array.isArray(responseNodes)) return;
+    for (const node of responseNodes) {
+      if (!isRawAXNode(node)) continue;
+      nodes.push({ ...node, sourceFrameId: frameIds[index] });
+    }
+  });
+  const bounds = buildBrowserBounds(domSnapshot, viewport, page.id);
+  const nodesByKey = new Map(nodes.map((node) => [`${node.sourceFrameId}:${node.nodeId}`, node]));
+  const propertyMap = browserStateProperties;
+  const roleOf = (node) => clippedText(node.role?.value, 80);
+  const nameOf = (node) => clippedText(node.name?.value);
+  const valueOf = (node) => {
+    if (propertyMap(node).protected === true) return null;
+    const value = node.value?.value;
+    if (typeof value === "number" || typeof value === "boolean") return value;
+    const text = clippedText(value);
+    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(({ node, role, bound }) => {
+    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;
+    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);
+  }).sort((a, b) => a.bound.rect.y - b.bound.rect.y || a.bound.rect.x - b.bound.rect.x);
+  const elements = [];
+  const entries = [];
+  const meaningfulKeys = new Set(meaningful.map(({ node }) => `${node.sourceFrameId}:${node.nodeId}`));
+  const visibleText = [];
+  let visibleTextLength = 0;
+  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 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 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 = [
+      ...actionable ? ["click"] : [],
+      ...["textbox", "searchbox", "combobox", "spinbutton", "slider"].includes(role) || states.editable === true ? ["set_value"] : [],
+      "scroll"
+    ];
+    if (ref) {
+      elements.push({
+        ref,
+        role,
+        name: name || null,
+        description,
+        value,
+        states,
+        actions,
+        rect,
+        frameId: node.sourceFrameId
+      });
+    }
+    const stateText = Object.entries(states).filter(([key]) => key !== "url" && key !== "focusable").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;
+    let parentId = node.parentId;
+    const visited = /* @__PURE__ */ new Set();
+    while (parentId && depth < 8) {
+      const parentKey = `${node.sourceFrameId}:${parentId}`;
+      if (visited.has(parentKey)) break;
+      visited.add(parentKey);
+      if (meaningfulKeys.has(parentKey)) depth++;
+      parentId = nodesByKey.get(parentKey)?.parentId;
+    }
+    const line = `${"  ".repeat(depth)}${ref ? `[ref=${ref}]` : "-"} ${semantic} (${rect.x},${rect.y} ${rect.width}x${rect.height})`;
+    if (treeLength + line.length + 1 <= treeLimit) {
+      const key = Number.isInteger(node.backendDOMNodeId) ? `dom:${node.sourceFrameId}:${node.backendDOMNodeId}` : `ax:${node.sourceFrameId}:${node.nodeId}`;
+      entries.push({ key, semantic, line });
+      treeLength += line.length + 1;
+    }
+    if (name && visibleTextLength < options.textLimit && (role === "StaticText" || role === "heading" || BROWSER_INTERACTIVE_ROLES.has(role))) {
+      const remaining = options.textLimit - visibleTextLength;
+      visibleText.push(name.slice(0, remaining));
+      visibleTextLength += Math.min(name.length, remaining) + 1;
+    }
+  }
+  const revision = createHash("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
+  const snapshot = {
+    title: (page.title ?? "").slice(0, 1e3),
+    url: (page.url ?? "").slice(0, 2e3),
+    documentId: browserDocumentId(frameTree),
+    revision,
+    viewport,
+    text: visibleText.join(" ").slice(0, options.textLimit),
+    tree: entries.map(({ line }) => line).join("\n"),
+    elements,
+    controls: elements,
+    nodeCount: entries.length,
+    elementCount: elements.length,
+    truncated: entries.length < meaningful.length || elements.length < meaningful.filter(({ node, role }) => browserNodeActionable(role, propertyMap(node))).length
+  };
+  return { snapshot, entries };
+}
+async function computerBrowserCommand(options = {}) {
+  const textLimit = options.limit ? parseCoord(options.limit, "--limit") : 4e3;
+  const elementLimit = options.elementLimit ? parseCoord(options.elementLimit, "--element-limit") : 80;
+  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");
+  const targets = options.targetId || options.page || options.title || options.url ? [await selectChromePage(options)] : await getChromePages();
+  const pages = targets.map((target) => ({
+    target,
+    page: {
+      id: target.id ?? null,
+      title: target.title ?? "",
+      url: target.url ?? "",
+      attached: !!target.attached
+    }
+  }));
+  const pageResults = [];
+  for (const { target, page } of pages) {
+    if (options.snapshot && target.webSocketDebuggerUrl) {
+      try {
+        const { snapshot } = await captureBrowserSnapshot(
+          { ...target, webSocketDebuggerUrl: target.webSocketDebuggerUrl },
+          { textLimit, elementLimit }
+        );
+        pageResults.push({ ...page, snapshot });
+      } catch (error) {
+        pageResults.push({ ...page, snapshotError: error instanceof Error ? error.message : "snapshot failed" });
+      }
+    } else {
+      pageResults.push(page);
+    }
+  }
+  console.log(JSON.stringify({
+    port: CHROME_DEBUG_PORT,
+    pageCount: pageResults.length,
+    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) {
+  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 {
+    }
+    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`;
+}
+function browserStateDiff(previous, current) {
+  const before = new Map(previous.map((entry) => [entry.key, entry]));
+  const after = new Map(current.map((entry) => [entry.key, entry]));
+  const lines = [];
+  let added = 0;
+  let changed = 0;
+  let removed = 0;
+  for (const entry of current) {
+    const old = before.get(entry.key);
+    if (!old) {
+      added++;
+      lines.push(`+ ${entry.line}`);
+    } else if (old.semantic !== entry.semantic) {
+      changed++;
+      lines.push(`~ ${old.line}
+  ${entry.line}`);
+    }
+  }
+  for (const entry of previous) {
+    if (after.has(entry.key)) continue;
+    removed++;
+    lines.push(`- ${entry.line}`);
+  }
+  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);
+  mkdirSync3(dirname3(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
+    })
+  ]);
+  const data = screenshotResult.data;
+  if (typeof data !== "string") fail("Chrome did not return screenshot data");
+  writeFileSync3(target, Buffer.from(data, "base64"));
+  const screenshot = readPngDimensions(target);
+  const targetId = page.id ?? "unknown";
+  const cachePath = browserStateCachePath(targetId);
+  let mode = "full";
+  let tree = snapshot.tree;
+  let changes = { added: snapshot.nodeCount, changed: 0, removed: 0 };
+  if (!options.full && existsSync3(cachePath)) {
+    const cached = readBrowserStateCache(cachePath);
+    if (cached?.url === snapshot.url && cached.documentId === snapshot.documentId) {
+      mode = "diff";
+      const diff = browserStateDiff(cached.entries, entries);
+      tree = diff.tree;
+      changes = { added: diff.added, changed: diff.changed, removed: diff.removed };
+    }
+  }
+  mkdirSync3(STATE_DIR, { recursive: true });
+  writeFileSync3(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
+  };
+  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));
+}
+var DESKTOP_POINT_JS = `
+    const desktopPoint = (rect) => {
+      const borderX = Math.max(0, (window.outerWidth - window.innerWidth) / 2);
+      const topChrome = Math.max(0, window.outerHeight - window.innerHeight - borderX);
+      return {
+        x: Math.round(window.screenX + borderX + rect.x + rect.width / 2),
+        y: Math.round(window.screenY + topChrome + rect.y + rect.height / 2),
+      };
+    };`;
+function parseBrowserRef(value) {
+  const ref = parseCoord(value.replace(/^ref=/, ""), "--ref");
+  if (ref <= 0) fail("--ref must be a positive backend DOM node ID from the latest browser state");
+  return ref;
+}
+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 (!existsSync3(cachePath)) fail(`No browser state is cached for target ${targetId}. Run replicas computer browser-state <path> --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) {
+  const viewport = chromeVisualViewport(layout);
+  return {
+    x: 0,
+    y: 0,
+    width: viewport.width,
+    height: viewport.height,
+    centerX: viewport.width / 2,
+    centerY: viewport.height / 2
+  };
+}
+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 axNodes = (await sendChromeSessionCommand(session, "Accessibility.getPartialAXTree", {
+      backendNodeId,
+      fetchRelatives: false
+    })).nodes;
+    const rawNode = Array.isArray(axNodes) && isRawAXNode(axNodes[0]) ? axNodes[0] : null;
+    const states = rawNode ? browserStateProperties(rawNode) : {};
+    const role = clippedText(rawNode?.role?.value, 80);
+    const element = rawNode ? {
+      ref: String(backendNodeId),
+      role,
+      name: clippedText(rawNode.name?.value) || null,
+      description: clippedText(rawNode.description?.value) || null,
+      value: typeof rawNode.value?.value === "string" ? clippedText(rawNode.value.value) : typeof rawNode.value?.value === "number" || typeof rawNode.value?.value === "boolean" ? rawNode.value.value : null,
+      states,
+      actions: [
+        "click",
+        ...["textbox", "searchbox", "combobox", "spinbutton", "slider"].includes(role) || states.editable === true ? ["set_value"] : [],
+        "scroll"
+      ]
+    } : null;
+    const desktopPoint = await evaluateChromeSession(session, `(() => {
+${DESKTOP_POINT_JS}
+    return desktopPoint({ x: ${rect.centerX}, y: ${rect.centerY}, width: 0, height: 0 });
+  })()`);
+    return {
+      ref: String(backendNodeId),
+      rect,
+      element,
+      desktopPoint: typeof desktopPoint === "object" && desktopPoint !== null && "x" in desktopPoint && typeof desktopPoint.x === "number" && "y" in desktopPoint && typeof desktopPoint.y === "number" ? { x: desktopPoint.x, y: desktopPoint.y } : null
+    };
+  });
+}
+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.`);
+  }
+  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)}`);
+  }
+  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]);
+}
+function buildBrowserClickExpression(query, options) {
+  return `(() => {
+    const query = ${JSON.stringify(query)};
+    const exact = ${JSON.stringify(options.exact)};
+    const index = ${options.index};
+    const normalize = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+${VISIBLE_JS}
+    const label = (el) => normalize(el.innerText || el.value || el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('placeholder') || el.href || el.id || el.name || el.tagName);
+${DESKTOP_POINT_JS}
+    const matches = (text) => {
+      const haystack = text.toLowerCase();
+      const needle = query.toLowerCase();
+      return exact ? haystack === needle : haystack.includes(needle);
+    };
+    const selector = 'a,button,input,textarea,select,[role="button"],[role="link"],[role="textbox"],[contenteditable="true"]';
+    const candidates = Array.from(document.querySelectorAll(selector))
+      .filter(visible)
+      .map((el) => ({ el, text: label(el) }))
+      .filter((candidate) => candidate.text && matches(candidate.text));
+    const candidate = candidates[index];
+    if (!candidate) {
+      return {
+        clicked: false,
+        query,
+        matchCount: candidates.length,
+        reason: candidates.length ? 'index out of range' : 'no visible matching control',
+      };
+    }
+    const { el, text } = candidate;
+    el.scrollIntoView({ block: 'center', inline: 'center' });
+    const rect = el.getBoundingClientRect();
+    if (typeof el.focus === 'function') el.focus({ preventScroll: true });
+    return {
+      clicked: true,
+      query,
+      matchCount: candidates.length,
+      index,
+      tag: el.tagName.toLowerCase(),
+      role: el.getAttribute('role') || null,
+      type: el.getAttribute('type') || null,
+      text,
+      href: el.href || null,
+      desktopPoint: desktopPoint(rect),
+      rect: {
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        centerX: Math.round(rect.x + rect.width / 2),
+        centerY: Math.round(rect.y + rect.height / 2),
+      },
+    };
+  })()`;
+}
+function browserActionRectCenter(result) {
+  if (typeof result !== "object" || result === null || !("rect" in result)) return null;
+  const rect = result.rect;
+  if (typeof rect !== "object" || rect === null) return null;
+  const x = "centerX" in rect ? rect.centerX : void 0;
+  const y = "centerY" in rect ? rect.centerY : void 0;
+  if (typeof x !== "number" || typeof y !== "number" || !Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y };
+}
+function browserActionPoint(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const action = "result" in result ? result.result : result;
+  if (typeof action !== "object" || action === null || !("desktopPoint" in action)) return null;
+  const point = action.desktopPoint;
+  if (typeof point !== "object" || point === null) return null;
+  const x = "x" in point ? point.x : void 0;
+  const y = "y" in point ? point.y : void 0;
+  if (typeof x !== "number" || typeof y !== "number" || !Number.isFinite(x) || !Number.isFinite(y)) return null;
+  const dimensions = getDisplayDimensions();
+  return {
+    x: clamp(Math.round(x), 0, dimensions.width),
+    y: clamp(Math.round(y), 0, dimensions.height)
+  };
+}
+async function dispatchChromeClick(page, x, y, button, clicks) {
+  await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+    await dispatchChromeClickInSession(session, x, y, button, clicks);
+  });
+}
+async function dispatchChromeClickInSession(session, x, y, button, clicks) {
+  for (let clickCount = 1; clickCount <= clicks; clickCount++) {
+    await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", {
+      type: "mousePressed",
+      x,
+      y,
+      button,
+      clickCount
+    });
+    await sendChromeSessionCommand(session, "Input.dispatchMouseEvent", {
+      type: "mouseReleased",
+      x,
+      y,
+      button,
+      clickCount
+    });
+  }
+}
+async function replaceChromeText(page, text) {
+  await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+    await replaceChromeTextInSession(session, text);
+  });
+}
+async function replaceChromeTextInSession(session, text) {
+  await sendChromeSessionCommand(session, "Input.dispatchKeyEvent", {
+    type: "rawKeyDown",
+    key: "a",
+    code: "KeyA",
+    windowsVirtualKeyCode: 65,
+    nativeVirtualKeyCode: 65,
+    modifiers: 2
+  });
+  await sendChromeSessionCommand(session, "Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: "a",
+    code: "KeyA",
+    windowsVirtualKeyCode: 65,
+    nativeVirtualKeyCode: 65,
+    modifiers: 2
+  });
+  await sendChromeSessionCommand(session, "Input.insertText", { text });
+}
+var BROWSER_DIRECT_VALUE_INPUT_TYPES = /* @__PURE__ */ new Set(["number", "range", "date", "datetime-local", "month", "week", "time", "color"]);
+function browserFillInvalid(actual, expected, fieldType, semanticSelection = false, selectionMatched = false) {
+  if (semanticSelection) return !selectionMatched;
+  if (["number", "range"].includes(fieldType)) {
+    const actualNumber = typeof actual === "number" ? actual : Number(actual);
+    const expectedNumber = Number(expected);
+    return !Number.isFinite(actualNumber) || !Number.isFinite(expectedNumber) || actualNumber !== expectedNumber;
+  }
+  if (fieldType === "color") return String(actual).toLowerCase() !== expected.toLowerCase();
+  return actual !== expected;
+}
+async function fillChromeNodeInSession(session, backendNodeId, value) {
+  await sendChromeSessionCommand(session, "DOM.focus", { backendNodeId });
+  const directResult = await callFunctionOnChromeNodeInSession(
+    session,
+    backendNodeId,
+    `function(value) {
+      const emit = () => {
+        this.dispatchEvent(new Event('input', { bubbles: true }));
+        this.dispatchEvent(new Event('change', { bubbles: true }));
+      };
+      if (this instanceof HTMLSelectElement) {
+        const option = Array.from(this.options).find((item) => item.value === value || item.text.trim() === value);
+        if (option) this.value = option.value;
+        else this.value = value;
+        emit();
+        return { handled: true, semanticSelection: true, matched: !!option, value: this.value };
+      }
+      if (this instanceof HTMLInputElement && ${JSON.stringify([...BROWSER_DIRECT_VALUE_INPUT_TYPES])}.includes(this.type.toLowerCase())) {
+        const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+        if (!setter) return { handled: false };
+        setter.call(this, value);
+        emit();
+        return { handled: true, semanticSelection: false, matched: true, value: this.value };
+      }
+      return { handled: false };
+    }`,
+    [value]
+  );
+  const directValue = chromeCallValue(directResult);
+  const directHandled = isRecord(directValue) && directValue.handled === true;
+  if (!directHandled) await replaceChromeTextInSession(session, value);
+  const verification = await callFunctionOnChromeNodeInSession(
+    session,
+    backendNodeId,
+    `function() {
+      const value = this instanceof HTMLSelectElement || 'value' in this ? this.value : this.textContent;
+      const type = this instanceof HTMLSelectElement
+        ? 'select'
+        : this instanceof HTMLInputElement
+          ? this.type.toLowerCase()
+          : this.isContentEditable
+            ? 'contenteditable'
+            : 'text';
+      return { value, valueLength: String(value ?? '').length, type };
+    }`
+  );
+  const actual = chromeCallValue(verification);
+  if (!isRecord(actual)) fail(`Chrome did not return a value for browser element ref ${backendNodeId}.`);
+  const fieldType = typeof actual.type === "string" ? actual.type : "";
+  const semanticSelection = isRecord(directValue) && directValue.semanticSelection === true;
+  const selectionMatched = isRecord(directValue) && directValue.matched === true;
+  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 };
+}
+async function computerBrowserClickCommand(query, options = {}) {
+  const page = await selectChromePage(options);
+  if (options.ref) {
+    const target = await prepareBrowserElement(page, options.ref);
+    const buttonNames = { "1": "left", "2": "middle", "3": "right", left: "left", middle: "middle", right: "right" };
+    const button = buttonNames[(options.button ?? "left").toLowerCase()];
+    if (!button) fail("--button must be one of left|middle|right|1|2|3");
+    const clicks = options.double ? 2 : 1;
+    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 }
+    }, null, 2));
+    return;
+  }
+  if (!query) fail("Provide control text or --ref <id> from the latest browser state");
+  const index = options.index ? parseCoord(options.index, "--index") : 0;
+  if (index < 0) fail("--index must be >= 0");
+  const result = await evaluateChromeTarget(
+    page.webSocketDebuggerUrl,
+    buildBrowserClickExpression(query, { exact: !!options.exact, index })
+  );
+  const center = browserActionRectCenter(result);
+  if (center) await dispatchChromeClick(page, center.x, center.y, "left", 1);
+  const point = browserActionPoint(result);
+  if (point) logRecordingAction({ type: "click", ...point });
+  console.log(JSON.stringify({
+    ...browserTargetOutput(page),
+    result
+  }, null, 2));
+}
+function buildBrowserFillExpression(query, value, options) {
+  return `(() => {
+    const query = ${JSON.stringify(query)};
+    const value = ${JSON.stringify(value)};
+    const exact = ${JSON.stringify(options.exact)};
+    const index = ${options.index};
+    const normalize = (text) => String(text || '').replace(/\\s+/g, ' ').trim();
+    const escape = (text) => globalThis.CSS && CSS.escape ? CSS.escape(text) : String(text).replace(/["\\\\]/g, '\\\\$&');
+${VISIBLE_JS}
+    const matches = (text) => {
+      const haystack = text.toLowerCase();
+      const needle = query.toLowerCase();
+      return exact ? haystack === needle : haystack.includes(needle);
+    };
+    const labelParts = (el) => {
+      const id = el.getAttribute('id');
+      const labels = [];
+      if (id) labels.push(...Array.from(document.querySelectorAll('label[for="' + escape(id) + '"]')).map((label) => label.innerText));
+      const wrappingLabel = el.closest('label');
+      if (wrappingLabel) labels.push(wrappingLabel.innerText);
+      labels.push(
+        el.getAttribute('aria-label'),
+        el.getAttribute('title'),
+        el.getAttribute('placeholder'),
+        el.getAttribute('name'),
+        el.getAttribute('id'),
+        el.value,
+        el.innerText,
+      );
+      return labels.map(normalize).filter(Boolean);
+    };
+    const labelText = (el) => labelParts(el).join(' ');
+${DESKTOP_POINT_JS}
+    const fieldMatches = (el) => {
+      const parts = labelParts(el);
+      return exact ? parts.some(matches) : matches(parts.join(' '));
+    };
+    const selector = 'input:not([type="button"]):not([type="submit"]):not([type="reset"]):not([type="checkbox"]):not([type="radio"]),textarea,select,[role="textbox"],[contenteditable="true"]';
+    const candidates = Array.from(document.querySelectorAll(selector))
+      .filter(visible)
+      .map((el) => ({ el, text: labelText(el) }))
+      .filter((candidate) => candidate.text && fieldMatches(candidate.el));
+    const candidate = candidates[index];
+    if (!candidate) {
+      return {
+        filled: false,
+        query,
+        matchCount: candidates.length,
+        reason: candidates.length ? 'index out of range' : 'no visible matching field',
+      };
+    }
+    const { el, text } = candidate;
+    el.scrollIntoView({ block: 'center', inline: 'center' });
+    if (typeof el.focus === 'function') el.focus({ preventScroll: true });
+    const fieldType = el.tagName.toLowerCase() === 'select' ? 'select' : String(el.getAttribute('type') || 'text').toLowerCase();
+    let nativeInputRequired = false;
+    let semanticSelection = false;
+    let selectionMatched = false;
+    if (el.tagName.toLowerCase() === 'select') {
+      const option = Array.from(el.options).find((item) => item.value === value || normalize(item.text) === value);
+      if (option) el.value = option.value;
+      else el.value = value;
+      semanticSelection = true;
+      selectionMatched = !!option;
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+    } else if (el instanceof HTMLInputElement && ${JSON.stringify([...BROWSER_DIRECT_VALUE_INPUT_TYPES])}.includes(fieldType)) {
+      const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+      if (setter) {
+        setter.call(el, value);
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+      } else {
+        nativeInputRequired = true;
+      }
+    } else if (el.isContentEditable) {
+      const selection = getSelection();
+      const range = document.createRange();
+      range.selectNodeContents(el);
+      selection.removeAllRanges();
+      selection.addRange(range);
+      nativeInputRequired = true;
+    } else if (typeof el.select === 'function') {
+      el.select();
+      nativeInputRequired = true;
+    } else {
+      el.setSelectionRange(0, String(el.value || '').length);
+      nativeInputRequired = true;
+    }
+    const rect = el.getBoundingClientRect();
+    return {
+      filled: true,
+      query,
+      matchCount: candidates.length,
+      index,
+      tag: el.tagName.toLowerCase(),
+      role: el.getAttribute('role') || null,
+      type: fieldType,
+      text,
+      actualValue: el.isContentEditable ? el.textContent : 'value' in el ? el.value : null,
+      valueLength: String(el.isContentEditable ? el.textContent : 'value' in el ? el.value : '').length,
+      nativeInputRequired,
+      semanticSelection,
+      selectionMatched,
+      desktopPoint: desktopPoint(rect),
+      rect: {
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        centerX: Math.round(rect.x + rect.width / 2),
+        centerY: Math.round(rect.y + rect.height / 2),
+      },
+    };
+  })()`;
+}
+async function computerBrowserFillCommand(query, value, options = {}) {
+  const page = await selectChromePage(options);
+  if (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));
+    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 }
+    }, null, 2));
+    return;
+  }
+  if (!query) fail("Provide field text or --ref <id> from the latest browser state");
+  const index = options.index ? parseCoord(options.index, "--index") : 0;
+  if (index < 0) fail("--index must be >= 0");
+  const result = await evaluateChromeTarget(
+    page.webSocketDebuggerUrl,
+    buildBrowserFillExpression(query, value, { exact: !!options.exact, index })
+  );
+  const point = browserActionPoint(result);
+  if (typeof result === "object" && result !== null && "nativeInputRequired" in result && result.nativeInputRequired === true) {
+    await replaceChromeText(page, value);
+    const actualValue = await evaluateChromeTarget(page.webSocketDebuggerUrl, `(() => {
+      const el = document.activeElement;
+      return el && el.isContentEditable ? el.textContent : el && 'value' in el ? el.value : null;
+    })()`);
+    const fieldType = "type" in result && typeof result.type === "string" ? result.type.toLowerCase() : "";
+    if (browserFillInvalid(actualValue, value, fieldType)) {
+      fail(`Chrome reported that ${JSON.stringify(query)} contains ${JSON.stringify(actualValue)} after filling, expected ${JSON.stringify(value)}.`);
+    }
+    if (isRecord(result)) {
+      Object.assign(result, { actualValue, valueLength: String(actualValue ?? "").length });
+    }
+  } else if (isRecord(result) && result.filled === true) {
+    const fieldType = typeof result.type === "string" ? result.type : "";
+    if (browserFillInvalid(result.actualValue, value, fieldType, result.semanticSelection === true, result.selectionMatched === true)) {
+      fail(`Chrome reported that ${JSON.stringify(query)} contains ${JSON.stringify(result.actualValue)} after filling, expected ${JSON.stringify(value)}.`);
+    }
+  }
+  if (point) logRecordingAction({ type: "type", ...point });
+  console.log(JSON.stringify({
+    ...browserTargetOutput(page),
+    result
+  }, null, 2));
+}
+function buildBrowserWaitExpression(query, options) {
+  return `(() => {
+    const query = ${JSON.stringify(query)};
+    const mode = ${JSON.stringify(options.mode)};
+    const exact = ${JSON.stringify(options.exact)};
+    const normalize = (text) => String(text || '').replace(/\\s+/g, ' ').trim();
+${VISIBLE_JS}
+    const matches = (text) => {
+      const haystack = normalize(text).toLowerCase();
+      const needle = query.toLowerCase();
+      return exact ? haystack === needle : haystack.includes(needle);
+    };
+    const controlText = (el) => normalize(el.innerText || el.value || el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('placeholder') || el.href || el.id || el.name || el.tagName);
+    const controls = () => Array.from(document.querySelectorAll('a,button,input,textarea,select,[role="button"],[role="link"],[role="textbox"],[contenteditable="true"]'))
+      .filter(visible)
+      .map(controlText)
+      .filter(Boolean);
+    const values = {
+      title: [document.title],
+      url: [location.href],
+      text: [document.body ? document.body.innerText : ''],
+      control: controls(),
+      any: [document.title, location.href, document.body ? document.body.innerText : '', ...controls()],
+    }[mode];
+    if (!values) return { matched: false, query, mode, reason: 'invalid mode' };
+    const match = values.find(matches) || null;
+    return {
+      matched: !!match,
+      query,
+      mode,
+      exact,
+      match: match ? normalize(match).slice(0, 500) : null,
+      title: document.title,
+      url: location.href,
+    };
+  })()`;
+}
+async function computerBrowserWaitCommand(query, options = {}) {
+  const mode = options.mode ?? "any";
+  if (!["any", "text", "title", "url", "control"].includes(mode)) fail("--mode must be one of any|text|title|url|control");
+  const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 1e4;
+  const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 250;
+  if (timeoutMs < 0) fail("--timeout must be >= 0");
+  if (pollMs < 50 || pollMs > 2e3) fail("--poll-ms must be between 50 and 2000");
+  const page = await selectChromePage(options);
+  const start = Date.now();
+  const expression = buildBrowserWaitExpression(query, { mode, exact: !!options.exact });
+  let attempts = 0;
+  let lastResult = null;
+  while (Date.now() - start <= timeoutMs) {
+    attempts++;
+    lastResult = await evaluateChromeTarget(page.webSocketDebuggerUrl, expression);
+    if (typeof lastResult === "object" && lastResult !== null && "matched" in lastResult && lastResult.matched) {
+      console.log(JSON.stringify({ ok: true, elapsedMs: Date.now() - start, attempts, result: lastResult }, null, 2));
+      return;
+    }
+    await sleep(pollMs);
+  }
+  console.log(JSON.stringify({ ok: false, elapsedMs: Date.now() - start, attempts, result: lastResult }, null, 2));
+  process.exitCode = 1;
+}
+async function computerBrowserScrollCommand(direction, options = {}) {
+  const page = await selectChromePage(options);
+  const normalized = direction.toLowerCase();
+  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 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
+  });
+  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) }
+  }, null, 2));
+}
+function browserKeyDetails(combo) {
+  const tokens = combo.split("+").map((token) => token.trim()).filter(Boolean);
+  if (tokens.length === 0) fail("key combination cannot be empty");
+  let modifiers = 0;
+  for (const token of tokens.slice(0, -1)) {
+    const normalized2 = token.toLowerCase();
+    if (["alt", "option"].includes(normalized2)) modifiers |= 1;
+    else if (["ctrl", "control"].includes(normalized2)) modifiers |= 2;
+    else if (["meta", "cmd", "command", "super"].includes(normalized2)) modifiers |= 4;
+    else if (normalized2 === "shift") modifiers |= 8;
+    else fail(`Unsupported browser key modifier ${JSON.stringify(token)}`);
+  }
+  const requested = tokens[tokens.length - 1];
+  const aliases = {
+    enter: { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 },
+    return: { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 },
+    tab: { key: "Tab", code: "Tab", windowsVirtualKeyCode: 9 },
+    escape: { key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 },
+    esc: { key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 },
+    backspace: { key: "Backspace", code: "Backspace", windowsVirtualKeyCode: 8 },
+    delete: { key: "Delete", code: "Delete", windowsVirtualKeyCode: 46 },
+    space: { key: " ", code: "Space", windowsVirtualKeyCode: 32 },
+    up: { key: "ArrowUp", code: "ArrowUp", windowsVirtualKeyCode: 38 },
+    arrowup: { key: "ArrowUp", code: "ArrowUp", windowsVirtualKeyCode: 38 },
+    down: { key: "ArrowDown", code: "ArrowDown", windowsVirtualKeyCode: 40 },
+    arrowdown: { key: "ArrowDown", code: "ArrowDown", windowsVirtualKeyCode: 40 },
+    left: { key: "ArrowLeft", code: "ArrowLeft", windowsVirtualKeyCode: 37 },
+    arrowleft: { key: "ArrowLeft", code: "ArrowLeft", windowsVirtualKeyCode: 37 },
+    right: { key: "ArrowRight", code: "ArrowRight", windowsVirtualKeyCode: 39 },
+    arrowright: { key: "ArrowRight", code: "ArrowRight", windowsVirtualKeyCode: 39 },
+    home: { key: "Home", code: "Home", windowsVirtualKeyCode: 36 },
+    end: { key: "End", code: "End", windowsVirtualKeyCode: 35 },
+    pageup: { key: "PageUp", code: "PageUp", windowsVirtualKeyCode: 33 },
+    pagedown: { key: "PageDown", code: "PageDown", windowsVirtualKeyCode: 34 }
+  };
+  const normalized = requested.toLowerCase();
+  const alias = aliases[normalized];
+  if (alias) return { ...alias, modifiers, ...alias.key === " " && modifiers === 0 ? { text: " " } : {} };
+  if (/^[a-z]$/i.test(requested)) {
+    const upper = requested.toUpperCase();
+    const key = modifiers & 8 ? upper : requested.toLowerCase();
+    return { key, code: `Key${upper}`, windowsVirtualKeyCode: upper.charCodeAt(0), modifiers, ...modifiers === 0 ? { text: key } : {} };
+  }
+  if (/^[0-9]$/.test(requested)) {
+    return { key: requested, code: `Digit${requested}`, windowsVirtualKeyCode: requested.charCodeAt(0), modifiers, ...modifiers === 0 ? { text: requested } : {} };
+  }
+  fail(`Unsupported browser key ${JSON.stringify(requested)}`);
+}
+async function computerBrowserKeyCommand(combo, options = {}) {
+  const page = await selectChromePage(options);
+  const key = browserKeyDetails(combo);
+  await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+    await dispatchChromeKeyInSession(session, key);
+  });
+  logRecordingAction({ type: "key" });
+  console.log(JSON.stringify({ targetId: page.id ?? null, result: { pressed: combo } }, null, 2));
+}
+async function dispatchChromeKeyInSession(session, key) {
+  await sendChromeSessionCommand(session, "Input.dispatchKeyEvent", {
+    type: "keyDown",
+    ...key,
+    nativeVirtualKeyCode: key.windowsVirtualKeyCode
+  });
+  await sendChromeSessionCommand(session, "Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: key.key,
+    code: key.code,
+    modifiers: key.modifiers,
+    windowsVirtualKeyCode: key.windowsVirtualKeyCode,
+    nativeVirtualKeyCode: key.windowsVirtualKeyCode
+  });
+}
+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));
+}
+function parseBrowserBatchActions(value) {
+  let input;
+  try {
+    input = JSON.parse(value);
+  } catch (error) {
+    fail(`Batch actions must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!Array.isArray(input) || input.length === 0 || input.length > 100) {
+    fail("Batch actions must be a JSON array containing 1 to 100 actions");
+  }
+  return input.map((item, index) => {
+    if (!isRecord(item) || typeof item.action !== "string") fail(`Batch action ${index} must be an object with an action`);
+    if (item.action === "click") {
+      if (typeof item.ref !== "string" && typeof item.ref !== "number") fail(`Batch click ${index} requires ref`);
+      const buttons = { "1": "left", "2": "middle", "3": "right", left: "left", middle: "middle", right: "right" };
+      const requestedButton = item.button === void 0 ? "left" : String(item.button).toLowerCase();
+      const button = buttons[requestedButton];
+      if (!button) fail(`Batch click ${index} button must be left, middle, or right`);
+      return { action: "click", ref: String(item.ref), button, clicks: item.double === true ? 2 : 1 };
+    }
+    if (item.action === "fill") {
+      if (typeof item.ref !== "string" && typeof item.ref !== "number" || typeof item.value !== "string") {
+        fail(`Batch fill ${index} requires ref and string value`);
+      }
+      return { action: "fill", ref: String(item.ref), value: item.value };
+    }
+    if (item.action === "key") {
+      if (typeof item.combo !== "string") fail(`Batch key ${index} requires combo`);
+      return { action: "key", combo: item.combo };
+    }
+    if (item.action === "type") {
+      if (typeof item.text !== "string") fail(`Batch type ${index} requires text`);
+      return { action: "type", text: item.text };
+    }
+    if (item.action === "scroll") {
+      const directions = { up: "up", down: "down", left: "left", right: "right" };
+      const direction = typeof item.direction === "string" ? directions[item.direction] : void 0;
+      if (!direction) {
+        fail(`Batch scroll ${index} direction must be up, down, left, or right`);
+      }
+      const amount = item.amount === void 0 ? 600 : Number(item.amount);
+      if (!Number.isFinite(amount) || amount <= 0 || amount > 1e4) fail(`Batch scroll ${index} amount must be between 1 and 10000`);
+      if (item.ref !== void 0 && typeof item.ref !== "string" && typeof item.ref !== "number") fail(`Batch scroll ${index} ref is invalid`);
+      return {
+        action: "scroll",
+        direction,
+        amount,
+        ...item.ref === void 0 ? {} : { ref: String(item.ref) }
+      };
+    }
+    if (item.action === "wait") {
+      if (typeof item.text !== "string") fail(`Batch wait ${index} requires text`);
+      const mode = item.mode === void 0 ? "any" : String(item.mode);
+      if (!["any", "text", "title", "url", "control"].includes(mode)) fail(`Batch wait ${index} mode is invalid`);
+      const timeoutMs = item.timeoutMs === void 0 ? 1e4 : Number(item.timeoutMs);
+      const pollMs = item.pollMs === void 0 ? 250 : Number(item.pollMs);
+      if (!Number.isFinite(timeoutMs) || timeoutMs < 0) fail(`Batch wait ${index} timeoutMs must be >= 0`);
+      if (!Number.isFinite(pollMs) || pollMs < 50 || pollMs > 2e3) fail(`Batch wait ${index} pollMs must be between 50 and 2000`);
+      return { action: "wait", text: item.text, mode, exact: item.exact === true, timeoutMs, pollMs };
+    }
+    fail(`Batch action ${index} has unsupported action ${JSON.stringify(item.action)}`);
+  });
+}
+async function computerBrowserBatchCommand(actionsJson, options = {}) {
+  const actions = parseBrowserBatchActions(actionsJson);
+  const page = await selectChromePage(options);
+  const { targetId, cached } = readBrowserRefCache(page);
+  const startedAt = Date.now();
+  const completed = [];
+  try {
+    await withChromeSession(page.webSocketDebuggerUrl, async (session) => {
+      const layout = await sendChromeSessionCommand(session, "Page.getLayoutMetrics", {});
+      const viewportRect = browserViewportRect(layout);
+      for (const [index, action] of actions.entries()) {
+        const actionStartedAt = Date.now();
+        if (action.action === "click") {
+          const ref = parseBrowserRef(action.ref);
+          const 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 });
+        } else if (action.action === "fill") {
+          const ref = parseBrowserRef(action.ref);
+          await prepareBrowserRefInSession(session, ref, cached, viewportRect);
+          const result = await fillChromeNodeInSession(session, ref, action.value);
+          logRecordingAction({ type: "type" });
+          completed.push({ index, action: action.action, ref: String(ref), valueLength: result.valueLength, elapsedMs: Date.now() - actionStartedAt });
+        } else if (action.action === "key") {
+          await dispatchChromeKeyInSession(session, browserKeyDetails(action.combo));
+          logRecordingAction({ type: "key" });
+          completed.push({ index, action: action.action, elapsedMs: Date.now() - actionStartedAt });
+        } else if (action.action === "type") {
+          await sendChromeSessionCommand(session, "Input.insertText", { text: action.text });
+          logRecordingAction({ type: "type" });
+          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
+          });
+          logRecordingAction({ type: "scroll" });
+          completed.push({ index, action: action.action, direction: action.direction, amount: action.amount, elapsedMs: Date.now() - actionStartedAt });
+        } else {
+          const expression = buildBrowserWaitExpression(action.text, { mode: action.mode, exact: action.exact });
+          let attempts = 0;
+          let result = null;
+          while (Date.now() - actionStartedAt <= action.timeoutMs) {
+            attempts++;
+            result = await evaluateChromeSession(session, expression);
+            if (isRecord(result) && result.matched === true) break;
+            await sleep(action.pollMs);
+          }
+          if (!isRecord(result) || result.matched !== true) fail(`Batch wait ${index} timed out after ${Date.now() - actionStartedAt}ms`);
+          completed.push({ index, action: action.action, attempts, elapsedMs: Date.now() - actionStartedAt });
+        }
+      }
+    });
+  } 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));
+    throw error;
+  }
+  console.log(JSON.stringify({ ok: true, targetId, elapsedMs: Date.now() - startedAt, completed }, null, 2));
+}
+async function computerClickCommand(xStr, yStr, options) {
+  const dimensions = getDisplayDimensions();
+  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)];
+  if (options.modifiers) {
+    for (const mod of options.modifiers.split("+")) {
+      args.push("keydown", mod);
+    }
+  }
+  if (options.double) {
+    args.push("click", "--repeat", "2", "--delay", "50", button);
+  } else {
+    args.push("click", button);
+  }
+  if (options.modifiers) {
+    for (const mod of options.modifiers.split("+").reverse()) {
+      args.push("keyup", mod);
+    }
+  }
+  runDesktopInputCmd(args);
+  logRecordingAction({ type: "click", x, y });
+  console.log(`clicked ${button === "1" ? "left" : button === "2" ? "middle" : button === "3" ? "right" : `button ${button}`} at (${x},${y})${options.double ? " x2" : ""}`);
+}
+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)]);
+  logRecordingAction({ type: "move", x, y });
+  console.log(`moved to (${x},${y})`);
+}
+async function computerTypeCommand(text, options) {
+  const delay = options.delay ? parseCoord(options.delay, "--delay") : 12;
+  runDesktopInputCmd(["type", "--delay", String(delay), "--", text]);
+  const position = recordingMousePosition();
+  logRecordingAction({ type: "type", ...position ?? {} });
+  console.log(`typed ${text.length} char${text.length === 1 ? "" : "s"}`);
+}
+async function computerKeyCommand(combo) {
+  runDesktopInputCmd(["key", "--", combo]);
+  const position = recordingMousePosition();
+  logRecordingAction({ type: "key", ...position ?? {} });
+  console.log(`pressed ${combo}`);
+}
+async function computerScrollCommand(direction, options) {
+  const dir = direction.toLowerCase();
+  const buttonMap = { up: "4", down: "5", left: "6", right: "7" };
+  const button = buttonMap[dir];
+  if (!button) fail(`direction must be one of up|down|left|right (got "${direction}")`);
+  const amount = options.amount ? parseCoord(options.amount, "--amount") : 3;
+  const args = [];
+  let hoverPosition = null;
+  if (options.x && options.y) {
+    const dimensions = getDisplayDimensions();
+    hoverPosition = {
+      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("click", "--repeat", String(amount), "--delay", "30", button);
+  runDesktopInputCmd(args);
+  const position = hoverPosition ?? recordingMousePosition();
+  logRecordingAction({ type: "scroll", ...position ?? {} });
+  console.log(`scrolled ${dir} x${amount}`);
+}
+async function computerDragCommand(fx, fy, tx, ty) {
+  const dimensions = getDisplayDimensions();
+  const fromX = parseScreenCoord(fx, "fromX", dimensions.width);
+  const fromY = parseScreenCoord(fy, "fromY", dimensions.height);
+  const toX = parseScreenCoord(tx, "toX", dimensions.width);
+  const toY = parseScreenCoord(ty, "toY", dimensions.height);
+  const distance = Math.hypot(toX - fromX, toY - fromY);
+  const steps = clamp(Math.ceil(distance / 70), 8, 24);
+  const args = [
+    "mousemove",
+    "--sync",
+    String(fromX),
+    String(fromY),
+    "mousedown",
+    "1"
+  ];
+  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("mouseup", "1");
+  runDesktopInputCmd(args);
+  logRecordingAction({ type: "drag", x: fromX, y: fromY, toX, toY });
+  console.log(`dragged (${fromX},${fromY}) -> (${toX},${toY})`);
+}
+var APP_ALIASES = {
+  chrome: [CHROME_WRAPPER],
+  chromium: ["chromium", "--no-first-run", "--no-default-browser-check"],
+  firefox: ["firefox"],
+  terminal: ["xfce4-terminal"],
+  xterm: ["xterm"],
+  notepad: ["mousepad"],
+  editor: ["mousepad"],
+  files: ["thunar"],
+  filemanager: ["thunar"]
+};
+var LEGACY_CHROME_ALIAS = [
+  "google-chrome",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--start-maximized",
+  "--user-data-dir=/tmp/replicas-computer/chrome-profile"
+];
+async function computerLaunchCommand(app, args) {
+  ensureServicesRunning();
+  const baseArgs = app === "chrome" && !existsSync3(CHROME_WRAPPER) ? LEGACY_CHROME_ALIAS : APP_ALIASES[app] ?? [app];
+  const bin = baseArgs[0];
+  const fullArgs = [...baseArgs.slice(1), ...args];
+  const expectsNewChromePage = args.some((arg) => !arg.startsWith("-"));
+  const existingChromePageIds = /* @__PURE__ */ new Set();
+  if (app === "chrome") {
+    try {
+      for (const page of await getChromePages()) {
+        if (page.id) existingChromePageIds.add(page.id);
+      }
+    } catch {
+    }
+  }
+  const child = spawn2(bin, fullArgs, {
+    env: withDisplay(),
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  if (app === "chrome") {
+    const startedAt = Date.now();
+    let pageCount = 0;
+    let readyPage = null;
+    while (Date.now() - startedAt < 15e3) {
+      let pages = [];
+      try {
+        pages = await getChromePages();
+      } catch {
+      }
+      pageCount = pages.length;
+      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") {
+          readyPage = page;
+          break;
+        }
+      }
+      if (readyPage) break;
+      try {
+        if (child.pid) process.kill(child.pid, 0);
+      } catch {
+        fail(`Chrome exited before its desktop control channel became ready.`);
+      }
+      await sleep(100);
+    }
+    if (!readyPage?.webSocketDebuggerUrl) fail(`Chrome launched but its requested page was not controllable after 15 seconds.`);
+    await sendChromeCommand(readyPage.webSocketDebuggerUrl, "Page.bringToFront", {});
+    console.log(`launched ${bin} (pid ${child.pid}, ready in ${Date.now() - startedAt}ms, page ${readyPage.id}, ${pageCount} open)`);
+    return;
+  }
+  console.log(`launched ${bin} (pid ${child.pid})`);
+}
+
+// src/version.ts
+var COMPUTER_USE_VERSION = "0.1.0";
+var COMPUTER_USE_PROTOCOL_VERSION = 1;
+
+// src/program.ts
+function createProgram() {
+  const program = new Command().name("replicas-computer").description("Drive the Replicas workspace computer").version(COMPUTER_USE_VERSION).exitOverride();
+  program.command("setup").description("Validate dependencies and install the computer-use runtime").option("--check", "Validate without installing files").action(() => {
+    throw new Error("setup must run outside the computer-use daemon");
+  });
+  program.command("daemon").description("Run the computer-use daemon").action(() => {
+    throw new Error("daemon must run outside the computer-use daemon");
+  });
+  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("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-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) => {
+    const resolvedValue = value ?? (options.ref ? field : void 0);
+    const resolvedField = value === void 0 && options.ref ? void 0 : field;
+    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-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));
+  program.command("click <x> <y>").description("Move to a desktop coordinate and click").option("-b, --button <n>", "Mouse button. Default 1.").option("--double", "Double-click").option("--modifiers <mods>", "Modifier keys, such as ctrl+shift").action((x, y, options) => computerClickCommand(x, y, options));
+  program.command("move <x> <y>").description("Move the desktop pointer").action((x, y) => computerMoveCommand(x, y));
+  program.command("type <text>").description("Type literal desktop text").option("--delay <ms>", "Per-character delay").action((text, options) => computerTypeCommand(text, options));
+  program.command("key <combo>").description("Press a desktop key chord").action((combo) => computerKeyCommand(combo));
+  program.command("scroll <direction>").description("Scroll the desktop").option("--amount <n>", "Wheel ticks").option("--x <x>", "Pointer x").option("--y <y>", "Pointer y").action((direction, options) => computerScrollCommand(direction, options));
+  program.command("drag <fromX> <fromY> <toX> <toY>").description("Drag between desktop coordinates").action((fromX, fromY, toX, toY) => computerDragCommand(fromX, fromY, toX, toY));
+  program.command("launch <app> [args...]").description("Launch an application on the desktop").action((app, args) => computerLaunchCommand(app, args));
+  const record = program.command("record").description("Record the workspace display");
+  record.command("start <path>").description("Start a recording").option("--fps <n>", "Frame rate. Default 60.").action((path, options) => computerRecordStartCommand(path, options));
+  record.command("stop").description("Stop and finalize the active recording").action(() => computerRecordStopCommand());
+  return program;
+}
+async function runDirectCommand(argv, cwd = process.cwd()) {
+  const stdout = [];
+  const stderr = [];
+  const previousCwd = process.cwd();
+  const previousLog = console.log;
+  const previousError = console.error;
+  const program = createProgram().configureOutput({
+    writeOut: (value) => stdout.push(value),
+    writeErr: (value) => stderr.push(value)
+  });
+  console.log = (...values) => stdout.push(`${format(...values)}
+`);
+  console.error = (...values) => stderr.push(`${format(...values)}
+`);
+  try {
+    process.chdir(cwd);
+    await program.parseAsync(argv, { from: "user" });
+    return { exitCode: 0, stdout: stdout.join(""), stderr: stderr.join("") };
+  } catch (error) {
+    if (error instanceof CommanderError && ["commander.helpDisplayed", "commander.version"].includes(error.code)) {
+      return { exitCode: 0, stdout: stdout.join(""), stderr: stderr.join("") };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (!stderr.join("").includes(message)) stderr.push(`Error: ${message}
+`);
+    return { exitCode: error instanceof CommanderError ? error.exitCode : 1, stdout: stdout.join(""), stderr: stderr.join("") };
+  } finally {
+    process.chdir(previousCwd);
+    console.log = previousLog;
+    console.error = previousError;
+  }
+}
+
+// src/daemon.ts
+var COMPUTER_USE_SOCKET_PATH = process.env.REPLICAS_COMPUTER_SOCKET || `${STATE_DIR}/control.sock`;
+var MAX_REQUEST_BYTES = 1024 * 1024;
+function isDaemonRequest(value) {
+  return typeof value === "object" && value !== null && "protocolVersion" in value && value.protocolVersion === COMPUTER_USE_PROTOCOL_VERSION && "cwd" in value && typeof value.cwd === "string" && value.cwd.startsWith("/") && "argv" in value && Array.isArray(value.argv) && value.argv.length <= 100 && value.argv.every((arg) => typeof arg === "string" && arg.length <= 1e5);
+}
+function writeResult(socket, result) {
+  socket.end(`${JSON.stringify({ protocolVersion: COMPUTER_USE_PROTOCOL_VERSION, ...result })}
+`);
+}
+async function hasSocketListener() {
+  if (!existsSync4(COMPUTER_USE_SOCKET_PATH)) return false;
+  return await new Promise((resolve3) => {
+    const socket = createConnection(COMPUTER_USE_SOCKET_PATH);
+    socket.setTimeout(500, () => socket.destroy());
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve3(true);
+    });
+    socket.once("error", () => resolve3(false));
+    socket.once("close", () => resolve3(false));
+  });
+}
+async function runComputerDaemon() {
+  if (await hasSocketListener()) throw new Error(`Computer-use daemon is already listening on ${COMPUTER_USE_SOCKET_PATH}`);
+  ensureServicesRunning();
+  mkdirSync4(dirname4(COMPUTER_USE_SOCKET_PATH), { recursive: true, mode: 448 });
+  rmSync4(COMPUTER_USE_SOCKET_PATH, { force: true });
+  let queue = Promise.resolve();
+  const server = createServer({ allowHalfOpen: true }, (socket) => {
+    let input = "";
+    let rejected = false;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      if (rejected) return;
+      input += chunk;
+      if (Buffer.byteLength(input) > MAX_REQUEST_BYTES) {
+        rejected = true;
+        writeResult(socket, { exitCode: 2, stdout: "", stderr: "Computer-use request exceeds 1MB\n" });
+      }
+    });
+    socket.on("end", () => {
+      if (rejected) return;
+      queue = queue.then(async () => {
+        let request;
+        try {
+          request = JSON.parse(input);
+        } catch {
+          writeResult(socket, { exitCode: 2, stdout: "", stderr: "Invalid computer-use request JSON\n" });
+          return;
+        }
+        if (!isDaemonRequest(request)) {
+          writeResult(socket, { exitCode: 2, stdout: "", stderr: "Invalid or incompatible computer-use request\n" });
+          return;
+        }
+        writeResult(socket, await runDirectCommand(request.argv, request.cwd));
+      }).catch((error) => {
+        writeResult(socket, { exitCode: 1, stdout: "", stderr: `${error instanceof Error ? error.message : String(error)}
+` });
+      });
+    });
+  });
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(COMPUTER_USE_SOCKET_PATH, () => {
+      server.off("error", reject);
+      chmodSync(COMPUTER_USE_SOCKET_PATH, 384);
+      console.log(`replicas-computer ${COMPUTER_USE_VERSION} listening on ${COMPUTER_USE_SOCKET_PATH}`);
+      resolve3();
+    });
+  });
+  const healthTimer = setInterval(() => {
+    queue = queue.then(() => ensureServicesRunning()).catch((error) => {
+      console.error(error instanceof Error ? error.message : String(error));
+    });
+  }, 5e3);
+  healthTimer.unref();
+  await new Promise((resolve3) => {
+    let closing = false;
+    const close = () => {
+      if (closing) return;
+      closing = true;
+      clearInterval(healthTimer);
+      server.close(() => resolve3());
+    };
+    process.once("SIGTERM", close);
+    process.once("SIGINT", close);
+  });
+  spawnSync4("bash", [SERVICES_SCRIPT, "--stop"], { stdio: "inherit" });
+  rmSync4(COMPUTER_USE_SOCKET_PATH, { force: true });
+}
+
+// src/client.ts
+var DAEMON_STARTUP_TIMEOUT_MS = 5e3;
+var ComputerDaemonUnavailableError = class extends Error {
+};
+function sendComputerRequest(argv) {
+  return new Promise((resolve3, reject) => {
+    const socket = createConnection2(COMPUTER_USE_SOCKET_PATH);
+    let response = "";
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      if (error) reject(error);
+      else if (result) resolve3(result);
+    };
+    socket.setEncoding("utf8");
+    socket.setTimeout(10 * 60 * 1e3, () => socket.destroy(new Error("Computer-use command timed out")));
+    socket.once("connect", () => socket.end(JSON.stringify({
+      protocolVersion: COMPUTER_USE_PROTOCOL_VERSION,
+      argv,
+      cwd: process.cwd()
+    })));
+    socket.on("data", (chunk) => {
+      response += chunk;
+    });
+    socket.once("error", (error) => finish(new ComputerDaemonUnavailableError(`Computer-use daemon is unavailable at ${COMPUTER_USE_SOCKET_PATH}: ${error.message}`)));
+    socket.once("close", () => {
+      if (!response) {
+        finish(new ComputerDaemonUnavailableError("Computer-use daemon closed the connection without a response"));
+        return;
+      }
+      try {
+        const value = JSON.parse(response);
+        if (typeof value !== "object" || value === null || !("protocolVersion" in value) || value.protocolVersion !== COMPUTER_USE_PROTOCOL_VERSION || !("exitCode" in value) || typeof value.exitCode !== "number" || !("stdout" in value) || typeof value.stdout !== "string" || !("stderr" in value) || typeof value.stderr !== "string") {
+          finish(new Error("Computer-use daemon returned an incompatible response"));
+          return;
+        }
+        finish(void 0, { exitCode: value.exitCode, stdout: value.stdout, stderr: value.stderr });
+      } catch (error) {
+        finish(new Error(`Computer-use daemon returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    });
+  });
+}
+async function runComputerClient(argv) {
+  const deadline = Date.now() + DAEMON_STARTUP_TIMEOUT_MS;
+  while (true) {
+    try {
+      return await sendComputerRequest(argv);
+    } catch (error) {
+      if (!(error instanceof ComputerDaemonUnavailableError) || Date.now() >= deadline) throw error;
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
+    }
+  }
+}
+
+// src/setup.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { accessSync, appendFileSync as appendFileSync2, chmodSync as chmodSync2, constants, cpSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var dependencies = [
+  ["bash", "bash"],
+  ["Node.js", "node"],
+  ["Xvfb", "Xvfb"],
+  ["xdpyinfo", "xdpyinfo"],
+  ["xprop", "xprop"],
+  ["xdotool", "xdotool"],
+  ["scrot", "scrot"],
+  ["openbox", "openbox"],
+  ["tint2", "tint2"],
+  ["picom", "picom"],
+  ["ffmpeg", "ffmpeg"],
+  ["x11vnc", "x11vnc"],
+  ["websockify", "websockify"],
+  ["Google Chrome", "google-chrome-stable"],
+  ["flock", "flock"],
+  ["ss", "ss"],
+  ["pgrep", "pgrep"],
+  ["setsid", "setsid"],
+  ["sudo", "sudo"],
+  ["systemctl", "systemctl"],
+  ["hsetroot", "hsetroot"],
+  ["XFCE terminal", "xfce4-terminal"],
+  ["Mousepad", "mousepad"],
+  ["Thunar", "thunar"]
+];
+var serviceUnit = `[Unit]
+Description=Replicas computer-use runtime
+After=basic.target local-fs.target
+
+[Service]
+Type=exec
+User=user
+Group=user
+WorkingDirectory=/home/user/workspaces
+Environment=HOME=/home/user
+Environment=USER=user
+ExecStart=/bin/bash -lc 'export NVM_DIR=/usr/local/nvm; if [ -s /usr/local/nvm/nvm.sh ]; then . /usr/local/nvm/nvm.sh; fi; if [ -f /home/user/.replicas/runtime-env.sh ]; then . /home/user/.replicas/runtime-env.sh; fi; exec replicas-computer daemon'
+Restart=on-failure
+RestartSec=2
+TimeoutStopSec=15
+StandardOutput=journal
+StandardError=inherit
+
+[Install]
+WantedBy=multi-user.target
+`;
+function commandVersion(command) {
+  const result = spawnSync5(command, ["--version"], { encoding: "utf8" });
+  return `${result.stdout || result.stderr}`.trim().split("\n")[0]?.slice(0, 200) || "available";
+}
+function hasCommand(command) {
+  return (process.env.PATH ?? "").split(":").some((directory) => {
+    try {
+      accessSync(resolve2(directory, command), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function setupComputer(options = {}) {
+  const found = {};
+  const missing = [];
+  for (const [name, command] of dependencies) {
+    if (hasCommand(command)) {
+      found[command] = commandVersion(command);
+      console.log(`\u2713 ${name}`);
+    } else {
+      missing.push(`${name} (${command})`);
+      console.error(`\u2717 ${name} \u2014 ${command} is not on PATH`);
+    }
+  }
+  if (found.ffmpeg) {
+    const encoders = spawnSync5("ffmpeg", ["-hide_banner", "-encoders"], { encoding: "utf8" });
+    if (!`${encoders.stdout}${encoders.stderr}`.includes("libx264")) {
+      missing.push("ffmpeg encoder libx264");
+      console.error("\u2717 ffmpeg encoder libx264 is unavailable");
+    } else {
+      console.log("\u2713 ffmpeg encoder libx264");
+    }
+  }
+  const noVncRoot = ["/usr/share/novnc", "/usr/share/novnc-common"].find(existsSync5);
+  if (!noVncRoot) {
+    missing.push("noVNC web root");
+    console.error("\u2717 noVNC web root \u2014 /usr/share/novnc and /usr/share/novnc-common are missing");
+  } else {
+    console.log(`\u2713 noVNC web root (${noVncRoot})`);
+  }
+  if (spawnSync5("id", ["user"], { stdio: "ignore" }).status !== 0) {
+    missing.push("workspace user account");
+    console.error("\u2717 workspace user account \u2014 user does not exist");
+  } else {
+    console.log("\u2713 workspace user account");
+  }
+  if (missing.length > 0) throw new Error(`Missing ${missing.length} computer-use requirement${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}`);
+  if (!noVncRoot) throw new Error("noVNC web root is unavailable");
+  if (options.checkOnly) return;
+  if (process.getuid?.() !== 0) throw new Error("replicas-computer setup must run as root to install runtime files");
+  const packageRoot = resolve2(dirname5(fileURLToPath(import.meta.url)), "..");
+  const assets = resolve2(packageRoot, "assets", "desktop");
+  if (!existsSync5(assets)) throw new Error(`Computer-use assets are missing from ${assets}`);
+  mkdirSync5("/usr/local/share/replicas/desktop", { recursive: true });
+  cpSync(assets, "/usr/local/share/replicas/desktop", { recursive: true, force: true });
+  cpSync(resolve2(assets, "start-services.sh"), "/usr/local/bin/replicas-start-desktop-services", { force: true });
+  cpSync(resolve2(assets, "replicas-chrome"), "/usr/local/bin/replicas-chrome", { force: true });
+  cpSync(resolve2(assets, "replicas-chrome.desktop"), "/usr/share/applications/replicas-chrome.desktop", { force: true });
+  chmodSync2("/usr/local/bin/replicas-start-desktop-services", 493);
+  chmodSync2("/usr/local/bin/replicas-chrome", 493);
+  cpSync(resolve2(assets, "novnc-index.html"), resolve2(noVncRoot, "index.html"), { force: true });
+  cpSync(resolve2(assets, "geist-mono.woff2"), resolve2(noVncRoot, "geist-mono.woff2"), { force: true });
+  const noVncStyles = resolve2(noVncRoot, "app", "styles", "base.css");
+  const styleOverride = "\n#noVNC_status { display: none !important; }\n#noVNC_control_bar_anchor { display: none !important; }\n";
+  if (existsSync5(noVncStyles) && !readFileSync4(noVncStyles, "utf8").includes("#noVNC_status { display: none !important; }")) {
+    appendFileSync2(noVncStyles, styleOverride);
+  }
+  writeFileSync4("/etc/systemd/system/replicas-computer.service", serviceUnit, { mode: 420 });
+  if (existsSync5("/run/systemd/system")) {
+    const reload = spawnSync5("systemctl", ["daemon-reload"], { stdio: "pipe" });
+    if (reload.status !== 0) throw new Error(`Failed to reload systemd: ${reload.stderr?.toString().trim() || `exit ${reload.status}`}`);
+  }
+  mkdirSync5("/usr/local/share/replicas-computer", { recursive: true });
+  writeFileSync4("/usr/local/share/replicas-computer/install.json", `${JSON.stringify({
+    version: COMPUTER_USE_VERSION,
+    protocolVersion: COMPUTER_USE_PROTOCOL_VERSION,
+    dependencies: found
+  }, null, 2)}
+`);
+  console.log(`replicas-computer ${COMPUTER_USE_VERSION} setup complete`);
+}
+
+// src/index.ts
+async function main() {
+  const argv = process.argv.slice(2);
+  if (["setup", "daemon"].includes(argv[0]) && argv.slice(1).some((arg) => ["--help", "-h"].includes(arg))) {
+    const result2 = await runDirectCommand(argv);
+    if (result2.stdout) process.stdout.write(result2.stdout);
+    if (result2.stderr) process.stderr.write(result2.stderr);
+    process.exitCode = result2.exitCode;
+    return;
+  }
+  if (argv[0] === "setup") {
+    const unsupported = argv.slice(1).filter((arg) => arg !== "--check");
+    if (unsupported.length > 0) throw new Error(`Unknown setup option: ${unsupported[0]}`);
+    setupComputer({ checkOnly: argv.includes("--check") });
+    return;
+  }
+  if (argv[0] === "daemon") {
+    if (argv.length > 1) throw new Error(`Unknown daemon option: ${argv[1]}`);
+    await runComputerDaemon();
+    return;
+  }
+  const direct = argv[0] === "--direct";
+  const commandArgv = direct ? argv.slice(1) : argv;
+  const local = commandArgv.length === 0 || ["--help", "-h", "--version", "-V", "help"].includes(commandArgv[0]);
+  const result = direct || local ? await runDirectCommand(commandArgv) : await runComputerClient(commandArgv);
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exitCode = result.exitCode;
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});