browser-pilot 0.0.13 → 0.0.14

package/dist/browser.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/browser/index.ts
@@ -29,6 +39,24 @@ __export(browser_exports, {
 });
 module.exports = __toCommonJS(browser_exports);
 
+// src/utils/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+
 // src/cdp/protocol.ts
 var CDPError = class extends Error {
   code;
@@ -144,8 +172,12 @@ function getReadyStateString(state) {
 
 // src/cdp/client.ts
 async function createCDPClient(wsUrl, options = {}) {
-  const { debug = false, timeout = 3e4 } = options;
+  const { timeout = 3e4 } = options;
   const transport = await createTransport(wsUrl, { timeout });
+  return buildCDPClient(transport, options);
+}
+function buildCDPClient(transport, options = {}) {
+  const { debug = false, timeout = 3e4 } = options;
   let messageId = 0;
   let currentSessionId;
   let connected = true;
@@ -155,7 +187,19 @@ async function createCDPClient(wsUrl, options = {}) {
   transport.onMessage((raw) => {
     let msg;
     try {
-      msg = JSON.parse(raw);
+      const parsed = JSON.parse(raw);
+      if (!isRecord(parsed)) {
+        if (debug) console.error("[CDP] Ignoring non-object message:", raw);
+        return;
+      }
+      if ("id" in parsed && typeof parsed["id"] === "number") {
+        msg = parsed;
+      } else if ("method" in parsed && typeof parsed["method"] === "string") {
+        msg = parsed;
+      } else {
+        if (debug) console.error("[CDP] Ignoring invalid message shape:", raw);
+        return;
+      }
     } catch {
       if (debug) console.error("[CDP] Failed to parse message:", raw);
       return;
@@ -268,6 +312,9 @@ async function createCDPClient(wsUrl, options = {}) {
     onAny(handler) {
       anyEventHandlers.add(handler);
     },
+    offAny(handler) {
+      anyEventHandlers.delete(handler);
+    },
     async close() {
       connected = false;
       await transport.close();
@@ -472,6 +519,230 @@ function createProvider(options) {
   }
 }
 
+// src/actions/executor.ts
+var fs = __toESM(require("fs"), 1);
+var import_node_path = require("path");
+
+// src/recording/redaction.ts
+var REDACTED_VALUE = "[REDACTED]";
+var SENSITIVE_AUTOCOMPLETE_TOKENS = [
+  "current-password",
+  "new-password",
+  "one-time-code",
+  "cc-number",
+  "cc-csc",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year"
+];
+function autocompleteTokens(autocomplete) {
+  if (!autocomplete) return [];
+  return autocomplete.toLowerCase().split(/\s+/).map((token) => token.trim()).filter(Boolean);
+}
+function isSensitiveFieldMetadata(metadata) {
+  if (!metadata) return false;
+  if (metadata.sensitiveValue) return true;
+  const inputType = metadata.inputType?.toLowerCase();
+  if (inputType === "password" || inputType === "hidden") {
+    return true;
+  }
+  const sensitiveAutocompleteTokens = new Set(SENSITIVE_AUTOCOMPLETE_TOKENS);
+  return autocompleteTokens(metadata.autocomplete).some(
+    (token) => sensitiveAutocompleteTokens.has(token)
+  );
+}
+function redactValueForRecording(value, metadata) {
+  if (value === void 0) return void 0;
+  return isSensitiveFieldMetadata(metadata) ? REDACTED_VALUE : value;
+}
+
+// src/browser/action-highlight.ts
+var HIGHLIGHT_STYLES = {
+  click: { outline: "3px solid rgba(229,57,53,0.8)", badge: "#e53935", marker: "crosshair" },
+  fill: { outline: "3px solid rgba(33,150,243,0.8)", badge: "#2196f3" },
+  type: { outline: "3px solid rgba(33,150,243,0.6)", badge: "#2196f3" },
+  select: { outline: "3px solid rgba(156,39,176,0.8)", badge: "#9c27b0" },
+  hover: { outline: "2px dashed rgba(158,158,158,0.5)", badge: "#9e9e9e" },
+  scroll: { outline: "none", badge: "#607d8b", marker: "arrow" },
+  navigate: { outline: "none", badge: "#4caf50" },
+  submit: { outline: "3px solid rgba(255,152,0,0.8)", badge: "#ff9800" },
+  "assert-pass": { outline: "3px solid rgba(76,175,80,0.8)", badge: "#4caf50", marker: "check" },
+  "assert-fail": { outline: "3px solid rgba(244,67,54,0.8)", badge: "#f44336", marker: "cross" },
+  evaluate: { outline: "none", badge: "#ffc107" },
+  focus: { outline: "3px dotted rgba(33,150,243,0.6)", badge: "#2196f3" }
+};
+function buildHighlightScript(options) {
+  const style = HIGHLIGHT_STYLES[options.kind];
+  const label = options.label ? options.label.slice(0, 80) : void 0;
+  const escapedLabel = label ? label.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n") : "";
+  return `(function() {
+    // Remove any existing highlight
+    var existing = document.getElementById('__bp-action-highlight');
+    if (existing) existing.remove();
+
+    var container = document.createElement('div');
+    container.id = '__bp-action-highlight';
+    container.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:99999;';
+
+    ${options.bbox ? `
+    // Element outline
+    var outline = document.createElement('div');
+    outline.style.cssText = 'position:fixed;' +
+      'left:${options.bbox.x}px;top:${options.bbox.y}px;' +
+      'width:${options.bbox.width}px;height:${options.bbox.height}px;' +
+      '${style.outline !== "none" ? `outline:${style.outline};outline-offset:-1px;` : ""}' +
+      'pointer-events:none;box-sizing:border-box;';
+    container.appendChild(outline);
+    ` : ""}
+
+    ${options.point && style.marker === "crosshair" ? `
+    // Crosshair at click point
+    var hLine = document.createElement('div');
+    hLine.style.cssText = 'position:fixed;left:${options.point.x - 12}px;top:${options.point.y}px;' +
+      'width:24px;height:2px;background:${style.badge};pointer-events:none;';
+    var vLine = document.createElement('div');
+    vLine.style.cssText = 'position:fixed;left:${options.point.x}px;top:${options.point.y - 12}px;' +
+      'width:2px;height:24px;background:${style.badge};pointer-events:none;';
+    // Dot at center
+    var dot = document.createElement('div');
+    dot.style.cssText = 'position:fixed;left:${options.point.x - 4}px;top:${options.point.y - 4}px;' +
+      'width:8px;height:8px;border-radius:50%;background:${style.badge};pointer-events:none;';
+    container.appendChild(hLine);
+    container.appendChild(vLine);
+    container.appendChild(dot);
+    ` : ""}
+
+    ${label ? `
+    // Badge with label
+    var badge = document.createElement('div');
+    badge.style.cssText = 'position:fixed;' +
+      ${options.bbox ? `'left:${options.bbox.x}px;top:${Math.max(0, options.bbox.y - 28)}px;'` : options.kind === "navigate" ? "'left:50%;top:8px;transform:translateX(-50%);'" : "'right:8px;top:8px;'"} +
+      'background:${style.badge};color:white;padding:4px 8px;' +
+      'font-family:monospace;font-size:12px;font-weight:bold;' +
+      'border-radius:3px;white-space:nowrap;max-width:400px;overflow:hidden;text-overflow:ellipsis;' +
+      'pointer-events:none;';
+    badge.textContent = '${escapedLabel}';
+    container.appendChild(badge);
+    ` : ""}
+
+    ${style.marker === "check" && options.bbox ? `
+    // Checkmark
+    var check = document.createElement('div');
+    check.style.cssText = 'position:fixed;left:${options.bbox.x + options.bbox.width / 2 - 10}px;' +
+      'top:${options.bbox.y + options.bbox.height / 2 - 10}px;' +
+      'width:20px;height:20px;font-size:18px;color:${style.badge};pointer-events:none;text-align:center;line-height:20px;';
+    check.textContent = '\\u2713';
+    container.appendChild(check);
+    ` : ""}
+
+    ${style.marker === "cross" && options.bbox ? `
+    // Cross mark
+    var cross = document.createElement('div');
+    cross.style.cssText = 'position:fixed;left:${options.bbox.x + options.bbox.width / 2 - 10}px;' +
+      'top:${options.bbox.y + options.bbox.height / 2 - 10}px;' +
+      'width:20px;height:20px;font-size:18px;color:${style.badge};pointer-events:none;text-align:center;line-height:20px;font-weight:bold;';
+    cross.textContent = '\\u2717';
+    container.appendChild(cross);
+    ` : ""}
+
+    document.body.appendChild(container);
+    window.__bpRemoveActionHighlight = function() {
+      var el = document.getElementById('__bp-action-highlight');
+      if (el) el.remove();
+      delete window.__bpRemoveActionHighlight;
+    };
+  })();`;
+}
+async function injectActionHighlight(page, options) {
+  try {
+    await page.evaluate(buildHighlightScript(options));
+  } catch {
+  }
+}
+async function removeActionHighlight(page) {
+  try {
+    await page.evaluate(`(function() {
+      if (window.__bpRemoveActionHighlight) {
+        window.__bpRemoveActionHighlight();
+      }
+    })()`);
+  } catch {
+  }
+}
+function stepToHighlightKind(step) {
+  switch (step.action) {
+    case "click":
+      return "click";
+    case "fill":
+      return "fill";
+    case "type":
+      return "type";
+    case "select":
+      return "select";
+    case "hover":
+      return "hover";
+    case "scroll":
+      return "scroll";
+    case "goto":
+      return "navigate";
+    case "submit":
+      return "submit";
+    case "focus":
+      return "focus";
+    case "evaluate":
+    case "press":
+    case "shortcut":
+      return "evaluate";
+    case "assertVisible":
+    case "assertExists":
+    case "assertText":
+    case "assertUrl":
+    case "assertValue":
+      return step.success ? "assert-pass" : "assert-fail";
+    // Observation-only actions — no highlight
+    case "wait":
+    case "snapshot":
+    case "forms":
+    case "text":
+    case "screenshot":
+    case "newTab":
+    case "closeTab":
+    case "switchFrame":
+    case "switchToMain":
+      return null;
+    default:
+      return null;
+  }
+}
+function getHighlightLabel(step, result, targetMetadata) {
+  switch (step.action) {
+    case "fill":
+    case "type":
+      return typeof step.value === "string" ? `"${redactValueForRecording(step.value, targetMetadata)}"` : void 0;
+    case "select":
+      return redactValueForRecording(
+        typeof step.value === "string" ? step.value : void 0,
+        targetMetadata
+      );
+    case "goto":
+      return step.url;
+    case "evaluate":
+      return "JS";
+    case "press":
+      return step.key;
+    case "shortcut":
+      return step.combo;
+    case "assertText":
+    case "assertUrl":
+    case "assertValue":
+    case "assertVisible":
+    case "assertExists":
+      return result.success ? "\u2713" : "\u2717";
+    default:
+      return void 0;
+  }
+}
+
 // src/browser/actionability.ts
 var ActionabilityError = class extends Error {
   failureType;
@@ -1086,6 +1357,13 @@ var NavigationError = class extends Error {
 
 // src/actions/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RECORDING_SKIP_ACTIONS = [
+  "wait",
+  "snapshot",
+  "forms",
+  "text",
+  "screenshot"
+];
 function classifyFailure(error) {
   if (error instanceof ElementNotFoundError) {
     return { reason: "missing" };
@@ -1165,6 +1443,9 @@ var BatchExecutor = class {
     const { timeout = DEFAULT_TIMEOUT, onFail = "stop" } = options;
     const results = [];
     const startTime = Date.now();
+    const recording = options.record ? this.createRecordingContext(options.record) : null;
+    const startUrl = recording ? await this.getPageUrlSafe() : "";
+    let stoppedAtIndex;
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
       const stepStart = Date.now();
@@ -1177,8 +1458,9 @@ var BatchExecutor = class {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
         try {
+          this.page.resetLastActionPosition();
           const result = await this.executeStep(step, timeout);
-          results.push({
+          const stepResult = {
             index: i,
             action: step.action,
             selector: step.selector,
@@ -1186,8 +1468,15 @@ var BatchExecutor = class {
             success: true,
             durationMs: Date.now() - stepStart,
             result: result.value,
-            text: result.text
-          });
+            text: result.text,
+            timestamp: Date.now(),
+            coordinates: this.page.getLastActionCoordinates() ?? void 0,
+            boundingBox: this.page.getLastActionBoundingBox() ?? void 0
+          };
+          if (recording && !recording.skipActions.has(step.action)) {
+            await this.captureRecordingFrame(step, stepResult, recording);
+          }
+          results.push(stepResult);
           succeeded = true;
           break;
         } catch (error) {
@@ -1208,7 +1497,7 @@ var BatchExecutor = class {
           } catch {
           }
         }
-        results.push({
+        const failedResult = {
           index: i,
           action: step.action,
           selector: step.selector,
@@ -1218,25 +1507,177 @@ var BatchExecutor = class {
           hints,
           failureReason: reason,
           coveringElement,
-          suggestion: getSuggestion(reason)
-        });
+          suggestion: getSuggestion(reason),
+          timestamp: Date.now()
+        };
+        if (recording && !recording.skipActions.has(step.action)) {
+          await this.captureRecordingFrame(step, failedResult, recording);
+        }
+        results.push(failedResult);
         if (onFail === "stop" && !step.optional) {
-          return {
-            success: false,
-            stoppedAtIndex: i,
-            steps: results,
-            totalDurationMs: Date.now() - startTime
-          };
+          stoppedAtIndex = i;
+          break;
         }
       }
     }
-    const allSuccess = results.every((r) => r.success || steps[r.index]?.optional);
+    const totalDurationMs = Date.now() - startTime;
+    const allSuccess = stoppedAtIndex === void 0 && results.every((result) => result.success || steps[result.index]?.optional);
+    let recordingManifest;
+    if (recording) {
+      recordingManifest = await this.writeRecordingManifest(
+        recording,
+        startTime,
+        startUrl,
+        allSuccess
+      );
+    }
     return {
       success: allSuccess,
+      stoppedAtIndex,
       steps: results,
-      totalDurationMs: Date.now() - startTime
+      totalDurationMs,
+      recordingManifest
     };
   }
+  createRecordingContext(record) {
+    const baseDir = record.outputDir ?? (0, import_node_path.join)(process.cwd(), ".browser-pilot");
+    const screenshotDir = (0, import_node_path.join)(baseDir, "screenshots");
+    const manifestPath = (0, import_node_path.join)(baseDir, "recording.json");
+    let existingFrames = [];
+    try {
+      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      if (existing.frames && Array.isArray(existing.frames)) {
+        existingFrames = existing.frames;
+      }
+    } catch {
+    }
+    fs.mkdirSync(screenshotDir, { recursive: true });
+    return {
+      baseDir,
+      screenshotDir,
+      sessionId: record.sessionId ?? this.page.targetId,
+      frames: existingFrames,
+      format: record.format ?? "webp",
+      quality: Math.max(0, Math.min(100, record.quality ?? 40)),
+      highlights: record.highlights !== false,
+      skipActions: new Set(record.skipActions ?? DEFAULT_RECORDING_SKIP_ACTIONS)
+    };
+  }
+  async getPageUrlSafe() {
+    try {
+      return await this.page.url();
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Capture a recording screenshot frame with optional highlight overlay
+   */
+  async captureRecordingFrame(step, stepResult, recording) {
+    const targetMetadata = this.page.getLastActionTargetMetadata();
+    let highlightInjected = false;
+    try {
+      const ts = Date.now();
+      const seq = String(recording.frames.length + 1).padStart(4, "0");
+      const filename = `${seq}-${ts}-${stepResult.action}.${recording.format}`;
+      const filepath = (0, import_node_path.join)(recording.screenshotDir, filename);
+      if (recording.highlights) {
+        const kind = stepToHighlightKind(stepResult);
+        if (kind) {
+          await injectActionHighlight(this.page, {
+            kind,
+            bbox: stepResult.boundingBox,
+            point: stepResult.coordinates,
+            label: getHighlightLabel(step, stepResult, targetMetadata)
+          });
+          highlightInjected = true;
+        }
+      }
+      const base64 = await this.page.screenshot({
+        format: recording.format,
+        quality: recording.quality
+      });
+      const buffer = Buffer.from(base64, "base64");
+      fs.writeFileSync(filepath, buffer);
+      stepResult.screenshotPath = filepath;
+      let pageUrl;
+      let pageTitle;
+      try {
+        pageUrl = await this.page.url();
+        pageTitle = await this.page.title();
+      } catch {
+      }
+      recording.frames.push({
+        seq: recording.frames.length + 1,
+        timestamp: ts,
+        action: stepResult.action,
+        selector: stepResult.selectorUsed ?? (Array.isArray(step.selector) ? step.selector[0] : step.selector),
+        value: redactValueForRecording(
+          typeof step.value === "string" ? step.value : void 0,
+          targetMetadata
+        ),
+        url: step.url,
+        coordinates: stepResult.coordinates,
+        boundingBox: stepResult.boundingBox,
+        success: stepResult.success,
+        durationMs: stepResult.durationMs,
+        error: stepResult.error,
+        screenshot: filename,
+        pageUrl,
+        pageTitle
+      });
+    } catch {
+    } finally {
+      if (recording.highlights || highlightInjected) {
+        await removeActionHighlight(this.page);
+      }
+    }
+  }
+  /**
+   * Write recording manifest to disk
+   */
+  async writeRecordingManifest(recording, startTime, startUrl, success) {
+    let endUrl = startUrl;
+    let viewport = { width: 1280, height: 720 };
+    try {
+      endUrl = await this.page.url();
+    } catch {
+    }
+    try {
+      const metrics = await this.page.cdpClient.send("Page.getLayoutMetrics");
+      viewport = {
+        width: metrics.cssVisualViewport.clientWidth,
+        height: metrics.cssVisualViewport.clientHeight
+      };
+    } catch {
+    }
+    const manifestPath = (0, import_node_path.join)(recording.baseDir, "recording.json");
+    let recordedAt = new Date(startTime).toISOString();
+    let originalStartUrl = startUrl;
+    try {
+      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      if (existing.recordedAt) recordedAt = existing.recordedAt;
+      if (existing.startUrl) originalStartUrl = existing.startUrl;
+    } catch {
+    }
+    const firstFrameTime = recording.frames[0]?.timestamp ?? startTime;
+    const totalDurationMs = Date.now() - Math.min(firstFrameTime, startTime);
+    const manifest = {
+      version: 1,
+      recordedAt,
+      sessionId: recording.sessionId,
+      startUrl: originalStartUrl,
+      endUrl,
+      viewport,
+      format: recording.format,
+      quality: recording.quality,
+      totalDurationMs,
+      success,
+      frames: recording.frames
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    return manifestPath;
+  }
   /**
    * Execute a single step
    */
@@ -3766,6 +4207,9 @@ var Page = class {
   brokenFrame = null;
   /** Last matched selector from findElement (for selectorUsed tracking) */
   _lastMatchedSelector;
+  _lastActionCoordinates = null;
+  _lastActionBoundingBox = null;
+  _lastActionTargetMetadata = null;
   /** Last snapshot for stale ref recovery */
   lastSnapshot;
   /** Audio input controller (lazy-initialized) */
@@ -3797,6 +4241,76 @@ var Page = class {
   getLastMatchedSelector() {
     return this._lastMatchedSelector;
   }
+  async getActionTargetMetadata(identifiers) {
+    try {
+      const objectId = identifiers.objectId ?? (identifiers.nodeId ? await this.resolveObjectId(identifiers.nodeId) : void 0);
+      if (!objectId) return null;
+      const response = await this.cdp.send("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: `function() {
+          const tagName = this.tagName?.toLowerCase?.() || '';
+          const inputType =
+            tagName === 'input' && typeof this.type === 'string' ? this.type.toLowerCase() : '';
+          const autocomplete =
+            typeof this.autocomplete === 'string' ? this.autocomplete.toLowerCase() : '';
+          return { tagName, inputType, autocomplete };
+        }`,
+        returnByValue: true
+      });
+      return response.result.value ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getElementPosition(identifiers) {
+    try {
+      const { quads } = await this.cdp.send(
+        "DOM.getContentQuads",
+        identifiers
+      );
+      if (quads?.length > 0) {
+        const q = quads[0];
+        const minX = Math.min(q[0], q[2], q[4], q[6]);
+        const maxX = Math.max(q[0], q[2], q[4], q[6]);
+        const minY = Math.min(q[1], q[3], q[5], q[7]);
+        const maxY = Math.max(q[1], q[3], q[5], q[7]);
+        return {
+          center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+          bbox: { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+        };
+      }
+    } catch {
+    }
+    if (identifiers.nodeId) {
+      const box = await this.getBoxModel(identifiers.nodeId);
+      if (box) {
+        return {
+          center: { x: box.content[0] + box.width / 2, y: box.content[1] + box.height / 2 },
+          bbox: { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        };
+      }
+    }
+    return null;
+  }
+  setLastActionPosition(coords, bbox) {
+    this._lastActionCoordinates = coords;
+    this._lastActionBoundingBox = bbox;
+  }
+  getLastActionCoordinates() {
+    return this._lastActionCoordinates;
+  }
+  getLastActionBoundingBox() {
+    return this._lastActionBoundingBox;
+  }
+  getLastActionTargetMetadata() {
+    return this._lastActionTargetMetadata;
+  }
+  /** Reset position tracking (call before each executor step) */
+  resetLastActionPosition() {
+    this._lastActionCoordinates = null;
+    this._lastActionBoundingBox = null;
+    this._lastActionTargetMetadata = null;
+  }
   /**
    * Initialize the page (enable required CDP domains)
    */
@@ -3964,6 +4478,14 @@ var Page = class {
           const quad = quads[0];
           clickX = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
           clickY = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+          const minX = Math.min(quad[0], quad[2], quad[4], quad[6]);
+          const maxX = Math.max(quad[0], quad[2], quad[4], quad[6]);
+          const minY = Math.min(quad[1], quad[3], quad[5], quad[7]);
+          const maxY = Math.max(quad[1], quad[3], quad[5], quad[7]);
+          this.setLastActionPosition(
+            { x: clickX, y: clickY },
+            { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+          );
         } else {
           throw new Error("No quads");
         }
@@ -3972,6 +4494,10 @@ var Page = class {
         if (!box) throw new Error("Could not get element position");
         clickX = box.content[0] + box.width / 2;
         clickY = box.content[1] + box.height / 2;
+        this.setLastActionPosition(
+          { x: clickX, y: clickY },
+          { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        );
       }
       const hitTargetCoordinates = this.currentFrame ? void 0 : { x: clickX, y: clickY };
       const HIT_TARGET_RETRIES = 3;
@@ -4022,13 +4548,20 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const fillPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (fillPos) this.setLastActionPosition(fillPos.center, fillPos.bbox);
       const tagInfo = await this.cdp.send("Runtime.callFunctionOn", {
         objectId,
         functionDeclaration: `function() {
-            return { tagName: this.tagName?.toLowerCase() || '', inputType: (this.type || '').toLowerCase() };
+            return {
+              tagName: this.tagName?.toLowerCase() || '',
+              inputType: (this.type || '').toLowerCase(),
+              autocomplete: typeof this.autocomplete === 'string' ? this.autocomplete.toLowerCase() : '',
+            };
           }`,
         returnByValue: true
       });
+      this._lastActionTargetMetadata = tagInfo.result.value;
       const { tagName, inputType } = tagInfo.result.value;
       const specialInputTypes = /* @__PURE__ */ new Set([
         "date",
@@ -4110,6 +4643,9 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const typePos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (typePos) this.setLastActionPosition(typePos.center, typePos.bbox);
+      this._lastActionTargetMetadata = await this.getActionTargetMetadata({ objectId });
       await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
       for (const char of text) {
         const def = US_KEYBOARD[char];
@@ -4189,6 +4725,9 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const selectPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (selectPos) this.setLastActionPosition(selectPos.center, selectPos.bbox);
+      this._lastActionTargetMetadata = await this.getActionTargetMetadata({ objectId });
       const metadata = await this.getNativeSelectMetadata(objectId, values);
       if (!metadata.isSelect) {
         throw new Error("select() target must be a native <select> element");
@@ -4325,6 +4864,8 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const checkPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (checkPos) this.setLastActionPosition(checkPos.center, checkPos.bbox);
       const before = await this.cdp.send("Runtime.callFunctionOn", {
         objectId: object.objectId,
         functionDeclaration: "function() { return !!this.checked; }",
@@ -4373,6 +4914,8 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const uncheckPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (uncheckPos) this.setLastActionPosition(uncheckPos.center, uncheckPos.bbox);
       const isRadio = await this.cdp.send(
         "Runtime.callFunctionOn",
         {
@@ -4428,6 +4971,8 @@ var Page = class {
         throw new ElementNotFoundError(selector, hints);
       }
       const objectId = await this.resolveObjectId(element.nodeId);
+      const submitPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (submitPos) this.setLastActionPosition(submitPos.center, submitPos.bbox);
       const isFormElement = await this.cdp.send(
         "Runtime.callFunctionOn",
         {
@@ -4524,6 +5069,8 @@ var Page = class {
       const hints = await generateHints(this, selectorList, "focus");
       throw new ElementNotFoundError(selector, hints);
     }
+    const focusPos = await this.getElementPosition({ nodeId: element.nodeId });
+    if (focusPos) this.setLastActionPosition(focusPos.center, focusPos.bbox);
     await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
     return true;
   }
@@ -4559,6 +5106,14 @@ var Page = class {
           const quad = quads[0];
           x = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
           y = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+          const minX = Math.min(quad[0], quad[2], quad[4], quad[6]);
+          const maxX = Math.max(quad[0], quad[2], quad[4], quad[6]);
+          const minY = Math.min(quad[1], quad[3], quad[5], quad[7]);
+          const maxY = Math.max(quad[1], quad[3], quad[5], quad[7]);
+          this.setLastActionPosition(
+            { x, y },
+            { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+          );
         } else {
           throw new Error("No quads");
         }
@@ -4570,6 +5125,10 @@ var Page = class {
         }
         x = box.content[0] + box.width / 2;
         y = box.content[1] + box.height / 2;
+        this.setLastActionPosition(
+          { x, y },
+          { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        );
       }
       await this.cdp.send("Input.dispatchMouseEvent", {
         type: "mouseMoved",
@@ -4595,6 +5154,8 @@ var Page = class {
       if (options.optional) return false;
       throw new ElementNotFoundError(selector);
     }
+    const scrollPos = await this.getElementPosition({ nodeId: element.nodeId });
+    if (scrollPos) this.setLastActionPosition(scrollPos.center, scrollPos.bbox);
     await this.scrollIntoView(element.nodeId);
     return true;
   }
@@ -5356,7 +5917,7 @@ var Page = class {
       return {
         role,
         name,
-        value: value !== void 0 ? String(value) : void 0,
+        value: value !== void 0 ? stringifyUnknown(value) : void 0,
         ref,
         children: children.length > 0 ? children : void 0,
         disabled,
@@ -5418,7 +5979,7 @@ var Page = class {
           selector,
           disabled,
           checked,
-          value: value !== void 0 ? String(value) : void 0
+          value: value !== void 0 ? stringifyUnknown(value) : void 0
         });
       }
     }
@@ -5888,7 +6449,7 @@ var Page = class {
    */
   formatConsoleArgs(args) {
     return args.map((arg) => {
-      if (arg.value !== void 0) return String(arg.value);
+      if (arg.value !== void 0) return stringifyUnknown(arg.value);
       if (arg.description) return arg.description;
       return "[object]";
     }).join(" ");
@@ -6677,6 +7238,25 @@ var Browser = class _Browser {
     this.cdp = cdp;
     this.providerSession = providerSession;
   }
+  /**
+   * Create a Browser from an existing CDPClient (used by daemon fast-path).
+   * The caller is responsible for the CDP connection lifecycle.
+   */
+  static fromCDP(cdp, sessionInfo) {
+    const providerSession = {
+      wsUrl: sessionInfo.wsUrl,
+      sessionId: sessionInfo.sessionId,
+      async close() {
+      }
+    };
+    const provider = {
+      name: sessionInfo.provider ?? "daemon",
+      async createSession() {
+        return providerSession;
+      }
+    };
+    return new _Browser(cdp, provider, providerSession, { provider: "generic" });
+  }
   /**
    * Connect to a browser instance
    */