@narumitw/pi-chrome-devtools 0.52.3 → 0.53.1

package/dist/chunks/{chunk-RH6KESL3.js → chunk-SRT3UUIP.js}

@@ -2,13 +2,24 @@
 // @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
 
 // src/tool-names.ts
-var CHROME_DEVTOOLS_TOOL_NAMES = [
+var CORE_CHROME_DEVTOOLS_TOOL_NAMES = [
   "chrome_devtools_list_pages",
   "chrome_devtools_select_page",
   "chrome_devtools_navigate",
   "chrome_devtools_evaluate",
   "chrome_devtools_screenshot"
 ];
+var WEBMCP_TOOL_NAMES = [
+  "chrome_devtools_webmcp_list_tools",
+  "chrome_devtools_webmcp_call_tool"
+];
+var CHROME_DEVTOOLS_TOOL_NAMES = [
+  ...CORE_CHROME_DEVTOOLS_TOOL_NAMES,
+  ...WEBMCP_TOOL_NAMES
+];
+function isWebMcpToolName(value) {
+  return WEBMCP_TOOL_NAMES.includes(value);
+}
 
 // src/settings.ts
 import { randomUUID } from "node:crypto";
@@ -82,7 +93,7 @@ async function loadSettings(options = {}) {
   const userBrowser = user.normalized?.browser ?? {};
   const effectiveBrowser = resolveEffectiveBrowser(userBrowser, project.normalized?.browser);
   const settings = resolveSettings(user.normalized, project.normalized, effectiveBrowser);
-  const recognized = settings.tools !== void 0 || user.normalized?.browser !== void 0 || project.normalized?.browser !== void 0;
+  const recognized = settings.tools !== void 0 || user.normalized?.browser !== void 0 || project.normalized?.browser !== void 0 || user.normalized?.webmcp !== void 0;
   const invalidReasons = [user, project].filter((result) => result.kind === "invalid").map((result) => result.reason).filter((reason) => Boolean(reason));
   const userFile = user.kind === "invalid" ? {
     kind: "invalid",
@@ -90,6 +101,7 @@ async function loadSettings(options = {}) {
   } : { kind: user.kind };
   const base = {
     effectiveBrowser,
+    effectiveWebMcpEnabled: settings.webmcp.enabled,
     paths,
     userFile,
     warnings,
@@ -104,7 +116,8 @@ async function loadSettings(options = {}) {
 function resolveSettings(user, _project, browser) {
   return {
     ...user?.tools ? { tools: user.tools, updatedAt: user.updatedAt } : {},
-    browser
+    browser,
+    webmcp: { enabled: user?.webmcp?.enabled ?? false }
   };
 }
 function resolveEffectiveBrowser(user, project) {
@@ -165,7 +178,7 @@ async function readSettingsDocument(filePath, scope, cwd) {
     const reason = `${filePath}: expected a JSON object`;
     return { kind: "invalid", reason, warnings: [`Chrome DevTools settings ignored: ${reason}`] };
   }
-  const scopeWarnings = projectMachineSettingsWarnings(parsed, scope, filePath);
+  const scopeWarnings = projectOwnedSettingsWarnings(parsed, scope, filePath);
   try {
     const normalized = await normalizeSettingsDocument(parsed, scope, filePath, cwd);
     return { kind: "valid", document: { ...parsed }, normalized, warnings: scopeWarnings };
@@ -178,12 +191,18 @@ async function readSettingsDocument(filePath, scope, cwd) {
     };
   }
 }
-function projectMachineSettingsWarnings(document, scope, filePath) {
-  if (scope !== "project" || !isRecord(document.browser)) return [];
-  const browser = document.browser;
-  return ["endpoint", "autoLaunch", "executablePath"].filter((field) => browser[field] !== void 0).map(
+function projectOwnedSettingsWarnings(document, scope, filePath) {
+  if (scope !== "project") return [];
+  const browser = isRecord(document.browser) ? document.browser : void 0;
+  const warnings = browser ? ["endpoint", "autoLaunch", "executablePath"].filter((field) => browser[field] !== void 0).map(
     (field) => `Chrome DevTools project browser.${field} ignored in ${filePath}; configure this machine-owned setting in ${settingsFilePath()}.`
-  );
+  ) : [];
+  if (document.webmcp !== void 0) {
+    warnings.push(
+      `Chrome DevTools project webmcp settings ignored in ${filePath}; only the user settings file may enable experimental WebMCP.`
+    );
+  }
+  return warnings;
 }
 async function normalizeSettingsDocument(document, scope, filePath, cwd) {
   const normalized = {};
@@ -201,6 +220,12 @@ async function normalizeSettingsDocument(document, scope, filePath, cwd) {
     if (!isRecord(document.browser)) throw new Error("expected browser to be an object");
     normalized.browser = await normalizeBrowserSection(document.browser, scope, filePath, cwd);
   }
+  if (scope === "user" && document.webmcp !== void 0) {
+    if (!isRecord(document.webmcp) || typeof document.webmcp.enabled !== "boolean") {
+      throw new Error("expected webmcp.enabled to be a boolean");
+    }
+    normalized.webmcp = { enabled: document.webmcp.enabled };
+  }
   return normalized;
 }
 async function normalizeBrowserSection(browser, scope, _filePath, cwd) {
@@ -337,6 +362,18 @@ function saveSettings(settings, operations = {}) {
     operations
   );
 }
+function saveWebMcpSettings(enabled, operations = {}) {
+  return queueSettingsMutation(
+    (current) => ({
+      ...current,
+      webmcp: {
+        ...isRecord(current.webmcp) ? current.webmcp : {},
+        enabled
+      }
+    }),
+    operations
+  );
+}
 function saveBrowserSettings(patch, operations = {}) {
   return queueSettingsMutation(async (current) => {
     const browser = isRecord(current.browser) ? { ...current.browser } : {};
@@ -446,6 +483,72 @@ var state = {
   sessionGeneration: 0,
   sessionController: new AbortController()
 };
+var webMcpRuntimeByOwner = /* @__PURE__ */ new WeakMap();
+function setWebMcpSessionOwner(owner) {
+  const runtime = webMcpRuntime(owner);
+  runtime.enabled = false;
+  runtime.sessionGeneration += 1;
+}
+function beginWebMcpOperation(owner, toolSignal) {
+  const runtime = webMcpRuntime(owner);
+  const controller = new AbortController();
+  runtime.controllers.add(controller);
+  const signals = [controller.signal, runtime.controller.signal];
+  if (toolSignal) signals.push(toolSignal);
+  const signal = AbortSignal.any(signals);
+  return {
+    signal,
+    owner,
+    sessionGeneration: runtime.sessionGeneration,
+    webMcpGeneration: runtime.generation,
+    dispose() {
+      runtime.controllers.delete(controller);
+    }
+  };
+}
+function invalidateWebMcpOperations(owner, reason) {
+  const runtime = webMcpRuntime(owner);
+  runtime.generation += 1;
+  const controllers = [...runtime.controllers];
+  runtime.controllers.clear();
+  const error = new DOMException(reason, "AbortError");
+  runtime.controller.abort(error);
+  runtime.controller = new AbortController();
+  for (const controller of controllers) controller.abort(error);
+}
+function currentWebMcpGeneration(owner) {
+  return webMcpRuntime(owner).generation;
+}
+function webMcpSessionSignal(owner) {
+  return webMcpRuntime(owner).controller.signal;
+}
+function applyRuntimeWebMcpSetting(enabled, owner) {
+  const runtime = webMcpRuntime(owner);
+  if (runtime.enabled !== enabled) {
+    invalidateWebMcpOperations(owner, `WebMCP ${enabled ? "enabled" : "disabled"}`);
+  }
+  runtime.enabled = enabled;
+}
+function webMcpEnabled(owner) {
+  return webMcpRuntime(owner).enabled;
+}
+function webMcpOperationIsCurrent(operation) {
+  const runtime = webMcpRuntime(operation.owner);
+  return operation.sessionGeneration === runtime.sessionGeneration && operation.webMcpGeneration === runtime.generation;
+}
+function webMcpRuntime(owner) {
+  const existing = webMcpRuntimeByOwner.get(owner);
+  if (existing) return existing;
+  const created = {
+    controller: new AbortController(),
+    controllers: /* @__PURE__ */ new Set(),
+    enabled: false,
+    generation: 0,
+    sessionGeneration: 0
+  };
+  webMcpRuntimeByOwner.set(owner, created);
+  return created;
+}
 function applyRuntimeBrowserSettings(browser, paths, projectTrusted) {
   state.host = browser.host;
   state.port = browser.port;
@@ -483,6 +586,94 @@ var DEFAULT_BROWSER_MANAGER_OPERATIONS = {
   sleep: abortableSleep
 };
 var browserManagerOperations = DEFAULT_BROWSER_MANAGER_OPERATIONS;
+var managedBrowserScopes = /* @__PURE__ */ new WeakMap();
+function cloneBrowserSettings(browser) {
+  return { ...browser, extensionPaths: [...browser.extensionPaths] };
+}
+function runtimeBrowserSettings() {
+  return {
+    endpoint: `http://${formatHostForUrl(state.host)}:${state.configuredPort}`,
+    host: state.host,
+    port: state.configuredPort,
+    hostConfigured: state.hostConfigured,
+    portConfigured: state.portConfigured,
+    autoLaunchEnabled: state.autoLaunchEnabled,
+    ...state.browserExecutable ? { executablePath: state.browserExecutable } : {},
+    extensionPaths: [...state.extensionPaths],
+    endpointSource: state.endpointSource,
+    autoLaunchSource: state.autoLaunchSource,
+    executablePathSource: state.browserExecutableSource,
+    extensionPathsSource: state.extensionPathsSource
+  };
+}
+function managedBrowserScope(owner) {
+  const existing = managedBrowserScopes.get(owner);
+  if (existing) return existing;
+  const browser = runtimeBrowserSettings();
+  const created = {
+    browser,
+    controller: new AbortController(),
+    generation: 0,
+    port: browser.port
+  };
+  managedBrowserScopes.set(owner, created);
+  return created;
+}
+function startManagedBrowserSession(owner) {
+  const scope = managedBrowserScope(owner);
+  scope.controller.abort(new DOMException("Chrome DevTools session replaced", "AbortError"));
+  scope.controller = new AbortController();
+  scope.generation += 1;
+  scope.lastLaunchAttempt = void 0;
+}
+function syncManagedBrowserSettings(owner, browser) {
+  const scope = managedBrowserScope(owner);
+  scope.browser = cloneBrowserSettings(browser);
+  scope.port = browser.port;
+}
+function browserSettingsForOwner(owner) {
+  return owner ? managedBrowserScope(owner).browser : runtimeBrowserSettings();
+}
+function managedBrowserExtensionPaths(owner) {
+  return browserSettingsForOwner(owner).extensionPaths;
+}
+function managedBrowserForOwner(owner) {
+  if (!owner) return state.managedBrowser;
+  const scopedBrowser = managedBrowserScope(owner).managedBrowser;
+  if (scopedBrowser) return scopedBrowser;
+  return state.managedBrowser?.sessionOwner === owner ? state.managedBrowser : void 0;
+}
+function setManagedBrowser(owner, browser) {
+  if (owner) managedBrowserScope(owner).managedBrowser = browser;
+  else state.managedBrowser = browser;
+}
+function launchPromiseForOwner(owner) {
+  return owner ? managedBrowserScope(owner).launchPromise : state.launchPromise;
+}
+function setLaunchPromise(owner, launchPromise) {
+  if (owner) managedBrowserScope(owner).launchPromise = launchPromise;
+  else state.launchPromise = launchPromise;
+}
+function managedBrowserPort(owner) {
+  return owner ? managedBrowserScope(owner).port : state.port;
+}
+function managedBrowserConfiguredPort(owner) {
+  return browserSettingsForOwner(owner).port;
+}
+function managedBrowserPortConfigured(owner) {
+  return browserSettingsForOwner(owner).portConfigured;
+}
+function setManagedBrowserPort(owner, port) {
+  if (owner) managedBrowserScope(owner).port = port;
+  else state.port = port;
+}
+function lastLaunchAttempt(owner) {
+  return owner ? managedBrowserScope(owner).lastLaunchAttempt : state.lastLaunchAttempt;
+}
+function setLastLaunchAttempt(owner, attempt) {
+  if (owner) managedBrowserScope(owner).lastLaunchAttempt = attempt;
+  else state.lastLaunchAttempt = attempt;
+}
 function formatError2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -492,142 +683,189 @@ function isNodeError2(error) {
 function normalizePathForComparison(value) {
   return process.platform === "win32" ? value.toLowerCase() : value;
 }
-async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS) {
-  if (extensionsConfigured()) {
-    validateExtensionLaunchMode();
-    await ensureManagedBrowserLaunched(waitMs);
+async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS, callerSignal, owner) {
+  callerSignal?.throwIfAborted();
+  if (extensionsConfigured(owner)) {
+    validateExtensionLaunchMode(owner);
+    await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
     return;
   }
-  if (canAutoLaunchBrowser()) {
+  if (canAutoLaunchBrowser(owner)) {
     try {
-      await withEndpointRetry(() => fetchDevToolsJson("/json/version"), waitMs);
+      await withEndpointRetry(
+        () => fetchDevToolsJson("/json/version", { signal: callerSignal }, owner),
+        waitMs,
+        callerSignal
+      );
       return;
     } catch (error) {
-      if (shouldAutoLaunchAfterEndpointError(error)) {
-        await ensureManagedBrowserLaunched(waitMs);
+      if (shouldAutoLaunchAfterEndpointError(error, owner)) {
+        await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
         return;
       }
       throw error;
     }
   }
   try {
-    await fetchDevToolsJson("/json/version");
+    await fetchDevToolsJson("/json/version", { signal: callerSignal }, owner);
   } catch (error) {
     if (isRetryableEndpointError(error)) return;
     throw error;
   }
 }
-function validateExtensionLaunchMode() {
-  if (!isLocalDevToolsHost(state.host)) {
+function validateExtensionLaunchMode(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (!isLocalDevToolsHost(browser.host)) {
     throw new DevToolsEndpointError(
       "Unpacked extensions require a local extension-owned managed browser; remote CDP endpoints cannot be modified."
     );
   }
-  if (!state.autoLaunchEnabled) {
+  if (!browser.autoLaunchEnabled) {
     throw new DevToolsEndpointError(
       "Auto-launch is required for unpacked extensions so Pi can create an isolated managed browser."
     );
   }
-  if (!state.browserExecutable) {
+  if (!browser.executablePath) {
     throw new DevToolsEndpointError(
       "Unpacked extensions require browser.executablePath for Chrome for Testing or Chromium in pi-chrome-devtools.json."
     );
   }
 }
-async function ensureManagedBrowserLaunched(waitMs) {
-  if (state.launchPromise) return state.launchPromise;
-  if (state.managedBrowser && !state.managedBrowser.exited && state.managedBrowser.ready) return;
-  const generation = state.sessionGeneration;
-  const signal = state.sessionController.signal;
-  throwIfBrowserLaunchCancelled(generation, signal);
-  const launchPromise = prepareManagedBrowserLaunch(waitMs, generation, signal);
+async function ensureManagedBrowserLaunched(waitMs, callerSignal, owner) {
+  const existingLaunch = launchPromiseForOwner(owner);
+  if (existingLaunch) {
+    await waitForCaller(existingLaunch, callerSignal);
+    return;
+  }
+  const existingBrowser = managedBrowserForOwner(owner);
+  if (existingBrowser && !existingBrowser.exited && existingBrowser.ready) return;
+  const generation = owner ? managedBrowserScope(owner).generation : state.sessionGeneration;
+  const signal = owner ? managedBrowserScope(owner).controller.signal : state.sessionController.signal;
+  throwIfBrowserLaunchCancelled(generation, signal, owner);
+  const launchPromise = prepareManagedBrowserLaunch(waitMs, generation, signal, owner);
   const wrappedPromise = launchPromise.finally(() => {
-    if (state.launchPromise === wrappedPromise) state.launchPromise = void 0;
+    if (launchPromiseForOwner(owner) === wrappedPromise) setLaunchPromise(owner, void 0);
   });
-  state.launchPromise = wrappedPromise;
-  return wrappedPromise;
+  setLaunchPromise(owner, wrappedPromise);
+  await waitForCaller(wrappedPromise, callerSignal);
 }
-async function prepareManagedBrowserLaunch(waitMs, generation, signal) {
-  if (state.managedBrowser) {
-    await shutdownManagedBrowser(state.managedBrowser, { awaitLaunch: false });
-    throwIfBrowserLaunchCancelled(generation, signal);
+function waitForCaller(operation, signal) {
+  if (!signal) return operation;
+  signal.throwIfAborted();
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    const onAbort = () => settle(() => reject(signal.reason));
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => settle(() => resolve3(value)),
+      (error) => settle(() => reject(error))
+    );
+  });
+}
+async function prepareManagedBrowserLaunch(waitMs, generation, signal, owner) {
+  const existingBrowser = managedBrowserForOwner(owner);
+  if (existingBrowser) {
+    await shutdownManagedBrowser(existingBrowser, { awaitLaunch: false, owner });
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
   }
-  if (state.portConfigured) {
-    const available = await browserManagerOperations.isPortAvailable(state.host, state.port);
-    throwIfBrowserLaunchCancelled(generation, signal);
+  if (managedBrowserPortConfigured(owner)) {
+    const available = await browserManagerOperations.isPortAvailable(
+      browserSettingsForOwner(owner).host,
+      managedBrowserPort(owner)
+    );
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     if (!available) {
       throw new DevToolsEndpointError(
-        `Cannot launch the extension-owned browser because explicit port ${state.port} is already in use. Choose a free browser.endpoint port or reset the endpoint to use a dynamic managed port.`
+        `Cannot launch the extension-owned browser because explicit port ${managedBrowserPort(owner)} is already in use. Choose a free browser.endpoint port or reset the endpoint to use a dynamic managed port.`
       );
     }
   }
-  return launchManagedBrowser(waitMs, generation, signal);
+  return launchManagedBrowser(waitMs, generation, signal, owner);
 }
-async function launchManagedBrowser(waitMs, generation, signal) {
-  throwIfBrowserLaunchCancelled(generation, signal);
-  const candidateDefinitions = browserCandidateDefinitions();
-  const candidates = await resolveBrowserCandidates(candidateDefinitions, generation, signal);
-  throwIfBrowserLaunchCancelled(generation, signal);
-  state.lastLaunchAttempt = {
+async function launchManagedBrowser(waitMs, generation, signal, owner) {
+  throwIfBrowserLaunchCancelled(generation, signal, owner);
+  const candidateDefinitions = browserCandidateDefinitions(owner);
+  const candidates = await resolveBrowserCandidates(
+    candidateDefinitions,
+    generation,
+    signal,
+    owner
+  );
+  throwIfBrowserLaunchCancelled(generation, signal, owner);
+  setLastLaunchAttempt(owner, {
     candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-    mode: state.portConfigured ? "explicit-port" : "dynamic-port"
-  };
+    mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
+  });
   if (candidates.length === 0) {
-    throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions));
+    throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions, owner));
   }
   let lastError;
   for (const candidate of candidates) {
-    throwIfBrowserLaunchCancelled(generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     try {
-      if (extensionsConfigured())
-        await requireSupportedExtensionBrowser(candidate, generation, signal);
-      await launchBrowserCandidate(candidate, waitMs, generation, signal);
-      throwIfBrowserLaunchCancelled(generation, signal);
-      state.lastLaunchAttempt = {
-        ...state.lastLaunchAttempt,
+      if (extensionsConfigured(owner))
+        await requireSupportedExtensionBrowser(candidate, generation, signal, owner);
+      await launchBrowserCandidate(candidate, waitMs, generation, signal, owner);
+      throwIfBrowserLaunchCancelled(generation, signal, owner);
+      setLastLaunchAttempt(owner, {
+        ...lastLaunchAttempt(owner),
+        candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+        mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
         selectedCandidate: formatBrowserCandidate(candidate),
-        userDataDir: state.managedBrowser?.userDataDir
-      };
+        userDataDir: managedBrowserForOwner(owner)?.userDataDir
+      });
       return;
     } catch (error) {
       try {
-        throwIfBrowserLaunchCancelled(generation, signal);
+        throwIfBrowserLaunchCancelled(generation, signal, owner);
       } catch (cancellation) {
-        state.lastLaunchAttempt = {
-          ...state.lastLaunchAttempt,
+        setLastLaunchAttempt(owner, {
+          ...lastLaunchAttempt(owner) ?? {
+            candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+            mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
+          },
           lastError: formatError2(cancellation)
-        };
+        });
         throw cancellation;
       }
       lastError = error;
-      state.lastLaunchAttempt = {
-        ...state.lastLaunchAttempt,
+      setLastLaunchAttempt(owner, {
+        ...lastLaunchAttempt(owner) ?? {
+          candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+          mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
+        },
         lastError: formatError2(error)
-      };
+      });
     }
   }
-  if (lastError instanceof DevToolsEndpointError && extensionsConfigured()) throw lastError;
+  if (lastError instanceof DevToolsEndpointError && extensionsConfigured(owner)) throw lastError;
   throw new DevToolsEndpointError(
     [
       "Unable to auto-launch a Chromium-family browser for Chrome DevTools.",
       `Tried: ${candidates.map(formatBrowserCandidate).join(", ")}`,
       lastError ? `Last error: ${formatError2(lastError)}` : void 0,
-      launchHint(),
+      launchHint(owner),
       endpointConfigHint()
     ].filter(Boolean).join("\n")
   );
 }
-async function requireSupportedExtensionBrowser(candidate, generation, signal) {
+async function requireSupportedExtensionBrowser(candidate, generation, signal, owner) {
   let version;
   try {
     version = (await browserManagerOperations.inspectBrowserVersion(candidate.resolvedExecutable, signal)).trim();
   } catch (error) {
-    throwIfBrowserLaunchCancelled(generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     throw new DevToolsEndpointError(
       `Unable to identify the configured extension browser ${candidate.resolvedExecutable}: ${formatError2(error)}. Configure Chrome for Testing or Chromium.`
     );
   }
-  throwIfBrowserLaunchCancelled(generation, signal);
+  throwIfBrowserLaunchCancelled(generation, signal, owner);
   const classification = classifyExtensionBrowserVersion(version);
   if (!classification.supported) {
     throw new DevToolsEndpointError(
@@ -643,19 +881,19 @@ function classifyExtensionBrowserVersion(version) {
   const product = version.trim().replace(/\s+\d+(?:\.\d+)*.*$/, "") || "Unknown";
   return { supported: false, product };
 }
-async function launchBrowserCandidate(candidate, waitMs, generation, signal) {
-  throwIfBrowserLaunchCancelled(generation, signal);
+async function launchBrowserCandidate(candidate, waitMs, generation, signal, owner) {
+  throwIfBrowserLaunchCancelled(generation, signal, owner);
   const userDataDir = await browserManagerOperations.mkdtemp(
     join2(tmpdir(), MANAGED_BROWSER_PROFILE_PREFIX)
   );
   let managedBrowser;
   try {
-    throwIfBrowserLaunchCancelled(generation, signal);
-    const portArgument = state.portConfigured ? String(state.port) : "0";
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
+    const portArgument = managedBrowserPortConfigured(owner) ? String(managedBrowserPort(owner)) : "0";
     const args = buildManagedBrowserLaunchArguments(
       userDataDir,
       portArgument,
-      state.extensionPaths
+      managedBrowserExtensionPaths(owner)
     );
     const child = browserManagerOperations.spawn(candidate.resolvedExecutable, args, {
       shell: false,
@@ -666,37 +904,42 @@ async function launchBrowserCandidate(candidate, waitMs, generation, signal) {
       userDataDir,
       exited: false,
       ready: false,
-      ownerGeneration: generation
+      ownerGeneration: generation,
+      ...owner ? { sessionOwner: owner } : {}
     };
     managedBrowser = launchedBrowser;
-    state.managedBrowser = launchedBrowser;
+    setManagedBrowser(owner, launchedBrowser);
     child.once("exit", () => {
+      if (managedBrowserForOwner(owner) === launchedBrowser && owner) {
+        invalidateWebMcpOperations(owner, "Chrome DevTools managed browser exited");
+      }
       launchedBrowser.exited = true;
       launchedBrowser.ready = false;
-      if (!state.portConfigured && launchedBrowser.port === state.port) {
-        state.port = state.configuredPort;
+      if (!managedBrowserPortConfigured(owner) && launchedBrowser.port === managedBrowserPort(owner)) {
+        setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
       }
     });
     await waitForBrowserSpawn(child);
-    throwIfBrowserLaunchCancelled(generation, signal);
-    if (state.portConfigured) {
-      launchedBrowser.port = state.port;
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
+    if (managedBrowserPortConfigured(owner)) {
+      launchedBrowser.port = managedBrowserPort(owner);
     } else {
       launchedBrowser.port = await readManagedBrowserPort(
         userDataDir,
         launchedBrowser,
         waitMs,
         generation,
-        signal
+        signal,
+        owner
       );
-      throwIfBrowserLaunchCancelled(generation, signal);
-      state.port = launchedBrowser.port;
+      throwIfBrowserLaunchCancelled(generation, signal, owner);
+      setManagedBrowserPort(owner, launchedBrowser.port);
     }
-    await waitForDevToolsEndpoint(waitMs, launchedBrowser, generation, signal);
-    throwIfBrowserLaunchCancelled(generation, signal);
+    await waitForDevToolsEndpoint(waitMs, launchedBrowser, generation, signal, owner);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     launchedBrowser.ready = true;
   } catch (error) {
-    if (managedBrowser) await shutdownManagedBrowser(managedBrowser, { awaitLaunch: false });
+    if (managedBrowser) await shutdownManagedBrowser(managedBrowser, { awaitLaunch: false, owner });
     else {
       await browserManagerOperations.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
     }
@@ -734,7 +977,7 @@ function waitForBrowserSpawn(child) {
     child.once("spawn", onSpawn);
   });
 }
-async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, generation, signal) {
+async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, generation, signal, owner) {
   const activePortFile = join2(userDataDir, DEVTOOLS_ACTIVE_PORT_FILE);
   const deadline = Date.now() + waitMs;
   while (true) {
@@ -743,7 +986,7 @@ async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, gener
       if (isNodeError2(error) && error.code === "ENOENT") return void 0;
       throw error;
     });
-    throwIfBrowserLaunchCancelled(generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     const portText = text?.split(/\r?\n/, 1)[0]?.trim();
     const port = Number(portText);
     if (Number.isInteger(port) && port > 0) return port;
@@ -753,31 +996,31 @@ async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, gener
         [
           "Timed out waiting for auto-launched browser DevToolsActivePort.",
           `Expected file: ${activePortFile}`,
-          launchHint()
+          launchHint(owner)
         ].join("\n")
       );
     }
     await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs), signal);
   }
 }
-async function waitForDevToolsEndpoint(waitMs, managedBrowser, generation, signal) {
+async function waitForDevToolsEndpoint(waitMs, managedBrowser, generation, signal, owner) {
   const deadline = Date.now() + waitMs;
   while (true) {
     throwIfManagedBrowserExited(managedBrowser);
     try {
-      await fetchDevToolsJson("/json/version", { signal });
-      throwIfBrowserLaunchCancelled(generation, signal);
+      await fetchDevToolsJson("/json/version", { signal }, owner);
+      throwIfBrowserLaunchCancelled(generation, signal, owner);
       return;
     } catch (error) {
       if (!isRetryableEndpointError(error)) throw error;
     }
-    throwIfBrowserLaunchCancelled(generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
       throw new DevToolsEndpointError(
         [
-          `Timed out waiting for auto-launched browser at ${devToolsEndpoint()}.`,
-          launchHint()
+          `Timed out waiting for auto-launched browser at ${devToolsEndpoint(owner)}.`,
+          launchHint(owner)
         ].join("\n")
       );
     }
@@ -788,28 +1031,44 @@ function throwIfManagedBrowserExited(managedBrowser) {
   if (!managedBrowser.exited) return;
   throw new DevToolsEndpointError("Auto-launched browser exited before DevTools became available.");
 }
-function throwIfBrowserLaunchCancelled(generation, signal) {
-  if (!state.shuttingDown && generation === state.sessionGeneration && !signal.aborted) {
-    return;
-  }
+function throwIfBrowserLaunchCancelled(generation, signal, owner) {
+  const currentGeneration = owner ? managedBrowserScope(owner).generation : state.sessionGeneration;
+  const shuttingDown = owner ? signal.aborted : state.shuttingDown;
+  if (!shuttingDown && generation === currentGeneration && !signal.aborted) return;
   throw new DevToolsEndpointError(
-    generation === state.sessionGeneration ? "Chrome DevTools browser launch cancelled during shutdown." : "Chrome DevTools browser launch cancelled because the session was replaced."
+    generation === currentGeneration ? "Chrome DevTools browser launch cancelled during shutdown." : "Chrome DevTools browser launch cancelled because the session was replaced."
   );
 }
-async function shutdownManagedBrowser(managedBrowser = state.managedBrowser, options = {}) {
-  if (options.cancelLaunch) state.shuttingDown = true;
+async function shutdownManagedBrowser(managedBrowser, options = {}) {
+  const owner = options.owner ?? managedBrowser?.sessionOwner;
+  if (options.cancelLaunch) {
+    if (owner) {
+      const scope = managedBrowserScope(owner);
+      scope.controller.abort(
+        new DOMException("Chrome DevTools browser launch cancelled during shutdown", "AbortError")
+      );
+      scope.generation += 1;
+    } else {
+      state.shuttingDown = true;
+    }
+  }
+  managedBrowser ??= managedBrowserForOwner(owner);
   if (options.awaitLaunch !== false) {
-    await state.launchPromise?.catch(() => void 0);
-    managedBrowser = managedBrowser ?? state.managedBrowser;
+    await launchPromiseForOwner(owner)?.catch(() => void 0);
+    managedBrowser ??= managedBrowserForOwner(owner);
   }
   if (!managedBrowser) return;
   if (managedBrowser.cleanupPromise) return managedBrowser.cleanupPromise;
-  const cleanup = cleanupManagedBrowser(managedBrowser);
+  const cleanup = cleanupManagedBrowser(managedBrowser, owner);
   managedBrowser.cleanupPromise = cleanup;
   return cleanup;
 }
-async function cleanupManagedBrowser(managedBrowser) {
-  if (state.managedBrowser === managedBrowser) state.managedBrowser = void 0;
+async function cleanupManagedBrowser(managedBrowser, owner) {
+  if (managedBrowserForOwner(owner) === managedBrowser) {
+    if (owner) invalidateWebMcpOperations(owner, "Chrome DevTools managed browser closed");
+    if (state.managedBrowser === managedBrowser) state.managedBrowser = void 0;
+    else setManagedBrowser(owner, void 0);
+  }
   if (!managedBrowser.exited) {
     killManagedBrowserProcess(managedBrowser);
     await waitForManagedBrowserExit(managedBrowser, BROWSER_SHUTDOWN_WAIT_MS).catch(async () => {
@@ -820,8 +1079,8 @@ async function cleanupManagedBrowser(managedBrowser) {
     });
   }
   await browserManagerOperations.rm(managedBrowser.userDataDir, { recursive: true, force: true }).catch(() => void 0);
-  if (!state.portConfigured && managedBrowser.port === state.port) {
-    state.port = state.configuredPort;
+  if (!managedBrowserPortConfigured(owner) && managedBrowser.port === managedBrowserPort(owner)) {
+    setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
   }
 }
 function killManagedBrowserProcess(managedBrowser, signal) {
@@ -851,8 +1110,8 @@ function waitForManagedBrowserExit(managedBrowser, waitMs) {
     managedBrowser.process.once("close", onExitOrClose);
   });
 }
-async function fetchDevToolsJson(path, init) {
-  const url = `${devToolsEndpoint()}${path}`;
+async function fetchDevToolsJson(path, init, owner) {
+  const url = `${devToolsEndpoint(owner)}${path}`;
   let response;
   try {
     const timeoutSignal = AbortSignal.timeout(DEFAULT_HTTP_TIMEOUT_MS);
@@ -861,7 +1120,7 @@ async function fetchDevToolsJson(path, init) {
       signal: init?.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal
     });
   } catch (error) {
-    throw new DevToolsEndpointError(endpointConnectionErrorMessage(error), {
+    throw new DevToolsEndpointError(endpointConnectionErrorMessage(error, owner), {
       launchable: true,
       retryable: true
     });
@@ -888,16 +1147,20 @@ async function fetchDevToolsJson(path, init) {
     );
   }
 }
-async function withEndpointRetry(operation, waitMs) {
+async function withEndpointRetry(operation, waitMs, signal) {
   const deadline = Date.now() + waitMs;
   while (true) {
+    signal?.throwIfAborted();
     try {
       return await operation();
     } catch (error) {
       if (!isRetryableEndpointError(error)) throw error;
       const remainingMs = deadline - Date.now();
       if (remainingMs <= 0) throw error;
-      await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs));
+      await browserManagerOperations.sleep(
+        Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs),
+        signal
+      );
     }
   }
 }
@@ -907,100 +1170,101 @@ function isRetryableEndpointError(error) {
 function isLaunchableEndpointError(error) {
   return error instanceof DevToolsEndpointError && error.launchable;
 }
-function shouldAutoLaunchAfterEndpointError(error) {
-  if (!canAutoLaunchBrowser()) return false;
+function shouldAutoLaunchAfterEndpointError(error, owner) {
+  if (!canAutoLaunchBrowser(owner)) return false;
   if (isLaunchableEndpointError(error)) return true;
-  return !state.portConfigured && error instanceof DevToolsEndpointError;
+  return !managedBrowserPortConfigured(owner) && error instanceof DevToolsEndpointError;
 }
-function canAutoLaunchBrowser() {
-  return state.autoLaunchEnabled && isLocalDevToolsHost(state.host);
+function canAutoLaunchBrowser(owner) {
+  const browser = browserSettingsForOwner(owner);
+  return browser.autoLaunchEnabled && isLocalDevToolsHost(browser.host);
 }
-function extensionsConfigured() {
-  return state.extensionPaths.length > 0;
+function extensionsConfigured(owner) {
+  return managedBrowserExtensionPaths(owner).length > 0;
 }
-function endpointConnectionErrorMessage(error) {
+function endpointConnectionErrorMessage(error, owner) {
   const reason = isTimeoutError(error) ? "request timed out" : "connection failed";
   return [
-    `Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint()} (${reason}).`,
-    launchHint(),
+    `Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint(owner)} (${reason}).`,
+    launchHint(owner),
     endpointConfigHint()
   ].join("\n");
 }
 function isTimeoutError(error) {
   return error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name);
 }
-function devToolsEndpoint() {
-  return `http://${formatHostForUrl(state.host)}:${state.port}`;
+function devToolsEndpoint(owner) {
+  return `http://${formatHostForUrl(browserSettingsForOwner(owner).host)}:${managedBrowserPort(owner)}`;
 }
 function formatHostForUrl(host) {
   if (host.startsWith("[") && host.endsWith("]")) return host;
   return host.includes(":") ? `[${host}]` : host;
 }
-function endpointSourceLabel() {
-  return state.endpointSource;
+function endpointSourceLabel(owner) {
+  return browserSettingsForOwner(owner).endpointSource;
 }
-function browserLifecycleState() {
-  if (state.launchPromise) return "starting";
-  if (state.managedBrowser?.exited) return "exited";
-  if (state.managedBrowser?.ready) return "running";
-  if (state.lastLaunchAttempt?.lastError) return "failed";
+function browserLifecycleState(owner) {
+  if (launchPromiseForOwner(owner)) return "starting";
+  if (managedBrowserForOwner(owner)?.exited) return "exited";
+  if (managedBrowserForOwner(owner)?.ready) return "running";
+  if (lastLaunchAttempt(owner)?.lastError) return "failed";
   return "unobserved";
 }
-function launchModeLabel() {
-  if (extensionsConfigured()) {
-    if (!isLocalDevToolsHost(state.host)) return "invalid; extensions require a local endpoint";
-    if (!state.autoLaunchEnabled) return "invalid; extensions require auto-launch";
-    if (state.managedBrowser && !state.managedBrowser.exited) {
-      return state.portConfigured ? "extension-owned browser on explicit port" : "extension-owned browser on dynamic port";
+function launchModeLabel(owner) {
+  const browser = browserSettingsForOwner(owner);
+  const managedBrowser = managedBrowserForOwner(owner);
+  if (extensionsConfigured(owner)) {
+    if (!isLocalDevToolsHost(browser.host)) return "invalid; extensions require a local endpoint";
+    if (!browser.autoLaunchEnabled) return "invalid; extensions require auto-launch";
+    if (managedBrowser && !managedBrowser.exited) {
+      return managedBrowserPortConfigured(owner) ? "extension-owned browser on explicit port" : "extension-owned browser on dynamic port";
     }
-    return state.portConfigured ? "force extension-owned launch on explicit port" : "force extension-owned launch on dynamic port";
+    return managedBrowserPortConfigured(owner) ? "force extension-owned launch on explicit port" : "force extension-owned launch on dynamic port";
   }
-  if (!isLocalDevToolsHost(state.host)) return "manual remote endpoint";
-  if (!state.autoLaunchEnabled) return "manual; auto-launch disabled";
-  if (state.managedBrowser && !state.managedBrowser.exited) {
-    return state.portConfigured ? "auto-launched on explicit port" : "auto-launched on dynamic port";
+  if (!isLocalDevToolsHost(browser.host)) return "manual remote endpoint";
+  if (!browser.autoLaunchEnabled) return "manual; auto-launch disabled";
+  if (managedBrowser && !managedBrowser.exited) {
+    return managedBrowserPortConfigured(owner) ? "auto-launched on explicit port" : "auto-launched on dynamic port";
   }
-  return state.portConfigured ? "attach first; auto-launch explicit port" : "attach first; auto-launch dynamic port";
+  return managedBrowserPortConfigured(owner) ? "attach first; auto-launch explicit port" : "attach first; auto-launch dynamic port";
 }
-function launchAttemptLines() {
-  if (!state.lastLaunchAttempt) return [];
-  const lines = [`Last launch attempt: ${state.lastLaunchAttempt.mode}`];
-  if (state.lastLaunchAttempt.selectedCandidate) {
-    lines.push(`Launched browser: ${state.lastLaunchAttempt.selectedCandidate}`);
+function launchAttemptLines(owner) {
+  const attempt = lastLaunchAttempt(owner);
+  if (!attempt) return [];
+  const lines = [`Last launch attempt: ${attempt.mode}`];
+  if (attempt.selectedCandidate) {
+    lines.push(`Launched browser: ${attempt.selectedCandidate}`);
   } else {
-    lines.push(`Tried browser candidates: ${state.lastLaunchAttempt.candidateLabels.join(", ")}`);
-  }
-  if (state.lastLaunchAttempt.userDataDir) {
-    lines.push(`Managed browser profile: ${state.lastLaunchAttempt.userDataDir}`);
-  }
-  if (state.lastLaunchAttempt.lastError) {
-    lines.push(`Last launch error: ${state.lastLaunchAttempt.lastError}`);
+    lines.push(`Tried browser candidates: ${attempt.candidateLabels.join(", ")}`);
   }
+  if (attempt.userDataDir) lines.push(`Managed browser profile: ${attempt.userDataDir}`);
+  if (attempt.lastError) lines.push(`Last launch error: ${attempt.lastError}`);
   return lines;
 }
-function launchHint() {
-  if (extensionsConfigured()) {
+function launchHint(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (extensionsConfigured(owner)) {
     return "Configured unpacked extensions force an isolated extension-owned launch; existing CDP browsers are never reused, modified, or closed.";
   }
-  if (!isLocalDevToolsHost(state.host)) {
-    return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint()}.`;
+  if (!isLocalDevToolsHost(browser.host)) {
+    return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint(owner)}.`;
   }
-  if (!state.autoLaunchEnabled) {
-    return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand()}`;
+  if (!browser.autoLaunchEnabled) {
+    return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand(owner)}`;
   }
-  const managedMode = state.portConfigured ? `port ${state.port}` : "a dynamic DevTools port";
-  return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand()}`;
+  const managedMode = managedBrowserPortConfigured(owner) ? `port ${managedBrowserPort(owner)}` : "a dynamic DevTools port";
+  return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand(owner)}`;
 }
-function browserCandidateHint() {
-  if (extensionsConfigured()) {
+function browserCandidateHint(owner) {
+  if (extensionsConfigured(owner)) {
     return "Extension browser requirement: configure Chrome for Testing or Chromium with browser.executablePath; branded Chrome is rejected because it may ignore unpacked-extension flags.";
   }
-  return `Browser candidates: ${browserCandidateDefinitions().map((candidate) => candidate.label).join(", ")}`;
+  return `Browser candidates: ${browserCandidateDefinitions(owner).map((candidate) => candidate.label).join(", ")}`;
 }
-function chromeLaunchCommand() {
-  const executable = state.browserExecutable ?? defaultManualBrowserExecutable();
+function chromeLaunchCommand(owner) {
+  const executable = browserSettingsForOwner(owner).executablePath ?? defaultManualBrowserExecutable();
   const dataDir = process.platform === "win32" ? "%TEMP%\\pi-chrome-devtools" : "/tmp/pi-chrome-devtools";
-  return `${quoteCommandPart(executable)} --remote-debugging-port=${state.port} --user-data-dir=${dataDir}`;
+  return `${quoteCommandPart(executable)} --remote-debugging-port=${managedBrowserPort(owner)} --user-data-dir=${dataDir}`;
 }
 function defaultManualBrowserExecutable() {
   return process.platform === "darwin" ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" : process.platform === "win32" ? "chrome.exe" : "google-chrome";
@@ -1015,17 +1279,18 @@ function isLocalDevToolsHost(host) {
   const normalizedHost = host.toLowerCase().replace(/^\[(.*)]$/, "$1");
   return ["localhost", "127.0.0.1", "::1", "0:0:0:0:0:0:0:1"].includes(normalizedHost);
 }
-function browserCandidateDefinitions() {
-  const explicitCandidate = explicitBrowserCandidateDefinition();
+function browserCandidateDefinitions(owner) {
+  const explicitCandidate = explicitBrowserCandidateDefinition(owner);
   if (explicitCandidate.length > 0) return explicitCandidate;
   return uniqueBrowserCandidates(platformBrowserCandidateDefinitions());
 }
-function explicitBrowserCandidateDefinition() {
-  if (!state.browserExecutable) return [];
+function explicitBrowserCandidateDefinition(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (!browser.executablePath) return [];
   return [
     {
-      label: state.browserExecutableSource === "environment" ? "PI_CHROME_DEVTOOLS_BROWSER" : "browser.executablePath",
-      executable: state.browserExecutable,
+      label: browser.executablePathSource === "environment" ? "PI_CHROME_DEVTOOLS_BROWSER" : "browser.executablePath",
+      executable: browser.executablePath,
       source: "env"
     }
   ];
@@ -1111,11 +1376,11 @@ function uniqueBrowserCandidates(candidates) {
     return true;
   });
 }
-async function resolveBrowserCandidates(definitions, generation, signal) {
+async function resolveBrowserCandidates(definitions, generation, signal, owner) {
   const candidates = [];
   for (const definition of definitions) {
     const resolvedExecutable = await resolveBrowserExecutable(definition.executable);
-    throwIfBrowserLaunchCancelled(generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal, owner);
     if (!resolvedExecutable) continue;
     candidates.push({ ...definition, resolvedExecutable });
   }
@@ -1170,8 +1435,8 @@ function formatBrowserCandidate(candidate) {
 function formatBrowserCandidateDefinition(candidate) {
   return `${candidate.label} (${candidate.executable})`;
 }
-function noBrowserCandidateMessage(candidateDefinitions) {
-  if (extensionsConfigured()) {
+function noBrowserCandidateMessage(candidateDefinitions, owner) {
+  if (extensionsConfigured(owner)) {
     return [
       "Cannot launch unpacked extensions because the configured browser executable was not found or is not executable.",
       `Tried: ${candidateDefinitions.map(formatBrowserCandidateDefinition).join(", ")}`,
@@ -1249,412 +1514,46 @@ var DevToolsEndpointError = class extends Error {
   }
 };
 
-// src/lazy-tools.ts
-import {
-  defineTool
-} from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-var CHROME_DEVTOOLS_LOAD_TOOL_NAME = "chrome_devtools_load";
-var AVAILABLE_TOOLS_STORE = /* @__PURE__ */ Symbol.for("@narumitw/pi-chrome-devtools.available-tools-store");
-var sharedGlobal = globalThis;
-var existingAvailableToolsStore = sharedGlobal[AVAILABLE_TOOLS_STORE];
-var availableToolsByApi = existingAvailableToolsStore ?? /* @__PURE__ */ new WeakMap();
-if (!existingAvailableToolsStore) sharedGlobal[AVAILABLE_TOOLS_STORE] = availableToolsByApi;
-var lazyExposureByApi = /* @__PURE__ */ new WeakMap();
-var SEARCH_TEXT = {
-  chrome_devtools_list_pages: "list open inspectable chrome browser pages tabs targets",
-  chrome_devtools_select_page: "select choose active chrome browser page tab target",
-  chrome_devtools_navigate: "navigate open create chrome browser page url website",
-  chrome_devtools_evaluate: "evaluate run javascript expression dom inspect chrome browser page",
-  chrome_devtools_screenshot: "capture screenshot png image visual chrome browser page"
-};
-function initializeAvailableChromeDevtoolsTools(pi) {
-  if (availableToolsByApi.has(pi)) return;
-  const activeTools = new Set(pi.getActiveTools());
-  setAvailableTools(
-    pi,
-    CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => activeTools.has(name))
-  );
-}
-function configureChromeDevtoolsToolExposure(pi, availableTools, model) {
-  const available = setAvailableTools(pi, availableTools);
-  const lazyExposure = supportsNativeDeferredToolLoading(model);
-  lazyExposureByApi.set(pi, lazyExposure);
-  const exposedTools = lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
-  const nonCapabilityTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
-  pi.setActiveTools(
-    unique([...nonCapabilityTools, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...exposedTools])
-  );
-}
-function requireEagerChromeDevtoolsToolExposure(pi) {
-  lazyExposureByApi.set(pi, false);
-  const active = pi.getActiveTools();
-  const available = availableChromeDevtoolsTools(pi);
-  pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...available]));
-}
-function applyAvailableChromeDevtoolsTools(pi, availableTools) {
-  const available = setAvailableTools(pi, availableTools);
-  const lazyExposure = lazyExposureByApi.get(pi) === true;
-  const active = pi.getActiveTools().filter(
-    (name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name) || lazyExposure && available.has(name)
-  );
-  const eagerTools = lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
-  pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...eagerTools]));
-}
-function chromeDevtoolsToolExposureMode(pi) {
-  return lazyExposureByApi.get(pi) === true ? "native deferred" : "eager";
-}
-function supportsNativeDeferredToolLoading(model) {
-  if (!model) return false;
-  if (model.api === "anthropic-messages") {
-    const configured = compatBoolean(model.compat, "supportsToolReferences");
-    if (configured !== void 0) return configured;
-    if (model.provider !== "anthropic" || model.id.includes("haiku")) return false;
-    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
-    if (!version) return false;
-    const major = Number(version[1]);
-    const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
-    return major > 4 || major === 4 && minor >= 5;
-  }
-  if (model.api === "openai-completions") {
-    return compatString(model.compat, "deferredToolsMode") === "kimi";
-  }
-  if (model.api === "openai-responses" || model.api === "openai-codex-responses") {
-    return compatBoolean(model.compat, "supportsAdditionalTools") === true || compatBoolean(model.compat, "supportsToolSearch") === true;
-  }
-  return false;
-}
-function availableChromeDevtoolsTools(pi) {
-  const available = availableToolsByApi.get(pi) ?? /* @__PURE__ */ new Set();
-  return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
-}
-function createChromeDevtoolsLoadTool(pi) {
-  return defineTool({
-    name: CHROME_DEVTOOLS_LOAD_TOOL_NAME,
-    label: "Chrome DevTools: Load Tools",
-    description: "Find and enable Chrome DevTools browser tools relevant to a task. Loaded tools remain available for the session.",
-    promptSnippet: "Load Chrome DevTools browser capabilities on demand",
-    promptGuidelines: [
-      "Use chrome_devtools_load when a task requires inspecting or controlling a Chrome browser and the needed chrome_devtools_* capability is not active."
-    ],
-    parameters: Type.Object({
-      query: Type.String({
-        description: "Browser capability or task to find tools for.",
-        maxLength: 500
-      }),
-      limit: Type.Optional(
-        Type.Integer({
-          description: "Maximum tools to load. Defaults to 3.",
-          minimum: 1,
-          maximum: 5
-        })
-      )
-    }),
-    async execute(_toolCallId, params, signal) {
-      signal?.throwIfAborted();
-      const available = new Set(availableChromeDevtoolsTools(pi));
-      const matches = matchChromeDevtoolsTools(params.query, params.limit ?? 3, available);
-      const active = pi.getActiveTools();
-      const activeSet = new Set(active);
-      const added = matches.filter((name) => !activeSet.has(name));
-      if (added.length > 0) {
-        pi.setActiveTools(unique([...active, ...added]));
-      }
-      const text = matches.length === 0 ? "No available Chrome DevTools tools matched the query." : added.length > 0 ? `Loaded Chrome DevTools tools: ${added.join(", ")}` : `Matching Chrome DevTools tools are already loaded: ${matches.join(", ")}`;
-      return {
-        content: [{ type: "text", text }],
-        details: { matches, added }
-      };
-    }
-  });
-}
-function matchChromeDevtoolsTools(query, limit, available) {
-  const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length >= 2);
-  if (terms.length === 0) return [];
-  return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name)).map((name, index) => ({
-    name,
-    index,
-    score: terms.reduce((score, term) => score + (SEARCH_TEXT[name].includes(term) ? 1 : 0), 0)
-  })).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.index - right.index).slice(0, limit).map((match) => match.name);
-}
-function setAvailableTools(pi, availableTools) {
-  const available = new Set(availableTools);
-  availableToolsByApi.set(pi, available);
-  return available;
-}
-function compatBoolean(value, key) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const record = value;
-  return typeof record[key] === "boolean" ? record[key] : void 0;
-}
-function compatString(value, key) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const record = value;
-  return typeof record[key] === "string" ? record[key] : void 0;
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-
-// src/tool-selector.ts
-import { stripVTControlCharacters } from "node:util";
-function unique2(values) {
-  return Array.from(new Set(values));
-}
-function formatError3(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-async function updateChromeDevtoolsTools(pi, ctx, selectedTools, action) {
-  const generation = state.sessionGeneration;
-  const result = await transactSelectedTools(pi, ctx, selectedTools, generation);
-  if (result !== "saved" || generation !== state.sessionGeneration) return;
-  const status = await buildToolStatusMessage(pi);
-  if (generation !== state.sessionGeneration) return;
-  ctx.ui.notify(`Chrome DevTools tool catalog ${action}.
-
-${status}`, "info");
-}
-async function setSelectedChromeDevtoolsTools(pi, ctx, selectedTools, expectedActiveTools) {
-  return transactSelectedTools(
-    pi,
-    ctx,
-    selectedTools,
-    state.sessionGeneration,
-    expectedActiveTools
-  );
-}
-var toolTransactionQueue = Promise.resolve();
-async function waitForChromeDevtoolsSettings() {
-  await toolTransactionQueue;
-}
-function transactSelectedTools(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
-  const operation = toolTransactionQueue.then(
-    () => transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools)
-  );
-  toolTransactionQueue = operation.then(
-    () => void 0,
-    () => void 0
-  );
-  return operation;
-}
-async function transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
-  if (expectedGeneration !== state.sessionGeneration) return "failed";
-  if (expectedActiveTools && !arraysEqual(availableChromeDevtoolsTools(pi), expectedActiveTools)) {
-    ctx.ui.notify(
-      "Browser tool selection changed while review was open. Review the current state, then apply again.",
-      "warning"
-    );
-    return "active-tools-changed";
-  }
-  const previousActiveTools = pi.getActiveTools();
-  const previousAvailableTools = availableChromeDevtoolsTools(pi);
-  try {
-    applyChromeDevtoolsTools(pi, selectedTools);
-    await persistSettings(selectedTools);
-    return expectedGeneration === state.sessionGeneration ? "saved" : "failed";
-  } catch (error) {
-    let rollbackError;
-    try {
-      applyAvailableChromeDevtoolsTools(pi, previousAvailableTools);
-      const currentNonChromeTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
-      const previousLoadedChromeTools = previousActiveTools.filter(
-        (name) => CHROME_DEVTOOLS_TOOL_NAMES.includes(name)
-      );
-      const restoredChromeTools = chromeDevtoolsToolExposureMode(pi) === "eager" ? previousAvailableTools : previousLoadedChromeTools;
-      pi.setActiveTools(unique2([...currentNonChromeTools, ...restoredChromeTools]));
-    } catch (caught) {
-      rollbackError = caught;
-    }
-    if (expectedGeneration !== state.sessionGeneration) return "failed";
-    ctx.ui.notify(
-      sanitizeChromeDevtoolsDisplay(
-        rollbackError ? `Chrome DevTools settings save failed: ${formatError3(error)}; active-tool rollback failed: ${formatError3(rollbackError)}` : `Chrome DevTools settings save failed; active tools restored: ${formatError3(error)}`
-      ),
-      "warning"
-    );
-    return "failed";
-  }
-}
-function arraysEqual(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function applyChromeDevtoolsTools(pi, selectedTools) {
-  applyAvailableChromeDevtoolsTools(pi, selectedTools);
-}
-function getToolStatusSummary(pi) {
-  const chromeToolNames = new Set(CHROME_DEVTOOLS_TOOL_NAMES);
-  const activeToolNames = new Set(pi.getActiveTools());
-  const loadedChromeToolCount = CHROME_DEVTOOLS_TOOL_NAMES.filter(
-    (name) => activeToolNames.has(name)
-  ).length;
-  const availableChromeToolCount = availableChromeDevtoolsTools(pi).length;
-  const activeNonChromeToolCount = Array.from(activeToolNames).filter(
-    (name) => !chromeToolNames.has(name) && name !== CHROME_DEVTOOLS_LOAD_TOOL_NAME
-  ).length;
-  const availabilityStatus = availableChromeToolCount === CHROME_DEVTOOLS_TOOL_NAMES.length ? "enabled" : availableChromeToolCount === 0 ? "disabled" : "partial";
-  return {
-    availabilityStatus,
-    availableChromeToolCount,
-    loadedChromeToolCount,
-    activeNonChromeToolCount
-  };
-}
-async function buildToolStatusMessage(pi) {
-  const summary = getToolStatusSummary(pi);
-  const persistedSetting = await persistedSettingLabel();
-  return sanitizeChromeDevtoolsDisplay(
-    [
-      `Chrome DevTools tools available: ${formatRuntimeStatus(summary)}`,
-      `Tool exposure: ${chromeDevtoolsToolExposureMode(pi)}`,
-      `Loaded capability tools this session: ${summary.loadedChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length}`,
-      `Loader: ${pi.getActiveTools().includes(CHROME_DEVTOOLS_LOAD_TOOL_NAME) ? "active" : "inactive"}`,
-      `Persisted tool catalog: ${persistedSetting}`,
-      ...browserSettingsStatusLines(),
-      ...state.settingsNotice ? [`Settings note: ${state.settingsNotice}`] : [],
-      `Other active tools preserved: ${summary.activeNonChromeToolCount}`,
-      `Endpoint: ${devToolsEndpoint()}`,
-      `Endpoint source: ${endpointSourceLabel()}`,
-      `Launch mode: ${launchModeLabel()}`,
-      ...launchAttemptLines()
-    ].join("\n")
-  );
-}
-function buildQuickstartMessage() {
-  return buildSettingsSetupMessage();
-}
-function buildBrowserStatusMessage() {
-  const lifecycle = browserLifecycleState();
-  const browserState = lifecycle === "starting" ? "starting managed browser" : lifecycle === "running" ? "managed browser running" : lifecycle === "exited" ? "managed browser exited" : lifecycle === "failed" ? "last launch failed" : "not started; connection has not been checked";
-  const needsRecovery = lifecycle === "exited" || lifecycle === "failed";
-  return sanitizeChromeDevtoolsDisplay(
-    [
-      `Browser: ${browserState}`,
-      "Viewing this status does not probe the endpoint or launch Chrome.",
-      `Endpoint: ${devToolsEndpoint()}`,
-      `Endpoint source: ${endpointSourceLabel()}`,
-      `Launch mode: ${launchModeLabel()}`,
-      `Unpacked extensions: ${state.extensionPaths.length} (${state.extensionPathsSource})`,
-      ...state.extensionPaths.length > 0 ? ["Unpacked extensions execute trusted browser code in an isolated managed browser."] : [],
-      ...launchAttemptLines(),
-      ...needsRecovery ? [launchHint(), endpointConfigHint()] : []
-    ].join("\n")
-  );
-}
-function buildSettingsSetupMessage() {
-  return sanitizeChromeDevtoolsDisplay(
-    [
-      `Chrome DevTools endpoint: ${devToolsEndpoint()}`,
-      `Endpoint source: ${endpointSourceLabel()}`,
-      `Launch mode: ${launchModeLabel()}`,
-      ...browserSettingsStatusLines(),
-      launchHint(),
-      browserCandidateHint(),
-      ...launchAttemptLines(),
-      endpointConfigHint()
-    ].join("\n")
-  );
-}
-function sanitizeChromeDevtoolsDisplay(value, maxCharacters = 5e4) {
-  const sanitized = Array.from(stripVTControlCharacters(value), (character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    const unsafeControl = codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
-    return unsafeControl ? "\uFFFD" : character;
-  }).join("");
-  if (sanitized.length <= maxCharacters) return sanitized;
-  return `${sanitized.slice(0, Math.max(0, maxCharacters - 1))}\u2026`;
-}
-function browserSettingsStatusLines() {
-  const extensionLines = state.extensionPaths.length > 0 ? state.extensionPaths.map((extensionPath) => `  - ${extensionPath}`) : ["  - none"];
-  return [
-    `Settings file: ${state.settingsFilePath ?? settingsFilePath()} (user)`,
-    ...state.projectSettingsFilePath ? [
-      `Project settings: ${state.projectSettingsFilePath} (${state.projectSettingsTrusted ? "trusted" : "untrusted; ignored"})`
-    ] : [],
-    `Auto-launch: ${state.autoLaunchEnabled ? "on" : "off"} (${state.autoLaunchSource})`,
-    `Browser executable: ${state.browserExecutable ?? "automatic discovery"} (${state.browserExecutableSource})`,
-    `Unpacked extensions (${state.extensionPathsSource}):`,
-    ...extensionLines,
-    "Confirmed menu settings apply before the next browser connection; manual JSON edits require /reload or session replacement.",
-    ...state.extensionPaths.length > 0 ? [
-      "Unpacked extensions require Chrome for Testing or Chromium and execute trusted browser code."
-    ] : []
-  ];
-}
-function buildCommandGuide() {
-  return [
-    "Chrome DevTools commands:",
-    "/chrome-devtools \u2014 open this menu",
-    "/chrome-devtools help \u2014 show command usage",
-    "/chrome-devtools quickstart \u2014 show endpoint and launch help",
-    "/chrome-devtools status \u2014 show tool and settings status",
-    "/chrome-devtools settings \u2014 edit browser connection settings",
-    "/chrome-devtools tools \u2014 choose available Chrome DevTools tools",
-    "/chrome-devtools toggle|select \u2014 compatibility aliases for tools",
-    "/chrome-devtools enable|on \u2014 make all Chrome DevTools tools available",
-    "/chrome-devtools disable|off \u2014 make all Chrome DevTools capability tools unavailable"
-  ].join("\n");
-}
-function allChromeDevtoolsTools() {
-  return [...CHROME_DEVTOOLS_TOOL_NAMES];
-}
-function formatRuntimeStatus(summary) {
-  return `${summary.availabilityStatus} (${summary.availableChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length} available)`;
-}
-async function persistedSettingLabel() {
-  const settings = await loadSettings();
-  if (settings.kind === "loaded" && settings.settings.tools) {
-    return formatPersistedSelection(settings.settings.tools);
-  }
-  if (settings.kind === "invalid") {
-    return `none; current active-tool policy preserved (invalid settings ignored: ${settings.reason})`;
-  }
-  return "none; current active-tool policy preserved";
-}
-function formatPersistedSelection(tools) {
-  if (tools.length === CHROME_DEVTOOLS_TOOL_NAMES.length) {
-    return `all available (${tools.length}/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
-  }
-  if (tools.length === 0)
-    return `all unavailable (0/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
-  return `${tools.length}/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected: ${tools.join(", ")}`;
-}
-async function persistSettings(selectedTools) {
-  await saveSettings({ tools: [...selectedTools], updatedAt: Date.now() });
-}
-
 export {
+  CORE_CHROME_DEVTOOLS_TOOL_NAMES,
+  WEBMCP_TOOL_NAMES,
   CHROME_DEVTOOLS_TOOL_NAMES,
+  isWebMcpToolName,
   waitForSettingsWrites,
   loadSettings,
   parseBrowserEndpoint,
+  saveSettings,
+  saveWebMcpSettings,
   saveBrowserSettings,
+  settingsFilePath,
   DEFAULT_TIMEOUT_MS,
   DEFAULT_ENDPOINT_WAIT_MS,
   state,
+  setWebMcpSessionOwner,
+  beginWebMcpOperation,
+  invalidateWebMcpOperations,
+  currentWebMcpGeneration,
+  webMcpSessionSignal,
+  applyRuntimeWebMcpSetting,
+  webMcpEnabled,
+  webMcpOperationIsCurrent,
   applyRuntimeBrowserSettings,
+  startManagedBrowserSession,
+  syncManagedBrowserSettings,
+  browserSettingsForOwner,
+  managedBrowserForOwner,
   ensureDevToolsEndpoint,
   shutdownManagedBrowser,
   fetchDevToolsJson,
   withEndpointRetry,
   devToolsEndpoint,
+  endpointSourceLabel,
   browserLifecycleState,
   launchModeLabel,
+  launchAttemptLines,
   launchHint,
-  formatPageListItem,
-  initializeAvailableChromeDevtoolsTools,
-  configureChromeDevtoolsToolExposure,
-  requireEagerChromeDevtoolsToolExposure,
-  supportsNativeDeferredToolLoading,
-  availableChromeDevtoolsTools,
-  createChromeDevtoolsLoadTool,
-  updateChromeDevtoolsTools,
-  setSelectedChromeDevtoolsTools,
-  waitForChromeDevtoolsSettings,
-  buildToolStatusMessage,
-  buildQuickstartMessage,
-  buildBrowserStatusMessage,
-  sanitizeChromeDevtoolsDisplay,
-  buildCommandGuide,
-  allChromeDevtoolsTools
+  browserCandidateHint,
+  endpointConfigHint,
+  formatPageListItem
 };
-//# sourceMappingURL=chunk-RH6KESL3.js.map
+//# sourceMappingURL=chunk-SRT3UUIP.js.map