browser-pilot 0.0.16 → 0.0.18

package/dist/actions.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,15 +30,550 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/browser/combobox.ts
+var combobox_exports = {};
+__export(combobox_exports, {
+  chooseOption: () => chooseOption
+});
+async function chooseOption(page, config) {
+  const {
+    trigger,
+    listbox,
+    optionSelector,
+    searchText,
+    value,
+    match = "contains",
+    timeout = 1e4
+  } = config;
+  try {
+    await page.click(trigger, { timeout });
+    const listboxSelectors = listbox ? Array.isArray(listbox) ? listbox : [listbox] : DEFAULT_LISTBOX_SELECTORS;
+    const listboxFound = await page.waitFor(listboxSelectors, {
+      timeout: Math.min(timeout, 3e3),
+      optional: true,
+      state: "visible"
+    });
+    if (!listboxFound) {
+      return {
+        success: false,
+        failedAt: "open",
+        error: "Listbox did not appear after clicking trigger"
+      };
+    }
+    if (searchText) {
+      try {
+        const triggerSel = Array.isArray(trigger) ? trigger[0] : trigger;
+        await page.type(triggerSel, searchText, {
+          delay: 30,
+          timeout: Math.min(timeout, 3e3)
+        });
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      } catch {
+        return { success: false, failedAt: "search", error: "Failed to type search text" };
+      }
+    }
+    const optionSelectors = optionSelector ? [optionSelector] : DEFAULT_OPTION_SELECTORS;
+    const matchFn = match === "exact" ? "exact" : match === "startsWith" ? "startsWith" : "contains";
+    const clickedOption = await page.evaluate(`(() => {
+      const selectors = ${JSON.stringify(optionSelectors)};
+      const targetValue = ${JSON.stringify(value)};
+      const matchMode = ${JSON.stringify(matchFn)};
+
+      for (const sel of selectors) {
+        const options = document.querySelectorAll(sel);
+        for (const opt of options) {
+          const text = (opt.textContent || '').trim();
+          let matches = false;
+          if (matchMode === 'exact') matches = text === targetValue;
+          else if (matchMode === 'startsWith') matches = text.startsWith(targetValue);
+          else matches = text.includes(targetValue);
+
+          if (matches) {
+            opt.click();
+            return text;
+          }
+        }
+      }
+      return null;
+    })()`);
+    if (!clickedOption) {
+      return { success: false, failedAt: "select", error: `No option matching "${value}" found` };
+    }
+    return {
+      success: true,
+      selectedText: String(clickedOption)
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var DEFAULT_LISTBOX_SELECTORS, DEFAULT_OPTION_SELECTORS;
+var init_combobox = __esm({
+  "src/browser/combobox.ts"() {
+    "use strict";
+    DEFAULT_LISTBOX_SELECTORS = [
+      '[role="listbox"]',
+      '[role="menu"]',
+      '[role="tree"]',
+      'ul[class*="dropdown"]',
+      'ul[class*="option"]',
+      'ul[class*="list"]',
+      'div[class*="dropdown"]',
+      'div[class*="menu"]'
+    ];
+    DEFAULT_OPTION_SELECTORS = [
+      '[role="option"]',
+      '[role="menuitem"]',
+      '[role="treeitem"]',
+      "li"
+    ];
+  }
+});
+
+// src/browser/upload.ts
+var upload_exports = {};
+__export(upload_exports, {
+  uploadFiles: () => uploadFiles
+});
+async function uploadFiles(page, config) {
+  const { selector, files, timeout = 1e4 } = config;
+  const fileNames = files.map((f) => f.split("/").pop() ?? f);
+  try {
+    const selectors = Array.isArray(selector) ? selector : [selector];
+    let nodeId;
+    for (const sel of selectors) {
+      try {
+        const found = await page.waitFor(sel, {
+          timeout: Math.min(timeout, 5e3),
+          optional: true,
+          state: "attached"
+        });
+        if (found) {
+          const result = await page.evaluate(`(() => {
+            const el = document.querySelector(${JSON.stringify(sel)});
+            if (!el) return null;
+            return el.tagName.toLowerCase() === 'input' && el.type === 'file' ? 'file-input' : 'not-file-input';
+          })()`);
+          if (result === "file-input") {
+            const doc = await page.cdpClient.send("DOM.getDocument");
+            const queryResult = await page.cdpClient.send("DOM.querySelector", {
+              nodeId: doc.root.nodeId,
+              selector: sel
+            });
+            nodeId = queryResult.nodeId;
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+    if (!nodeId) {
+      return {
+        accepted: false,
+        fileCount: 0,
+        fileNames,
+        error: "No file input element found"
+      };
+    }
+    await page.cdpClient.send("DOM.setFileInputFiles", {
+      files,
+      nodeId
+    });
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    let validationError;
+    try {
+      const errorText = await page.evaluate(`(() => {
+        const errorSelectors = ['.error', '.validation-error', '[class*="error"]', '[role="alert"]'];
+        for (const sel of errorSelectors) {
+          const el = document.querySelector(sel);
+          if (el && el.offsetParent !== null && el.textContent.trim()) {
+            return el.textContent.trim();
+          }
+        }
+        return null;
+      })()`);
+      if (errorText) validationError = String(errorText);
+    } catch {
+    }
+    let visibleInUI;
+    try {
+      const visible = await page.evaluate(`(() => {
+        const text = document.body.innerText;
+        const fileNames = ${JSON.stringify(fileNames)};
+        return fileNames.some(name => text.includes(name));
+      })()`);
+      visibleInUI = visible === true;
+    } catch {
+    }
+    return {
+      accepted: true,
+      fileCount: files.length,
+      fileNames,
+      visibleInUI,
+      validationError
+    };
+  } catch (error) {
+    return {
+      accepted: false,
+      fileCount: 0,
+      fileNames,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var init_upload = __esm({
+  "src/browser/upload.ts"() {
+    "use strict";
+  }
+});
+
 // src/actions/index.ts
 var actions_exports = {};
 __export(actions_exports, {
   BatchExecutor: () => BatchExecutor,
+  NetworkResponseTracker: () => NetworkResponseTracker,
   addBatchToPage: () => addBatchToPage,
+  captureStateSignature: () => captureStateSignature,
+  conditionAll: () => conditionAll,
+  conditionAny: () => conditionAny,
+  conditionNot: () => conditionNot,
+  conditionRace: () => conditionRace,
+  evaluateCondition: () => evaluateCondition,
+  evaluateOutcome: () => evaluateOutcome,
   validateSteps: () => validateSteps
 });
 module.exports = __toCommonJS(actions_exports);
 
+// src/utils/strings.ts
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readStringOr(value, fallback = "") {
+  return readString(value) ?? fallback;
+}
+function formatConsoleArg(entry) {
+  return readString(entry["value"]) ?? readString(entry["description"]) ?? "";
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const withWildcards = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${withWildcards}$`);
+}
+
+// src/actions/conditions.ts
+var NetworkResponseTracker = class {
+  responses = [];
+  listening = false;
+  handler = null;
+  start(cdp) {
+    if (this.listening) return;
+    this.listening = true;
+    this.handler = (params) => {
+      const response = params["response"];
+      if (response) {
+        this.responses.push({ url: response.url, status: response.status });
+      }
+    };
+    cdp.on("Network.responseReceived", this.handler);
+  }
+  stop(cdp) {
+    if (this.handler) {
+      cdp.off("Network.responseReceived", this.handler);
+      this.handler = null;
+    }
+    this.listening = false;
+  }
+  getResponses() {
+    return this.responses;
+  }
+  reset() {
+    this.responses = [];
+  }
+};
+async function captureStateSignature(page) {
+  try {
+    const url = await page.url();
+    const text = await page.text();
+    const truncated = text.slice(0, 2e3);
+    return `${url}|${simpleHash(truncated)}`;
+  } catch {
+    return "";
+  }
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return hash.toString(36);
+}
+async function evaluateCondition(condition, page, context = {}) {
+  switch (condition.kind) {
+    case "urlMatches": {
+      try {
+        const currentUrl = await page.url();
+        const regex = globToRegex(condition.pattern);
+        const matched = regex.test(currentUrl);
+        return {
+          condition,
+          matched,
+          detail: matched ? `URL "${currentUrl}" matches "${condition.pattern}"` : `URL "${currentUrl}" does not match "${condition.pattern}"`
+        };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get current URL" };
+      }
+    }
+    case "elementVisible": {
+      try {
+        const selectors = Array.isArray(condition.selector) ? condition.selector : [condition.selector];
+        for (const sel of selectors) {
+          const visible = await page.waitFor(sel, {
+            timeout: 2e3,
+            optional: true,
+            state: "visible"
+          });
+          if (visible) {
+            return { condition, matched: true, detail: `Element "${sel}" is visible` };
+          }
+        }
+        return { condition, matched: false, detail: "No matching visible element found" };
+      } catch {
+        return { condition, matched: false, detail: "Visibility check failed" };
+      }
+    }
+    case "elementHidden": {
+      try {
+        const selectors = Array.isArray(condition.selector) ? condition.selector : [condition.selector];
+        for (const sel of selectors) {
+          const visible = await page.waitFor(sel, {
+            timeout: 500,
+            optional: true,
+            state: "visible"
+          });
+          if (visible) {
+            return { condition, matched: false, detail: `Element "${sel}" is still visible` };
+          }
+        }
+        return { condition, matched: true, detail: "Element is hidden or not found" };
+      } catch {
+        return { condition, matched: true, detail: "Element is hidden (check threw)" };
+      }
+    }
+    case "textAppears": {
+      try {
+        const selector = Array.isArray(condition.selector) ? condition.selector[0] : condition.selector;
+        const text = await page.text(selector);
+        const matched = text.includes(condition.text);
+        return {
+          condition,
+          matched,
+          detail: matched ? `Text "${condition.text}" found` : `Text "${condition.text}" not found in page content`
+        };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get page text" };
+      }
+    }
+    case "textChanges": {
+      try {
+        const selector = Array.isArray(condition.selector) ? condition.selector[0] : condition.selector;
+        const text = await page.text(selector);
+        if (condition.to !== void 0) {
+          const matched = text.includes(condition.to);
+          return {
+            condition,
+            matched,
+            detail: matched ? `Text changed to include "${condition.to}"` : `Text does not include "${condition.to}"`
+          };
+        }
+        return { condition, matched: true, detail: "textChanges without `to` defaults to true" };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get text for change detection" };
+      }
+    }
+    case "networkResponse": {
+      const tracker = context.networkTracker;
+      if (!tracker) {
+        return { condition, matched: false, detail: "No network tracker active" };
+      }
+      const regex = globToRegex(condition.urlPattern);
+      const responses = tracker.getResponses();
+      for (const resp of responses) {
+        if (regex.test(resp.url)) {
+          if (condition.status !== void 0 && resp.status !== condition.status) {
+            continue;
+          }
+          return {
+            condition,
+            matched: true,
+            detail: `Network response ${resp.url} (${resp.status}) matches pattern "${condition.urlPattern}"`
+          };
+        }
+      }
+      return {
+        condition,
+        matched: false,
+        detail: `No network response matching "${condition.urlPattern}" (saw ${responses.length} responses)`
+      };
+    }
+    case "stateSignatureChanges": {
+      if (!context.beforeSignature) {
+        return { condition, matched: false, detail: "No before-signature captured" };
+      }
+      const afterSignature = await captureStateSignature(page);
+      const matched = afterSignature !== context.beforeSignature;
+      return {
+        condition,
+        matched,
+        detail: matched ? "Page state changed" : "Page state unchanged"
+      };
+    }
+    default: {
+      const _exhaustive = condition;
+      return { condition: _exhaustive, matched: false, detail: "Unknown condition kind" };
+    }
+  }
+}
+async function evaluateOutcome(page, options) {
+  const {
+    expectAny,
+    expectAll,
+    failIf,
+    dangerous = false,
+    networkTracker,
+    beforeSignature
+  } = options;
+  const allMatched = [];
+  const context = { networkTracker, beforeSignature };
+  if (failIf && failIf.length > 0) {
+    for (const condition of failIf) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (result.matched) {
+        return {
+          outcomeStatus: "failed",
+          matchedConditions: allMatched,
+          retrySafe: !dangerous
+        };
+      }
+    }
+  }
+  if (expectAll && expectAll.length > 0) {
+    let allPassed = true;
+    for (const condition of expectAll) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (!result.matched) {
+        allPassed = false;
+      }
+    }
+    if (!allPassed) {
+      const status = dangerous ? "unsafe_to_retry" : "ambiguous";
+      return {
+        outcomeStatus: status,
+        matchedConditions: allMatched,
+        retrySafe: !dangerous
+      };
+    }
+    if (!expectAny || expectAny.length === 0) {
+      return {
+        outcomeStatus: "success",
+        matchedConditions: allMatched,
+        retrySafe: true
+      };
+    }
+  }
+  if (expectAny && expectAny.length > 0) {
+    let anyPassed = false;
+    for (const condition of expectAny) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (result.matched) {
+        anyPassed = true;
+      }
+    }
+    if (anyPassed) {
+      return {
+        outcomeStatus: "success",
+        matchedConditions: allMatched,
+        retrySafe: true
+      };
+    }
+    const status = dangerous ? "unsafe_to_retry" : "ambiguous";
+    return {
+      outcomeStatus: status,
+      matchedConditions: allMatched,
+      retrySafe: !dangerous
+    };
+  }
+  return {
+    outcomeStatus: "success",
+    matchedConditions: allMatched,
+    retrySafe: true
+  };
+}
+
+// src/actions/combinators.ts
+async function conditionAny(conditions, page, context) {
+  const results = [];
+  let winnerIndex;
+  for (let i = 0; i < conditions.length; i++) {
+    const result = await evaluateCondition(conditions[i], page, context);
+    results.push(result);
+    if (result.matched && winnerIndex === void 0) {
+      winnerIndex = i;
+    }
+  }
+  return {
+    matched: winnerIndex !== void 0,
+    matchedConditions: results,
+    winnerIndex
+  };
+}
+async function conditionAll(conditions, page, context) {
+  const results = [];
+  let allMatched = true;
+  for (const condition of conditions) {
+    const result = await evaluateCondition(condition, page, context);
+    results.push(result);
+    if (!result.matched) allMatched = false;
+  }
+  return {
+    matched: allMatched,
+    matchedConditions: results
+  };
+}
+async function conditionNot(condition, page, context) {
+  const result = await evaluateCondition(condition, page, context);
+  return {
+    matched: !result.matched,
+    matchedConditions: [
+      {
+        condition: result.condition,
+        matched: !result.matched,
+        detail: result.matched ? `NOT: condition was true (inverted to false): ${result.detail}` : `NOT: condition was false (inverted to true): ${result.detail}`
+      }
+    ]
+  };
+}
+async function conditionRace(conditions, page, options = {}) {
+  const { timeout = 1e4, pollInterval = 200, networkTracker, beforeSignature } = options;
+  const context = { networkTracker, beforeSignature };
+  const startTime = Date.now();
+  const deadline = startTime + timeout;
+  const immediate = await conditionAny(conditions, page, context);
+  if (immediate.matched) return immediate;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    const result = await conditionAny(conditions, page, context);
+    if (result.matched) return result;
+  }
+  return await conditionAny(conditions, page, context);
+}
+
 // src/actions/executor.ts
 var fs = __toESM(require("fs"), 1);
 var import_node_path = require("path");
@@ -1171,13 +1709,6 @@ var TRACE_SCRIPT = `
 })();
 `;
 
-// src/trace/live.ts
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const withWildcards = escaped.replace(/\*/g, ".*");
-  return new RegExp(`^${withWildcards}$`);
-}
-
 // src/actions/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_RECORDING_SKIP_ACTIONS = [
@@ -1187,15 +1718,6 @@ var DEFAULT_RECORDING_SKIP_ACTIONS = [
   "text",
   "screenshot"
 ];
-function readString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function readStringOr(value, fallback = "") {
-  return readString(value) ?? fallback;
-}
-function formatConsoleArg(entry) {
-  return readString(entry["value"]) ?? readString(entry["description"]) ?? "";
-}
 function loadExistingRecording(manifestPath) {
   try {
     const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
@@ -1309,6 +1831,25 @@ function getSuggestion(reason) {
     }
   }
 }
+function hasOutcomeConditions(step) {
+  return step.expectAny !== void 0 && step.expectAny.length > 0 || step.expectAll !== void 0 && step.expectAll.length > 0 || step.failIf !== void 0 && step.failIf.length > 0;
+}
+function needsNetworkTracking(step) {
+  const allConditions = [
+    ...step.expectAny ?? [],
+    ...step.expectAll ?? [],
+    ...step.failIf ?? []
+  ];
+  return allConditions.some((c) => c.kind === "networkResponse");
+}
+function needsStateSignature(step) {
+  const allConditions = [
+    ...step.expectAny ?? [],
+    ...step.expectAll ?? [],
+    ...step.failIf ?? []
+  ];
+  return allConditions.some((c) => c.kind === "stateSignatureChanges");
+}
 var BatchExecutor = class {
   page;
   constructor(page) {
@@ -1354,9 +1895,25 @@ var BatchExecutor = class {
           })
         );
       }
+      const hasOutcome = hasOutcomeConditions(step);
+      let networkTracker;
+      let beforeSignature;
+      if (hasOutcome) {
+        if (needsNetworkTracking(step)) {
+          networkTracker = new NetworkResponseTracker();
+          networkTracker.start(this.page.cdpClient);
+        }
+        if (needsStateSignature(step)) {
+          beforeSignature = await captureStateSignature(this.page);
+        }
+      }
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         if (attempt > 0) {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          if (networkTracker) networkTracker.reset();
+          if (hasOutcome && needsStateSignature(step)) {
+            beforeSignature = await captureStateSignature(this.page);
+          }
         }
         try {
           this.page.resetLastActionPosition();
@@ -1374,6 +1931,28 @@ var BatchExecutor = class {
             coordinates: this.page.getLastActionCoordinates() ?? void 0,
             boundingBox: this.page.getLastActionBoundingBox() ?? void 0
           };
+          if (hasOutcome) {
+            if (networkTracker) networkTracker.stop(this.page.cdpClient);
+            const outcome = await evaluateOutcome(this.page, {
+              expectAny: step.expectAny,
+              expectAll: step.expectAll,
+              failIf: step.failIf,
+              dangerous: step.dangerous,
+              networkTracker,
+              beforeSignature
+            });
+            stepResult.outcomeStatus = outcome.outcomeStatus;
+            stepResult.matchedConditions = outcome.matchedConditions;
+            stepResult.retrySafe = outcome.retrySafe;
+            if (outcome.outcomeStatus !== "success") {
+              stepResult.success = false;
+              stepResult.error = `Outcome: ${outcome.outcomeStatus}`;
+              const failedDetails = outcome.matchedConditions.filter((mc) => outcome.outcomeStatus === "failed" ? mc.matched : !mc.matched).map((mc) => mc.detail).filter(Boolean);
+              if (failedDetails.length > 0) {
+                stepResult.suggestion = failedDetails.join("; ");
+              }
+            }
+          }
           if (recording && !recording.skipActions.has(step.action)) {
             await this.captureRecordingFrame(step, stepResult, recording);
           }
@@ -1383,13 +1962,14 @@ var BatchExecutor = class {
                 traceId: createTraceId("action"),
                 elapsedMs: Date.now() - startTime,
                 channel: "action",
-                event: "action.succeeded",
-                summary: `${step.action} succeeded`,
+                event: stepResult.success ? "action.succeeded" : "action.outcome_failed",
+                summary: stepResult.success ? `${step.action} succeeded` : `${step.action} outcome: ${stepResult.outcomeStatus}`,
                 data: {
                   action: step.action,
                   selector: step.selector ?? null,
                   selectorUsed: result.selectorUsed ?? null,
-                  durationMs: Date.now() - stepStart
+                  durationMs: Date.now() - stepStart,
+                  outcomeStatus: stepResult.outcomeStatus ?? null
                 },
                 actionId: `action-${i + 1}`,
                 stepIndex: i,
@@ -1399,6 +1979,18 @@ var BatchExecutor = class {
               })
             );
           }
+          if (hasOutcome && !stepResult.success) {
+            if (step.dangerous) {
+              results.push(stepResult);
+              break;
+            }
+            if (attempt < maxAttempts - 1) {
+              lastError = new Error(stepResult.error ?? "Outcome failed");
+              continue;
+            }
+            results.push(stepResult);
+            break;
+          }
           results.push(stepResult);
           succeeded = true;
           break;
@@ -1406,59 +1998,63 @@ var BatchExecutor = class {
           lastError = error instanceof Error ? error : new Error(String(error));
         }
       }
+      if (networkTracker) networkTracker.stop(this.page.cdpClient);
       if (!succeeded) {
-        const errorMessage = lastError?.message ?? "Unknown error";
-        let hints = lastError instanceof ElementNotFoundError ? lastError.hints : void 0;
-        const { reason, coveringElement } = classifyFailure(lastError);
-        if (step.selector && !step.optional && ["missing", "hidden", "covered", "disabled", "detached", "replaced"].includes(reason)) {
-          try {
-            const selectors = Array.isArray(step.selector) ? step.selector : [step.selector];
-            const autoHints = await generateHints(this.page, selectors, step.action, 3);
-            if (autoHints.length > 0) {
-              hints = autoHints;
+        const resultAlreadyPushed = results.length > 0 && results[results.length - 1].index === i;
+        if (!resultAlreadyPushed) {
+          const errorMessage = lastError?.message ?? "Unknown error";
+          let hints = lastError instanceof ElementNotFoundError ? lastError.hints : void 0;
+          const { reason, coveringElement } = classifyFailure(lastError);
+          if (step.selector && !step.optional && ["missing", "hidden", "covered", "disabled", "detached", "replaced"].includes(reason)) {
+            try {
+              const selectors = Array.isArray(step.selector) ? step.selector : [step.selector];
+              const autoHints = await generateHints(this.page, selectors, step.action, 3);
+              if (autoHints.length > 0) {
+                hints = autoHints;
+              }
+            } catch {
             }
-          } catch {
           }
+          const failedResult = {
+            index: i,
+            action: step.action,
+            selector: step.selector,
+            success: false,
+            durationMs: Date.now() - stepStart,
+            error: errorMessage,
+            hints,
+            failureReason: reason,
+            coveringElement,
+            suggestion: getSuggestion(reason),
+            timestamp: Date.now()
+          };
+          if (recording && !recording.skipActions.has(step.action)) {
+            await this.captureRecordingFrame(step, failedResult, recording);
+          }
+          if (recording) {
+            recording.traceEvents.push(
+              normalizeTraceEvent({
+                traceId: createTraceId("action"),
+                elapsedMs: Date.now() - startTime,
+                channel: "action",
+                event: "action.failed",
+                severity: "error",
+                summary: `${step.action} failed: ${errorMessage}`,
+                data: {
+                  action: step.action,
+                  selector: step.selector ?? null,
+                  error: errorMessage,
+                  reason
+                },
+                actionId: `action-${i + 1}`,
+                stepIndex: i,
+                selector: step.selector,
+                url: step.url
+              })
+            );
+          }
+          results.push(failedResult);
         }
-        const failedResult = {
-          index: i,
-          action: step.action,
-          selector: step.selector,
-          success: false,
-          durationMs: Date.now() - stepStart,
-          error: errorMessage,
-          hints,
-          failureReason: reason,
-          coveringElement,
-          suggestion: getSuggestion(reason),
-          timestamp: Date.now()
-        };
-        if (recording && !recording.skipActions.has(step.action)) {
-          await this.captureRecordingFrame(step, failedResult, recording);
-        }
-        if (recording) {
-          recording.traceEvents.push(
-            normalizeTraceEvent({
-              traceId: createTraceId("action"),
-              elapsedMs: Date.now() - startTime,
-              channel: "action",
-              event: "action.failed",
-              severity: "error",
-              summary: `${step.action} failed: ${errorMessage}`,
-              data: {
-                action: step.action,
-                selector: step.selector ?? null,
-                error: errorMessage,
-                reason
-              },
-              actionId: `action-${i + 1}`,
-              stepIndex: i,
-              selector: step.selector,
-              url: step.url
-            })
-          );
-        }
-        results.push(failedResult);
         if (onFail === "stop" && !step.optional) {
           stoppedAtIndex = i;
           break;
@@ -1769,6 +2365,14 @@ var BatchExecutor = class {
       case "forms": {
         return { value: await this.page.forms() };
       }
+      case "delta": {
+        const review = await this.page.review();
+        return { value: review };
+      }
+      case "review": {
+        const review = await this.page.review();
+        return { value: review };
+      }
       case "screenshot": {
         const data = await this.page.screenshot({
           format: step.format,
@@ -1919,6 +2523,35 @@ var BatchExecutor = class {
         const media = await this.assertMediaTrackLive(step.kind);
         return { value: media };
       }
+      case "chooseOption": {
+        const { chooseOption: chooseOption2 } = await Promise.resolve().then(() => (init_combobox(), combobox_exports));
+        if (!step.value) throw new Error("chooseOption requires value");
+        const result = await chooseOption2(this.page, {
+          trigger: step.trigger ?? step.selector ?? "",
+          listbox: step.option ? Array.isArray(step.option) ? step.option : [step.option] : void 0,
+          value: typeof step.value === "string" ? step.value : step.value[0] ?? "",
+          match: step.match,
+          timeout: step.timeout ?? timeout
+        });
+        if (!result.success) {
+          throw new Error(result.error ?? `chooseOption failed at ${result.failedAt}`);
+        }
+        return { value: result };
+      }
+      case "upload": {
+        const { uploadFiles: uploadFiles2 } = await Promise.resolve().then(() => (init_upload(), upload_exports));
+        if (!step.selector) throw new Error("upload requires selector");
+        if (!step.files || step.files.length === 0) throw new Error("upload requires files");
+        const result = await uploadFiles2(this.page, {
+          selector: step.selector,
+          files: step.files,
+          timeout: step.timeout ?? timeout
+        });
+        if (!result.accepted) {
+          throw new Error(result.error ?? "Upload was not accepted");
+        }
+        return { value: result };
+      }
       default: {
         const action = step.action;
         const aliases = {
@@ -2512,6 +3145,30 @@ var ACTION_RULES = {
       kind: { type: "string", enum: ["audio", "video"] }
     },
     optional: {}
+  },
+  delta: {
+    required: {},
+    optional: {}
+  },
+  review: {
+    required: {},
+    optional: {}
+  },
+  chooseOption: {
+    required: { value: { type: "string|string[]" } },
+    optional: {
+      trigger: { type: "string|string[]" },
+      selector: { type: "string|string[]" },
+      option: { type: "string|string[]" },
+      match: { type: "string", enum: ["exact", "contains", "startsWith"] }
+    }
+  },
+  upload: {
+    required: {
+      selector: { type: "string|string[]" },
+      files: { type: "string|string[]" }
+    },
+    optional: {}
   }
 };
 var VALID_ACTIONS = Object.keys(ACTION_RULES);
@@ -2551,7 +3208,12 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "name",
   "state",
   "kind",
-  "windowMs"
+  "windowMs",
+  "expectAny",
+  "expectAll",
+  "failIf",
+  "dangerous",
+  "files"
 ]);
 function resolveAction(name) {
   if (VALID_ACTIONS.includes(name)) {
@@ -2771,6 +3433,64 @@ function validateSteps(steps) {
         });
       }
     }
+    if ("dangerous" in obj && obj["dangerous"] !== void 0) {
+      if (typeof obj["dangerous"] !== "boolean") {
+        errors.push({
+          stepIndex: i,
+          field: "dangerous",
+          message: `"dangerous" expected boolean, got ${typeof obj["dangerous"]}.`
+        });
+      }
+    }
+    for (const condField of ["expectAny", "expectAll", "failIf"]) {
+      if (condField in obj && obj[condField] !== void 0) {
+        if (!Array.isArray(obj[condField])) {
+          errors.push({
+            stepIndex: i,
+            field: condField,
+            message: `"${condField}" expected array, got ${typeof obj[condField]}.`
+          });
+        } else {
+          const conditions = obj[condField];
+          for (let ci = 0; ci < conditions.length; ci++) {
+            const cond = conditions[ci];
+            if (!cond || typeof cond !== "object" || Array.isArray(cond)) {
+              errors.push({
+                stepIndex: i,
+                field: condField,
+                message: `"${condField}[${ci}]" must be a condition object.`
+              });
+              continue;
+            }
+            const condObj = cond;
+            if (!("kind" in condObj) || typeof condObj["kind"] !== "string") {
+              errors.push({
+                stepIndex: i,
+                field: condField,
+                message: `"${condField}[${ci}]" missing required "kind" field.`
+              });
+            } else {
+              const validKinds = [
+                "urlMatches",
+                "elementVisible",
+                "elementHidden",
+                "textAppears",
+                "textChanges",
+                "networkResponse",
+                "stateSignatureChanges"
+              ];
+              if (!validKinds.includes(condObj["kind"])) {
+                errors.push({
+                  stepIndex: i,
+                  field: condField,
+                  message: `"${condField}[${ci}].kind" must be one of: ${validKinds.join(", ")}. Got "${condObj["kind"]}".`
+                });
+              }
+            }
+          }
+        }
+      }
+    }
     if (action === "assertText") {
       if (!("expect" in obj) && !("value" in obj)) {
         errors.push({
@@ -2848,6 +3568,14 @@ function validateSteps(steps) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BatchExecutor,
+  NetworkResponseTracker,
   addBatchToPage,
+  captureStateSignature,
+  conditionAll,
+  conditionAny,
+  conditionNot,
+  conditionRace,
+  evaluateCondition,
+  evaluateOutcome,
   validateSteps
 });