@anvia/browser 1.0.7 → 1.0.10

package/MIGRATION.md

@@ -0,0 +1,68 @@
+# `@anvia/browser` migration notes
+
+## Selected-tab tools to explicit tabs
+
+Existing tools remain source compatible and connections still default to serial scheduling. Calls that
+omit `tabId` continue using the selected tab.
+
+To opt into independent-tab concurrency:
+
+```ts
+const connection = await browser.connect({
+  scheduling: { mode: "per-tab", maxConcurrentTabs: 8 },
+});
+
+const [{ id: first }, { id: second }] = await connection.listTabs();
+
+await Promise.all([
+  snapshot.call({ tabId: first }),
+  navigate.call({ tabId: second, url: "https://example.com" }),
+]);
+```
+
+Add `tabId` to `browser_navigate`, `browser_snapshot`, `browser_click`, `browser_type`,
+`browser_press_key`, and `browser_screenshot`. `browser_open_tab` returns the new stable ID. Selection is
+still useful for human-oriented or legacy serial workflows, but should not be shared mutable targeting
+state for concurrent agents. IDs are scoped to one connection; call `browser_list_tabs` after reconnect.
+
+A browser handle now allows one active or pending automation connection. Share that connection between
+agents that use the same browser, and disconnect it before reconnecting. This is required so one
+resource scheduler and navigation policy arbitrate the shared Chromium context deterministically.
+
+## All-or-nothing readiness to capabilities
+
+`waitUntilReady({ timeoutMs })` still waits for all runtime, browser, automation, and desktop
+capabilities. Consumers that do not require every capability should migrate to:
+
+```ts
+await browser.waitForCapabilities({
+  capabilities: ["desktop"],
+  timeoutMs: 10_000,
+  abortSignal,
+});
+
+const { capabilities } = browser.readiness();
+```
+
+Handle `BrowserError.capability` and preserve healthy capabilities when another is degraded.
+
+## Cancellation and errors
+
+Connection cancellation now terminates and joins an isolated Playwright worker. Cancelling an active
+page tool closes that tab because Playwright page actions do not accept `AbortSignal`; obtain a fresh tab
+ID before retrying. If page cleanup cannot finish, the entire connection closes and must be recreated.
+
+`destroy({ timeoutMs, abortSignal })` starts an irreversible terminal transition. If Docker cleanup
+cannot be cancelled, the caller now stops waiting at its own deadline while the handle remains
+`destroying` and retains ownership of the shared cleanup. A later `destroy()` call joins that operation;
+control cannot become active again while cleanup finishes.
+
+Prefer `error.retryable` and `error.recovery` over a closed switch on `error.code`. Legacy
+`human_controlled` remains active for an acquired lease; pending acquisition now uses
+`human_control_conflict`. Legacy `not_ready` remains available, while bounded connection and readiness
+operations use the more specific `connection_timeout` and `readiness_timeout` codes.
+
+`BrowserControlSnapshot` now includes required `state`, `availability`, `activeAgentActions`, and
+`humanPending` fields in addition to the existing mode and optional lease metadata. Consumers that
+provide a structural browser-control test double should add those fields; consumers that only read the
+snapshot remain source compatible.

package/README.md

@@ -1,7 +1,8 @@
 # `@anvia/browser`
 
