browser-pilot 0.0.13 → 0.0.14

package/README.md

@@ -373,6 +373,8 @@ The CLI provides session persistence for interactive workflows:
 # Connect to a browser
 bp connect --provider browserbase --name my-session
 bp connect --provider generic  # auto-discovers local Chrome
+bp connect --no-daemon          # skip daemon (direct WebSocket only)
+bp connect --daemon-idle 30     # custom idle timeout (minutes)
 
 # Execute actions
 bp exec -s my-session '{"action":"goto","url":"https://example.com"}'
@@ -398,16 +400,23 @@ bp connect --new-tab --url https://example.com --name fresh
 
 # Handle native dialogs (alert/confirm/prompt)
 bp exec --dialog accept '{"action":"click","selector":"#delete-btn"}'
+bp exec --record '[{"action":"click","selector":"#checkout"},{"action":"assertText","expect":"Thanks"}]'
 
 # Other commands
 bp text -s my-session --selector ".main-content"
 bp screenshot -s my-session --output page.png
 bp listen ws -m "*voice*"  # monitor WebSocket traffic
 bp list                    # list all sessions
+bp clean --max-size 500MB  # trim old sessions by disk usage
 bp close -s my-session     # close session
 bp actions                 # show complete action reference
 bp run workflow.json       # run a workflow file
 
+# Daemon management
+bp daemon status           # check daemon health
+bp daemon stop             # stop daemon for default session
+bp daemon logs             # view daemon log
+
 # Actions with inline assertions (no extra bp eval needed)
 bp exec '[
   {"action":"goto","url":"https://example.com/login"},
@@ -534,10 +543,32 @@ The output format is compatible with `page.batch()`:
 ```
 
 **Notes:**
-- Password fields are automatically redacted as `[REDACTED]`
+- Sensitive fields are automatically redacted as `[REDACTED]` based on input settings such as `type="password"`, `type="hidden"`, and secret/autofill hints like `autocomplete="one-time-code"` or `cc-number`
 - Selectors are multi-selector arrays ordered by reliability (data attributes > IDs > CSS paths)
 - Edit the JSON to adjust selectors or add `optional: true` flags
 
+### Screenshot Trail During Replay
+
+Capture a lightweight visual trail while replaying steps. Enable recording at the session level so all `bp exec` calls are captured automatically:
+
+```bash
+# Enable recording for the entire session
+bp connect --provider generic --name my-session --record
+
+# All exec calls now produce screenshots — frames accumulate in one manifest
+bp exec -s my-session '[
+  {"action":"goto","url":"https://example.com/login"},
+  {"action":"fill","selector":"#email","value":"user@example.com"},
+  {"action":"submit","selector":"form"}
+]'
+bp exec -s my-session '{"action":"assertUrl","expect":"/dashboard"}'
+
+# Or enable recording on a single exec call
+bp exec --record '[{"action":"click","selector":"#checkout"}]'
+```
+
+This writes `recording.json` plus a `screenshots/` directory in the session directory. Sensitive field values are redacted in both the manifest and the screenshot overlays. See the [Action Recording Guide](./docs/guides/action-recording.md) for options like `--record-format`, `--record-quality`, and `--no-highlights`.
+
 ## Examples
 
 ### Login Flow with Error Handling
@@ -573,8 +604,32 @@ await page.fill('.dropdown-search', 'United');
 await page.click('.dropdown-option:has-text("United States")');
 ```
 
+### WebSocket Daemon
+
+By default, `bp connect` spawns a lightweight background daemon that holds the CDP WebSocket open. Subsequent CLI commands connect via Unix socket (~5-15ms) instead of re-establishing WebSocket (~280-1030ms per command).
+
+```bash
+# Daemon spawns automatically on connect
+bp connect --provider generic --name dev
+
+# Subsequent commands use the fast daemon path
+bp exec -s dev '{"action":"snapshot"}'  # ~5-15ms overhead instead of ~280ms
+
+# Manage the daemon
+bp daemon status           # check health, PID, uptime
+bp daemon stop             # stop daemon
+bp daemon logs             # view daemon log
+
+# Disable daemon for direct WebSocket
+bp connect --no-daemon
+```
+
+The daemon is transparent — if it dies or becomes stale, CLI commands fall back to direct WebSocket silently. Each session gets its own daemon with a 60-minute idle timeout.
+
 ### Cloudflare Workers
 
