@wrongstack/tools 0.313.0 → 0.316.1

package/dist/browser/index.js

@@ -1,1347 +1,33 @@
-// src/browser/artifacts.ts
-import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { atomicWrite, ulid } from "@wrongstack/core/utils";
-var ARTIFACT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
-var sweptRoots = /* @__PURE__ */ new Set();
-var MAX_SWEPT_ROOTS = 128;
-function sweepOldArtifacts(root) {
-  if (sweptRoots.has(root)) return;
-  while (sweptRoots.size >= MAX_SWEPT_ROOTS) {
-    const oldest = sweptRoots.values().next().value;
-    if (oldest === void 0) break;
-    sweptRoots.delete(oldest);
-  }
-  sweptRoots.add(root);
-  void (async () => {
-    const cutoff = Date.now() - ARTIFACT_RETENTION_MS;
-    let sessionDirs;
-    try {
-      const entries = await fs.readdir(root, { withFileTypes: true });
-      sessionDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    } catch {
-      return;
-    }
-    for (const sessionDir of sessionDirs) {
-      const dir = path.join(root, sessionDir);
-      let names;
-      try {
-        names = await fs.readdir(dir);
-      } catch {
-        continue;
-      }
-      let removed = 0;
-      for (const name of names) {
-        const target = path.join(dir, name);
-        try {
-          const stat3 = await fs.stat(target);
-          if (stat3.isFile() && stat3.mtimeMs < cutoff) {
-            await fs.rm(target, { force: true });
-            removed++;
-          }
-        } catch {
-        }
-      }
-      if (removed === names.length && names.length > 0) {
-        await fs.rmdir(dir).catch(() => void 0);
-      }
-    }
-  })();
-}
-var BrowserArtifactStore = class {
-  constructor(root) {
-    this.root = root;
-    sweepOldArtifacts(root);
-  }
-  root;
-  async write(sessionId, kind, extension, mimeType, content) {
-    const id = ulid();
-    const dir = path.join(this.root, safeSegment(sessionId));
-    const target = path.join(dir, `${id}.${extension.replace(/^\./, "")}`);
-    await atomicWrite(target, content, { mode: 384 });
-    return this.record(id, sessionId, kind, target, mimeType);
-  }
-  async record(id, sessionId, kind, target, mimeType) {
-    await fs.chmod(target, 384).catch(() => void 0);
-    const [stat3, sha256] = await Promise.all([fs.stat(target), hashFile(target)]);
-    const artifact = {
-      id,
-      kind,
-      sensitivity: "sensitive",
-      path: target,
-      mimeType,
-      sizeBytes: stat3.size,
-      sha256,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const metadataPath = path.join(path.dirname(target), `${id}.metadata.json`);
-    try {
-      await atomicWrite(
-        metadataPath,
-        `${JSON.stringify({
-          id: artifact.id,
-          sessionId: safeSegment(sessionId),
-          kind: artifact.kind,
-          sensitivity: artifact.sensitivity,
-          mimeType: artifact.mimeType,
-          sizeBytes: artifact.sizeBytes,
-          sha256: artifact.sha256,
-          createdAt: artifact.createdAt
-        })}
-`,
-        { mode: 384 }
-      );
-    } catch (error) {
-      await fs.rm(target, { force: true }).catch(() => void 0);
-      throw error;
-    }
-    return artifact;
-  }
-  pathFor(sessionId, extension) {
-    const id = ulid();
-    return {
-      id,
-      path: path.join(this.root, safeSegment(sessionId), `${id}.${extension.replace(/^\./, "")}`)
-    };
-  }
-  async describe(id, kind, target, mimeType) {
-    return this.record(id, path.basename(path.dirname(target)), kind, target, mimeType);
-  }
-};
-async function hashFile(target) {
-  const hash = createHash("sha256");
-  await new Promise((resolve3, reject) => {
-    const stream = createReadStream(target);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.once("error", reject);
-    stream.once("end", resolve3);
-  });
-  return hash.digest("hex");
-}
-function safeSegment(value) {
-  return value.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80);
-}
-
-// src/browser/manager.ts
-import * as fs2 from "node:fs/promises";
-import * as path2 from "node:path";
-import { ulid as ulid2 } from "@wrongstack/core/utils";
-
-// src/browser/network-guard-proxy.ts
-import * as http from "node:http";
-import * as net2 from "node:net";
-
-// src/browser/security.ts
-import * as dns from "node:dns/promises";
-import * as net from "node:net";
-import { assertNotPrivateHost, isPrivateIPv4, isPrivateIPv6 } from "@wrongstack/core/utils";
-var SAFE_SUBRESOURCE_PROTOCOLS = /* @__PURE__ */ new Set(["about:", "blob:", "data:"]);
-async function assertBrowserUrlAllowed(rawUrl, opts) {
-  const url = parseBrowserUrl(rawUrl, opts.navigation ?? true);
-  if (!opts.navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
-  if (!opts.allowPrivateHosts && !isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins)) {
-    await assertNotPrivateHost(url.hostname);
-  }
-  return url;
-}
-async function resolvePinnedBrowserTarget(rawUrl, opts = {}) {
-  const url = parseBrowserUrl(rawUrl, true);
-  const allowPrivate = opts.allowPrivateHosts === true || isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins);
-  const hostname = unbracket(url.hostname);
-  const literalFamily = net.isIP(hostname);
-  if (literalFamily === 4 || literalFamily === 6) {
-    if (!allowPrivate && isPrivateAddress(hostname, literalFamily)) {
-      throw new Error(`browser: blocked private/loopback address "${hostname}"`);
-    }
-    return { url, address: hostname, family: literalFamily };
-  }
-  if ((hostname === "localhost" || hostname.endsWith(".localhost")) && !allowPrivate) {
-    throw new Error("browser: blocked localhost target");
-  }
-  const lookup2 = opts.lookup ?? ((host) => dns.lookup(host, { all: true }));
-  let records;
-  try {
-    records = await lookup2(hostname);
-  } catch (error) {
-    throw new Error(
-      `browser: DNS resolution failed for "${hostname}": ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (records.length === 0) throw new Error(`browser: DNS returned no addresses for "${hostname}"`);
-  for (const record of records) {
-    if (record.family !== 4 && record.family !== 6) {
-      throw new Error(`browser: DNS returned an unsupported address family for "${hostname}"`);
-    }
-    if (!allowPrivate && isPrivateAddress(record.address, record.family)) {
-      throw new Error(`browser: resolved to private address ${record.address}`);
-    }
-  }
-  const selected = records[0];
-  return { url, address: selected.address, family: selected.family };
-}
-function parsePrivateOriginAllowlist(raw) {
-  if (!raw?.trim()) return [];
-  const origins = /* @__PURE__ */ new Set();
-  for (const entry of raw.split(",")) {
-    const candidate = entry.trim().replace(/^["']+|["']+$/gu, "");
-    if (!candidate) continue;
-    const url = parseBrowserUrl(candidate, true);
-    if (url.pathname !== "/" || url.search || url.hash) {
-      throw new Error(`browser: private origin allowlist entry must be an origin: "${candidate}"`);
-    }
-    origins.add(url.origin);
-  }
-  return [...origins];
-}
-function parseBrowserUrl(rawUrl, navigation) {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    throw new Error("browser: url must be an absolute URL");
-  }
-  if (!navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error(`browser: unsupported protocol "${url.protocol}"`);
-  }
-  if (url.username || url.password) {
-    throw new Error("browser: credentials in URLs are not allowed");
-  }
-  return url;
-}
-function isAllowedPrivateOrigin(url, origins) {
-  return origins?.includes(url.origin) ?? false;
-}
-function isPrivateAddress(address, family) {
-  return family === 4 ? isPrivateIPv4(address) : isPrivateIPv6(address);
-}
-function unbracket(hostname) {
-  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-}
-function safeBrowserUrl(rawUrl) {
-  try {
-    const url = new URL(rawUrl);
-    url.username = "";
-    url.password = "";
-    url.search = "";
-    url.hash = "";
-    return url.toString();
-  } catch {
-    return "about:blank";
-  }
-}
-function redactBrowserText(text) {
-  return text.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
-    /\b(api[-_ ]?key|access[-_ ]?token|auth[-_ ]?token|token|password|secret)\b\s*[:=]\s*[^\s,;]+/gi,
-    "$1=[REDACTED]"
-  );
-}
-
-// src/browser/network-guard-proxy.ts
-var BrowserNetworkGuardProxy = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.server = http.createServer((request2, response) => {
-      void this.forwardHttp(request2, response);
-    });
-    this.server.on("connect", (request2, socket, head) => {
-      void this.forwardConnect(request2, socket, head);
-    });
-    this.server.on("upgrade", (request2, socket, head) => {
-      void this.forwardUpgrade(request2, socket, head);
-    });
-    this.server.on("connection", (socket) => {
-      this.sockets.add(socket);
-      socket.once("close", () => this.sockets.delete(socket));
-      socket.on("error", () => {
-        socket.destroy();
-      });
-    });
-    this.server.on("clientError", (_error, socket) => {
-      socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
-    });
-  }
-  options;
-  server;
-  sockets = /* @__PURE__ */ new Set();
-  startPromise;
-  url;
-  async start() {
-    if (this.url) return this.url;
-    if (this.startPromise) return this.startPromise;
-    this.startPromise = new Promise((resolve3, reject) => {
-      const onError = (error) => {
-        this.server.off("listening", onListening);
-        reject(error);
-      };
-      const onListening = () => {
-        this.server.off("error", onError);
-        const address = this.server.address();
-        if (!address || typeof address === "string") {
-          reject(new Error("browser: network guard proxy failed to bind"));
-          return;
-        }
-        this.url = `http://127.0.0.1:${address.port}`;
-        resolve3(this.url);
-      };
-      this.server.once("error", onError);
-      this.server.once("listening", onListening);
-      this.server.listen(0, "127.0.0.1");
-    }).finally(() => {
-      this.startPromise = void 0;
-    });
-    return this.startPromise;
-  }
-  async close() {
-    this.url = void 0;
-    for (const socket of this.sockets) socket.destroy();
-    this.sockets.clear();
-    if (!this.server.listening) return;
-    await new Promise((resolve3) => this.server.close(() => resolve3()));
-  }
-  async forwardHttp(request2, response) {
-    try {
-      const target = await this.resolve(request2.url ?? "");
-      if (target.url.protocol !== "http:") throw new Error("browser: HTTPS must use CONNECT");
-      const headers = sanitizeHeaders(request2.headers);
-      headers.host = target.url.host;
-      const upstream = http.request({
-        host: target.address,
-        family: target.family,
-        port: Number(target.url.port || 80),
-        method: request2.method,
-        path: `${target.url.pathname}${target.url.search}`,
-        headers,
-        agent: false
-      });
-      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => {
-        upstream.destroy(new Error("browser: upstream connection timed out"));
-      });
-      upstream.on("response", (upstreamResponse) => {
-        response.writeHead(
-          upstreamResponse.statusCode ?? 502,
-          sanitizeHeaders(upstreamResponse.headers)
-        );
-        upstreamResponse.pipe(response);
-      });
-      upstream.on("error", () => writeProxyError(response, 502, "Bad Gateway"));
-      request2.on("aborted", () => upstream.destroy());
-      request2.pipe(upstream);
-    } catch (error) {
-      writeProxyError(response, 403, policyBlockMessage(error));
-    }
-  }
-  async forwardConnect(request2, client, head) {
-    try {
-      const authority = request2.url ?? "";
-      const target = await this.resolve(`https://${authority}`);
-      const upstream = net2.connect({
-        host: target.address,
-        family: target.family,
-        port: Number(target.url.port || 443)
-      });
-      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => upstream.destroy());
-      const onConnectError = () => {
-        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
-      };
-      upstream.once("error", onConnectError);
-      upstream.once("connect", () => {
-        upstream.off("error", onConnectError);
-        client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-        if (head.length > 0) upstream.write(head);
-        pipeDuplexPair(upstream, client);
-      });
-      client.once("close", () => upstream.destroy());
-    } catch (error) {
-      client.end(rawForbiddenResponse(policyBlockMessage(error)));
-    }
-  }
-  async forwardUpgrade(request2, client, head) {
-    let upstream;
-    try {
-      const rawUrl = request2.url ?? "";
-      const websocketUrl = new URL(rawUrl);
-      if (websocketUrl.protocol !== "ws:") {
-        throw new Error("browser: only plain ws upgrades are handled by the HTTP proxy");
-      }
-      websocketUrl.protocol = "http:";
-      const target = await this.resolve(websocketUrl.toString());
-      const headers = sanitizeHeaders(request2.headers, true);
-      headers.host = target.url.host;
-      upstream = http.request({
-        host: target.address,
-        family: target.family,
-        port: Number(target.url.port || 80),
-        method: request2.method,
-        path: `${target.url.pathname}${target.url.search}`,
-        headers,
-        agent: false
-      });
-      upstream.once("upgrade", (response, upstreamSocket, upstreamHead) => {
-        writeRawResponseHead(client, response);
-        if (head.length > 0) upstreamSocket.write(head);
-        if (upstreamHead.length > 0) client.write(upstreamHead);
-        pipeDuplexPair(upstreamSocket, client);
-        client.once("close", () => upstreamSocket.destroy());
-      });
-      upstream.once("response", (response) => {
-        writeRawResponseHead(client, response);
-        response.once("error", () => client.destroy());
-        response.pipe(client);
-      });
-      upstream.once("error", () => {
-        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
-      });
-      client.once("close", () => upstream?.destroy());
-      upstream.end();
-    } catch (error) {
-      upstream?.destroy();
-      client.end(rawForbiddenResponse(policyBlockMessage(error)));
-    }
-  }
-  resolve(rawUrl) {
-    return resolvePinnedBrowserTarget(rawUrl, {
-      allowPrivateHosts: this.options.allowPrivateHosts,
-      allowedPrivateOrigins: this.options.allowedPrivateOrigins,
-      lookup: this.options.lookup
-    });
-  }
-};
-function pipeDuplexPair(left, right) {
-  left.on("error", () => right.destroy());
-  right.on("error", () => left.destroy());
-  left.pipe(right);
-  right.pipe(left);
-}
-function sanitizeHeaders(headers, preserveUpgrade = false) {
-  const sanitized = { ...headers };
-  delete sanitized["proxy-authorization"];
-  delete sanitized["proxy-connection"];
-  if (!preserveUpgrade) delete sanitized.connection;
-  return sanitized;
-}
-function writeRawResponseHead(client, response) {
-  const status = response.statusCode ?? 502;
-  const statusText = response.statusMessage ?? "Bad Gateway";
-  const lines = [`HTTP/1.1 ${status} ${statusText}`];
-  for (let index = 0; index < response.rawHeaders.length; index += 2) {
-    lines.push(`${response.rawHeaders[index]}: ${response.rawHeaders[index + 1]}`);
-  }
-  client.write(`${lines.join("\r\n")}\r
-\r
-`);
-}
-function writeProxyError(response, status, message) {
-  if (response.headersSent || response.destroyed) return;
-  response.writeHead(status, { "content-type": "text/plain", connection: "close" });
-  response.end(message);
-}
-function policyBlockMessage(error) {
-  const reason = error instanceof Error ? error.message : String(error);
-  return reason ? `Blocked by browser network policy: ${reason}` : "Blocked by browser network policy";
-}
-function rawForbiddenResponse(message) {
-  return `HTTP/1.1 403 Forbidden\r
-Content-Type: text/plain\r
-Content-Length: ${Buffer.byteLength(message)}\r
-Connection: close\r
-\r
-` + message;
-}
-
-// src/browser/manager.ts
-var DEFAULT_OPERATION_TIMEOUT_MS = 3e4;
-var DEFAULT_MAX_SNAPSHOT_CHARS = 64 * 1024;
-var DEFAULT_MAX_ENTRIES = 100;
-var BrowserSessionManager = class {
-  constructor(options, launcher = defaultLauncher) {
-    this.launcher = launcher;
-    this.artifacts = new BrowserArtifactStore(options.artifactRoot);
-    this.allowPrivateHosts = options.allowPrivateHosts ?? false;
-    this.allowedPrivateOrigins = options.allowedPrivateOrigins ?? [];
-    this.networkProxy = new BrowserNetworkGuardProxy({
-      allowPrivateHosts: this.allowPrivateHosts,
-      allowedPrivateOrigins: this.allowedPrivateOrigins
-    });
-    this.headless = options.headless ?? true;
-    this.operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
-    this.maxSnapshotChars = options.maxSnapshotChars ?? DEFAULT_MAX_SNAPSHOT_CHARS;
-    this.maxConsoleEntries = options.maxConsoleEntries ?? DEFAULT_MAX_ENTRIES;
-    this.maxNetworkEntries = options.maxNetworkEntries ?? DEFAULT_MAX_ENTRIES;
-  }
-  launcher;
-  sessions = /* @__PURE__ */ new Map();
-  artifacts;
-  allowPrivateHosts;
-  allowedPrivateOrigins;
-  networkProxy;
-  headless;
-  operationTimeoutMs;
-  maxSnapshotChars;
-  maxConsoleEntries;
-  maxNetworkEntries;
-  browser;
-  launching;
-  async open(ownerId, input, signal) {
-    signal.throwIfAborted();
-    if (input.url) {
-      await assertBrowserUrlAllowed(input.url, {
-        allowPrivateHosts: this.allowPrivateHosts,
-        allowedPrivateOrigins: this.allowedPrivateOrigins,
-        navigation: true
-      });
-    }
-    const browser = await this.ensureBrowser(signal);
-    const proxyServer = await this.networkProxy.start();
-    const context = await abortable(
-      signal,
-      async () => {
-        const created = await browser.newContext({
-          acceptDownloads: false,
-          ignoreHTTPSErrors: false,
-          serviceWorkers: "block",
-          proxy: { server: proxyServer },
-          viewport: input.viewport ?? { width: 1440, height: 900 }
-        });
-        if (signal.aborted) {
-          await created.close().catch(() => void 0);
-          signal.throwIfAborted();
-        }
-        return created;
-      },
-      () => void 0
-    );
-    const session = {
-      id: ulid2(),
-      ownerId,
-      context,
-      page: await context.newPage(),
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      lastUsedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      tracing: input.trace ?? true,
-      console: [],
-      network: []
-    };
-    this.sessions.set(session.id, session);
-    this.attachEvidenceCollectors(session);
-    await context.route("**/*", async (route) => {
-      try {
-        await assertBrowserUrlAllowed(route.request().url(), {
-          allowPrivateHosts: this.allowPrivateHosts,
-          allowedPrivateOrigins: this.allowedPrivateOrigins,
-          navigation: false
-        });
-        await route.continue();
-      } catch {
-        this.pushNetwork(session, {
-          method: route.request().method(),
-          url: safeBrowserUrl(route.request().url()),
-          failed: true,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        await route.abort("blockedbyclient");
-      }
-    });
-    try {
-      if (session.tracing) {
-        await context.tracing.start({ screenshots: true, snapshots: true, sources: false });
-      }
-      if (input.url) await this.navigate(session.id, ownerId, input.url, signal);
-      return await this.summary(session);
-    } catch (err) {
-      await context.close().catch(() => void 0);
-      this.sessions.delete(session.id);
-      await this.closeBrowserIfIdle();
-      throw err;
-    }
-  }
-  async list(ownerId) {
-    const owned = [...this.sessions.values()].filter((session) => session.ownerId === ownerId);
-    return Promise.all(owned.map((session) => this.summary(session)));
-  }
-  async navigate(id, ownerId, rawUrl, signal) {
-    await assertBrowserUrlAllowed(rawUrl, {
-      allowPrivateHosts: this.allowPrivateHosts,
-      allowedPrivateOrigins: this.allowedPrivateOrigins,
-      navigation: true
-    });
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.goto(rawUrl, {
-        waitUntil: "domcontentloaded",
-        timeout: this.operationTimeoutMs
-      })
-    );
-    return this.summary(session);
-  }
-  async snapshot(id, ownerId, signal) {
-    const session = this.requireOwned(id, ownerId);
-    const raw = await this.runPageOperation(session, signal, async () => {
-      try {
-        return await session.page.locator("body").ariaSnapshot({ timeout: this.operationTimeoutMs });
-      } catch {
-        return await session.page.locator("body").innerText({ timeout: this.operationTimeoutMs });
-      }
-    });
-    const aria = redactBrowserText(raw);
-    const truncated = aria.length > this.maxSnapshotChars;
-    return {
-      session: await this.summary(session),
-      aria: truncated ? `${aria.slice(0, this.maxSnapshotChars)}
-\u2026[snapshot truncated]` : aria,
-      console: session.console.map((entry) => ({ ...entry })),
-      network: session.network.map((entry) => ({ ...entry })),
-      truncated
-    };
-  }
-  async screenshot(id, ownerId, input, signal) {
-    const session = this.requireOwned(id, ownerId);
-    const bytes = await this.runPageOperation(
-      session,
-      signal,
-      () => input.selector ? session.page.locator(input.selector).screenshot({ type: "png", timeout: this.operationTimeoutMs }) : session.page.screenshot({ type: "png", fullPage: input.fullPage ?? false })
-    );
-    signal.throwIfAborted();
-    return this.artifacts.write(session.id, "screenshot", "png", "image/png", bytes);
-  }
-  async click(id, ownerId, selector, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(selector).click({ timeout: this.operationTimeoutMs })
-    );
-  }
-  async type(id, ownerId, selector, text, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(selector).fill(text, { timeout: this.operationTimeoutMs })
-    );
-  }
-  async select(id, ownerId, selector, value, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(selector).selectOption(value, { timeout: this.operationTimeoutMs })
-    );
-  }
-  async press(id, ownerId, key, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(session, signal, () => session.page.keyboard.press(key));
-  }
-  async hover(id, ownerId, selector, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(selector).hover({ timeout: this.operationTimeoutMs })
-    );
-  }
-  async wait(id, ownerId, input, signal) {
-    const session = this.requireOwned(id, ownerId);
-    const timeout = Math.min(
-      Math.max(input.timeoutMs ?? this.operationTimeoutMs, 0),
-      this.operationTimeoutMs
-    );
-    await this.runPageOperation(
-      session,
-      signal,
-      () => input.selector ? session.page.locator(input.selector).waitFor({ state: "visible", timeout }) : session.page.waitForTimeout(timeout)
-    );
-  }
-  async drag(id, ownerId, from, to, signal) {
-    const session = this.requireOwned(id, ownerId);
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(from).dragTo(session.page.locator(to), {
-        timeout: this.operationTimeoutMs
-      })
-    );
-  }
-  async upload(id, ownerId, selector, files, projectRoot, signal) {
-    const session = this.requireOwned(id, ownerId);
-    const root = path2.resolve(projectRoot);
-    const realRoot = await fs2.realpath(root);
-    const resolved = [];
-    for (const file of files) {
-      const absolute = path2.resolve(root, file);
-      const relative2 = path2.relative(root, absolute);
-      if (relative2.startsWith("..") || path2.isAbsolute(relative2)) {
-        throw new Error("browser: upload files must stay inside the project root");
-      }
-      let realFile;
-      try {
-        realFile = await fs2.realpath(absolute);
-      } catch (error) {
-        if (error?.code === "ENOENT") {
-          throw new Error(`browser: upload file not found: ${file}`);
-        }
-        throw error;
-      }
-      const realRelative = path2.relative(realRoot, realFile);
-      if (realRelative.startsWith("..") || path2.isAbsolute(realRelative)) {
-        throw new Error("browser: upload files must not escape the project root through a symlink");
-      }
-      const stat3 = await fs2.stat(realFile);
-      if (!stat3.isFile()) throw new Error(`browser: upload target is not a file: ${file}`);
-      resolved.push(realFile);
-    }
-    await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.locator(selector).setInputFiles(resolved, { timeout: this.operationTimeoutMs })
-    );
-  }
-  async evaluate(id, ownerId, expression, signal) {
-    const session = this.requireOwned(id, ownerId);
-    const result = await this.runPageOperation(
-      session,
-      signal,
-      () => session.page.evaluate(expression)
-    );
-    const serialized = JSON.stringify(result);
-    if (serialized && serialized.length > this.maxSnapshotChars) {
-      throw new Error(`browser: evaluation result exceeds ${this.maxSnapshotChars} characters`);
-    }
-    return result;
-  }
-  async close(id, ownerId) {
-    const session = this.requireOwned(id, ownerId);
-    let trace;
-    try {
-      if (session.tracing) {
-        const target = this.artifacts.pathFor(session.id, "zip");
-        await fs2.mkdir(path2.dirname(target.path), { recursive: true });
-        await session.context.tracing.stop({ path: target.path });
-        trace = await this.artifacts.describe(target.id, "trace", target.path, "application/zip");
-      }
-    } finally {
-      await session.context.close().catch(() => void 0);
-      this.sessions.delete(id);
-      await this.closeBrowserIfIdle();
-    }
-    return trace ? { trace } : {};
-  }
-  async closeOwner(ownerId) {
-    const ids = [...this.sessions.values()].filter((session) => session.ownerId === ownerId).map((session) => session.id);
-    for (const id of ids) await this.close(id, ownerId).catch(() => void 0);
-  }
-  /** True when the manager owns no live browser contexts. */
-  isIdle() {
-    return this.sessions.size === 0;
-  }
-  async dispose() {
-    for (const session of [...this.sessions.values()]) {
-      await session.context.close().catch(() => void 0);
-    }
-    this.sessions.clear();
-    const browser = this.browser;
-    this.browser = void 0;
-    this.launching = void 0;
-    await browser?.close().catch(() => void 0);
-    await this.networkProxy.close();
-  }
-  async ensureBrowser(signal) {
-    if (this.browser?.isConnected()) return this.browser;
-    if (!this.launching) {
-      this.launching = this.launcher(this.headless).then((browser) => {
-        this.browser = browser;
-        browser.on("disconnected", () => {
-          if (this.browser === browser) this.browser = void 0;
-          for (const [id, session] of this.sessions) {
-            if (session.context.browser() === browser) this.sessions.delete(id);
-          }
-        });
-        return browser;
-      });
-    }
-    try {
-      return await abortable(
-        signal,
-        () => this.launching,
-        async () => {
-          const browser = await this.launching?.catch(() => void 0);
-          await browser?.close().catch(() => void 0);
-        }
-      );
-    } finally {
-      this.launching = void 0;
-    }
-  }
-  requireOwned(id, ownerId) {
-    const session = this.sessions.get(id);
-    if (!session) throw new Error(`browser: unknown session "${id}"`);
-    if (session.ownerId !== ownerId) throw new Error("browser: session belongs to another agent");
-    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return session;
-  }
-  async summary(session) {
-    return {
-      id: session.id,
-      ownerId: session.ownerId,
-      url: safeBrowserUrl(session.page.url()),
-      title: redactBrowserText(await session.page.title().catch(() => "")),
-      createdAt: session.createdAt,
-      lastUsedAt: session.lastUsedAt,
-      tracing: session.tracing
-    };
-  }
-  attachEvidenceCollectors(session) {
-    session.page.on("console", (message) => {
-      pushBounded(
-        session.console,
-        {
-          level: message.type(),
-          text: redactBrowserText(message.text()).slice(0, 4096),
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        this.maxConsoleEntries
-      );
-    });
-    session.page.on("response", (response) => {
-      this.pushNetwork(session, {
-        method: response.request().method(),
-        url: safeBrowserUrl(response.url()),
-        status: response.status(),
-        at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    session.page.on("requestfailed", (request2) => {
-      this.pushNetwork(session, {
-        method: request2.method(),
-        url: safeBrowserUrl(request2.url()),
-        failed: true,
-        at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-  }
-  pushNetwork(session, entry) {
-    pushBounded(session.network, entry, this.maxNetworkEntries);
-  }
-  async runPageOperation(session, signal, operation) {
-    signal.throwIfAborted();
-    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return abortable(signal, operation, async () => {
-      await session.context.close().catch(() => void 0);
-      this.sessions.delete(session.id);
-      await this.closeBrowserIfIdle();
-    });
-  }
-  async closeBrowserIfIdle() {
-    if (this.sessions.size > 0 || !this.browser) return;
-    const browser = this.browser;
-    this.browser = void 0;
-    await browser.close().catch(() => void 0);
-  }
-};
-async function defaultLauncher(headless) {
-  try {
-    const { chromium } = await import("@playwright/test");
-    return await chromium.launch({ headless });
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new Error(
-      `browser: Playwright Chromium is unavailable (${detail}). Run "pnpm exec playwright install chromium".`
-    );
-  }
-}
-async function browserInstallationDiagnostics() {
-  try {
-    const { chromium } = await import("@playwright/test");
-    const executablePath = chromium.executablePath();
-    await fs2.access(executablePath);
-    return { available: true, executablePath, message: "Playwright Chromium is available." };
-  } catch {
-    return {
-      available: false,
-      message: 'Playwright Chromium is unavailable. Run "pnpm exec playwright install chromium".'
-    };
-  }
-}
-function pushBounded(target, value, limit) {
-  target.push(value);
-  if (target.length > limit) target.splice(0, target.length - limit);
-}
-async function abortable(signal, operation, onAbort) {
-  signal.throwIfAborted();
-  return new Promise((resolve3, reject) => {
-    let settled = false;
-    let aborting = false;
-    const finish = (fn) => {
-      if (settled) return;
-      settled = true;
-      signal.removeEventListener("abort", abort);
-      fn();
-    };
-    const abort = () => {
-      aborting = true;
-      void Promise.resolve(onAbort()).finally(() => {
-        finish(() => reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted")));
-      });
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    operation().then(
-      (value) => {
-        if (!aborting) finish(() => resolve3(value));
-      },
-      (err) => {
-        if (!aborting) finish(() => reject(err));
-      }
-    );
-  });
-}
-
-// src/browser/tools.ts
-import * as path3 from "node:path";
-import { ToolCapabilities } from "@wrongstack/core/security";
-import { resolveWstackPaths } from "@wrongstack/core/utils";
-var managers = /* @__PURE__ */ new Map();
-var cleanupSignalByContext = /* @__PURE__ */ new WeakMap();
-function managerFor(ctx) {
-  const root = path3.resolve(ctx.projectRoot);
-  let manager = managers.get(root);
-  if (!manager) {
-    const wpaths = resolveWstackPaths({ projectRoot: root });
-    manager = new BrowserSessionManager({
-      artifactRoot: path3.join(wpaths.projectDir, "browser-artifacts"),
-      allowedPrivateOrigins: parsePrivateOriginAllowlist(
-        process.env["WRONGSTACK_BROWSER_PRIVATE_ORIGINS"]
-      )
-    });
-    managers.set(root, manager);
-  }
-  const runSignal = ctx.signal;
-  if (cleanupSignalByContext.get(ctx) !== runSignal) {
-    cleanupSignalByContext.set(ctx, runSignal);
-    const managerForRun = manager;
-    const rootForRun = root;
-    const ownerForRun = owner(ctx);
-    ctx.registerAbortHook?.(async () => {
-      if (cleanupSignalByContext.get(ctx) === runSignal) {
-        cleanupSignalByContext.delete(ctx);
-      }
-      await managerForRun.closeOwner(ownerForRun);
-      if (managerForRun.isIdle() && managers.get(rootForRun) === managerForRun) {
-        managers.delete(rootForRun);
-        await managerForRun.dispose();
-      }
-    });
-  }
-  return manager;
-}
-function owner(ctx) {
-  return ctx.agentId || "leader";
-}
-function json(value) {
-  return JSON.stringify(value, null, 2);
-}
-var sessionIdSchema = {
-  type: "string",
-  minLength: 1,
-  description: "Browser session id returned by browser_open."
-};
-var browserOpenTool = {
-  name: "browser_open",
-  description: "Open an isolated first-party Playwright browser session, optionally navigating to a URL. Private/localhost origins are blocked by default; enable specific origins via the WRONGSTACK_BROWSER_PRIVATE_ORIGINS env allowlist.",
-  usageHint: "browser_open({ url?, width?, height?, trace? })",
-  permission: "confirm",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  subjectKey: "url",
-  inputSchema: {
-    type: "object",
-    properties: {
-      url: { type: "string", description: "Optional absolute http(s) URL." },
-      width: { type: "integer", minimum: 320, maximum: 3840 },
-      height: { type: "integer", minimum: 240, maximum: 2160 },
-      trace: { type: "boolean", description: "Capture a Playwright trace; defaults to true." }
-    }
-  },
-  async execute(input, ctx, opts) {
-    const viewport = input.width || input.height ? { width: input.width ?? 1440, height: input.height ?? 900 } : void 0;
-    return json(
-      await managerFor(ctx).open(
-        owner(ctx),
-        { url: input.url, viewport, trace: input.trace },
-        opts.signal
-      )
-    );
-  }
-};
-var browserListTool = {
-  name: "browser_list",
-  description: "List browser sessions owned by the current agent without exposing other agents sessions.",
-  permission: "auto",
-  mutating: false,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: { type: "object", properties: {} },
-  async execute(_input, ctx) {
-    return json(await managerFor(ctx).list(owner(ctx)));
-  }
-};
-var browserStatusTool = {
-  name: "browser_status",
-  description: "Check whether first-party Playwright Chromium is installed and ready to launch.",
-  permission: "auto",
-  mutating: false,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.TOOL_META],
-  inputSchema: { type: "object", properties: {} },
-  async execute() {
-    return json(await browserInstallationDiagnostics());
-  }
-};
-var browserNavigateTool = {
-  name: "browser_navigate",
-  description: "Navigate an owned browser session to an approved http(s) URL. Private/localhost origins are blocked by default; enable specific origins via the WRONGSTACK_BROWSER_PRIVATE_ORIGINS env allowlist.",
-  usageHint: "browser_navigate({ sessionId, url })",
-  permission: "confirm",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  subjectKey: "url",
-  inputSchema: {
-    type: "object",
-    properties: { sessionId: sessionIdSchema, url: { type: "string", minLength: 1 } },
-    required: ["sessionId", "url"]
-  },
-  async execute(input, ctx, opts) {
-    return json(
-      await managerFor(ctx).navigate(input.sessionId, owner(ctx), input.url, opts.signal)
-    );
-  }
-};
-var browserSnapshotTool = {
-  name: "browser_snapshot",
-  description: "Return bounded accessibility state plus redacted console and network summaries.",
-  usageHint: "browser_snapshot({ sessionId })",
-  permission: "auto",
-  mutating: false,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: { sessionId: sessionIdSchema },
-    required: ["sessionId"]
-  },
-  async execute(input, ctx, opts) {
-    return json(await managerFor(ctx).snapshot(input.sessionId, owner(ctx), opts.signal));
-  }
-};
-var browserScreenshotTool = {
-  name: "browser_screenshot",
-  description: "Capture a page or element PNG and return sensitive artifact metadata with integrity hash.",
-  usageHint: "browser_screenshot({ sessionId, fullPage?, selector? })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "selector",
-  mutating: true,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      fullPage: { type: "boolean" },
-      selector: { type: "string", minLength: 1 }
-    },
-    required: ["sessionId"]
-  },
-  async execute(input, ctx, opts) {
-    return json(
-      await managerFor(ctx).screenshot(
-        input.sessionId,
-        owner(ctx),
-        { fullPage: input.fullPage, selector: input.selector },
-        opts.signal
-      )
-    );
-  }
-};
-function selectorTool(name, description, run) {
-  return {
-    name,
-    description,
-    usageHint: `${name}({ sessionId, selector })`,
-    permission: "confirm",
-    // WS-046: the element/expression acted on, not the sessionId — a trust
-    // rule must distinguish clicking one control from another.
-    subjectKey: "selector",
-    mutating: true,
-    riskTier: "standard",
-    capabilities: [ToolCapabilities.NET_OUTBOUND],
-    inputSchema: {
-      type: "object",
-      properties: { sessionId: sessionIdSchema, selector: { type: "string", minLength: 1 } },
-      required: ["sessionId", "selector"]
-    },
-    async execute(input, ctx, opts) {
-      await run(managerFor(ctx), input, owner(ctx), opts.signal);
-      return "ok";
-    }
-  };
-}
-var browserClickTool = selectorTool(
-  "browser_click",
-  "Click an element in an owned browser session.",
-  (manager, input, ownerId, signal) => manager.click(input.sessionId, ownerId, input.selector, signal)
-);
-var browserHoverTool = selectorTool(
-  "browser_hover",
-  "Hover an element in an owned browser session.",
-  (manager, input, ownerId, signal) => manager.hover(input.sessionId, ownerId, input.selector, signal)
-);
-var browserTypeTool = {
-  name: "browser_type",
-  description: "Fill an input in an owned browser session. Use secretEnv instead of text for credentials so values stay out of tool arguments and session audit.",
-  usageHint: "browser_type({ sessionId, selector, text? | secretEnv? })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "selector",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      selector: { type: "string", minLength: 1 },
-      text: { type: "string" },
-      secretEnv: {
-        type: "string",
-        pattern: "^[A-Z_][A-Z0-9_]*$",
-        description: "Host environment variable resolved only at execution time."
-      }
-    },
-    required: ["sessionId", "selector"]
-  },
-  validate(input) {
-    return input.text === void 0 === (input.secretEnv === void 0) ? ["exactly one of text or secretEnv is required"] : [];
-  },
-  async execute(input, ctx, opts) {
-    const value = input.text ?? (input.secretEnv ? process.env[input.secretEnv] : void 0);
-    if (value === void 0) {
-      throw new Error(`browser: secret environment variable "${input.secretEnv ?? ""}" is not set`);
-    }
-    await managerFor(ctx).type(input.sessionId, owner(ctx), input.selector, value, opts.signal);
-    return "ok";
-  }
-};
-var browserSelectTool = {
-  name: "browser_select",
-  description: "Select an option in an owned browser session.",
-  usageHint: "browser_select({ sessionId, selector, value })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "selector",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      selector: { type: "string", minLength: 1 },
-      value: { type: "string" }
-    },
-    required: ["sessionId", "selector", "value"]
-  },
-  async execute(input, ctx, opts) {
-    await managerFor(ctx).select(
-      input.sessionId,
-      owner(ctx),
-      input.selector,
-      input.value,
-      opts.signal
-    );
-    return "ok";
-  }
-};
-var browserPressTool = {
-  name: "browser_press",
-  description: "Press a keyboard key in an owned browser session.",
-  usageHint: "browser_press({ sessionId, key })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "key",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: { sessionId: sessionIdSchema, key: { type: "string", minLength: 1 } },
-    required: ["sessionId", "key"]
-  },
-  async execute(input, ctx, opts) {
-    await managerFor(ctx).press(input.sessionId, owner(ctx), input.key, opts.signal);
-    return "ok";
-  }
-};
-var browserDragTool = {
-  name: "browser_drag",
-  description: "Drag one element to another in an owned browser session.",
-  usageHint: "browser_drag({ sessionId, from, to })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "from",
-  mutating: true,
-  riskTier: "standard",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      from: { type: "string", minLength: 1 },
-      to: { type: "string", minLength: 1 }
-    },
-    required: ["sessionId", "from", "to"]
-  },
-  async execute(input, ctx, opts) {
-    await managerFor(ctx).drag(input.sessionId, owner(ctx), input.from, input.to, opts.signal);
-    return "ok";
-  }
-};
-var browserWaitTool = {
-  name: "browser_wait",
-  description: "Wait for an element or a bounded duration in an owned browser session.",
-  usageHint: "browser_wait({ sessionId, selector?, timeoutMs? })",
-  permission: "auto",
-  mutating: false,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      selector: { type: "string", minLength: 1 },
-      timeoutMs: { type: "integer", minimum: 0, maximum: 3e4 }
-    },
-    required: ["sessionId"]
-  },
-  async execute(input, ctx, opts) {
-    await managerFor(ctx).wait(
-      input.sessionId,
-      owner(ctx),
-      { selector: input.selector, timeoutMs: input.timeoutMs },
-      opts.signal
-    );
-    return "ok";
-  }
-};
-var browserEvaluateTool = {
-  name: "browser_evaluate",
-  description: "Evaluate bounded JavaScript in the page. Requires confirmation because page code is arbitrary.",
-  usageHint: "browser_evaluate({ sessionId, expression })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "expression",
-  mutating: true,
-  riskTier: "destructive",
-  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.TOOL_MUTATE_ANY],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      expression: { type: "string", minLength: 1, maxLength: 16384 }
-    },
-    required: ["sessionId", "expression"]
-  },
-  async execute(input, ctx, opts) {
-    return json(
-      await managerFor(ctx).evaluate(input.sessionId, owner(ctx), input.expression, opts.signal)
-    );
-  }
-};
-var browserUploadTool = {
-  name: "browser_upload",
-  description: "Upload project-local files through a file input in an owned browser session.",
-  usageHint: "browser_upload({ sessionId, selector, files })",
-  permission: "confirm",
-  // WS-046: the element/expression acted on, not the sessionId — a trust
-  // rule must distinguish clicking one control from another.
-  subjectKey: "selector",
-  mutating: true,
-  riskTier: "destructive",
-  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.FS_READ],
-  inputSchema: {
-    type: "object",
-    properties: {
-      sessionId: sessionIdSchema,
-      selector: { type: "string", minLength: 1 },
-      files: { type: "array", minItems: 1, maxItems: 20, items: { type: "string", minLength: 1 } }
-    },
-    required: ["sessionId", "selector", "files"]
-  },
-  async execute(input, ctx, opts) {
-    await managerFor(ctx).upload(
-      input.sessionId,
-      owner(ctx),
-      input.selector,
-      input.files,
-      ctx.projectRoot,
-      opts.signal
-    );
-    return "ok";
-  }
-};
-var browserCloseTool = {
-  name: "browser_close",
-  description: "Close an owned browser session, reclaim its context, and return sensitive trace metadata.",
-  usageHint: "browser_close({ sessionId })",
-  permission: "auto",
-  mutating: false,
-  riskTier: "safe",
-  capabilities: [ToolCapabilities.NET_OUTBOUND],
-  inputSchema: {
-    type: "object",
-    properties: { sessionId: sessionIdSchema },
-    required: ["sessionId"]
-  },
-  async execute(input, ctx) {
-    return json(await managerFor(ctx).close(input.sessionId, owner(ctx)));
-  }
-};
-var browserTools = [
-  browserOpenTool,
-  browserStatusTool,
+import "../chunk-Z6DAKQ3U.js";
+import {
+  BrowserArtifactStore,
+  BrowserNetworkGuardProxy,
+  BrowserSessionManager,
+  assertBrowserUrlAllowed,
+  browserClickTool,
+  browserCloseTool,
+  browserDragTool,
+  browserEvaluateTool,
+  browserHoverTool,
+  browserInstallationDiagnostics,
   browserListTool,
   browserNavigateTool,
-  browserSnapshotTool,
+  browserOpenTool,
+  browserPressTool,
   browserScreenshotTool,
-  browserClickTool,
-  browserTypeTool,
   browserSelectTool,
-  browserPressTool,
-  browserHoverTool,
-  browserDragTool,
-  browserWaitTool,
-  browserEvaluateTool,
+  browserSnapshotTool,
+  browserStatusTool,
+  browserTools,
+  browserTypeTool,
   browserUploadTool,
-  browserCloseTool
-];
-for (const tool of browserTools) tool.icon = "web";
-for (const tool of browserTools) tool.timeoutMs ??= 6e4;
-async function shutdownBrowserTools() {
-  const active = [...managers.values()];
-  managers.clear();
-  await Promise.all(active.map((manager) => manager.dispose()));
-}
+  browserWaitTool,
+  parsePrivateOriginAllowlist,
+  redactBrowserText,
+  resolvePinnedBrowserTarget,
+  safeBrowserUrl,
+  shutdownBrowserTools
+} from "../chunk-K3WNSHUF.js";
 export {
   BrowserArtifactStore,
   BrowserNetworkGuardProxy,