-Visible Chromium ownership and semantic browser tools for Anvia agents. Docker infrastructure remains
-owned by `@anvia/sandbox`; this package owns the browser workload running inside that sandbox.
+Visible Chromium ownership and semantic browser tools for concurrent Anvia agents and human viewers.
+Docker infrastructure remains owned by `@anvia/sandbox`; this package owns the browser workload,
+capability readiness, isolated Playwright connection, action scheduling, and control arbitration.
 
 ```ts
 import { DockerBrowserClient, createBrowserTools } from "@anvia/browser";
@@ -13,7 +14,7 @@ const browserClient = new DockerBrowserClient({
   image: "ghcr.io/anvia-hq/browser@sha256:...",
 });
 
-await browserClient.pullImage();
+await browserClient.pullImage({ timeoutMs: 120_000 });
 await using browser = await browserClient.createBrowser({
   workspace: { type: "ephemeral" },
   network: { mode: "bridge" },
@@ -24,8 +25,19 @@ await using browser = await browserClient.createBrowser({
   },
 });
 
-await browser.waitUntilReady({ timeoutMs: 30_000 });
-await using connection = await browser.connect();
+await browser.waitForCapabilities({
+  capabilities: ["automation", "desktop"],
+  timeoutMs: 30_000,
+});
+
+await using connection = await browser.connect({
+  timeoutMs: 30_000,
+  scheduling: {
+    mode: "per-tab",
+    maxConcurrentTabs: 8,
+    maxQueuedActions: 1_000,
+  },
+});
 
 const tools = createBrowserTools({
   connection,
@@ -47,34 +59,196 @@ const tools = createBrowserTools({
 const agent = new Agent({ id: "browser-agent", model, tools });
 ```
 