+> Note: Cloudflare Workers' Node-compat runtime can expose parts of `node:net` with compatibility flags, but browser-pilot's daemon fast-path is intentionally CLI/Node-specific (Unix domain sockets + local background process). In Workers, use the normal direct WebSocket path shown below.
+
 ```typescript
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
@@ -656,9 +711,9 @@ enableTracing({ output: 'console' });
 browser-pilot is designed for AI agents. Two resources for agent setup:
 
 - **[llms.txt](./docs/llms.txt)** - Abbreviated reference for LLM context windows
-- **[Claude Code Skill](./docs/skill/SKILL.md)** - Full skill for Claude Code agents
+- **[Claude Code Skill](./docs/automating-browsers/SKILL.md)** - Full skill for Claude Code agents
 
-To use with Claude Code, copy `docs/skill/` to your project or reference it in your agent's context.
+To use with Claude Code, copy `docs/automating-browsers/` to your project or reference it in your agent's context.
 
 ## Documentation
 
@@ -666,6 +721,7 @@ See the [docs](./docs) folder for detailed documentation:
 
 - [Getting Started](./docs/getting-started.md)
 - [Providers](./docs/providers.md)
+- [Action Recording](./docs/guides/action-recording.md)
 - [Multi-Selector Guide](./docs/guides/multi-selector.md)
 - [Batch Actions](./docs/guides/batch-actions.md)
 - [Snapshots](./docs/guides/snapshots.md)

package/dist/actions.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/actions/index.ts
@@ -26,6 +36,230 @@ __export(actions_exports, {
 });
 module.exports = __toCommonJS(actions_exports);
 
+// 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;
@@ -328,6 +562,13 @@ var CDPError = 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" };
@@ -407,6 +648,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();
@@ -419,8 +663,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,
@@ -428,8 +673,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) {
@@ -450,7 +702,7 @@ var BatchExecutor = class {
           } catch {
           }
         }
-        results.push({
+        const failedResult = {
           index: i,
           action: step.action,
           selector: step.selector,
@@ -460,24 +712,176 @@ 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

package/dist/actions.d.cts

@@ -1,6 +1,6 @@
-import { H as Page, S as Step, B as BatchOptions, b as BatchResult } from './types-BXMGFtnB.cjs';
-export { A as ActionType, ai as FailureReason, c as StepResult } from './types-BXMGFtnB.cjs';
-import './client-DRqxBdHv.cjs';
+import { J as Page, S as Step, B as BatchOptions, b as BatchResult } from './types-BSoh5v1Y.cjs';
+export { A as ActionType, aj as FailureReason, c as RecordOptions, d as StepResult } from './types-BSoh5v1Y.cjs';
+import './client-Ck2nQksT.cjs';
 
 /**
  * Batch action executor
@@ -13,6 +13,16 @@ declare class BatchExecutor {
      * Execute a batch of steps
      */
     execute(steps: Step[], options?: BatchOptions): Promise<BatchResult>;
+    private createRecordingContext;
+    private getPageUrlSafe;
+    /**
+     * Capture a recording screenshot frame with optional highlight overlay
+     */
+    private captureRecordingFrame;
+    /**
+     * Write recording manifest to disk
+     */
+    private writeRecordingManifest;
     /**
      * Execute a single step
      */

package/dist/actions.d.ts

@@ -1,6 +1,6 @@
-import { H as Page, S as Step, B as BatchOptions, b as BatchResult } from './types-CzgQjai9.js';
-export { A as ActionType, ai as FailureReason, c as StepResult } from './types-CzgQjai9.js';
-import './client-DRqxBdHv.js';
+import { J as Page, S as Step, B as BatchOptions, b as BatchResult } from './types-CjT0vClo.js';
+export { A as ActionType, aj as FailureReason, c as RecordOptions, d as StepResult } from './types-CjT0vClo.js';
+import './client-Ck2nQksT.js';
 
 /**
  * Batch action executor
@@ -13,6 +13,16 @@ declare class BatchExecutor {
      * Execute a batch of steps
      */
     execute(steps: Step[], options?: BatchOptions): Promise<BatchResult>;
+    private createRecordingContext;
+    private getPageUrlSafe;
+    /**
+     * Capture a recording screenshot frame with optional highlight overlay
+     */
+    private captureRecordingFrame;
+    /**
+     * Write recording manifest to disk
+     */
+    private writeRecordingManifest;
     /**
      * Execute a single step
      */

package/dist/actions.mjs

@@ -2,7 +2,7 @@ import {
   BatchExecutor,
   addBatchToPage,
   validateSteps
-} from "./chunk-A2ZRAEO3.mjs";
+} from "./chunk-XMJABKCF.mjs";
 import "./chunk-JXAUPHZM.mjs";
 export {
   BatchExecutor,