@runcofactor/cli 0.16.0 → 0.17.0

package/dist/{chunk-AI3Y3AZH.js → chunk-MO5G5TP5.js}

@@ -50122,6 +50122,52 @@ var ToolAbortedError = class extends Error {
     this.name = "ToolAbortedError";
   }
 };
+function labelForContext(context) {
+  return context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+}
+function elementDescription(context) {
+  const role = context.role ? ` role=${context.role}` : "";
+  const type = context.inputType ? ` type=${context.inputType}` : "";
+  return `${context.tagName}${type}${role}`;
+}
+function formatFillTargetNotEditableMessage(context) {
+  if (context.state === "not-fillable") {
+    return `Cannot fill target ${labelForContext(context)}: ${elementDescription(context)} cannot accept text.`;
+  }
+  return `Cannot fill ${context.state} field ${labelForContext(context)}: ${elementDescription(context)} is not editable.`;
+}
+var FillTargetNotEditableError = class extends Error {
+  fillTarget;
+  constructor(context) {
+    super(formatFillTargetNotEditableMessage(context));
+    this.name = "FillTargetNotEditableError";
+    this.fillTarget = context;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFillTargetNotEditableError(error) {
+  if (error instanceof FillTargetNotEditableError) return true;
+  if (!isRecord(error) || error.name !== "FillTargetNotEditableError") return false;
+  if (!isRecord(error.fillTarget)) return false;
+  const context = error.fillTarget;
+  return typeof context.ref === "string" && typeof context.tagName === "string" && (context.state === "readonly" || context.state === "disabled" || context.state === "not-fillable");
+}
+function formatFillTargetNotEditableRecovery(error, toolName = "browser_fill_form") {
+  const context = error.fillTarget;
+  const action = toolName === "browser_type" ? "type into" : "fill";
+  if (context.state === "not-fillable") {
+    return [
+      `Error: ${toolName} cannot ${action} target ${labelForContext(context)}: ${elementDescription(context)} cannot accept typed text.`,
+      `Do not retry ${toolName} for this ref. Call browser_snapshot and choose the actual editable input or textarea. If the target is a dropdown, use browser_select_option or click the dropdown and select an option.`
+    ].join(" ");
+  }
+  return [
+    `Error: ${toolName} cannot ${action} ${context.state} field ${labelForContext(context)}: ${elementDescription(context)} is not editable.`,
+    `Do not retry ${toolName} for this ref. Call browser_snapshot and choose an editable input or textarea for the same requirement, or complete the prerequisite that unlocks this field first.`
+  ].join(" ");
+}
 function isMCPContentWithImages(result) {
   return typeof result === "object" && result !== null && "text" in result && "images" in result && Array.isArray(result.images) && result.images.length > 0;
 }
@@ -50212,6 +50258,31 @@ function formatEmptyPressKeyRecovery() {
     'Do not retry with an empty string. Use a Playwright key such as "Enter", "Escape", "Tab", "ArrowDown", or use browser_type when you need to enter text.'
   ].join(" ");
 }
+function normalizeRef(ref2) {
+  const trimmed = ref2?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function formatEmptyRefRecovery(toolName) {
+  return [
+    `Error: ${toolName} requires a non-empty element ref from the latest browser_snapshot.`,
+    'Do not retry with an empty string. Call browser_snapshot and use a concrete ref such as "e42", or use the coordinate path when that tool supports coordinates.'
+  ].join(" ");
+}
+function extractWaitingAriaRef(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.match(/waiting for locator\('aria-ref=([^']+)'\)/)?.[1];
+}
+function isStaleAriaRefActionTimeout(error, action) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes(`${action}: Timeout`) && message.includes("waiting for locator('aria-ref=") && !message.includes("locator resolved to <");
+}
+function formatStaleRefActionRecovery(toolName, ref2, element) {
+  const label = element ? ` for "${element}"` : "";
+  return [
+    `Error: ${toolName} could not find ref ${ref2}${label} in the current page snapshot.`,
+    "Do not retry the same ref. Call browser_snapshot and choose a fresh ref, or use the coordinate path when that tool supports coordinates."
+  ].join(" ");
+}
 function isSelectOptionNonSelectError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("selectOption:") && message.includes("Element is not a <select>");
@@ -50219,6 +50290,35 @@ function isSelectOptionNonSelectError(error) {
 function isMissingDownloadTempFileError(message) {
   return /\bENOENT:\s+no such file or directory,\s+open\b/.test(message) && message.includes("/playwright-downloads-");
 }
+function isNavigateDownloadStartingError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /\bgoto:\s+Download is starting\b/.test(message);
+}
+function formatNavigateDownloadStartingRecovery() {
+  return [
+    "Error: browser_navigate started a file download instead of loading a page.",
+    "Do not retry browser_navigate for the same URL. Call browser_list_downloads to find the captured file, then use browser_read_download or browser_pdf_read to inspect it."
+  ].join(" ");
+}
+function isRelativeNavigateTarget(url) {
+  const trimmed = url.trim();
+  return trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("?") || trimmed.startsWith("#");
+}
+function isHttpUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function formatRelativeNavigateRecovery(url, currentUrl) {
+  const baseDescription = currentUrl ? `current page URL is "${currentUrl}"` : "current page URL is unavailable";
+  return [
+    `Error: browser_navigate received relative URL "${url}", but the ${baseDescription}.`,
+    "Use an absolute http(s) URL, or call browser_snapshot first if the current page needs to be inspected before navigating."
+  ].join(" ");
+}
 function formatSelectOptionNonSelectRecovery(ref2, value, element) {
   return [
     `Error: browser_select_option can only operate on native <select> elements; ref ${ref2} for "${element}" resolved to a custom dropdown or combobox.`,
@@ -50676,11 +50776,38 @@ var BrowserToolExecutor = class {
   }
   // ==================== Navigation ====================
   async navigate(url) {
-    ensureAllowedHost(url, this.allowedHosts);
-    const rawResult = await this.client.navigate(url, { signal: this.currentSignal });
+    const navigationUrl = await this.resolveNavigateUrl(url);
+    if (navigationUrl.kind === "recovery") {
+      return navigationUrl.message;
+    }
+    ensureAllowedHost(navigationUrl.url, this.allowedHosts);
+    let rawResult;
+    try {
+      rawResult = await this.client.navigate(navigationUrl.url, { signal: this.currentSignal });
+    } catch (error) {
+      if (isNavigateDownloadStartingError(error)) {
+        return formatNavigateDownloadStartingRecovery();
+      }
+      throw error;
+    }
     const result = withRecoveryNotice(this.client, rawResult, this.logger);
     return this.formatNavigateResult(result);
   }
+  async resolveNavigateUrl(url) {
+    const trimmedUrl = url.trim();
+    if (!isRelativeNavigateTarget(trimmedUrl)) {
+      return { kind: "url", url: trimmedUrl };
+    }
+    const currentUrl = await this.client.getCurrentUrl({ signal: this.currentSignal }).catch(() => void 0);
+    if (!currentUrl || !isHttpUrl(currentUrl)) {
+      return { kind: "recovery", message: formatRelativeNavigateRecovery(trimmedUrl, currentUrl) };
+    }
+    try {
+      return { kind: "url", url: new URL(trimmedUrl, currentUrl).toString() };
+    } catch {
+      return { kind: "recovery", message: formatRelativeNavigateRecovery(trimmedUrl, currentUrl) };
+    }
+  }
   async navigateBack() {
     const result = await this.client.navigateBack({ signal: this.currentSignal });
     return this.formatNavigateResult(result);
@@ -50985,6 +51112,10 @@ ${body}
    * Returns a structured result with the message and optional created hint metadata.
    */
   async hint(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return { message: formatEmptyRefRecovery("browser_hint") };
+    }
     if (!this.hintProvider) {
       return { message: "Element hints are not available in this environment." };
     }
@@ -50998,9 +51129,9 @@ ${body}
       return { message: "Cannot create hint: no recent snapshot available. Take a snapshot first." };
     }
     const elements = parseSnapshot(lastYaml);
-    const fpResult = fingerprintForHint(elements, opts.ref);
+    const fpResult = fingerprintForHint(elements, ref2);
     if (!fpResult) {
-      return { message: `Cannot create hint: element ref "${opts.ref}" not found in the current snapshot.` };
+      return { message: `Cannot create hint: element ref "${ref2}" not found in the current snapshot.` };
     }
     if (opts.invalidate) {
       if (!opts.reason) {
@@ -51019,7 +51150,7 @@ ${body}
         fingerprintHash: fpResult.hash,
         reason: opts.reason
       });
-      return { message: `Hint on [${opts.ref}] invalidated: ${opts.reason}` };
+      return { message: `Hint on [${ref2}] invalidated: ${opts.reason}` };
     }
     if (!opts.frontmatter) {
       return { message: "Cannot create hint: frontmatter is required." };
@@ -51064,7 +51195,7 @@ ${body}
     });
     const anchorNote = fpResult.anchoredToParent ? ` (anchored to ${fpResult.anchor.role} "${fpResult.anchor.text ?? ""}")` : "";
     return {
-      message: `Hint created on [${opts.ref}]${anchorNote}: (${category}: ${opts.frontmatter})`,
+      message: `Hint created on [${ref2}]${anchorNote}: (${category}: ${opts.frontmatter})`,
       created: {
         id: created.id,
         frontmatter: opts.frontmatter,
@@ -51075,10 +51206,11 @@ ${body}
     };
   }
   async screenshot(opts) {
+    const ref2 = normalizeRef(opts?.ref);
     const img = await this.client.takeScreenshot({
       fullPage: opts?.fullPage,
       element: opts?.element,
-      ref: opts?.ref,
+      ref: ref2,
       type: opts?.type ?? "jpeg",
       label: opts?.label,
       signal: this.currentSignal
@@ -51099,9 +51231,10 @@ ${body}
     return `Screenshot captured${opts?.label ? ` (${opts.label})` : ""}: ${img ? "success" : "no screenshot"}`;
   }
   async evaluate(opts) {
+    const ref2 = normalizeRef(opts.ref);
     const result = await this.client.evaluate(opts.expression, {
       label: opts.label,
-      ref: opts.ref,
+      ref: ref2,
       signal: this.currentSignal
     });
     return typeof result === "string" ? result : JSON.stringify(result, null, 2);
@@ -51119,7 +51252,7 @@ ${body}
   }
   // ==================== Interaction ====================
   async click(opts) {
-    const { ref: ref2 } = opts;
+    const ref2 = normalizeRef(opts.ref);
     let x2 = opts.x;
     let y2 = opts.y;
     if (x2 === 0 && y2 === 0) {
@@ -51135,29 +51268,40 @@ ${body}
     const useCoordinates = !ref2 && x2 !== void 0 && y2 !== void 0;
     const clickVerb = opts.doubleClick ? "Double-clicked" : "Clicked";
     const actionDesc = useCoordinates ? `${clickVerb} "${opts.element}" at (${x2}, ${y2})` : `${clickVerb} "${opts.element}" via ref ${ref2}`;
-    this.lastReplayableAction = { description: actionDesc, thunk: () => this.click(opts) };
+    this.lastReplayableAction = {
+      description: actionDesc,
+      thunk: () => this.click({ ...opts, ref: ref2 })
+    };
     let clickedElement;
     let fallbackUsed = false;
     const preClickUrl = useCoordinates && this.augmentorProvider ? await this.client.getCurrentUrl({ signal: this.currentSignal }).catch(() => void 0) : void 0;
-    const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
-      if (useCoordinates) {
-        const coordResult = await this.client.clickAtCoordinates(x2, y2, opts.element, {
-          doubleClick: opts.doubleClick,
-          modifiers: opts.modifiers,
-          signal: this.currentSignal
-        });
-        clickedElement = coordResult.clickedElement;
-      } else {
-        const refResult = await this.client.click(ref2, opts.element, {
-          doubleClick: opts.doubleClick,
-          button: opts.button,
-          modifiers: opts.modifiers,
-          signal: this.currentSignal
-        });
-        clickedElement = refResult.clickedElement;
-        fallbackUsed = refResult.fallbackUsed;
+    let diffText;
+    try {
+      ({ diffText } = await this.withSemanticDiff(actionDesc, async () => {
+        if (useCoordinates) {
+          const coordResult = await this.client.clickAtCoordinates(x2, y2, opts.element, {
+            doubleClick: opts.doubleClick,
+            modifiers: opts.modifiers,
+            signal: this.currentSignal
+          });
+          clickedElement = coordResult.clickedElement;
+        } else {
+          const refResult = await this.client.click(ref2, opts.element, {
+            doubleClick: opts.doubleClick,
+            button: opts.button,
+            modifiers: opts.modifiers,
+            signal: this.currentSignal
+          });
+          clickedElement = refResult.clickedElement;
+          fallbackUsed = refResult.fallbackUsed;
+        }
+      }));
+    } catch (error) {
+      if (!useCoordinates && ref2 && isStaleAriaRefActionTimeout(error, "click")) {
+        return formatStaleRefActionRecovery("browser_click", ref2, opts.element);
       }
-    });
+      throw error;
+    }
     if (useCoordinates) {
       await this.emitAugmentorSignal("coordinate_click", x2, y2, preClickUrl ?? "");
     } else {
@@ -51173,36 +51317,56 @@ ${body}
     return withRecoveryNoticeMCP(this.client, result, this.logger);
   }
   async type(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_type");
+    }
     const submitNote = opts.submit ? " and submitted" : "";
     const actionDesc = `Typed "${opts.text}" into "${opts.element}"${submitNote}`;
-    this.lastReplayableAction = { description: actionDesc, thunk: () => this.type(opts) };
-    if (opts.submit) {
-      const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
-        await this.client.type(opts.ref, opts.text, opts.element, opts.submit, {
-          delay: opts.delay,
-          signal: this.currentSignal
+    this.lastReplayableAction = {
+      description: actionDesc,
+      thunk: () => this.type({ ...opts, ref: ref2 })
+    };
+    try {
+      if (opts.submit) {
+        const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
+          await this.client.type(ref2, opts.text, opts.element, opts.submit, {
+            delay: opts.delay,
+            signal: this.currentSignal
+          });
         });
+        return withRecoveryNoticeMCP(this.client, diffText, this.logger);
+      }
+      await this.client.type(ref2, opts.text, opts.element, opts.submit, {
+        delay: opts.delay,
+        signal: this.currentSignal
       });
-      return withRecoveryNoticeMCP(this.client, diffText, this.logger);
+      return withRecoveryNotice(this.client, actionDesc, this.logger);
+    } catch (error) {
+      if (isFillTargetNotEditableError(error)) {
+        return formatFillTargetNotEditableRecovery(error, "browser_type");
+      }
+      throw error;
     }
-    await this.client.type(opts.ref, opts.text, opts.element, opts.submit, {
-      delay: opts.delay,
-      signal: this.currentSignal
-    });
-    return withRecoveryNotice(this.client, actionDesc, this.logger);
   }
   async hover(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_hover");
+    }
     const { diffText } = await this.withSemanticDiff(
-      `Hovered over "${opts.element}" via ref ${opts.ref}`,
+      `Hovered over "${opts.element}" via ref ${ref2}`,
       async () => {
-        await this.client.hover(opts.ref, opts.element, { signal: this.currentSignal });
+        await this.client.hover(ref2, opts.element, { signal: this.currentSignal });
       }
     );
     return diffText;
   }
   async drag(opts) {
+    const startRef = normalizeRef(opts.startRef);
+    const endRef = normalizeRef(opts.endRef);
     const useCoordinates = opts.startX !== void 0 && opts.startY !== void 0 && opts.endX !== void 0 && opts.endY !== void 0;
-    const useRefs = opts.startRef !== void 0 && opts.endRef !== void 0;
+    const useRefs = startRef !== void 0 && endRef !== void 0;
     if (!useCoordinates && !useRefs) {
       return "Error: Provide either startRef + endRef, or all four coordinates (startX, startY, endX, endY)";
     }
@@ -51221,7 +51385,7 @@ ${body}
           { signal: this.currentSignal }
         );
       } else {
-        await this.client.drag(opts.startRef, opts.startElement, opts.endRef, opts.endElement, {
+        await this.client.drag(startRef, opts.startElement, endRef, opts.endElement, {
           signal: this.currentSignal
         });
       }
@@ -51247,35 +51411,63 @@ ${body}
     return withRecoveryNotice(this.client, `Pressed ${key}`, this.logger);
   }
   async fillForm(fields) {
-    const { diffText } = await this.withSemanticDiff(
-      `Filled ${fields.length} form field(s)`,
-      async () => {
-        await this.client.fillForm(fields, { signal: this.currentSignal });
+    const normalizedFields = fields.map((field) => ({
+      ...field,
+      ref: normalizeRef(field.ref) ?? ""
+    }));
+    if (normalizedFields.some((field) => field.ref.length === 0)) {
+      return formatEmptyRefRecovery("browser_fill_form");
+    }
+    try {
+      const { diffText } = await this.withSemanticDiff(
+        `Filled ${fields.length} form field(s)`,
+        async () => {
+          await this.client.fillForm(normalizedFields, { signal: this.currentSignal });
+        }
+      );
+      return diffText;
+    } catch (error) {
+      if (isFillTargetNotEditableError(error)) {
+        return formatFillTargetNotEditableRecovery(error);
+      }
+      if (isStaleAriaRefActionTimeout(error, "fill")) {
+        const staleRef = extractWaitingAriaRef(error);
+        const field = normalizedFields.find((candidate) => candidate.ref === staleRef) ?? normalizedFields[0];
+        return formatStaleRefActionRecovery(
+          "browser_fill_form",
+          staleRef ?? field?.ref ?? "unknown",
+          field?.element
+        );
       }
-    );
-    return diffText;
+      throw error;
+    }
   }
   async selectOption(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_select_option");
+    }
     try {
       const { diffText } = await this.withSemanticDiff(
         `Selected "${opts.value}" in "${opts.element}"`,
         async () => {
-          await this.client.selectOption(opts.ref, opts.value, opts.element, { signal: this.currentSignal });
+          await this.client.selectOption(ref2, opts.value, opts.element, { signal: this.currentSignal });
         }
       );
       return diffText;
     } catch (error) {
       if (isSelectOptionNonSelectError(error)) {
-        return formatSelectOptionNonSelectRecovery(opts.ref, opts.value, opts.element);
+        return formatSelectOptionNonSelectRecovery(ref2, opts.value, opts.element);
       }
       throw error;
     }
   }
   async fileUpload(paths, ref2) {
+    const normalizedRef = normalizeRef(ref2);
     const { diffText } = await this.withSemanticDiff(
       `Uploaded ${paths.length} file(s)`,
       async () => {
-        await this.client.fileUpload(paths, { ref: ref2, signal: this.currentSignal });
+        await this.client.fileUpload(paths, { ref: normalizedRef, signal: this.currentSignal });
       }
     );
     return diffText;
@@ -51284,15 +51476,17 @@ ${body}
   async scroll(opts) {
     let result;
     let label;
-    if (opts.toRef) {
+    const withinRef = normalizeRef(opts.withinRef);
+    const toRef = normalizeRef(opts.toRef);
+    if (toRef) {
       result = await this.client.scroll(
         opts.direction,
         opts.amount,
-        opts.withinRef,
-        opts.toRef,
+        withinRef,
+        toRef,
         { signal: this.currentSignal }
       );
-      label = `toRef=${opts.toRef}`;
+      label = `toRef=${toRef}`;
     } else if (opts.x !== void 0 && opts.y !== void 0) {
       if (opts.x === 0 && opts.y === 0) {
         return "Error: Coordinate scroll at (0, 0) is invalid. The coordinates were likely defaulted instead of intentionally chosen. Use direction-based scroll, scroll to a ref, or provide real coordinates before retrying.";
@@ -51309,11 +51503,11 @@ ${body}
       result = await this.client.scroll(
         opts.direction,
         opts.amount,
-        opts.withinRef,
+        withinRef,
         void 0,
         { signal: this.currentSignal }
       );
-      label = `direction=${opts.direction}${opts.amount ? `, amount=${opts.amount}` : ""}${opts.withinRef ? `, withinRef=${opts.withinRef}` : ""}`;
+      label = `direction=${opts.direction}${opts.amount ? `, amount=${opts.amount}` : ""}${withinRef ? `, withinRef=${withinRef}` : ""}`;
     }
     const scrollInfo = typeof result === "object" && result !== null ? result.scrollInfo : void 0;
     if (scrollInfo && !scrollInfo.moved) {
@@ -51467,6 +51661,9 @@ ${header}
       if (message === "No downloads captured during this session.") {
         return `${message} Use browser_list_downloads after triggering a download, or try browser_pdf_read if the file opened inline instead of downloading.`;
       }
+      if (downloadId === 0 && message === "Download #0 not found. Use browser_list_downloads to see available downloads.") {
+        return "Download #0 was not found. Download ids start at 1; call browser_list_downloads and use the listed id, or omit downloadId to read the most recent download.";
+      }
       if (isMissingDownloadTempFileError(message)) {
         const label = downloadId !== null && downloadId !== void 0 ? `Download #${downloadId}` : "The most recent download";
         return `${label} was captured, but its temporary file is no longer available. Trigger the download again, then call browser_list_downloads and browser_read_download with the new id.`;
@@ -54653,6 +54850,42 @@ function resolveBrowserContextRequestUrl(url, pageUrl) {
     return url;
   }
 }
+function isRouteAlreadyHandledError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Route is already handled");
+}
+function createSingleUseContextRouteHandle(route, logger2) {
+  let handled = false;
+  const runOnce = async (action, fn) => {
+    if (handled) {
+      logger2.debug("[ContextRoute] Ignoring duplicate route action", { action });
+      return;
+    }
+    handled = true;
+    try {
+      await fn();
+    } catch (error) {
+      if (isRouteAlreadyHandledError(error)) {
+        logger2.debug("[ContextRoute] Route was already handled by Playwright", {
+          action,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+      throw error;
+    }
+  };
+  return {
+    fulfill: (opts) => runOnce("fulfill", () => route.fulfill(opts)),
+    continue: (opts) => runOnce("continue", () => route.continue(opts)),
+    request: () => ({
+      url: () => route.request().url(),
+      method: () => route.request().method(),
+      postData: () => route.request().postData(),
+      headers: () => route.request().headers()
+    })
+  };
+}
 var TOAST_SNAPSHOT_TTL = 5;
 function formatMcpResponse(input) {
   const lines = [];
@@ -54868,6 +55101,17 @@ function logLateRunCodeWaitRejection(logger2, kind, promise) {
     });
   });
 }
+function guardRunCodeFetch(logger2) {
+  return (...args) => {
+    const promise = globalThis.fetch(...args);
+    promise.catch((err) => {
+      logger2.debug("[DirectPlaywright] runCode fetch rejected after call", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    return promise;
+  };
+}
 function guardFileChooserWaitForEvent(page, logger2) {
   const originalWaitForEvent = page.waitForEvent;
   let guarded = 0;
@@ -56469,9 +56713,10 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
     let threwError = null;
     let aborted = runController.signal.aborted;
     let guardedWaits = { fileChooser: 0, request: 0, response: 0 };
+    const guardedFetch = guardRunCodeFetch(this.logger);
     try {
       if (!aborted) {
-        const fn = new Function("page", `return (async () => { ${code} })()`);
+        const fn = new Function("page", "fetch", `return (async () => { ${code} })()`);
         const abortPromise = new Promise((_, reject) => {
           runController.signal.addEventListener(
             "abort",
@@ -56479,7 +56724,7 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
             { once: true }
           );
         });
-        const inner = fn(page);
+        const inner = fn(page, guardedFetch);
         inner.catch((err) => {
           this.logger.debug("[DirectPlaywright] runCode orphan rejected after race", {
             error: err instanceof Error ? err.message : String(err)
@@ -56698,6 +56943,16 @@ ${warning}` : ""}`,
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      if (isPlaywrightTargetClosedError(err)) {
+        throw toBrowserActionTargetClosedError(err, {
+          operation: "click",
+          ref: ref2,
+          elementDesc,
+          lastKnownUrl: this.lastKnownUrl,
+          pendingCrashType: this._pendingCrashType,
+          pendingCrashUrl: this._pendingCrashUrl
+        });
+      }
       const isTimeout = message.includes("Timeout") || message.includes("timeout");
       if (isTimeout && preClickBox) {
         const centerX = Math.round(preClickBox.x + preClickBox.width / 2);
@@ -56849,6 +57104,7 @@ ${warning}` : ""}`,
     const dialogMsg = this.getPendingDialogMessage();
     if (dialogMsg) throw new Error(dialogMsg);
     const locator = await this.resolveRef(ref2);
+    await assertFillTargetEditable(locator, ref2, elementDesc);
     const timeout = opts?.timeoutMs ?? TIMEOUTS.TYPE;
     const inputType = await locator.evaluate((node) => node instanceof HTMLInputElement ? node.type : null).catch((err) => {
       this.logger.debug("[DirectPlaywright] Failed to inspect input type before typing", {
@@ -59477,15 +59733,7 @@ Legacy two-step (only if you need to change the action between calls): browser_h
     const context = await this.getContext();
     for (const route of routes) {
       await context.route(route.urlPattern, async (pwRoute) => {
-        await route.handler({
-          fulfill: (opts) => pwRoute.fulfill(opts),
-          continue: () => pwRoute.continue(),
-          request: () => ({
-            url: () => pwRoute.request().url(),
-            method: () => pwRoute.request().method(),
-            postData: () => pwRoute.request().postData()
-          })
-        });
+        await route.handler(createSingleUseContextRouteHandle(pwRoute, this.logger));
       });
     }
   }
@@ -59497,33 +59745,93 @@ Legacy two-step (only if you need to change the action between calls): browser_h
     return guessMimeType(filename);
   }
 };
-async function assertFillTargetEditable(locator, ref2, elementDesc) {
-  const probe = await locator.evaluate((el) => {
-    const element = el;
-    const htmlInput = element instanceof HTMLInputElement ? element : null;
-    const htmlTextArea = element instanceof HTMLTextAreaElement ? element : null;
-    const htmlSelect = element instanceof HTMLSelectElement ? element : null;
-    const htmlButton = element instanceof HTMLButtonElement ? element : null;
-    const ariaReadonly = element.getAttribute("aria-readonly") === "true";
-    const ariaDisabled = element.getAttribute("aria-disabled") === "true";
-    const contentEditableFalse = element.getAttribute("contenteditable") === "false";
-    return {
-      readonly: Boolean(
-        htmlInput?.readOnly || htmlTextArea?.readOnly || ariaReadonly || contentEditableFalse
-      ),
-      disabled: Boolean(
-        htmlInput?.disabled || htmlTextArea?.disabled || htmlSelect?.disabled || htmlButton?.disabled || ariaDisabled
-      ),
-      tagName: element.tagName.toLowerCase(),
-      role: element.getAttribute("role")
-    };
+function isPlaywrightTargetClosedError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Target page, context or browser has been closed/i.test(message);
+}
+function toBrowserActionTargetClosedError(error, context) {
+  const label = context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+  const message = error instanceof Error ? error.message : String(error);
+  const wrapped = new Error(`Browser click target closed for ${label}: ${message}`, {
+    cause: error instanceof Error ? error : void 0
   });
-  if (!probe.readonly && !probe.disabled) return;
-  const label = elementDesc ? `${elementDesc} (${ref2})` : ref2;
-  const state = probe.disabled ? "disabled" : "readonly";
+  wrapped.name = "BrowserActionTargetClosedError";
+  Object.assign(wrapped, { browserActionTargetClosed: context });
+  return wrapped;
+}
+function toFillTargetProbeError(error, context) {
+  const label = context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+  const message = error instanceof Error ? error.message : String(error);
+  const wrapped = new Error(`Fill target editability probe failed for ${label}: ${message}`, {
+    cause: error instanceof Error ? error : void 0
+  });
+  wrapped.name = "FillTargetProbeError";
+  Object.assign(wrapped, { fillTargetProbe: context });
+  return wrapped;
+}
+async function assertFillTargetEditable(locator, ref2, elementDesc) {
+  let probe;
+  try {
+    probe = await locator.evaluate((el) => {
+      const element = el;
+      const htmlInput = element instanceof HTMLInputElement ? element : null;
+      const htmlTextArea = element instanceof HTMLTextAreaElement ? element : null;
+      const htmlSelect = element instanceof HTMLSelectElement ? element : null;
+      const htmlButton = element instanceof HTMLButtonElement ? element : null;
+      const ariaReadonly = element.getAttribute("aria-readonly") === "true";
+      const ariaDisabled = element.getAttribute("aria-disabled") === "true";
+      const contentEditableFalse = element.getAttribute("contenteditable") === "false";
+      const inputType = htmlInput?.type.toLowerCase() ?? null;
+      const fillableInputTypes = /* @__PURE__ */ new Set([
+        "",
+        "color",
+        "date",
+        "datetime-local",
+        "email",
+        "month",
+        "number",
+        "password",
+        "range",
+        "search",
+        "tel",
+        "text",
+        "time",
+        "url",
+        "week"
+      ]);
+      return {
+        readonly: Boolean(
+          htmlInput?.readOnly || htmlTextArea?.readOnly || ariaReadonly || contentEditableFalse
+        ),
+        disabled: Boolean(
+          htmlInput?.disabled || htmlTextArea?.disabled || htmlSelect?.disabled || htmlButton?.disabled || ariaDisabled
+        ),
+        fillable: Boolean(
+          htmlInput && fillableInputTypes.has(inputType ?? "") || htmlTextArea || element.isContentEditable
+        ),
+        tagName: element.tagName.toLowerCase(),
+        role: element.getAttribute("role"),
+        inputType
+      };
+    });
+  } catch (error) {
+    throw toFillTargetProbeError(error, {
+      ref: ref2,
+      elementDesc,
+      stage: "editability_probe"
+    });
+  }
+  if (!probe.readonly && !probe.disabled && probe.fillable) return;
+  const state = probe.disabled ? "disabled" : probe.readonly ? "readonly" : "not-fillable";
   const tag = probe.tagName ?? "element";
-  const role = probe.role ? ` role=${probe.role}` : "";
-  throw new Error(`Cannot fill ${state} field ${label}: ${tag}${role} is not editable.`);
+  throw new FillTargetNotEditableError({
+    ref: ref2,
+    elementDesc,
+    state,
+    tagName: tag,
+    role: probe.role,
+    ...probe.inputType ? { inputType: probe.inputType } : {}
+  });
 }
 
 export {
@@ -59921,4 +60229,4 @@ playwright-extra/dist/index.esm.js:
    * @license MIT
    *)
 */
-//# sourceMappingURL=chunk-AI3Y3AZH.js.map
+//# sourceMappingURL=chunk-MO5G5TP5.js.map