-The client constructor performs no I/O. `pullImage()`, `createBrowser()`, readiness, and CDP
-connection are separate operations. `DockerBrowser` owns the underlying sandbox. A
-`PlaywrightBrowserConnection` owns only its CDP connection and never destroys the browser.
+The client constructor performs no I/O. Image pull, create/resume, readiness, and CDP connection are
+separate bounded operations. `DockerBrowser` owns the sandbox; a `PlaywrightBrowserConnection` owns
+only its automation worker and CDP connection. Disconnecting automation never destroys Chromium.
+
+## Lifecycle and cancellation
+
+Playwright and its CDP protocol state run in a supervised child process, one per connection. This is an
+intentional fault-containment boundary: Playwright 1.62.1 normally aborts its progress scope and closes
+the transport on timeout, but an internal exception raised by a late protocol message is outside the
+rejected `connectOverCDP()` promise. An in-process wrapper cannot guarantee host survival in that case.
+The child boundary contains that exception without installing process-global `uncaughtException` or
+`unhandledRejection` handlers.
+
+`connect()` defaults to 30 seconds and passes the remaining budget to Playwright. Caller cancellation,
+timeout, stop, and destroy terminate and join the worker before the attempt rejects. A worker response
+that loses the cancellation race is ignored. A failed attempt owns no state in `DockerBrowser`, so a
+later call starts a clean attempt.
+
+Image pull, create, resume, stop, and destroy accept `timeoutMs` and `abortSignal`; their default budget
+is 120 seconds. `disconnect()` defaults to 10 seconds. Docker sandbox destruction is irreversible and
+cannot currently be cancelled. Once it starts, timeout or cancellation bounds only that caller's wait:
+the browser remains visibly `destroying`, owns the eventual completion, and makes later `destroy()`
+calls join the same cleanup. Late completion can only transition the terminal handle to `destroyed` or
+`error`; it cannot restore agent or human control.
+Timeout values are integer milliseconds from 1 through `2_147_483_647`, matching Node's timer range.
+
+`stop()` first cancels pending readiness/connect work, disconnects all automation workers, and then
+stops the sandbox. It also cancels pending human acquisition and releases an active lease, while
+preserving the container. `resumeBrowser({ id })` returns a new handle and requires new readiness and
+automation connections. `destroy()` is idempotent, joins pending work, invalidates human-control leases,
+and removes the sandbox. Destroy remains available after a failed stop.
+Concurrent stop, destroy, or disconnect calls join the first shared transition. A later caller's own
+timeout or cancellation bounds its wait without rolling back that already-visible `stopping`,
+`destroying`, or closed transition.
+
+## Capability readiness
+
+Readiness is not all-or-nothing:
+
+| Capability   | What is proven                                                                                            |
+| ------------ | --------------------------------------------------------------------------------------------------------- |
+| `runtime`    | The Docker browser handle and sandbox are running.                                                        |
+| `browser`    | Chromium's CDP port is reachable and `/json/version` exposes a WebSocket debugger URL.                    |
+| `automation` | An isolated Playwright CDP connection initializes, exposes a context, and completes `Browser.getVersion`. |
+| `desktop`    | The noVNC port and HTTP client page respond successfully.                                                 |
+
+Use `waitForCapabilities()` to wait only for required capabilities and receive a
+`BrowserReadinessSnapshot`. `waitUntilReady()` remains available and defaults to all four capabilities.
+Both accept a required timeout and optional `AbortSignal`. `readiness()` is synchronous and reports
+`unknown`, `checking`, `partial`, `ready`, `degraded`, `failed`, `stopped`, or `destroyed` state
+without probing. `partial` means some capabilities are ready while others have not been checked;
+`degraded` means at least one checked capability failed while another remains usable.
+
+Desktop probing never establishes Playwright. A failed automation probe can therefore leave desktop
+ready and the runtime degraded. Retrying readiness replaces the requested capabilities' prior failed
+state. Caller cancellation restores their previous state. Stop and destroy abort and join every probe.
+
+```ts
+await browser.waitForCapabilities({ capabilities: ["desktop"], timeoutMs: 10_000 });
+const snapshot = browser.readiness();
+
+if (snapshot.capabilities.automation.state === "failed") {
+  // The desktop may still be offered to a human while automation is retried or restarted.
+}
+```
+
+## Concurrency guarantees
+
+The default `{ mode: "serial" }` scheduling preserves the original selected-tab behavior: every tool
+call on the connection executes in one bounded FIFO queue. This is the compatibility mode.
+
+`{ mode: "per-tab" }` enables resource-scoped scheduling:
+
+- Mutating operations for the same tab are FIFO and never overlap.
+- Operations for different explicit tab IDs may overlap up to `maxConcurrentTabs` (default 8).
+- Tab creation, listing, selection, and closure use a browser-context lock where necessary.
+- A close marks its tab as closing before it queues. Work already queued runs first; later work is
+  rejected with `invalid_state`.
+- One failed operation releases its queue. Cancelling one tab closes that page to stop uncancellable
+  Playwright work, then releases only that tab queue.
+- If page cleanup itself cannot settle within five seconds, the worker is terminated and consumers
+  reconnect. This fail-closed fallback can interrupt other tabs on that connection.
+- Queue admission is bounded by `maxQueuedActions` (default 1,000) and ready tab queues are scheduled
+  FIFO, one operation per turn, to avoid starvation.
+- Disconnect, stop, or destroy reject queued work with a structured lifecycle error.
+
+Concurrent tool dispatch does not imply concurrent execution when calls contend for the same tab,
+browser-context state, selected-tab compatibility lock, or human-control gate.
+
+Page tools now accept an optional `tabId`: `browser_navigate`, `browser_snapshot`, `browser_click`,
+`browser_type`, `browser_press_key`, and `browser_screenshot`. Omitting it uses selected-tab compatibility
+behavior. Obtain stable IDs from `browser_list_tabs` or `browser_open_tab`.
+Tab IDs are stable for one automation connection; reconnecting creates a fresh ID namespace, so list
+tabs again after reconnect.
+
+The scheduling domain is one connection, and a `DockerBrowser` handle permits one active or pending
+automation connection at a time. A second `connect()` rejects with `agent_action_busy`; share the first
+connection among agents and dispatch explicit-tab work through it. This prevents independent workers,
+ID namespaces, navigation-policy installations, and queues from racing over the same Chromium context.
+Disconnect before creating a replacement connection. Automation readiness may use a short-lived,
+non-mutating probe connection. Human control remains runtime-wide.
+
+```ts
+await Promise.all([
+  snapshotTool.call({ tabId: researchTabId }),
+  navigateTool.call({ tabId: monitoringTabId, url: "https://status.example.com" }),
+]);
+```
+
+## Human and agent control
+
+Human control is browser-wide and exclusive. Acquisition defaults to a 30-second wait and also accepts
+`timeoutMs` and `abortSignal`. The arbitration policy is:
+
+- Acquisition waits for active agent operations to finish.
+- Pending acquisition rejects work that has not entered the control gate, including queued and newly
+  dispatched work, with `human_control_conflict`.
+- An active lease rejects agent work with the backward-compatible `human_controlled` code.
+- A second acquisition is rejected; there is never more than one pending waiter or active lease.
+- Cancellation/timeout removes pending state before rejecting.
+- Renewal replaces the expiration timer atomically. Release, expiration, and destroy are idempotent.
+- Agent work resumes after release or expiration.
+
+`browser.desktop.control.snapshot()` reports `state` (`agent`, `agent-active`, `human-pending`, or
+`human`), `activeAgentActions`, `humanPending`, lease data, and availability (`available`, `degraded`,
+`disconnected`, or `destroyed`).
 
-`stop()` preserves the container. `resumeBrowser({ id })` starts a fresh browser service and requires
-a new readiness check and CDP connection. A named Docker volume preserves Chromium profile state even
-when the browser container is destroyed and later recreated with that volume.
+## Errors and recovery
 
-The browser tools use ARIA state and strict Playwright locators. They do not expose JavaScript
-evaluation, raw CDP, coordinate input, shell access, hidden retries, or automatic reconnection.
-Aborting an action that Playwright cannot cancel closes the CDP connection and leaves the browser
-running. The selected navigation policy is installed across the connection, so top-level navigation
-from links, forms, redirects, popups, and direct navigation is checked consistently. It does not block
-third-party subresources; Docker bridge networking remains outside that policy.
+Operational failures from public browser lifecycle/tool wrappers reject with `BrowserError`. Invalid
+API arguments still throw `TypeError` or `RangeError`. The original operational error is retained as
+`cause`; `code`, `retryable`, `recovery`, `phase`, and optional readiness `capability` support policy
+decisions.
 
-The image runs Chromium as a non-root user with Chromium sandboxing, the pinned Playwright seccomp
-profile, every Linux capability dropped except the explicit `SYS_CHROOT` capability required by the
-namespace sandbox, no-new-privileges, and private shared memory. Startup fails rather than silently
-switching Chromium to `--no-sandbox`. Docker bridge networking is not an SSRF boundary; use
-infrastructure network policy where browsing untrusted destinations requires isolation.
+`retryable` describes whether the runtime has a documented recovery path; it does not make a mutating
+tool call idempotent. After a timeout or transport loss, inspect or refresh tab state before deciding
+whether replaying navigation, typing, clicking, or key input is safe.
+
+| Codes                                                                   | Typical recovery                                                    |
+| ----------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| `cancelled`, `action_timeout`, `lifecycle_timeout`, `agent_action_busy` | Retry the operation when appropriate.                               |
+| `human_control_conflict`, `human_controlled`                            | Wait for acquisition/lease release or expiration.                   |
+| `readiness_timeout`, `not_ready`                                        | Retry the failed capability; inspect `capability`.                  |
+| `connection_timeout`, `connection_closed`, `transport_failure`          | Disconnect if needed, then create a new connection.                 |
+| `tool_failed`                                                           | Retry the tool if its inputs and tab are still valid.               |
+| `invalid_state`                                                         | Refresh tabs/state; restart when the runtime is stopped or errored. |
+| `navigation_blocked`                                                    | Do not retry unchanged input; update the explicit policy or URL.    |
+| `startup_failed`                                                        | Recreate the runtime after fixing image/runtime configuration.      |
+| `runtime_destroyed`                                                     | Create or resume a new runtime handle.                              |
+
+The legacy `not_ready` and `human_controlled` codes remain in the public union. New code should use
+`retryable` and `recovery` rather than hard-coding all recovery policy.
+
+## Browser tools and security
+
+The tools use ARIA state and strict Playwright locators. They do not expose JavaScript evaluation, raw
+CDP, coordinate input, shell access, hidden action retries, or automatic reconnection. The navigation
+policy is installed across the default browser context, so top-level navigation from links, forms,
+redirects, popups, and direct navigation is checked consistently. It does not block third-party
+subresources; Docker bridge networking remains outside that policy.
+
+The image runs Chromium as a non-root user with Chromium sandboxing, the Playwright seccomp profile,
+every Linux capability dropped except `SYS_CHROOT`, no-new-privileges, and private shared memory.
+Startup fails rather than switching Chromium to `--no-sandbox`. Docker bridge networking is not an SSRF
+boundary; use infrastructure network policy for untrusted destinations.
+
+The automation child process is a crash-containment boundary, not a privilege or tenant-isolation
+boundary. It inherits the host application's OS identity; the Docker browser sandbox and application
+authorization remain the security boundaries.
 
 The VNC protocol uses exactly eight printable ASCII password characters. noVNC is published only on a
 host-loopback Docker port, raw VNC is not published, and the password is not placed in image metadata,
 URLs, environment variables, or logs.
 
+## Playwright and Node compatibility
+
+The host package and browser image pin `playwright-core` 1.62.1 together. Playwright requires matching
+browser/package releases for its bundled browser and declares Node `>=20`; its current system matrix is
+the latest Node 22, 24, or 26. Anvia CI uses Node 24, and the isolation regression test also runs on the
+active host Node version. The package keeps its existing Node `>=20.12` engine for source compatibility,
+but production deployments should use a currently supported Node 22, 24, or 26 release. Keep the image
+and package pin aligned when upgrading.
+
+The CDP connection is lower fidelity than Playwright's native protocol, but a native Playwright server
+would conflict with this runtime's persistent, human-visible Chromium ownership. CDP remains the
+appropriate protocol; isolation contains its in-process failure modes.
+
 ## Studio desktop and takeover
 
-`browser.desktop` is structurally compatible with Studio without creating a package dependency:
+`browser.desktop` remains structurally compatible with Studio without a package dependency:
 
 ```ts
 const studio = new Studio([agent], {
@@ -99,8 +273,10 @@ const studio = new Studio([agent], {
 
 Use `{ mode: "authorize", authorize }` when Studio is reachable remotely. The callback is invoked for
 the viewer connection, WebSocket upgrade, and every control operation. When the registered agent uses a
-matching browser tool, Studio opens its clean programmatic noVNC viewer in a resizable Playground panel;
+matching browser tool, Studio opens its programmatic noVNC viewer in a resizable Playground panel;
 there is no stock noVNC toolbar, splash, or password prompt. Closing the panel restores Sessions and an
-**Open browser** action restores the current desktop. Studio human takeover waits for an active agent
-action, blocks new browser tool actions, and expires unless the Studio viewer renews its lease. Takeover
+**Open browser** action restores the current desktop. Studio human takeover waits for active agent
+actions, blocks new browser tool actions, and expires unless the viewer renews its lease. Takeover
 coordinates trusted viewers; application authorization remains the security boundary.
+
+See [MIGRATION.md](./MIGRATION.md) for selected-tab and readiness migration examples.

package/dist/automation-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/automation-worker.js

@@ -0,0 +1,298 @@
+// src/automation-worker.ts
+import { randomUUID } from "crypto";
+import { chromium } from "playwright-core";
+var browser;
+var selected;
+var tabIds = /* @__PURE__ */ new WeakMap();
+var pagesById = /* @__PURE__ */ new Map();
+var operations = /* @__PURE__ */ new Map();
+var navigationPolicyKey;
+process.once("disconnect", () => {
+  void closeAfterParentExit();
+});
+process.on("message", (message) => {
+  if (message.kind === "cancel") {
+    void cancelOperation(message);
+    return;
+  }
+  void runRequest(message);
+});
+async function runRequest(request) {
+  let complete;
+  const operation = {
+    cancelled: false,
+    completed: new Promise((resolve) => {
+      complete = resolve;
+    }),
+    complete: () => complete?.()
+  };
+  operations.set(request.id, operation);
+  try {
+    const value = await execute(request, operation);
+    send({ kind: "response", id: request.id, ok: true, value });
+  } catch (error) {
+    send({ kind: "response", id: request.id, ok: false, error: serializeError(error) });
+  } finally {
+    operation.complete();
+    operations.delete(request.id);
+  }
+}
+async function cancelOperation(request) {
+  const operation = operations.get(request.id);
+  if (operation !== void 0) {
+    operation.cancelled = true;
+    await operation.page?.close().catch(() => void 0);
+    await operation.completed;
+  }
+  send({ kind: "cancelled", id: request.id });
+}
+async function execute(request, operation) {
+  const command = request;
+  switch (command.method) {
+    case "connect": {
+      if (browser !== void 0) throw new Error("Automation worker is already connected.");
+      const connected = await chromium.connectOverCDP(command.params.endpointUrl, {
+        timeout: command.params.timeoutMs
+      });
+      try {
+        if (operation.cancelled) throw new Error("Connection attempt was cancelled.");
+        const context = connected.contexts()[0];
+        if (context === void 0) {
+          throw new Error("CDP connection did not expose a browser context.");
+        }
+        const session = await connected.newBrowserCDPSession();
+        try {
+          await session.send("Browser.getVersion");
+        } finally {
+          await session.detach().catch(() => void 0);
+        }
+        if (operation.cancelled) throw new Error("Connection attempt was cancelled.");
+      } catch (error) {
+        await connected.close().catch(() => void 0);
+        throw error;
+      }
+      browser = connected;
+      selected = pages()[0];
+      for (const page of pages()) idFor(page);
+      connected.once("disconnected", () => {
+        browser = void 0;
+        send({ kind: "event", event: "disconnected" });
+      });
+      return void 0;
+    }
+    case "disconnect": {
+      const connected = browser;
+      browser = void 0;
+      selected = void 0;
+      if (connected !== void 0) await connected.close();
+      return void 0;
+    }
+    case "listTabs":
+      return tabSummaries();
+    case "setNavigationPolicy":
+      await setNavigationPolicy(command.params.policy);
+      return void 0;
+    case "openTab": {
+      const context = assertBrowser().contexts()[0];
+      if (context === void 0) throw new Error("Browser has no CDP context.");
+      const page = await context.newPage();
+      operation.page = page;
+      if (operation.cancelled) {
+        await page.close().catch(() => void 0);
+        throw new Error("Open-tab operation was cancelled.");
+      }
+      selected = page;
+      return tabResult(page);
+    }
+    case "selectTab": {
+      const page = pageFor(command.params.tabId);
+      selected = page;
+      return tabResult(page);
+    }
+    case "closeTab": {
+      const page = pageFor(command.params.tabId);
+      operation.page = page;
+      await page.close();
+      if (page === selected) selected = pages()[0];
+      return { closedTabId: command.params.tabId, tabs: await tabSummaries() };
+    }
+    case "navigate": {
+      const page = targetPage(command.params.tabId, operation);
+      await page.goto(command.params.url, {
+        timeout: command.params.timeoutMs,
+        waitUntil: command.params.waitUntil
+      });
+      return tabResult(page);
+    }
+    case "snapshot": {
+      const page = targetPage(command.params.tabId, operation);
+      const snapshot = await page.locator("body").ariaSnapshot({
+        timeout: command.params.timeoutMs
+      });
+      const truncated = snapshot.length > command.params.maxChars;
+      return {
+        ...await tabResult(page),
+        snapshot: truncated ? snapshot.slice(0, command.params.maxChars) : snapshot,
+        truncated
+      };
+    }
+    case "click": {
+      const page = targetPage(command.params.tabId, operation);
+      await locatorFor(page, command.params.target).click({ timeout: command.params.timeoutMs });
+      return tabResult(page);
+    }
+    case "type": {
+      const page = targetPage(command.params.tabId, operation);
+      await locatorFor(page, command.params.target).fill(command.params.text, {
+        timeout: command.params.timeoutMs
+      });
+      return tabResult(page);
+    }
+    case "pressKey": {
+      const page = targetPage(command.params.tabId, operation);
+      await page.keyboard.press(command.params.key);
+      return tabResult(page);
+    }
+    case "screenshot": {
+      const page = targetPage(command.params.tabId, operation);
+      const png = await page.screenshot({
+        type: "png",
+        fullPage: false,
+        timeout: command.params.timeoutMs
+      });
+      return { metadata: await tabResult(page), pngBase64: png.toString("base64") };
+    }
+  }
+}
+function assertBrowser() {
+  if (browser === void 0 || !browser.isConnected())
+    throw new Error("Browser connection is closed.");
+  return browser;
+}
+function pages() {
+  return browser?.contexts().flatMap((context) => context.pages()) ?? [];
+}
+function idFor(page) {
+  const existing = tabIds.get(page);
+  if (existing !== void 0) return existing;
+  const id = randomUUID();
+  tabIds.set(page, id);
+  pagesById.set(id, page);
+  page.once("close", () => pagesById.delete(id));
+  return id;
+}
+function pageFor(id) {
+  assertBrowser();
+  const page = pagesById.get(id);
+  if (page === void 0 || page.isClosed() || !pages().includes(page)) {
+    throw new Error(`Browser tab does not exist: ${id}`);
+  }
+  return page;
+}
+function targetPage(id, operation) {
+  const page = pageFor(id);
+  operation.page = page;
+  return page;
+}
+async function tabSummaries() {
+  assertBrowser();
+  if (selected?.isClosed()) selected = pages()[0];
+  return Promise.all(
+    pages().map(async (page) => ({
+      id: idFor(page),
+      title: await page.title(),
+      url: page.url(),
+      selected: page === selected
+    }))
+  );
+}
+async function tabResult(page) {
+  return { tabId: idFor(page), title: await page.title(), url: page.url() };
+}
+async function setNavigationPolicy(policy) {
+  const key = JSON.stringify(policy);
+  if (navigationPolicyKey !== void 0) {
+    if (navigationPolicyKey !== key) {
+      throw new TypeError("Browser connection already has a different navigation policy.");
+    }
+    return;
+  }
+  navigationPolicyKey = key;
+  await Promise.all(
+    assertBrowser().contexts().map((context) => context.route("**/*", (route) => enforceNavigationPolicy(route, policy)))
+  );
+}
+async function enforceNavigationPolicy(route, policy) {
+  const request = route.request();
+  const frame = request.frame();
+  if (request.isNavigationRequest() && frame === frame.page().mainFrame() && !isNavigationAllowed(request.url(), policy)) {
+    await route.abort("blockedbyclient");
+    return;
+  }
+  await route.continue();
+}
+function isNavigationAllowed(value, policy) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  if (url.username.length > 0 || url.password.length > 0) return false;
+  return policy.mode === "allow-all-http" || policy.origins.includes(url.origin);
+}
+function locatorFor(page, target) {
+  switch (target.by) {
+    case "role": {
+      const options = {};
+      if (target.name !== void 0) options.name = target.name;
+      if (target.exact !== void 0) options.exact = target.exact;
+      return page.getByRole(target.role, options);
+    }
+    case "text": {
+      const options = {};
+      if (target.exact !== void 0) options.exact = target.exact;
+      return page.getByText(target.text, options);
+    }
+    case "label": {
+      const options = {};
+      if (target.exact !== void 0) options.exact = target.exact;
+      return page.getByLabel(target.label, options);
+    }
+    case "placeholder": {
+      const options = {};
+      if (target.exact !== void 0) options.exact = target.exact;
+      return page.getByPlaceholder(target.placeholder, options);
+    }
+    case "test-id":
+      return page.getByTestId(target.testId);
+    case "css":
+      return page.locator(target.selector);
+  }
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    const value = {
+      name: error.name,
+      message: error.message
+    };
+    if (error.stack !== void 0) value.stack = error.stack;
+    if ("code" in error && typeof error.code === "string") value.code = error.code;
+    return value;
+  }
+  return { name: "Error", message: String(error) };
+}
+function send(message) {
+  if (!process.connected || process.send === void 0) return;
+  process.send(message, () => void 0);
+}
+async function closeAfterParentExit() {
+  const forceExit = setTimeout(() => process.exit(1), 2e3);
+  const connected = browser;
+  browser = void 0;
+  await connected?.close().catch(() => void 0);
+  clearTimeout(forceExit);
+  process.exit(0);
+}
+//# sourceMappingURL=automation-worker.js.map