@vforsh/argus 0.4.0 → 0.5.0

package/dist/argus.js

@@ -2130,7 +2130,7 @@ var {
 // package.json
 var package_default = {
   name: "@vforsh/argus",
-  version: "0.4.0",
+  version: "0.5.0",
   repository: {
     type: "git",
     url: "git+https://github.com/vforsh/argus.git",
@@ -2160,10 +2160,10 @@ var package_default = {
     access: "public"
   },
   dependencies: {
-    "@vforsh/argus-client": "^0.4.0",
-    "@vforsh/argus-core": "^0.4.0",
-    "@vforsh/argus-plugin-api": "^0.4.0",
-    "@vforsh/argus-watcher": "^0.4.0",
+    "@vforsh/argus-client": "^0.5.0",
+    "@vforsh/argus-core": "^0.5.0",
+    "@vforsh/argus-plugin-api": "^0.5.0",
+    "@vforsh/argus-watcher": "^0.5.0",
     commander: "14.0.2",
     esbuild: "0.25.12",
     prettier: "3.7.4"
@@ -2178,19 +2178,23 @@ var package_default = {
 };
 
 // dist/cli/program.js
-function createProgram() {
+function createProgram(options = {}) {
   const program2 = new Command;
   program2.name("argus").description("Argus CLI for local watcher servers").version(package_default.version).option("--plugin <specifier>", "Load an extra CLI plugin for this invocation", collectPluginOption, []).configureOutput({
     outputError: (str, write) => write(str)
-  }).showSuggestionAfterError(true).enablePositionalOptions().exitOverride((error) => {
-    if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
-      process.exit(0);
-    }
-    console.error(error.message);
-    process.exit(2);
-  });
+  }).showSuggestionAfterError(true).enablePositionalOptions().exitOverride(options.mode === "session" ? throwOnExit : exitProcess);
   return program2;
 }
+var throwOnExit = (error) => {
+  throw error;
+};
+var exitProcess = (error) => {
+  if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
+    process.exit(0);
+  }
+  console.error(error.message);
+  process.exit(2);
+};
 var collectPluginOption = (value, previous) => [...previous, value];
 
 // dist/cli/defineCommand.js
@@ -3571,6 +3575,11 @@ var ARGUS_ERROR_CODES = [
   "not_interactable",
   "nth_out_of_range",
   "payload_too_large",
+  "session_command_failed",
+  "session_command_rejected",
+  "session_invalid_request",
+  "session_request_timeout",
+  "session_unknown_command",
   "unexpected_matches",
   "unsupported_platform"
 ];
@@ -3640,6 +3649,53 @@ var describeProtocolMismatch = (protocolVersion, watcherVersion) => {
 };
 // ../argus-core/dist/protocol/native-messaging.js
 var NATIVE_MESSAGING_PROTOCOL_VERSION = 2;
+// ../argus-core/dist/protocol/session.js
+var SESSION_PROTOCOL_VERSION = 1;
+var optionalRequestId = (source, key) => {
+  const field = source[key];
+  if (field == null) {
+    return;
+  }
+  if (typeof field === "string") {
+    return field;
+  }
+  if (typeof field === "number" && Number.isFinite(field)) {
+    return field;
+  }
+  return fieldError(`${key} must be a string or a finite number`);
+};
+var optionalTimeout = (source, key) => {
+  const field = source[key];
+  if (field == null) {
+    return;
+  }
+  if (typeof field === "string") {
+    return field;
+  }
+  if (typeof field === "number" && Number.isFinite(field) && field > 0) {
+    return field;
+  }
+  return fieldError(`${key} must be a duration string or a positive number of milliseconds`);
+};
+var SESSION_REQUEST_SCHEMA = defineProtocolSchema((value) => {
+  const invalid = requireObject(value);
+  if (invalid)
+    return invalid;
+  const source = value;
+  const fields = readFields(source, {
+    id: optionalRequestId,
+    cmd: requiredString,
+    args: optionalRecord,
+    argv: optionalStringArray,
+    timeout: optionalTimeout
+  });
+  if (!fields.ok)
+    return fields;
+  if (fields.value.args && fields.value.argv) {
+    return invalidProtocolPayload("args and argv are mutually exclusive");
+  }
+  return { ok: true, value: compact(fields.value) };
+});
 // ../argus-core/dist/registry/registry.js
 import fs2 from "node:fs/promises";
 import path3 from "node:path";
@@ -4408,9 +4464,16 @@ var ensureTrailingNewline = (value) => value.endsWith(`
 `) ? value : `${value}
 `;
 var configureMachineSafeConsole = (argv) => {
-  if (!argv.includes("--json") && !argv.includes("--json-full")) {
-    return;
+  if (argv.includes("--json") || argv.includes("--json-full") || isMachineOnlyCommand(argv)) {
+    routeConsoleToStderr();
   }
+};
+var MACHINE_ONLY_COMMANDS = new Set(["session"]);
+var isMachineOnlyCommand = (argv) => {
+  const command = argv.find((token, index) => !token.startsWith("-") && argv[index - 1] !== "--plugin");
+  return command != null && MACHINE_ONLY_COMMANDS.has(command);
+};
+var routeConsoleToStderr = () => {
   const writeConsoleError = console.error.bind(console);
   console.log = writeConsoleError;
   console.info = writeConsoleError;
@@ -7211,7 +7274,7 @@ var normalizeTimeout = (value) => {
 // ../argus-watcher/package.json
 var package_default2 = {
   name: "@vforsh/argus-watcher",
-  version: "0.4.0",
+  version: "0.5.0",
   repository: {
     type: "git",
     url: "git+https://github.com/vforsh/argus.git",
@@ -7238,7 +7301,7 @@ var package_default2 = {
   },
   dependencies: {
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@vforsh/argus-core": "^0.4.0",
+    "@vforsh/argus-core": "^0.5.0",
     emittery: "^1.2.0"
   },
   scripts: {
@@ -8299,9 +8362,9 @@ var netMockRoutes = [
 ];
 
 // ../argus-watcher/dist/cdp/pageState.js
-var evaluateInPage = async (session, expression, options = {}) => {
+var evaluateInPage = async (session2, expression, options = {}) => {
   const { failureMessage, awaitPromise, ...sendOptions } = options;
-  const payload = await session.sendAndWait("Runtime.evaluate", {
+  const payload = await session2.sendAndWait("Runtime.evaluate", {
     expression,
     awaitPromise: awaitPromise ?? false,
     returnByValue: true
@@ -8311,17 +8374,17 @@ var evaluateInPage = async (session, expression, options = {}) => {
   }
   return payload.result?.value;
 };
-var tryEvaluateInPage = async (session, expression, options = {}) => {
+var tryEvaluateInPage = async (session2, expression, options = {}) => {
   try {
-    return await evaluateInPage(session, expression, options);
+    return await evaluateInPage(session2, expression, options);
   } catch {
     return;
   }
 };
 var formatPageException = (details, fallback = "Page evaluation failed") => details.exception?.description ?? details.text ?? fallback;
-var callFunctionOnNode = async (session, node, fn, options = {}) => {
+var callFunctionOnNode = async (session2, node, fn, options = {}) => {
   const { onUnresolved, ...sendOptions } = options;
-  const resolved = await session.sendAndWait("DOM.resolveNode", node, sendOptions);
+  const resolved = await session2.sendAndWait("DOM.resolveNode", node, sendOptions);
   const objectId = resolved.object?.objectId;
   if (!objectId) {
     if (onUnresolved) {
@@ -8329,7 +8392,7 @@ var callFunctionOnNode = async (session, node, fn, options = {}) => {
     }
     return;
   }
-  const result = await session.sendAndWait("Runtime.callFunctionOn", {
+  const result = await session2.sendAndWait("Runtime.callFunctionOn", {
     objectId,
     functionDeclaration: fn.code,
     arguments: fn.args,
@@ -8343,8 +8406,8 @@ var callFunctionOnNode = async (session, node, fn, options = {}) => {
 };
 
 // ../argus-watcher/dist/cdp/authPageState.js
-var inspectPageState = async (session) => {
-  const state2 = await evaluateInPage(session, `(() => {
+var inspectPageState = async (session2) => {
+  const state2 = await evaluateInPage(session2, `(() => {
 				try {
 					const url = String(location.href)
 					const origin = new URL(url).origin
@@ -8567,9 +8630,9 @@ var normalizeSetCookieInput = (cookie) => ({
 var normalizeCookieExpires = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 
 // ../argus-watcher/dist/cdp/authCookies.js
-var inspectAuthCookies = async (session, options) => {
-  const { origin } = await inspectPageState(session);
-  const raw = await readRawCookies(session);
+var inspectAuthCookies = async (session2, options) => {
+  const { origin } = await inspectPageState(session2);
+  const raw = await readRawCookies(session2);
   const cookies2 = raw.map((cookie) => toAuthCookie(toStateCookie(cookie), options.includeValues === true)).sort(compareCookieIdentity);
   const normalizedDomain = normalizeCookieDomainFilter(options.domain);
   return {
@@ -8578,19 +8641,19 @@ var inspectAuthCookies = async (session, options) => {
     cookies: cookies2.filter((cookie) => matchesCookieDomain(cookie.domain, normalizedDomain))
   };
 };
-var inspectAuthCookie = async (session, options) => {
-  const pageState = await inspectPageState(session);
-  const cookie = await findContextCookie(session, pageState, options, options.readBrowserCookies);
+var inspectAuthCookie = async (session2, options) => {
+  const pageState = await inspectPageState(session2);
+  const cookie = await findContextCookie(session2, pageState, options, options.readBrowserCookies);
   return {
     ok: true,
     origin: pageState.origin,
     cookie: cookie ? toAuthCookie(cookie, options.includeValue === true) : null
   };
 };
-var setAuthCookie = async (session, options) => {
-  const pageState = await inspectPageState(session);
+var setAuthCookie = async (session2, options) => {
+  const pageState = await inspectPageState(session2);
   const cookie = normalizeSetCookieInput(options.cookie);
-  const payload = await session.sendAndWait("Network.setCookie", {
+  const payload = await session2.sendAndWait("Network.setCookie", {
     name: cookie.name,
     value: cookie.value,
     domain: cookie.domain,
@@ -8603,16 +8666,16 @@ var setAuthCookie = async (session, options) => {
   if (payload.success === false) {
     throw new Error(`Chrome rejected cookie ${cookie.name}`);
   }
-  const stored = await findContextCookie(session, pageState, cookie, options.readBrowserCookies);
+  const stored = await findContextCookie(session2, pageState, cookie, options.readBrowserCookies);
   return {
     ok: true,
     origin: pageState.origin,
     cookie: toAuthCookie(stored ?? cookie, false)
   };
 };
-var deleteAuthCookie = async (session, options) => {
-  const pageState = await inspectPageState(session);
-  const existing = await findContextCookie(session, pageState, options, options.readBrowserCookies);
+var deleteAuthCookie = async (session2, options) => {
+  const pageState = await inspectPageState(session2);
+  const existing = await findContextCookie(session2, pageState, options, options.readBrowserCookies);
   if (!existing) {
     return {
       ok: true,
@@ -8621,7 +8684,7 @@ var deleteAuthCookie = async (session, options) => {
       cookie: toCookieIdentity(options)
     };
   }
-  await deleteCookie(session, existing);
+  await deleteCookie(session2, existing);
   return {
     ok: true,
     origin: pageState.origin,
@@ -8629,13 +8692,13 @@ var deleteAuthCookie = async (session, options) => {
     cookie: toCookieIdentity(existing)
   };
 };
-var clearAuthCookies = async (session, options) => {
-  const pageState = await inspectPageState(session);
-  const cookies2 = await readStateCookies(session, options.readBrowserCookies, { url: pageState.url });
+var clearAuthCookies = async (session2, options) => {
+  const pageState = await inspectPageState(session2);
+  const cookies2 = await readStateCookies(session2, options.readBrowserCookies, { url: pageState.url });
   const matcher = createClearCookieMatcher(pageState, options);
   const targets = cookies2.filter((cookie) => matcher(cookie) && matchesCookieClearFilters(cookie, options));
   for (const cookie of targets) {
-    await deleteCookie(session, cookie);
+    await deleteCookie(session2, cookie);
   }
   return {
     ok: true,
@@ -8648,30 +8711,30 @@ var clearAuthCookies = async (session, options) => {
     cookies: targets.map((cookie) => toCookieIdentity(cookie)).sort(compareCookieIdentity)
   };
 };
-var readStateCookies = async (session, readBrowserCookiesFromSource, query2) => {
+var readStateCookies = async (session2, readBrowserCookiesFromSource, query2) => {
   const [browserCookies, pageCookies] = await Promise.all([
-    readBrowserCookiesFromSource ? readBrowserCookiesFromSource(query2) : readBrowserCookiesFromSession(session),
-    readRawCookies(session)
+    readBrowserCookiesFromSource ? readBrowserCookiesFromSource(query2) : readBrowserCookiesFromSession(session2),
+    readRawCookies(session2)
   ]);
   return mergeStateCookies(browserCookies, pageCookies.map(toStateCookie)).filter((cookie) => matchesCookieDomain(cookie.domain, query2.domain ?? null)).sort(compareCookieIdentity);
 };
-var findContextCookie = async (session, pageState, identity, readBrowserCookiesFromSource) => {
-  const cookies2 = await readStateCookies(session, readBrowserCookiesFromSource, { url: pageState.url });
+var findContextCookie = async (session2, pageState, identity, readBrowserCookiesFromSource) => {
+  const cookies2 = await readStateCookies(session2, readBrowserCookiesFromSource, { url: pageState.url });
   return cookies2.find((cookie) => matchesCookieIdentity(cookie, identity)) ?? null;
 };
-var deleteCookie = async (session, cookie) => {
-  await session.sendAndWait("Network.deleteCookies", { name: cookie.name, domain: cookie.domain, path: cookie.path }, { timeoutMs: 5000 });
+var deleteCookie = async (session2, cookie) => {
+  await session2.sendAndWait("Network.deleteCookies", { name: cookie.name, domain: cookie.domain, path: cookie.path }, { timeoutMs: 5000 });
 };
-var readRawCookies = async (session) => {
-  const payload = await session.sendAndWait("Network.getCookies", {}, { timeoutMs: 5000 });
+var readRawCookies = async (session2) => {
+  const payload = await session2.sendAndWait("Network.getCookies", {}, { timeoutMs: 5000 });
   return payload.cookies ?? [];
 };
-var readBrowserCookiesFromSession = async (session) => {
+var readBrowserCookiesFromSession = async (session2) => {
   try {
-    const payload = await session.sendAndWait("Storage.getCookies", {}, { timeoutMs: 5000 });
+    const payload = await session2.sendAndWait("Storage.getCookies", {}, { timeoutMs: 5000 });
     return (payload.cookies ?? []).map(toStateCookie);
   } catch {
-    return (await readRawCookies(session)).map(toStateCookie);
+    return (await readRawCookies(session2)).map(toStateCookie);
   }
 };
 var mergeStateCookies = (...groups) => {
@@ -8751,11 +8814,11 @@ var route15 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/cdp/authSnapshot.js
-var inspectAuthState = async (session, options) => {
-  const pageState = await inspectPageState(session);
+var inspectAuthState = async (session2, options) => {
+  const pageState = await inspectPageState(session2);
   const siteDomain = getLikelySiteDomain(pageState.origin);
   const normalizedDomain = normalizeCookieDomainFilter(options.domain) ?? siteDomain;
-  const cookies2 = await readStateCookies(session, options.readBrowserCookies, {
+  const cookies2 = await readStateCookies(session2, options.readBrowserCookies, {
     domain: normalizedDomain,
     url: pageState.url
   });
@@ -9008,12 +9071,12 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 var SCENARIO_ACTION_TIMEOUT_MS = 30000;
 var DEFAULT_LOG_LIMIT = 500;
 var MAX_LOG_LIMIT = 5000;
-var installScenarioBridge = async (session, expression, args, services, timeoutMs) => {
+var installScenarioBridge = async (session2, expression, args, services, timeoutMs) => {
   const token = randomUUID2();
   const suffix = token.replaceAll("-", "");
   const bindingName = `__argusScenarioSend_${suffix}`;
   const responseName = `__argusScenarioReceive_${suffix}`;
-  const off = session.onEvent("Runtime.bindingCalled", (rawEvent, meta) => {
+  const off = session2.onEvent("Runtime.bindingCalled", (rawEvent, meta) => {
     const { name, payload, executionContextId } = rawEvent;
     if (name !== bindingName || typeof payload !== "string" || typeof executionContextId !== "number" || !Number.isInteger(executionContextId)) {
       return;
@@ -9022,10 +9085,10 @@ var installScenarioBridge = async (session, expression, args, services, timeoutM
     if (!request) {
       return;
     }
-    respondToBridgeRequest(session, responseName, request, services, executionContextId, meta, timeoutMs);
+    respondToBridgeRequest(session2, responseName, request, services, executionContextId, meta, timeoutMs);
   });
   try {
-    await session.sendAndWait("Runtime.addBinding", { name: bindingName }, { timeoutMs });
+    await session2.sendAndWait("Runtime.addBinding", { name: bindingName }, { timeoutMs });
   } catch (error) {
     off();
     throw error;
@@ -9039,7 +9102,7 @@ var installScenarioBridge = async (session, expression, args, services, timeoutM
       disposed = true;
       off();
       try {
-        await session.sendAndWait("Runtime.removeBinding", { name: bindingName }, { timeoutMs });
+        await session2.sendAndWait("Runtime.removeBinding", { name: bindingName }, { timeoutMs });
       } catch {}
     }
   };
@@ -9059,7 +9122,7 @@ var parseBridgeRequest = (payload, token) => {
     return null;
   }
 };
-var respondToBridgeRequest = async (session, responseName, request, services, executionContextId, meta, timeoutMs) => {
+var respondToBridgeRequest = async (session2, responseName, request, services, executionContextId, meta, timeoutMs) => {
   let response;
   try {
     response = { id: request.id, ok: true, result: await handleBridgeRequest(request, services) };
@@ -9067,7 +9130,7 @@ var respondToBridgeRequest = async (session, responseName, request, services, ex
     response = { id: request.id, ok: false, error: formatError(error) };
   }
   try {
-    await sendBridgeResponse(session, responseName, response, executionContextId, meta, timeoutMs);
+    await sendBridgeResponse(session2, responseName, response, executionContextId, meta, timeoutMs);
   } catch {}
 };
 var handleBridgeRequest = async (request, services) => {
@@ -9199,8 +9262,8 @@ var requireRecord = (value, label) => {
   }
   return value;
 };
-var sendBridgeResponse = async (session, responseName, response, executionContextId, meta, timeoutMs) => {
-  await session.sendAndWait("Runtime.evaluate", {
+var sendBridgeResponse = async (session2, responseName, response, executionContextId, meta, timeoutMs) => {
+  await session2.sendAndWait("Runtime.evaluate", {
     expression: `globalThis[${JSON.stringify(responseName)}]?.(${JSON.stringify(response)})`,
     contextId: executionContextId,
     returnByValue: true,
@@ -9283,7 +9346,7 @@ var buildScenarioExpression = (expression, options) => `(async () => {
 })()`;
 
 // ../argus-watcher/dist/cdp/eval.js
-var evaluateExpression = async (session, options) => {
+var evaluateExpression = async (session2, options) => {
   const args = hasEvalArgs(options.args) ? options.args : undefined;
   let scenarioBridge;
   try {
@@ -9291,9 +9354,9 @@ var evaluateExpression = async (session, options) => {
       if (!options.scenarioServices) {
         throw new Error("Scenario host services are unavailable");
       }
-      scenarioBridge = await installScenarioBridge(session, options.expression, args, options.scenarioServices, options.timeoutMs);
+      scenarioBridge = await installScenarioBridge(session2, options.expression, args, options.scenarioServices, options.timeoutMs);
     }
-    const recordResult = await evaluateAndAwaitRecord(session, {
+    const recordResult = await evaluateAndAwaitRecord(session2, {
       ...options,
       expression: wrapExpressionWithArgs(scenarioBridge?.expression ?? options.expression, args),
       replMode: scenarioBridge ? false : options.replMode
@@ -9302,7 +9365,7 @@ var evaluateExpression = async (session, options) => {
       return recordResult.response;
     const record2 = recordResult.record;
     if (options.jsonValue) {
-      const jsonResult = await materializeJsonValue(session, record2, options);
+      const jsonResult = await materializeJsonValue(session2, record2, options);
       if (!jsonResult.ok)
         return jsonResult.response;
       return {
@@ -9312,7 +9375,7 @@ var evaluateExpression = async (session, options) => {
         exception: null
       };
     }
-    const value = await materializeRemoteObject(session, record2, options);
+    const value = await materializeRemoteObject(session2, record2, options);
     return {
       ok: true,
       result: value ?? null,
@@ -9331,8 +9394,8 @@ var wrapExpressionWithArgs = (expression, args) => {
 ${expression}
 }`;
 };
-var evaluateAndAwaitRecord = async (session, options) => {
-  const payload = await evaluateRawExpression(session, options);
+var evaluateAndAwaitRecord = async (session2, options) => {
+  const payload = await evaluateRawExpression(session2, options);
   if (payload.exceptionDetails) {
     return { response: formatExceptionResponse(payload), exception: true };
   }
@@ -9340,7 +9403,7 @@ var evaluateAndAwaitRecord = async (session, options) => {
   if (!(options.awaitPromise ?? true) || record2?.subtype !== "promise" || !record2.objectId) {
     return { record: record2, exception: false };
   }
-  const awaitedPayload = await awaitPromiseResult(session, record2.objectId, options.timeoutMs);
+  const awaitedPayload = await awaitPromiseResult(session2, record2.objectId, options.timeoutMs);
   if (awaitedPayload.exceptionDetails) {
     return { response: formatExceptionResponse(awaitedPayload), exception: true };
   }
@@ -9355,25 +9418,25 @@ var formatExceptionResponse = (payload) => ({
     details: payload.exceptionDetails?.exception ?? null
   }
 });
-var evaluateRawExpression = async (session, options) => await session.sendAndWait("Runtime.evaluate", {
+var evaluateRawExpression = async (session2, options) => await session2.sendAndWait("Runtime.evaluate", {
   expression: options.expression,
   replMode: options.replMode ?? true,
   awaitPromise: false,
   returnByValue: false
 }, { timeoutMs: options.timeoutMs });
-var awaitPromiseResult = async (session, promiseObjectId, timeoutMs) => await session.sendAndWait("Runtime.awaitPromise", {
+var awaitPromiseResult = async (session2, promiseObjectId, timeoutMs) => await session2.sendAndWait("Runtime.awaitPromise", {
   promiseObjectId,
   returnByValue: false
 }, { timeoutMs });
 var EMPTY_JSON_ENVELOPE = "{}";
-var materializeJsonValue = async (session, record2, options) => {
+var materializeJsonValue = async (session2, record2, options) => {
   if (!record2) {
     return { ok: true, json: EMPTY_JSON_ENVELOPE };
   }
   if (!record2.objectId) {
     return { ok: true, json: JSON.stringify({ v: record2.value }) ?? EMPTY_JSON_ENVELOPE };
   }
-  const payload = await session.sendAndWait("Runtime.callFunctionOn", {
+  const payload = await session2.sendAndWait("Runtime.callFunctionOn", {
     objectId: record2.objectId,
     functionDeclaration: "function () { return JSON.stringify({ v: this }) }",
     returnByValue: true
@@ -9384,23 +9447,23 @@ var materializeJsonValue = async (session, record2, options) => {
   const json = payload.result?.value;
   return { ok: true, json: typeof json === "string" ? json : EMPTY_JSON_ENVELOPE };
 };
-var materializeRemoteObject = async (session, record2, options) => {
+var materializeRemoteObject = async (session2, record2, options) => {
   if (!record2) {
     return null;
   }
   if ((options.returnByValue ?? true) && shouldMaterializeByValue(record2)) {
     try {
-      const byValuePayload = await session.sendAndWait("Runtime.callFunctionOn", {
+      const byValuePayload = await session2.sendAndWait("Runtime.callFunctionOn", {
         objectId: record2.objectId,
         functionDeclaration: "function () { return this; }",
         returnByValue: true
       }, { timeoutMs: options.timeoutMs });
       if (byValuePayload.result) {
-        return await serializeRemoteObject(byValuePayload.result, session);
+        return await serializeRemoteObject(byValuePayload.result, session2);
       }
     } catch {}
   }
-  return await serializeRemoteObject(record2, session);
+  return await serializeRemoteObject(record2, session2);
 };
 var shouldMaterializeByValue = (record2) => {
   return Boolean(record2.objectId) && record2.type === "object" && (record2.subtype == null || record2.subtype === "array");
@@ -9493,11 +9556,11 @@ var route21 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/cdp/text-filter.js
-var filterNodesByText = async (session, nodeIds, text) => {
+var filterNodesByText = async (session2, nodeIds, text) => {
   const pattern = parseTextPattern(text);
   const filtered = [];
   for (const nodeId of nodeIds) {
-    const trimmedText = await callFunctionOnNode(session, { nodeId }, { code: "function() { return this.textContent?.trim(); }" });
+    const trimmedText = await callFunctionOnNode(session2, { nodeId }, { code: "function() { return this.textContent?.trim(); }" });
     if (typeof trimmedText !== "string") {
       continue;
     }
@@ -9515,27 +9578,27 @@ var filterNodesByText = async (session, nodeIds, text) => {
 };
 
 // ../argus-watcher/dist/cdp/dom/selector.js
-var getDomRootId = async (session) => {
-  const targetContext = await session.getReadyTargetContext();
+var getDomRootId = async (session2) => {
+  const targetContext = await session2.getReadyTargetContext();
   if (targetContext?.kind === "frame") {
-    return getFrameDomRootId(session, targetContext);
+    return getFrameDomRootId(session2, targetContext);
   }
-  return getDocumentRootId(session);
+  return getDocumentRootId(session2);
 };
-var resolveSelectorMatches = async (session, rootId, selector, all, text) => {
-  const result = await session.sendAndWait("DOM.querySelectorAll", { nodeId: rootId, selector });
+var resolveSelectorMatches = async (session2, rootId, selector, all, text) => {
+  const result = await session2.sendAndWait("DOM.querySelectorAll", { nodeId: rootId, selector });
   let allNodeIds = result.nodeIds ?? [];
   if (text != null) {
-    allNodeIds = await filterNodesByText(session, allNodeIds, text);
+    allNodeIds = await filterNodesByText(session2, allNodeIds, text);
   }
   const nodeIds = all ? allNodeIds : allNodeIds.slice(0, 1);
   return { allNodeIds, nodeIds };
 };
-var waitForSelectorMatches = async (session, selector, all, text, waitMs, intervalMs = 100) => {
+var waitForSelectorMatches = async (session2, selector, all, text, waitMs, intervalMs = 100) => {
   const deadline = Date.now() + waitMs;
   while (true) {
-    const rootId = await getDomRootId(session);
-    const result = await resolveSelectorMatches(session, rootId, selector, all, text);
+    const rootId = await getDomRootId(session2);
+    const result = await resolveSelectorMatches(session2, rootId, selector, all, text);
     if (result.allNodeIds.length > 0)
       return result;
     const remaining = deadline - Date.now();
@@ -9544,17 +9607,17 @@ var waitForSelectorMatches = async (session, selector, all, text, waitMs, interv
     await new Promise((r) => setTimeout(r, Math.min(intervalMs, remaining)));
   }
 };
-var resolveSelectorTargets = async (session, options) => {
-  await session.sendAndWait("DOM.enable");
+var resolveSelectorTargets = async (session2, options) => {
+  await session2.sendAndWait("DOM.enable");
   const waitMs = options.waitMs ?? 0;
   if (waitMs > 0) {
-    return waitForSelectorMatches(session, options.selector, options.all, options.text, waitMs);
+    return waitForSelectorMatches(session2, options.selector, options.all, options.text, waitMs);
   }
-  const rootId = await getDomRootId(session);
-  return resolveSelectorMatches(session, rootId, options.selector, options.all, options.text);
+  const rootId = await getDomRootId(session2);
+  return resolveSelectorMatches(session2, rootId, options.selector, options.all, options.text);
 };
-var resolveElementTargets = async (session, elementRefs, options) => {
-  await session.sendAndWait("DOM.enable");
+var resolveElementTargets = async (session2, elementRefs, options) => {
+  await session2.sendAndWait("DOM.enable");
   if (options.ref) {
     const backendNodeId = elementRefs.resolve(options.ref);
     if (backendNodeId == null) {
@@ -9578,7 +9641,7 @@ var resolveElementTargets = async (session, elementRefs, options) => {
   if (!options.selector) {
     throw new Error("selector or ref is required");
   }
-  const result = (options.waitMs ?? 0) > 0 ? await waitForSelectorMatches(session, options.selector, options.all, options.text, options.waitMs ?? 0) : await resolveSelectorMatches(session, await getDomRootId(session), options.selector, options.all, options.text);
+  const result = (options.waitMs ?? 0) > 0 ? await waitForSelectorMatches(session2, options.selector, options.all, options.text, options.waitMs ?? 0) : await resolveSelectorMatches(session2, await getDomRootId(session2), options.selector, options.all, options.text);
   return {
     target: { kind: "selector", value: options.selector },
     allHandles: result.allNodeIds.map((nodeId) => ({ nodeId })),
@@ -9586,28 +9649,28 @@ var resolveElementTargets = async (session, elementRefs, options) => {
     ...result
   };
 };
-var resolveFirstSelectorNodeId = async (session, selector, text) => {
-  const { nodeIds } = await resolveSelectorTargets(session, {
+var resolveFirstSelectorNodeId = async (session2, selector, text) => {
+  const { nodeIds } = await resolveSelectorTargets(session2, {
     selector,
     all: false,
     text
   });
   return nodeIds[0] ?? null;
 };
-var describeNodeByBackendId = async (session, backendNodeId) => {
-  const described = await session.sendAndWait("DOM.describeNode", {
+var describeNodeByBackendId = async (session2, backendNodeId) => {
+  const described = await session2.sendAndWait("DOM.describeNode", {
     backendNodeId,
     depth: 0
   });
   return described.node ?? null;
 };
-var resolveNodeIdByBackendId = async (session, backendNodeId) => {
-  const describedNode = await describeNodeByBackendId(session, backendNodeId);
+var resolveNodeIdByBackendId = async (session2, backendNodeId) => {
+  const describedNode = await describeNodeByBackendId(session2, backendNodeId);
   if (describedNode?.nodeId) {
     return describedNode.nodeId;
   }
-  await getDomRootId(session);
-  const pushed = await session.sendAndWait("DOM.pushNodesByBackendIdsToFrontend", {
+  await getDomRootId(session2);
+  const pushed = await session2.sendAndWait("DOM.pushNodesByBackendIdsToFrontend", {
     backendNodeIds: [backendNodeId]
   });
   const nodeId = pushed.nodeIds?.[0];
@@ -9622,14 +9685,14 @@ var toDomNodeDescriptor = (handle) => {
   }
   throw new Error("DOM node handle is missing both nodeId and backendNodeId");
 };
-var getFrameDomRootId = async (session, targetContext) => {
+var getFrameDomRootId = async (session2, targetContext) => {
   if (targetContext.sessionId) {
-    return getDocumentRootId(session);
+    return getDocumentRootId(session2);
   }
   if (targetContext.executionContextId == null) {
     throw new Error(`Selected frame is not ready yet: ${targetContext.frameId}`);
   }
-  const evaluated = await session.sendAndWait("Runtime.evaluate", {
+  const evaluated = await session2.sendAndWait("Runtime.evaluate", {
     expression: "document",
     contextId: targetContext.executionContextId,
     returnByValue: false
@@ -9638,14 +9701,14 @@ var getFrameDomRootId = async (session, targetContext) => {
   if (!objectId) {
     throw new Error(`Unable to resolve DOM root for frame: ${targetContext.frameId}`);
   }
-  const requested = await session.sendAndWait("DOM.requestNode", { objectId });
+  const requested = await session2.sendAndWait("DOM.requestNode", { objectId });
   if (!requested.nodeId) {
     throw new Error(`Unable to resolve DOM root for frame: ${targetContext.frameId}`);
   }
   return requested.nodeId;
 };
-var getDocumentRootId = async (session) => {
-  const result = await session.sendAndWait("DOM.getDocument", { depth: 1 });
+var getDocumentRootId = async (session2) => {
+  const result = await session2.sendAndWait("DOM.getDocument", { depth: 1 });
   const rootId = result.root?.nodeId;
   if (!rootId) {
     throw new Error("Unable to resolve DOM root");
@@ -9737,9 +9800,9 @@ var RELEVANT_PROPERTIES = new Set([
   "multiselectable",
   "orientation"
 ]);
-var fetchAccessibilitySnapshot = async (session, options, elementRefs) => {
-  await session.sendAndWait("Accessibility.enable");
-  const nodes = await resolveAccessibilityNodes(session, options.selector);
+var fetchAccessibilitySnapshot = async (session2, options, elementRefs) => {
+  await session2.sendAndWait("Accessibility.enable");
+  const nodes = await resolveAccessibilityNodes(session2, options.selector);
   const totalNodes = nodes.length;
   const roots = buildTree(nodes, {
     depth: options.depth,
@@ -9749,8 +9812,8 @@ var fetchAccessibilitySnapshot = async (session, options, elementRefs) => {
   const returnedNodes = countNodes(roots);
   return { ok: true, roots, totalNodes, returnedNodes };
 };
-var listAccessibleElements = async (session, elementRefs, options = {}) => {
-  const nodes = await resolveAccessibilityNodes(session, options.selector);
+var listAccessibleElements = async (session2, elementRefs, options = {}) => {
+  const nodes = await resolveAccessibilityNodes(session2, options.selector);
   return collectAccessibleElements(nodes, elementRefs);
 };
 var buildTree = (cdpNodes, options) => {
@@ -9821,24 +9884,24 @@ var convertNode = (nodeMap, nodeId, currentDepth, options) => {
   }
   return [result];
 };
-var fetchAccessibilityNodes = async (session) => {
-  const axResult = await session.sendAndWait("Accessibility.getFullAXTree");
+var fetchAccessibilityNodes = async (session2) => {
+  const axResult = await session2.sendAndWait("Accessibility.getFullAXTree");
   return axResult.nodes ?? [];
 };
-var resolveAccessibilityNodes = async (session, selector) => {
-  const nodes = await fetchAccessibilityNodes(session);
+var resolveAccessibilityNodes = async (session2, selector) => {
+  const nodes = await fetchAccessibilityNodes(session2);
   if (!selector) {
     return nodes;
   }
-  return filterAccessibilityNodesBySelector(session, nodes, selector);
+  return filterAccessibilityNodesBySelector(session2, nodes, selector);
 };
-var filterAccessibilityNodesBySelector = async (session, nodes, selector) => {
-  const domNodeId = await resolveFirstSelectorNodeId(session, selector);
+var filterAccessibilityNodesBySelector = async (session2, nodes, selector) => {
+  const domNodeId = await resolveFirstSelectorNodeId(session2, selector);
   if (!domNodeId) {
     throw new Error(`No element found for selector: ${selector}`);
   }
-  await session.sendAndWait("DOM.getDocument", { depth: -1 });
-  const allDescendants = await session.sendAndWait("DOM.querySelectorAll", {
+  await session2.sendAndWait("DOM.getDocument", { depth: -1 });
+  const allDescendants = await session2.sendAndWait("DOM.querySelectorAll", {
     nodeId: domNodeId,
     selector: "*"
   });
@@ -9846,7 +9909,7 @@ var filterAccessibilityNodesBySelector = async (session, nodes, selector) => {
   const backendIds = new Set;
   const allDomNodeIds = [domNodeId, ...descendantNodeIds];
   for (const nid of allDomNodeIds) {
-    const desc = await session.sendAndWait("DOM.describeNode", { nodeId: nid, depth: 0 });
+    const desc = await session2.sendAndWait("DOM.describeNode", { nodeId: nid, depth: 0 });
     if (desc.node?.backendNodeId != null) {
       backendIds.add(desc.node.backendNodeId);
     }
@@ -9981,8 +10044,8 @@ var route22 = defineJsonRoute({
 
 // ../argus-watcher/dist/cdp/locate.js
 var LABELABLE_ROLES = new Set(["button", "checkbox", "combobox", "listbox", "radio", "searchbox", "slider", "spinbutton", "switch", "textbox"]);
-var locateByRole = async (session, elementRefs, request) => {
-  const matches = (await listAccessibleElements(session, elementRefs)).filter((element) => {
+var locateByRole = async (session2, elementRefs, request) => {
+  const matches = (await listAccessibleElements(session2, elementRefs)).filter((element) => {
     if (normalizeText(element.role) !== normalizeText(request.role)) {
       return false;
     }
@@ -9991,29 +10054,29 @@ var locateByRole = async (session, elementRefs, request) => {
     }
     return matchesText(element.name, request.name, request.exact ?? false);
   });
-  return buildLocateResponse(session, request.all ?? false, matches);
+  return buildLocateResponse(session2, request.all ?? false, matches);
 };
-var locateByText = async (session, elementRefs, request) => {
-  const matches = (await listAccessibleElements(session, elementRefs)).filter((element) => matchesText(element.name, request.text, request.exact ?? false) || matchesText(element.value ?? "", request.text, request.exact ?? false));
-  return buildLocateResponse(session, request.all ?? false, matches);
+var locateByText = async (session2, elementRefs, request) => {
+  const matches = (await listAccessibleElements(session2, elementRefs)).filter((element) => matchesText(element.name, request.text, request.exact ?? false) || matchesText(element.value ?? "", request.text, request.exact ?? false));
+  return buildLocateResponse(session2, request.all ?? false, matches);
 };
-var locateByLabel = async (session, elementRefs, request) => {
-  const matches = (await listAccessibleElements(session, elementRefs)).filter((element) => {
+var locateByLabel = async (session2, elementRefs, request) => {
+  const matches = (await listAccessibleElements(session2, elementRefs)).filter((element) => {
     if (!LABELABLE_ROLES.has(element.role)) {
       return false;
     }
     return matchesText(element.name, request.label, request.exact ?? false);
   });
-  return buildLocateResponse(session, request.all ?? false, await removeCompositeLabelWrappers(session, matches));
+  return buildLocateResponse(session2, request.all ?? false, await removeCompositeLabelWrappers(session2, matches));
 };
 var NATIVE_LABELABLE_TAGS = new Set(["button", "input", "select", "textarea"]);
-var removeCompositeLabelWrappers = async (session, matches) => {
+var removeCompositeLabelWrappers = async (session2, matches) => {
   if (matches.length < 2)
     return matches;
   const candidates = await Promise.all(matches.map(async (match) => {
     const [node, nodeId] = await Promise.all([
-      describeNodeByBackendId(session, match.backendNodeId),
-      resolveNodeIdByBackendId(session, match.backendNodeId)
+      describeNodeByBackendId(session2, match.backendNodeId),
+      resolveNodeIdByBackendId(session2, match.backendNodeId)
     ]);
     const tag = node ? (node.localName ?? node.nodeName).toLowerCase() : "";
     return { match, nodeId, native: NATIVE_LABELABLE_TAGS.has(tag) };
@@ -10027,7 +10090,7 @@ var removeCompositeLabelWrappers = async (session, matches) => {
       kept.push(candidate.match);
       continue;
     }
-    const descendants = await session.sendAndWait("DOM.querySelectorAll", {
+    const descendants = await session2.sendAndWait("DOM.querySelectorAll", {
       nodeId: candidate.nodeId,
       selector: "button,input,select,textarea"
     });
@@ -10038,17 +10101,17 @@ var removeCompositeLabelWrappers = async (session, matches) => {
   }
   return kept;
 };
-var buildLocateResponse = async (session, all, matches) => {
+var buildLocateResponse = async (session2, all, matches) => {
   const selected = all ? matches : matches.slice(0, 1);
-  const elements = await Promise.all(selected.map((element) => toLocatedElement(session, element)));
+  const elements = await Promise.all(selected.map((element) => toLocatedElement(session2, element)));
   return {
     ok: true,
     matches: matches.length,
     elements
   };
 };
-var toLocatedElement = async (session, element) => {
-  const node = await describeNodeByBackendId(session, element.backendNodeId);
+var toLocatedElement = async (session2, element) => {
+  const node = await describeNodeByBackendId(session2, element.backendNodeId);
   const attributes = node?.attributes ? toAttributesRecord(node.attributes) : undefined;
   return {
     ref: element.ref,
@@ -10189,13 +10252,13 @@ var DEFAULT_DEPTH = 2;
 var DEFAULT_MAX_NODES = 5000;
 var MAX_DEPTH = 10;
 var MAX_MAX_NODES = 50000;
-var fetchDomSubtreeBySelector = async (session, options) => {
+var fetchDomSubtreeBySelector = async (session2, options) => {
   const depth = clamp(options.depth ?? DEFAULT_DEPTH, 0, MAX_DEPTH);
   const maxNodes = clamp(options.maxNodes ?? DEFAULT_MAX_NODES, 1, MAX_MAX_NODES);
   const all = options.all ?? false;
-  await session.sendAndWait("DOM.enable");
-  const rootId = await getDomRootId(session);
-  const { allNodeIds, nodeIds } = await resolveSelectorMatches(session, rootId, options.selector, all, options.text);
+  await session2.sendAndWait("DOM.enable");
+  const rootId = await getDomRootId(session2);
+  const { allNodeIds, nodeIds } = await resolveSelectorMatches(session2, rootId, options.selector, all, options.text);
   if (allNodeIds.length === 0) {
     return { ok: true, matches: 0, roots: [], truncated: false };
   }
@@ -10207,7 +10270,7 @@ var fetchDomSubtreeBySelector = async (session, options) => {
       state2.truncatedReason = "max_nodes";
       break;
     }
-    const describeResult = await session.sendAndWait("DOM.describeNode", {
+    const describeResult = await session2.sendAndWait("DOM.describeNode", {
       nodeId,
       depth: depth + 1
     });
@@ -10278,10 +10341,10 @@ var toDomNodeTree = (node, remainingDepth, state2) => {
 // ../argus-watcher/dist/cdp/dom/info.js
 var DEFAULT_OUTER_HTML_MAX_CHARS = 50000;
 var MAX_OUTER_HTML_CHARS = 500000;
-var fetchDomInfoBySelector = async (session, elementRefs, options) => {
+var fetchDomInfoBySelector = async (session2, elementRefs, options) => {
   const all = options.all ?? false;
   const maxChars = clamp(options.outerHtmlMaxChars ?? DEFAULT_OUTER_HTML_MAX_CHARS, 0, MAX_OUTER_HTML_CHARS);
-  const resolved = await resolveElementTargets(session, elementRefs, {
+  const resolved = await resolveElementTargets(session2, elementRefs, {
     selector: options.selector,
     ref: options.ref,
     all,
@@ -10297,7 +10360,7 @@ var fetchDomInfoBySelector = async (session, elementRefs, options) => {
   const elements = [];
   for (const handle of handles) {
     const descriptor = toDomNodeDescriptor(handle);
-    const describeResult = await session.sendAndWait("DOM.describeNode", {
+    const describeResult = await session2.sendAndWait("DOM.describeNode", {
       ...descriptor,
       depth: 1
     });
@@ -10310,7 +10373,7 @@ var fetchDomInfoBySelector = async (session, elementRefs, options) => {
     let outerHTML = null;
     let outerHTMLTruncated = false;
     try {
-      const htmlResult = await session.sendAndWait("DOM.getOuterHTML", descriptor);
+      const htmlResult = await session2.sendAndWait("DOM.getOuterHTML", descriptor);
       outerHTML = htmlResult.outerHTML ?? null;
       if (outerHTML && outerHTML.length > maxChars) {
         outerHTML = outerHTML.slice(0, maxChars);
@@ -10330,18 +10393,18 @@ var fetchDomInfoBySelector = async (session, elementRefs, options) => {
   return { ok: true, matches: allHandles.length, elements };
 };
 // ../argus-watcher/dist/cdp/dom/mutate.js
-var mutateMatchedElements = async (session, target, apply) => {
-  await session.sendAndWait("DOM.enable");
-  const rootId = await getDomRootId(session);
-  const { allNodeIds, nodeIds } = await resolveSelectorMatches(session, rootId, target.selector, target.all ?? false, target.text);
+var mutateMatchedElements = async (session2, target, apply) => {
+  await session2.sendAndWait("DOM.enable");
+  const rootId = await getDomRootId(session2);
+  const { allNodeIds, nodeIds } = await resolveSelectorMatches(session2, rootId, target.selector, target.all ?? false, target.text);
   for (const nodeId of nodeIds) {
     await apply(nodeId);
   }
   return { allNodeIds, mutatedCount: nodeIds.length };
 };
-var mutateWithPageFunction = (session, target, fn) => mutateMatchedElements(session, target, (nodeId) => callFunctionOnNode(session, { nodeId }, fn));
-var removeElements = (session, options) => mutateWithPageFunction(session, options, { code: "function() { this.remove(); }" });
-var modifyElements = (session, options) => mutateWithPageFunction(session, options, buildModifyFunction(options));
+var mutateWithPageFunction = (session2, target, fn) => mutateMatchedElements(session2, target, (nodeId) => callFunctionOnNode(session2, { nodeId }, fn));
+var removeElements = (session2, options) => mutateWithPageFunction(session2, options, { code: "function() { this.remove(); }" });
+var modifyElements = (session2, options) => mutateWithPageFunction(session2, options, buildModifyFunction(options));
 var FILL_FUNCTION = `function(value) {
 	var el = this;
 	el.focus();
@@ -10363,29 +10426,29 @@ var FILL_FUNCTION = `function(value) {
 	el.dispatchEvent(new Event('input', { bubbles: true }));
 	el.dispatchEvent(new Event('change', { bubbles: true }));
 }`;
-var fillResolvedNodes = async (session, handles, value) => {
+var fillResolvedNodes = async (session2, handles, value) => {
   for (const handle of handles) {
-    await callFunctionOnNode(session, toDomNodeDescriptor(handle), { code: FILL_FUNCTION, args: [{ value }] });
+    await callFunctionOnNode(session2, toDomNodeDescriptor(handle), { code: FILL_FUNCTION, args: [{ value }] });
   }
   return handles.length;
 };
-var insertAdjacentHtml = async (session, options) => {
+var insertAdjacentHtml = async (session2, options) => {
   if (options.nodeIds.length === 0) {
     return 0;
   }
-  await session.sendAndWait("DOM.enable");
+  await session2.sendAndWait("DOM.enable");
   const fn = {
     code: options.text ? "function(pos, value) { this.insertAdjacentText(pos, value); }" : "function(pos, html) { this.insertAdjacentHTML(pos, html); }",
     args: [{ value: options.position ?? "beforeend" }, { value: options.html }]
   };
   for (const nodeId of options.nodeIds) {
-    await callFunctionOnNode(session, { nodeId }, fn);
+    await callFunctionOnNode(session2, { nodeId }, fn);
   }
   return options.nodeIds.length;
 };
-var setFileOnResolvedNodes = async (session, nodeIds, files) => {
+var setFileOnResolvedNodes = async (session2, nodeIds, files) => {
   for (const nodeId of nodeIds) {
-    await session.sendAndWait("DOM.setFileInputFiles", { files, nodeId });
+    await session2.sendAndWait("DOM.setFileInputFiles", { files, nodeId });
   }
   return nodeIds.length;
 };
@@ -10502,27 +10565,27 @@ var route28 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/cdp/mouse.js
-var resolveDomSelectorMatches = async (session, selector, all, text) => {
-  return resolveSelectorTargets(session, { selector, all, text });
+var resolveDomSelectorMatches = async (session2, selector, all, text) => {
+  return resolveSelectorTargets(session2, { selector, all, text });
 };
-var hoverDomNodes = async (session, handles) => {
+var hoverDomNodes = async (session2, handles) => {
   if (handles.length === 0) {
     return;
   }
   for (const handle of handles) {
-    await scrollIntoView(session, handle);
-    const point = await resolveNodePoint(session, handle);
-    await dispatchMouseEvent(session, { type: "mouseMoved", x: point.x, y: point.y });
+    await scrollIntoView(session2, handle);
+    const point = await resolveNodePoint(session2, handle);
+    await dispatchMouseEvent(session2, { type: "mouseMoved", x: point.x, y: point.y });
   }
 };
 var BUTTON_MASK = { left: 1, middle: 4, right: 2 };
-var clickAtPoint = async (session, x, y, button = "left") => {
+var clickAtPoint = async (session2, x, y, button = "left") => {
   const mask = BUTTON_MASK[button] ?? 1;
-  await dispatchMouseEvent(session, { type: "mouseMoved", x, y });
-  await dispatchMouseEvent(session, { type: "mousePressed", x, y, button, buttons: mask, clickCount: 1 });
-  await dispatchMouseEvent(session, { type: "mouseReleased", x, y, button, buttons: 0, clickCount: 1 });
+  await dispatchMouseEvent(session2, { type: "mouseMoved", x, y });
+  await dispatchMouseEvent(session2, { type: "mousePressed", x, y, button, buttons: mask, clickCount: 1 });
+  await dispatchMouseEvent(session2, { type: "mouseReleased", x, y, button, buttons: 0, clickCount: 1 });
 };
-var dragAtPoints = async (session, start, end, options = {}) => {
+var dragAtPoints = async (session2, start, end, options = {}) => {
   const button = options.button ?? "left";
   const mask = BUTTON_MASK[button] ?? 1;
   const steps = Math.max(1, Math.floor(options.steps ?? 12));
@@ -10530,35 +10593,35 @@ var dragAtPoints = async (session, start, end, options = {}) => {
   const stepDelayMs = durationMs / steps;
   let latest = start;
   let pressed = false;
-  await dispatchMouseEvent(session, { type: "mouseMoved", x: start.x, y: start.y });
+  await dispatchMouseEvent(session2, { type: "mouseMoved", x: start.x, y: start.y });
   try {
-    await dispatchMouseEvent(session, { type: "mousePressed", x: start.x, y: start.y, button, buttons: mask, clickCount: 1 });
+    await dispatchMouseEvent(session2, { type: "mousePressed", x: start.x, y: start.y, button, buttons: mask, clickCount: 1 });
     pressed = true;
     for (let i = 1;i <= steps; i++) {
       if (stepDelayMs > 0) {
         await delay(stepDelayMs);
       }
       latest = interpolatePoint(start, end, i / steps);
-      await dispatchMouseEvent(session, { type: "mouseMoved", x: latest.x, y: latest.y, button, buttons: mask, clickCount: 1 });
+      await dispatchMouseEvent(session2, { type: "mouseMoved", x: latest.x, y: latest.y, button, buttons: mask, clickCount: 1 });
     }
-    await dispatchMouseEvent(session, { type: "mouseReleased", x: end.x, y: end.y, button, buttons: 0, clickCount: 1 });
+    await dispatchMouseEvent(session2, { type: "mouseReleased", x: end.x, y: end.y, button, buttons: 0, clickCount: 1 });
     pressed = false;
   } finally {
     if (pressed) {
-      await dispatchMouseEvent(session, { type: "mouseReleased", x: latest.x, y: latest.y, button, buttons: 0, clickCount: 1 }).catch(() => {
+      await dispatchMouseEvent(session2, { type: "mouseReleased", x: latest.x, y: latest.y, button, buttons: 0, clickCount: 1 }).catch(() => {
         return;
       });
     }
   }
 };
-var dragDomNodes = async (session, handles, destination, options = {}) => {
+var dragDomNodes = async (session2, handles, destination, options = {}) => {
   if (handles.length === 0) {
     return;
   }
   for (const handle of handles) {
-    await scrollIntoView(session, handle);
-    const start = await resolveNodePoint(session, handle, options.offset);
-    await dragAtPoints(session, start, resolveDragEndPoint(start, destination), options);
+    await scrollIntoView(session2, handle);
+    const start = await resolveNodePoint(session2, handle, options.offset);
+    await dragAtPoints(session2, start, resolveDragEndPoint(start, destination), options);
   }
 };
 var resolveDragEndPoint = (start, destination) => {
@@ -10570,67 +10633,67 @@ var resolveDragEndPoint = (start, destination) => {
     y: start.y + destination.delta.y
   };
 };
-var clickDomNodes = async (session, handles, button = "left") => {
+var clickDomNodes = async (session2, handles, button = "left") => {
   if (handles.length === 0) {
     return;
   }
   const mask = BUTTON_MASK[button] ?? 1;
   for (const handle of handles) {
-    await scrollIntoView(session, handle);
-    const point = await resolveNodePoint(session, handle);
-    await dispatchMouseEvent(session, { type: "mouseMoved", x: point.x, y: point.y });
-    await dispatchMouseEvent(session, { type: "mousePressed", x: point.x, y: point.y, button, buttons: mask, clickCount: 1 });
-    await dispatchMouseEvent(session, { type: "mouseReleased", x: point.x, y: point.y, button, buttons: 0, clickCount: 1 });
+    await scrollIntoView(session2, handle);
+    const point = await resolveNodePoint(session2, handle);
+    await dispatchMouseEvent(session2, { type: "mouseMoved", x: point.x, y: point.y });
+    await dispatchMouseEvent(session2, { type: "mousePressed", x: point.x, y: point.y, button, buttons: mask, clickCount: 1 });
+    await dispatchMouseEvent(session2, { type: "mouseReleased", x: point.x, y: point.y, button, buttons: 0, clickCount: 1 });
   }
 };
-var focusDomNodes = async (session, handles) => {
+var focusDomNodes = async (session2, handles) => {
   if (handles.length === 0) {
     return;
   }
   for (const handle of handles) {
-    await scrollIntoView(session, handle);
-    await session.sendAndWait("DOM.focus", toDomNodeDescriptor(handle));
+    await scrollIntoView(session2, handle);
+    await session2.sendAndWait("DOM.focus", toDomNodeDescriptor(handle));
   }
 };
-var scrollIntoView = async (session, handle) => {
+var scrollIntoView = async (session2, handle) => {
   const descriptor = toDomNodeDescriptor(handle);
   try {
-    await session.sendAndWait("DOM.scrollIntoViewIfNeeded", descriptor);
+    await session2.sendAndWait("DOM.scrollIntoViewIfNeeded", descriptor);
     return;
   } catch {}
-  await callFunctionOnNode(session, descriptor, { code: 'function() { this.scrollIntoView({ block: "center", inline: "center" }); }' }, { onUnresolved: () => createNotInteractableError("Unable to resolve node for scrolling") });
+  await callFunctionOnNode(session2, descriptor, { code: 'function() { this.scrollIntoView({ block: "center", inline: "center" }); }' }, { onUnresolved: () => createNotInteractableError("Unable to resolve node for scrolling") });
 };
-var scrollDomNodes = async (session, handles, mode) => {
+var scrollDomNodes = async (session2, handles, mode) => {
   if (handles.length === 0) {
-    return getViewportScroll(session);
+    return getViewportScroll(session2);
   }
   for (const handle of handles) {
     if (mode.to || mode.by) {
-      await scrollElementContainer(session, handle, mode);
+      await scrollElementContainer(session2, handle, mode);
     } else {
-      await scrollIntoView(session, handle);
+      await scrollIntoView(session2, handle);
     }
   }
-  return getViewportScroll(session);
+  return getViewportScroll(session2);
 };
-var scrollViewport = async (session, mode) => {
+var scrollViewport = async (session2, mode) => {
   const fn = mode.to ? `window.scrollTo(${mode.to.x}, ${mode.to.y})` : `window.scrollBy(${mode.by.x}, ${mode.by.y})`;
-  await evaluateInPage(session, fn);
-  return getViewportScroll(session);
+  await evaluateInPage(session2, fn);
+  return getViewportScroll(session2);
 };
-var scrollElementContainer = async (session, handle, mode) => {
+var scrollElementContainer = async (session2, handle, mode) => {
   const fn = mode.to ? `function() { this.scrollTo(${mode.to.x}, ${mode.to.y}); }` : `function() { this.scrollBy(${mode.by.x}, ${mode.by.y}); }`;
-  await callFunctionOnNode(session, toDomNodeDescriptor(handle), { code: fn }, {
+  await callFunctionOnNode(session2, toDomNodeDescriptor(handle), { code: fn }, {
     onUnresolved: () => createNotInteractableError("Unable to resolve node for scrolling")
   });
 };
-var getViewportScroll = async (session) => {
-  const serialized = await evaluateInPage(session, "JSON.stringify({scrollX:window.scrollX,scrollY:window.scrollY})");
+var getViewportScroll = async (session2) => {
+  const serialized = await evaluateInPage(session2, "JSON.stringify({scrollX:window.scrollX,scrollY:window.scrollY})");
   const parsed = serialized ? JSON.parse(serialized) : { scrollX: 0, scrollY: 0 };
   return { scrollX: parsed.scrollX, scrollY: parsed.scrollY };
 };
-var resolveNodePoint = async (session, handle, offset) => {
-  const { x, y, w, h } = await resolveNodeRect(session, handle);
+var resolveNodePoint = async (session2, handle, offset) => {
+  const { x, y, w, h } = await resolveNodeRect(session2, handle);
   if (w <= 0 || h <= 0) {
     throw createNotInteractableError("Element has zero area");
   }
@@ -10639,9 +10702,9 @@ var resolveNodePoint = async (session, handle, offset) => {
   }
   return { x: x + w / 2, y: y + h / 2 };
 };
-var resolveNodeRect = async (session, handle) => {
+var resolveNodeRect = async (session2, handle) => {
   const descriptor = toDomNodeDescriptor(handle);
-  const boxModel = await session.sendAndWait("DOM.getBoxModel", descriptor).catch(() => null);
+  const boxModel = await session2.sendAndWait("DOM.getBoxModel", descriptor).catch(() => null);
   const quad = boxModel?.model?.border ?? boxModel?.model?.content;
   if (quad && quad.length >= 8) {
     const xs = [quad[0], quad[2], quad[4], quad[6]];
@@ -10652,7 +10715,7 @@ var resolveNodeRect = async (session, handle) => {
     const maxY = Math.max(...ys);
     return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
   }
-  const rect = await callFunctionOnNode(session, descriptor, {
+  const rect = await callFunctionOnNode(session2, descriptor, {
     code: "function(){var r=this.getBoundingClientRect();return{x:r.x,y:r.y,w:r.width,h:r.height}}"
   });
   if (!rect || !Number.isFinite(rect.x) || !Number.isFinite(rect.y)) {
@@ -10660,8 +10723,8 @@ var resolveNodeRect = async (session, handle) => {
   }
   return rect;
 };
-var emulateScroll = async (session, x, y, delta) => {
-  await session.sendAndWait("Input.dispatchMouseEvent", {
+var emulateScroll = async (session2, x, y, delta) => {
+  await session2.sendAndWait("Input.dispatchMouseEvent", {
     type: "mouseWheel",
     x,
     y,
@@ -10669,18 +10732,18 @@ var emulateScroll = async (session, x, y, delta) => {
     deltaY: delta.y
   });
 };
-var emulateScrollOnNodes = async (session, handles, delta) => {
+var emulateScrollOnNodes = async (session2, handles, delta) => {
   if (handles.length === 0) {
     return;
   }
   for (const handle of handles) {
-    await scrollIntoView(session, handle);
-    const point = await resolveNodePoint(session, handle);
-    await emulateScroll(session, point.x, point.y, delta);
+    await scrollIntoView(session2, handle);
+    const point = await resolveNodePoint(session2, handle);
+    await emulateScroll(session2, point.x, point.y, delta);
   }
 };
-var dispatchMouseEvent = async (session, options) => {
-  await session.sendAndWait("Input.dispatchMouseEvent", {
+var dispatchMouseEvent = async (session2, options) => {
+  await session2.sendAndWait("Input.dispatchMouseEvent", {
     type: options.type,
     x: options.x,
     y: options.y,
@@ -10963,12 +11026,12 @@ var resolveEventText = (key, def) => {
 };
 var isSingleLetter = (value) => /^[a-z]$/i.test(value);
 var isShift = (modifiers) => (modifiers & MODIFIER_BITS.shift) !== 0;
-var dispatchKeydown = async (session, options) => {
+var dispatchKeydown = async (session2, options) => {
   const { selector } = options;
   const event = resolveKeyboardEvent(options);
   let focused = false;
   if (selector) {
-    const { allNodeIds, nodeIds } = await resolveDomSelectorMatches(session, selector, false);
+    const { allNodeIds, nodeIds } = await resolveDomSelectorMatches(session2, selector, false);
     if (allNodeIds.length === 0) {
       throw new Error(`No element found for selector: ${selector}`);
     }
@@ -10976,7 +11039,7 @@ var dispatchKeydown = async (session, options) => {
       throw codedError("multiple_matches", `Selector matched ${allNodeIds.length} elements; keydown requires exactly one target`);
     }
     const nodeId = nodeIds[0];
-    await session.sendAndWait("DOM.focus", { nodeId });
+    await session2.sendAndWait("DOM.focus", { nodeId });
     focused = true;
   }
   const isPrintable = event.text != null && event.text !== "\r";
@@ -10988,12 +11051,12 @@ var dispatchKeydown = async (session, options) => {
     modifiers: event.modifiers
   };
   if (isPrintable) {
-    await session.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyDown", text: event.text });
-    await session.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "char", text: event.text });
-    await session.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyUp" });
+    await session2.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyDown", text: event.text });
+    await session2.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "char", text: event.text });
+    await session2.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyUp" });
   } else {
-    await session.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "rawKeyDown", text: event.text });
-    await session.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyUp" });
+    await session2.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "rawKeyDown", text: event.text });
+    await session2.sendAndWait("Input.dispatchKeyEvent", { ...baseParams, type: "keyUp" });
   }
   return { key: event.key, code: event.code, modifiers: event.modifiers, focused, event };
 };
@@ -11195,8 +11258,8 @@ var route39 = defineJsonRoute({
     return { ok: true, matches: allNodeIds.length, scrolled: nodeIds.length };
   }
 });
-var getViewportSize = async (session) => {
-  const serialized = await evaluateInPage(session, "JSON.stringify({width:window.innerWidth,height:window.innerHeight})");
+var getViewportSize = async (session2) => {
+  const serialized = await evaluateInPage(session2, "JSON.stringify({width:window.innerWidth,height:window.innerHeight})");
   const parsed = serialized ? JSON.parse(serialized) : { width: 800, height: 600 };
   return { width: parsed.width, height: parsed.height };
 };
@@ -11242,11 +11305,11 @@ var route42 = defineJsonRoute({
   bodySchema: emulationRequestSchema,
   endpoint: "emulation",
   handle: async ({ ctx, body: payload }) => {
-    const session = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
+    const session2 = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
     if (payload.action === "clear") {
-      return ctx.emulationController.clearDesired(session);
+      return ctx.emulationController.clearDesired(session2);
     }
-    return ctx.emulationController.setDesired(payload.state, session);
+    return ctx.emulationController.setDesired(payload.state, session2);
   }
 });
 
@@ -11265,11 +11328,11 @@ var route44 = defineJsonRoute({
   bodySchema: throttleRequestSchema,
   endpoint: "throttle",
   handle: ({ ctx, body: payload }) => {
-    const session = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
+    const session2 = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
     if (payload.action === "clear") {
-      return ctx.throttleController.clearDesired(session);
+      return ctx.throttleController.clearDesired(session2);
     }
-    return ctx.throttleController.setDesired(payload.rate, session);
+    return ctx.throttleController.setDesired(payload.rate, session2);
   }
 });
 
@@ -11319,9 +11382,9 @@ var route47 = defineJsonRoute({
   endpoint: "visibility",
   handle: async ({ ctx, body: payload }) => {
     const lock = payload.action === "show" ? "shown" : "default";
-    const session = ctx.pageCdpSession;
-    const attached = session.isAttached();
-    await ctx.visibilityController.setLock(attached ? session : null, lock);
+    const session2 = ctx.pageCdpSession;
+    const attached = session2.isAttached();
+    await ctx.visibilityController.setLock(attached ? session2 : null, lock);
     return { ok: true, attached, state: lock };
   }
 });
@@ -11331,8 +11394,8 @@ var storageAccessors = {
   local: "localStorage",
   session: "sessionStorage"
 };
-var executeStorage = async (session, area, request) => {
-  return await evaluateInPage(session, buildStorageExpression(area, request), { timeoutMs: 5000 });
+var executeStorage = async (session2, area, request) => {
+  return await evaluateInPage(session2, buildStorageExpression(area, request), { timeoutMs: 5000 });
 };
 var buildStorageExpression = (area, request) => {
   return `(() => {
@@ -11676,8 +11739,8 @@ var createInjectOnAttach = (inject, record2) => {
   if (!inject?.script) {
     return async () => {};
   }
-  return async (session, target) => {
-    if (!session.isAttached()) {
+  return async (session2, target) => {
+    if (!session2.isAttached()) {
       return;
     }
     const trimmedScript = inject.script.trim();
@@ -11699,8 +11762,8 @@ var createInjectOnAttach = (inject, record2) => {
       }
     } : null;
     const expression = buildInjectExpression(trimmedScript, argusPayload);
-    await runInjectStep("register", record2.id, () => session.sendAndWait("Page.addScriptToEvaluateOnNewDocument", { source: expression }));
-    await runInjectStep("run", record2.id, () => session.sendAndWait("Runtime.evaluate", { expression, silent: true }));
+    await runInjectStep("register", record2.id, () => session2.sendAndWait("Page.addScriptToEvaluateOnNewDocument", { source: expression }));
+    await runInjectStep("run", record2.id, () => session2.sendAndWait("Runtime.evaluate", { expression, silent: true }));
   };
 };
 var runInjectStep = async (step, watcherId, action) => {
@@ -12150,11 +12213,11 @@ var createPageIndicatorController = (options) => {
   let currentSession = null;
   let currentInfo = null;
   let currentState = { recording: false };
-  const onAttach = (session, _target, info) => {
+  const onAttach = (session2, _target, info) => {
     stop();
-    currentSession = session;
+    currentSession = session2;
     currentInfo = info;
-    installIndicator(session, {
+    installIndicator(session2, {
       info,
       position,
       ttlMs,
@@ -12172,9 +12235,9 @@ var createPageIndicatorController = (options) => {
       sendHeartbeat(currentSession, currentInfo, currentState);
     }, heartbeatMs);
   };
-  const onNavigation = (session, info) => {
+  const onNavigation = (session2, info) => {
     currentInfo = info;
-    installIndicator(session, {
+    installIndicator(session2, {
       info,
       position,
       ttlMs,
@@ -12229,7 +12292,7 @@ var createPageIndicatorController = (options) => {
   };
   return { onAttach, onNavigation, setRecording, reinstall, onDetach, stop };
 };
-var installIndicator = async (session, params) => {
+var installIndicator = async (session2, params) => {
   const { info, position, ttlMs, bgColor, hoverBgColor, iconColor, margin, size, state: state2 } = params;
   const expression = buildInstallExpression({
     info,
@@ -12242,15 +12305,15 @@ var installIndicator = async (session, params) => {
     size,
     state: state2
   });
-  await tryEvaluateInPage(session, expression);
+  await tryEvaluateInPage(session2, expression);
 };
-var sendHeartbeat = async (session, info, state2) => {
+var sendHeartbeat = async (session2, info, state2) => {
   const expression = buildHeartbeatExpression(info, state2);
-  await tryEvaluateInPage(session, expression);
+  await tryEvaluateInPage(session2, expression);
 };
-var removeIndicator = async (session) => {
+var removeIndicator = async (session2) => {
   const expression = buildRemoveExpression();
-  await tryEvaluateInPage(session, expression);
+  await tryEvaluateInPage(session2, expression);
 };
 
 // ../argus-watcher/dist/runtime/watcherIndicator.js
@@ -12268,23 +12331,23 @@ var createIndicatorBinding = (input) => {
     attachedAt: attachedAt ?? Date.now()
   });
   return {
-    onNavigation: (session, info) => {
+    onNavigation: (session2, info) => {
       if (!controller) {
         return;
       }
       const status2 = input.getCdpStatus();
       const target = status2.attached ? { title: status2.target?.title ?? null, url: status2.target?.url ?? info.url } : { title: null, url: info.url };
-      controller.onNavigation(session, buildInfo(target));
+      controller.onNavigation(session2, buildInfo(target));
     },
     onLoad: () => {
       controller?.reinstall();
     },
-    onAttach: (session, target) => {
+    onAttach: (session2, target) => {
       if (!controller) {
         return;
       }
       attachedAt = Date.now();
-      controller.onAttach(session, {
+      controller.onAttach(session2, {
         id: target.id,
         title: target.title,
         url: target.url,
@@ -13530,7 +13593,7 @@ var nextId = 1;
 var createCdpSessionHandle = () => {
   let connection = null;
   const handlers = new Map;
-  const session = {
+  const session2 = {
     isAttached: () => Boolean(connection),
     sendAndWait: async (method, params, options) => {
       if (!connection) {
@@ -13633,7 +13696,7 @@ var createCdpSessionHandle = () => {
     }
     connection = null;
   };
-  return { session, attach, detach };
+  return { session: session2, attach, detach };
 };
 var createCdpNotAttachedError = () => createNotAttachedError("Watcher not attached to a CDP target");
 var parseMessage = (data) => {
@@ -13686,30 +13749,30 @@ var openCdpConnection = async (wsUrl, connectTimeoutMs = 5000) => {
 };
 
 // ../argus-watcher/dist/cdp/emulation.js
-var applyEmulation = async (session, state2, baseline) => {
+var applyEmulation = async (session2, state2, baseline) => {
   if (state2.viewport) {
-    await session.sendAndWait("Emulation.setDeviceMetricsOverride", {
+    await session2.sendAndWait("Emulation.setDeviceMetricsOverride", {
       width: state2.viewport.width,
       height: state2.viewport.height,
       deviceScaleFactor: state2.viewport.deviceScaleFactor,
       mobile: state2.viewport.mobile
     });
   } else {
-    await session.sendAndWait("Emulation.clearDeviceMetricsOverride");
+    await session2.sendAndWait("Emulation.clearDeviceMetricsOverride");
   }
   const touchEnabled = state2.touch?.enabled ?? false;
-  await session.sendAndWait("Emulation.setTouchEmulationEnabled", { enabled: touchEnabled });
+  await session2.sendAndWait("Emulation.setTouchEmulationEnabled", { enabled: touchEnabled });
   if (state2.userAgent?.value != null) {
-    await session.sendAndWait("Emulation.setUserAgentOverride", { userAgent: state2.userAgent.value });
+    await session2.sendAndWait("Emulation.setUserAgentOverride", { userAgent: state2.userAgent.value });
   } else if (baseline.userAgent) {
-    await session.sendAndWait("Emulation.setUserAgentOverride", { userAgent: baseline.userAgent });
+    await session2.sendAndWait("Emulation.setUserAgentOverride", { userAgent: baseline.userAgent });
   }
 };
-var clearEmulation = async (session, baseline) => {
-  await session.sendAndWait("Emulation.clearDeviceMetricsOverride");
-  await session.sendAndWait("Emulation.setTouchEmulationEnabled", { enabled: false });
+var clearEmulation = async (session2, baseline) => {
+  await session2.sendAndWait("Emulation.clearDeviceMetricsOverride");
+  await session2.sendAndWait("Emulation.setTouchEmulationEnabled", { enabled: false });
   if (baseline.userAgent) {
-    await session.sendAndWait("Emulation.setUserAgentOverride", { userAgent: baseline.userAgent });
+    await session2.sendAndWait("Emulation.setUserAgentOverride", { userAgent: baseline.userAgent });
   }
 };
 
@@ -13719,7 +13782,7 @@ var createStickyController = (options) => {
   let applied = false;
   let lastError = null;
   const getState = () => ({ applied, state: desired, lastError });
-  const run = async (session, action, appliedOnSuccess) => {
+  const run = async (session2, action, appliedOnSuccess) => {
     try {
       await action();
       applied = appliedOnSuccess;
@@ -13737,30 +13800,30 @@ var createStickyController = (options) => {
   };
   return {
     getState,
-    setDesired: async (state2, session) => {
+    setDesired: async (state2, session2) => {
       desired = state2;
       lastError = null;
-      if (!session?.isAttached()) {
+      if (!session2?.isAttached()) {
         return detached();
       }
-      return await run(session, () => options.apply(session, state2), true);
+      return await run(session2, () => options.apply(session2, state2), true);
     },
-    clearDesired: async (session) => {
+    clearDesired: async (session2) => {
       desired = null;
       lastError = null;
-      if (!session?.isAttached()) {
+      if (!session2?.isAttached()) {
         return detached();
       }
-      return await run(session, () => options.clear(session), false);
+      return await run(session2, () => options.clear(session2), false);
     },
-    onAttach: async (session) => {
-      await options.onBeforeReapply?.(session);
+    onAttach: async (session2) => {
+      await options.onBeforeReapply?.(session2);
       if (!desired) {
         applied = false;
         return;
       }
       try {
-        await options.apply(session, desired);
+        await options.apply(session2, desired);
         applied = true;
         lastError = null;
       } catch (error) {
@@ -13778,10 +13841,10 @@ var createEmulationController = () => {
   const getBaseline = () => ({ userAgent: baselineUserAgent });
   const sticky = createStickyController({
     label: "Emulation",
-    apply: (session, state2) => applyEmulation(session, state2, getBaseline()),
-    clear: (session) => clearEmulation(session, getBaseline()),
-    onBeforeReapply: async (session) => {
-      const value = await evaluateInPage(session, "navigator.userAgent").catch(() => null);
+    apply: (session2, state2) => applyEmulation(session2, state2, getBaseline()),
+    clear: (session2) => clearEmulation(session2, getBaseline()),
+    onBeforeReapply: async (session2) => {
+      const value = await evaluateInPage(session2, "navigator.userAgent").catch(() => null);
       baselineUserAgent = typeof value === "string" ? value : null;
     }
   });
@@ -13790,12 +13853,12 @@ var createEmulationController = () => {
       const { applied, state: state2, lastError } = sticky.getState();
       return { ok: true, attached: ctx.attached, applied, state: state2, baseline: getBaseline(), lastError };
     },
-    setDesired: async (state2, session) => {
-      const { attached, applied, state: next, lastError } = await sticky.setDesired(state2, session);
+    setDesired: async (state2, session2) => {
+      const { attached, applied, state: next, lastError } = await sticky.setDesired(state2, session2);
       return { ok: true, attached, applied, state: next, ...lastError ? { error: lastError } : {} };
     },
-    clearDesired: async (session) => {
-      const { attached, applied, lastError } = await sticky.clearDesired(session);
+    clearDesired: async (session2) => {
+      const { attached, applied, lastError } = await sticky.clearDesired(session2);
       return { ok: true, attached, applied, state: null, ...lastError ? { error: lastError } : {} };
     },
     onAttach: sticky.onAttach
@@ -13803,31 +13866,31 @@ var createEmulationController = () => {
 };
 
 // ../argus-watcher/dist/cdp/throttle.js
-var applyThrottle = async (session, rate) => {
-  await session.sendAndWait("Emulation.setCPUThrottlingRate", { rate });
+var applyThrottle = async (session2, rate) => {
+  await session2.sendAndWait("Emulation.setCPUThrottlingRate", { rate });
 };
-var clearThrottle = async (session) => {
-  await session.sendAndWait("Emulation.setCPUThrottlingRate", { rate: 1 });
+var clearThrottle = async (session2) => {
+  await session2.sendAndWait("Emulation.setCPUThrottlingRate", { rate: 1 });
 };
 
 // ../argus-watcher/dist/throttle/ThrottleController.js
 var createThrottleController = () => {
   const sticky = createStickyController({
     label: "Throttle",
-    apply: (session, state2) => applyThrottle(session, state2.rate),
-    clear: (session) => clearThrottle(session)
+    apply: (session2, state2) => applyThrottle(session2, state2.rate),
+    clear: (session2) => clearThrottle(session2)
   });
   return {
     getStatus: (ctx) => {
       const { applied, state: state2, lastError } = sticky.getState();
       return { ok: true, attached: ctx.attached, applied, state: state2, lastError };
     },
-    setDesired: async (rate, session) => {
-      const { attached, applied, state: state2, lastError } = await sticky.setDesired({ rate }, session);
+    setDesired: async (rate, session2) => {
+      const { attached, applied, state: state2, lastError } = await sticky.setDesired({ rate }, session2);
       return { ok: true, attached, applied, state: state2, ...lastError ? { error: lastError } : {} };
     },
-    clearDesired: async (session) => {
-      const { attached, applied, lastError } = await sticky.clearDesired(session);
+    clearDesired: async (session2) => {
+      const { attached, applied, lastError } = await sticky.clearDesired(session2);
       return { ok: true, attached, applied, state: null, ...lastError ? { error: lastError } : {} };
     },
     onAttach: sticky.onAttach
@@ -13896,8 +13959,8 @@ class NetMockInterception {
     if (reset) {
       this.enabledTargets.clear();
     }
-    const session = this.binding?.pageSession;
-    if (!session?.isAttached()) {
+    const session2 = this.binding?.pageSession;
+    if (!session2?.isAttached()) {
       this.enabledTargets.clear();
       return false;
     }
@@ -13936,12 +13999,12 @@ class NetMockInterception {
     return targets;
   }
   async sendCommand(target, method, params = {}) {
-    const session = this.binding?.pageSession;
-    if (!session?.isAttached()) {
+    const session2 = this.binding?.pageSession;
+    if (!session2?.isAttached()) {
       return false;
     }
     try {
-      await session.sendAndWait(method, params, target.sessionId ? { sessionId: target.sessionId } : undefined);
+      await session2.sendAndWait(method, params, target.sessionId ? { sessionId: target.sessionId } : undefined);
       return true;
     } catch (error) {
       if (!isBenignInterceptionError(error)) {
@@ -14157,35 +14220,35 @@ var toPublicRule = (rule) => ({
 });
 
 // ../argus-watcher/dist/visibility/VisibilityController.js
-var applyLock = async (session, lock) => {
+var applyLock = async (session2, lock) => {
   if (lock !== "shown") {
-    await session.sendAndWait("Emulation.setFocusEmulationEnabled", { enabled: false });
+    await session2.sendAndWait("Emulation.setFocusEmulationEnabled", { enabled: false });
     return;
   }
   try {
-    await session.sendAndWait("Page.bringToFront");
+    await session2.sendAndWait("Page.bringToFront");
   } catch {}
-  await session.sendAndWait("Emulation.setFocusEmulationEnabled", { enabled: true });
+  await session2.sendAndWait("Emulation.setFocusEmulationEnabled", { enabled: true });
 };
 var createVisibilityController = () => {
   const sticky = createStickyController({
     label: "Visibility",
     apply: applyLock,
-    clear: (session) => applyLock(session, "default")
+    clear: (session2) => applyLock(session2, "default")
   });
   return {
     getDesired: () => sticky.getState().state ?? "default",
-    setLock: async (session, lock) => {
-      const result = await sticky.setDesired(lock, session);
+    setLock: async (session2, lock) => {
+      const result = await sticky.setDesired(lock, session2);
       if (result.lastError) {
         throw new Error(result.lastError.message);
       }
     },
-    onAttach: async (session) => {
+    onAttach: async (session2) => {
       if (sticky.getState().state !== "shown") {
         return;
       }
-      await sticky.onAttach(session);
+      await sticky.onAttach(session2);
     }
   };
 };
@@ -14992,25 +15055,25 @@ var createTraceRecorder = (options) => {
 import fs7 from "node:fs/promises";
 
 // ../argus-watcher/dist/cdp/visualCapture.js
-var createVisualCapturePlan = async (session, pageSession, request) => {
+var createVisualCapturePlan = async (session2, pageSession, request) => {
   const subject = resolveVisualCaptureSubject(request);
-  const targetContext = await session.getReadyTargetContext();
+  const targetContext = await session2.getReadyTargetContext();
   if (targetContext?.kind === "frame" && pageSession) {
     return createFrameCapturePlan({
-      frameSession: session,
+      frameSession: session2,
       pageSession,
       frameContext: targetContext,
       subject
     });
   }
-  const clip = await resolveSubjectClip(session, subject);
+  const clip = await resolveSubjectClip(session2, subject);
   if (!clip) {
-    return { session };
+    return { session: session2 };
   }
   return {
-    session,
+    session: session2,
     clip,
-    viewport: await resolveViewportSize(session)
+    viewport: await resolveViewportSize(session2)
   };
 };
 var createFrameCapturePlan = async (options) => {
@@ -15039,21 +15102,21 @@ var resolveFrameViewportClip = async (pageSession, frameId) => {
   }
   return resolveNodeClip(pageSession, owner);
 };
-var resolveSelectorClip = async (session, selector) => {
-  const nodeId = await resolveFirstSelectorNodeId(session, selector);
+var resolveSelectorClip = async (session2, selector) => {
+  const nodeId = await resolveFirstSelectorNodeId(session2, selector);
   if (!nodeId) {
     throw new Error(`No element found for selector: ${selector}`);
   }
-  return resolveNodeClip(session, { nodeId });
+  return resolveNodeClip(session2, { nodeId });
 };
-var resolveSubjectClip = async (session, subject) => {
+var resolveSubjectClip = async (session2, subject) => {
   switch (subject.kind) {
     case "viewport":
       return null;
     case "selector":
-      return resolveSelectorClip(session, subject.selector);
+      return resolveSelectorClip(session2, subject.selector);
     case "clip":
-      return resolveViewportRectClip(session, subject.clip);
+      return resolveViewportRectClip(session2, subject.clip);
   }
 };
 var resolveVisualCaptureSubject = (request) => {
@@ -15065,8 +15128,8 @@ var resolveVisualCaptureSubject = (request) => {
   }
   return { kind: "viewport" };
 };
-var resolveViewportRectClip = async (session, clip) => {
-  const viewport = await resolveVisualViewport(session);
+var resolveViewportRectClip = async (session2, clip) => {
+  const viewport = await resolveVisualViewport(session2);
   return {
     x: clip.x,
     y: clip.y,
@@ -15075,8 +15138,8 @@ var resolveViewportRectClip = async (session, clip) => {
     scale: viewport?.scale ?? 1
   };
 };
-var resolveNodeClip = async (session, target) => {
-  const boxResult = await session.sendAndWait("DOM.getBoxModel", target.nodeId != null ? { nodeId: target.nodeId } : { backendNodeId: target.backendNodeId });
+var resolveNodeClip = async (session2, target) => {
+  const boxResult = await session2.sendAndWait("DOM.getBoxModel", target.nodeId != null ? { nodeId: target.nodeId } : { backendNodeId: target.backendNodeId });
   const quad = boxResult.model?.content ?? boxResult.model?.border;
   if (!quad || quad.length < 8) {
     throw new Error("Unable to compute element box model");
@@ -15085,7 +15148,7 @@ var resolveNodeClip = async (session, target) => {
   if (rect.width <= 0 || rect.height <= 0) {
     throw new Error("Element has zero area");
   }
-  const viewport = await resolveVisualViewport(session);
+  const viewport = await resolveVisualViewport(session2);
   const pageX = viewport?.pageX ?? 0;
   const pageY = viewport?.pageY ?? 0;
   const scale = viewport?.scale ?? 1;
@@ -15097,17 +15160,17 @@ var resolveNodeClip = async (session, target) => {
     scale
   };
 };
-var resolveVisualViewport = async (session) => {
-  const metrics = await session.sendAndWait("Page.getLayoutMetrics");
+var resolveVisualViewport = async (session2) => {
+  const metrics = await session2.sendAndWait("Page.getLayoutMetrics");
   const payload = metrics;
   return payload.cssVisualViewport ?? payload.visualViewport;
 };
-var resolveViewportSize = async (session) => {
-  const viewport = await resolveVisualViewport(session);
+var resolveViewportSize = async (session2) => {
+  const viewport = await resolveVisualViewport(session2);
   if (isPositiveFiniteNumber(viewport?.clientWidth) && isPositiveFiniteNumber(viewport?.clientHeight)) {
     return { width: viewport.clientWidth, height: viewport.clientHeight };
   }
-  const evaluated = await evaluateInPage(session, "({width: window.visualViewport?.width ?? window.innerWidth, height: window.visualViewport?.height ?? window.innerHeight})");
+  const evaluated = await evaluateInPage(session2, "({width: window.visualViewport?.width ?? window.innerWidth, height: window.visualViewport?.height ?? window.innerHeight})");
   const width = evaluated?.width;
   const height = evaluated?.height;
   if (!isPositiveFiniteNumber(width) || !isPositiveFiniteNumber(height)) {
@@ -15161,11 +15224,11 @@ var createScreenshotter = (options) => {
   };
   return { capture };
 };
-var captureScreenshot = async (session, options) => {
+var captureScreenshot = async (session2, options) => {
   let lastError;
   for (let attempt = 1;attempt <= SCREENSHOT_CDP_MAX_ATTEMPTS; attempt += 1) {
     try {
-      const payload = await session.sendAndWait("Page.captureScreenshot", {
+      const payload = await session2.sendAndWait("Page.captureScreenshot", {
         format: options.format,
         clip: options.clip
       }, { timeoutMs: SCREENSHOT_CDP_TIMEOUT_MS });
@@ -15549,7 +15612,7 @@ var QUIET_PERIOD_MS = 100;
 var ENABLE_TIMEOUT_MS = 5000;
 var DEFAULT_READ_LIMIT = 2000;
 var MAX_GREP_MATCHES = 500;
-var createRuntimeEditor = (session) => {
+var createRuntimeEditor = (session2) => {
   const scripts = new Map;
   const stylesheets = new Map;
   const sources = new Map;
@@ -15595,9 +15658,9 @@ var createRuntimeEditor = (session) => {
       await ensureEnabled();
       const resource = getResource(url);
       if (resource.type === "stylesheet") {
-        await session.sendAndWait("CSS.setStyleSheetText", { styleSheetId: resource.id, text: source }, getSessionOptions(resource));
+        await session2.sendAndWait("CSS.setStyleSheetText", { styleSheetId: resource.id, text: source }, getSessionOptions(resource));
       } else {
-        await editScript(session, resource, source);
+        await editScript(session2, resource, source);
       }
       sources.set(getSourceCacheKey(resource), source);
       return { ok: true, resource: toCodeResource(resource) };
@@ -15686,9 +15749,9 @@ var createRuntimeEditor = (session) => {
     }
     enabling = (async () => {
       clearResourceState();
-      await session.sendAndWait("Debugger.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
-      await session.sendAndWait("DOM.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
-      await session.sendAndWait("CSS.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
+      await session2.sendAndWait("Debugger.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
+      await session2.sendAndWait("DOM.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
+      await session2.sendAndWait("CSS.enable", undefined, { timeoutMs: ENABLE_TIMEOUT_MS });
       await waitForResourceQuietPeriod();
       enabled = true;
     })();
@@ -15703,13 +15766,13 @@ var createRuntimeEditor = (session) => {
       return;
     }
     listenerDisposers = [
-      session.onEvent("Debugger.scriptParsed", (params, meta) => {
+      session2.onEvent("Debugger.scriptParsed", (params, meta) => {
         handleScriptParsed(params, meta);
       }),
-      session.onEvent("CSS.styleSheetAdded", (params, meta) => {
+      session2.onEvent("CSS.styleSheetAdded", (params, meta) => {
         handleStyleSheetAdded(params, meta);
       }),
-      session.onEvent("CSS.styleSheetRemoved", (params, meta) => {
+      session2.onEvent("CSS.styleSheetRemoved", (params, meta) => {
         handleStyleSheetRemoved(params, meta);
       })
     ];
@@ -15822,11 +15885,11 @@ var createRuntimeEditor = (session) => {
     sources.clear();
   }
   async function readStylesheetSource(resource) {
-    const result = await session.sendAndWait("CSS.getStyleSheetText", { styleSheetId: resource.id }, getSessionOptions(resource));
+    const result = await session2.sendAndWait("CSS.getStyleSheetText", { styleSheetId: resource.id }, getSessionOptions(resource));
     return result.text ?? "";
   }
   async function readScriptSource(resource) {
-    const result = await session.sendAndWait("Debugger.getScriptSource", { scriptId: resource.id }, getSessionOptions(resource));
+    const result = await session2.sendAndWait("Debugger.getScriptSource", { scriptId: resource.id }, getSessionOptions(resource));
     return result.scriptSource ?? "";
   }
 };
@@ -15851,10 +15914,10 @@ var matchesUrlPattern = (resource, pattern) => !pattern || resource.url.toLowerC
 var matchesLine = (line, pattern) => matchesTextPattern(line, pattern);
 var getSessionOptions = (resource) => resource.sessionId ? { sessionId: resource.sessionId } : undefined;
 var getSourceCacheKey = (resource) => `${resource.type}:${resource.sessionId ?? "root"}:${resource.id}`;
-async function editScript(session, resource, source) {
+async function editScript(session2, resource, source) {
   let result;
   try {
-    result = await session.sendAndWait("Debugger.setScriptSource", { scriptId: resource.id, scriptSource: source }, getSessionOptions(resource));
+    result = await session2.sendAndWait("Debugger.setScriptSource", { scriptId: resource.id, scriptSource: source }, getSessionOptions(resource));
   } catch (error) {
     const message = formatError(error);
     if (/setScriptSource.*no longer available/i.test(message)) {
@@ -15997,9 +16060,9 @@ var toExceptionEvent = async (params, page, config) => {
   };
   return applyLocation(baseEvent, details?.stackTrace?.callFrames, config);
 };
-var fetchPageIntl = async (session) => {
+var fetchPageIntl = async (session2) => {
   try {
-    const result = await session.sendAndWait("Runtime.evaluate", {
+    const result = await session2.sendAndWait("Runtime.evaluate", {
       expression: "(() => { const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone ?? null; const locale = navigator.language ?? null; return { timezone, locale }; })()",
       returnByValue: true
     });
@@ -16214,7 +16277,7 @@ var startCdpWatcher = (options) => {
   let stopped = false;
   let socket = null;
   let currentTarget = null;
-  const { session, attach, detach } = options.sessionHandle ?? createCdpSessionHandle();
+  const { session: session2, attach, detach } = options.sessionHandle ?? createCdpSessionHandle();
   const stop = async () => {
     stopped = true;
     if (socket) {
@@ -16222,19 +16285,19 @@ var startCdpWatcher = (options) => {
     }
   };
   runLoop();
-  session.onEvent("Runtime.consoleAPICalled", (params) => {
+  session2.onEvent("Runtime.consoleAPICalled", (params) => {
     if (!currentTarget) {
       return;
     }
-    toConsoleEvent(params, currentTarget, { ...options, cdp: session }).then((event) => options.onLog(event));
+    toConsoleEvent(params, currentTarget, { ...options, cdp: session2 }).then((event) => options.onLog(event));
   });
-  session.onEvent("Runtime.exceptionThrown", (params) => {
+  session2.onEvent("Runtime.exceptionThrown", (params) => {
     if (!currentTarget) {
       return;
     }
-    toExceptionEvent(params, currentTarget, { ...options, cdp: session }).then((event) => options.onLog(event));
+    toExceptionEvent(params, currentTarget, { ...options, cdp: session2 }).then((event) => options.onLog(event));
   });
-  session.onEvent("Page.frameNavigated", (params) => {
+  session2.onEvent("Page.frameNavigated", (params) => {
     if (!currentTarget) {
       return;
     }
@@ -16245,7 +16308,7 @@ var startCdpWatcher = (options) => {
     currentTarget.url = navigation.url;
     options.onPageNavigation?.({ url: navigation.url, title: currentTarget.title ?? null });
   });
-  session.onEvent("Page.domContentEventFired", () => {
+  session2.onEvent("Page.domContentEventFired", () => {
     if (!currentTarget) {
       return;
     }
@@ -16253,7 +16316,7 @@ var startCdpWatcher = (options) => {
   });
   return {
     stop,
-    session,
+    session: session2,
     getTarget: () => currentTarget ? { ...currentTarget } : null
   };
   async function runLoop() {
@@ -16295,13 +16358,13 @@ var startCdpWatcher = (options) => {
       options.onStatus({ attached: false, target: null, reason });
       options.onDetach?.(reason);
     });
-    const pageIntl = await fetchPageIntl(session);
+    const pageIntl = await fetchPageIntl(session2);
     if (pageIntl) {
       options.onPageIntl?.(pageIntl);
     }
-    await session.sendAndWait("Runtime.enable");
-    await session.sendAndWait("Page.enable");
-    await options.onAttach?.(session, target);
+    await session2.sendAndWait("Runtime.enable");
+    await session2.sendAndWait("Page.enable");
+    await options.onAttach?.(session2, target);
     options.onStatus({
       attached: true,
       target: {
@@ -16417,7 +16480,7 @@ var createCdpSource = (options) => {
     onPageNavigation: events.onPageNavigation,
     onPageLoad: events.onPageLoad,
     onPageIntl: events.onPageIntl,
-    onAttach: events.onAttach ? (session, target) => events.onAttach(session, {
+    onAttach: events.onAttach ? (session2, target) => events.onAttach(session2, {
       id: target.id,
       title: target.title,
       url: target.url,
@@ -16615,12 +16678,12 @@ class SessionManager {
     }
   }
   handleTabAttached(message) {
-    const session = this.createSession(message);
-    this.events.onAttach(session);
+    const session2 = this.createSession(message);
+    this.events.onAttach(session2);
   }
   handleTabDetached(message) {
-    const session = this.sessions.get(message.tabId);
-    if (session) {
+    const session2 = this.sessions.get(message.tabId);
+    if (session2) {
       this.sessions.delete(message.tabId);
       this.eventHandlers.delete(message.tabId);
     }
@@ -16688,7 +16751,7 @@ class SessionManager {
       getTargetContext: () => ({ kind: "page" }),
       getReadyTargetContext: async () => ({ kind: "page" })
     };
-    const session = {
+    const session2 = {
       tabId,
       url,
       title,
@@ -16709,8 +16772,8 @@ class SessionManager {
         }), options?.timeoutMs ?? 1e4);
       }
     };
-    this.sessions.set(tabId, session);
-    return session;
+    this.sessions.set(tabId, session2);
+    return session2;
   }
   async getCookies(tabId, query2, timeoutMs = 5000) {
     if (!this.sessions.has(tabId)) {
@@ -16773,13 +16836,13 @@ var parseExtensionTargetId = (targetId) => {
   }
   throw new Error(`Invalid extension target id: ${targetId}`);
 };
-var buildPageTarget = (session, options) => ({
-  id: formatPageTargetId(session.tabId),
-  title: session.title,
-  url: session.url,
+var buildPageTarget = (session2, options) => ({
+  id: formatPageTargetId(session2.tabId),
+  title: session2.title,
+  url: session2.url,
   type: "page",
   parentId: null,
-  faviconUrl: session.faviconUrl,
+  faviconUrl: session2.faviconUrl,
   attached: options.attached
 });
 var frameToTarget = (tabId, frame, options) => ({
@@ -16949,7 +17012,7 @@ var createDelegatingSession = (options) => {
     rebind: rebindSubscriptions,
     dispose: disposeSubscriptions
   };
-  const session = {
+  const session2 = {
     isAttached: () => options.getCurrentSession()?.handle.isAttached() ?? false,
     sendAndWait: async (method, params, commandOptions) => {
       const currentSession = options.requireCurrentSession();
@@ -16983,7 +17046,7 @@ var createDelegatingSession = (options) => {
     getReadyTargetContext: options.getReadyTargetContext ?? (async () => options.getTargetContext())
   };
   controller.rebind();
-  return { session, controller };
+  return { session: session2, controller };
 };
 var createDelegatingEventSubscription = (method, handler) => ({
   method,
@@ -16996,32 +17059,32 @@ var createDelegatingEventSubscription = (method, handler) => ({
 });
 
 // ../argus-watcher/dist/sources/extension-session-events.js
-var registerExtensionSessionEventHandlers = ({ session, events, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, sourcemaps, getOrCreateFrameState, reconcileTargetSelection, removeFrame, refreshFrameTitle, emitTargetChanged, setCurrentSession }) => {
-  session.handle.onEvent("Runtime.executionContextCreated", (params, meta) => {
+var registerExtensionSessionEventHandlers = ({ session: session2, events, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, sourcemaps, getOrCreateFrameState, reconcileTargetSelection, removeFrame, refreshFrameTitle, emitTargetChanged, setCurrentSession }) => {
+  session2.handle.onEvent("Runtime.executionContextCreated", (params, meta) => {
     const context = parseExecutionContext(params);
     if (!context?.isDefault || !context.frameId) {
       return;
     }
-    const state2 = getOrCreateFrameState(session.tabId);
+    const state2 = getOrCreateFrameState(session2.tabId);
     state2.executionContexts.set(context.frameId, context.id);
     const frame = state2.frames.get(context.frameId);
     if (frame) {
       frame.sessionId = meta.sessionId ?? null;
     }
-    refreshFrameTitle(session, context.frameId, context.id);
-    reconcileTargetSelection(session);
+    refreshFrameTitle(session2, context.frameId, context.id);
+    reconcileTargetSelection(session2);
   });
-  session.handle.onEvent("Runtime.executionContextsCleared", () => {
-    const state2 = getOrCreateFrameState(session.tabId);
+  session2.handle.onEvent("Runtime.executionContextsCleared", () => {
+    const state2 = getOrCreateFrameState(session2.tabId);
     state2.executionContexts.clear();
     state2.pendingTitleLoads.clear();
   });
-  session.handle.onEvent("Runtime.executionContextDestroyed", (params) => {
+  session2.handle.onEvent("Runtime.executionContextDestroyed", (params) => {
     const record2 = params;
     if (record2.executionContextId == null) {
       return;
     }
-    const state2 = getOrCreateFrameState(session.tabId);
+    const state2 = getOrCreateFrameState(session2.tabId);
     for (const [frameId, contextId] of state2.executionContexts.entries()) {
       if (contextId === record2.executionContextId) {
         state2.executionContexts.delete(frameId);
@@ -17029,42 +17092,42 @@ var registerExtensionSessionEventHandlers = ({ session, events, ignoreMatcher, s
       }
     }
   });
-  session.handle.onEvent("Page.frameNavigated", (params, meta) => {
+  session2.handle.onEvent("Page.frameNavigated", (params, meta) => {
     const frame = parseFrame(params);
     if (!frame) {
       return;
     }
-    const state2 = getOrCreateFrameState(session.tabId);
+    const state2 = getOrCreateFrameState(session2.tabId);
     const preservedSessionId = pickFrameSessionId(meta.sessionId, state2.frames.get(frame.frameId)?.sessionId);
     state2.frames.set(frame.frameId, frame);
     frame.sessionId = preservedSessionId;
     if (!frame.parentFrameId) {
       if (!meta.sessionId) {
         state2.topFrameId = frame.frameId;
-        session.url = frame.url;
+        session2.url = frame.url;
       } else if (state2.topFrameId == null) {
         state2.topFrameId = frame.parentFrameId;
       }
     } else if (state2.executionContexts.has(frame.frameId)) {
-      refreshFrameTitle(session, frame.frameId);
+      refreshFrameTitle(session2, frame.frameId);
     }
-    setCurrentSession(session);
+    setCurrentSession(session2);
     if (!frame.parentFrameId && !meta.sessionId) {
-      events.onPageNavigation?.({ url: frame.url, title: session.title ?? null });
+      events.onPageNavigation?.({ url: frame.url, title: session2.title ?? null });
     }
-    if (reconcileTargetSelection(session)) {
+    if (reconcileTargetSelection(session2)) {
       return;
     }
     if (!frame.parentFrameId && state2.activeFrameId == null || state2.activeFrameId === frame.frameId) {
-      emitTargetChanged(session);
+      emitTargetChanged(session2);
     }
   });
-  session.handle.onEvent("Page.frameAttached", (params, meta) => {
+  session2.handle.onEvent("Page.frameAttached", (params, meta) => {
     const record2 = params;
     if (!record2.frameId) {
       return;
     }
-    const state2 = getOrCreateFrameState(session.tabId);
+    const state2 = getOrCreateFrameState(session2.tabId);
     state2.frames.set(record2.frameId, {
       frameId: record2.frameId,
       parentFrameId: record2.parentFrameId ?? state2.topFrameId ?? null,
@@ -17072,25 +17135,25 @@ var registerExtensionSessionEventHandlers = ({ session, events, ignoreMatcher, s
       title: null,
       sessionId: pickFrameSessionId(meta.sessionId, state2.frames.get(record2.frameId)?.sessionId)
     });
-    reconcileTargetSelection(session);
+    reconcileTargetSelection(session2);
   });
-  session.handle.onEvent("Page.frameDetached", (params) => {
+  session2.handle.onEvent("Page.frameDetached", (params) => {
     const record2 = params;
     if (!record2.frameId) {
       return;
     }
-    removeFrame(session.tabId, record2.frameId);
-    reconcileTargetSelection(session);
+    removeFrame(session2.tabId, record2.frameId);
+    reconcileTargetSelection(session2);
   });
-  session.handle.onEvent("Page.domContentEventFired", () => {
+  session2.handle.onEvent("Page.domContentEventFired", () => {
     events.onPageLoad?.();
   });
-  const logConfig = { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, sourcemaps, cdp: session.handle };
-  session.handle.onEvent("Runtime.consoleAPICalled", (params) => {
-    toConsoleEvent(params, session, logConfig).then((event) => events.onLog(event));
+  const logConfig = { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, sourcemaps, cdp: session2.handle };
+  session2.handle.onEvent("Runtime.consoleAPICalled", (params) => {
+    toConsoleEvent(params, session2, logConfig).then((event) => events.onLog(event));
   });
-  session.handle.onEvent("Runtime.exceptionThrown", (params) => {
-    toExceptionEvent(params, session, logConfig).then((event) => events.onLog(event));
+  session2.handle.onEvent("Runtime.exceptionThrown", (params) => {
+    toExceptionEvent(params, session2, logConfig).then((event) => events.onLog(event));
   });
 };
 var pickFrameSessionId = (nextSessionId, existingSessionId) => nextSessionId ?? existingSessionId ?? null;
@@ -17280,18 +17343,18 @@ var FRAME_COMMAND_READY_POLL_MS = 100;
 var createTargetRecovery = (deps) => {
   const { getCurrentSession, getOrCreateFrameState, refreshFrameTree, reconcileTargetSelection } = deps;
   const recoveryByTabId = new Map;
-  const sync = (session, state2) => {
+  const sync = (session2, state2) => {
     if (!needsTargetRecovery(state2)) {
-      clear(session.tabId);
+      clear(session2.tabId);
       return;
     }
-    if (recoveryByTabId.has(session.tabId)) {
+    if (recoveryByTabId.has(session2.tabId)) {
       return;
     }
     const timer = setInterval(() => {
-      retry(session.tabId);
+      retry(session2.tabId);
     }, TARGET_RECOVERY_INTERVAL_MS);
-    recoveryByTabId.set(session.tabId, {
+    recoveryByTabId.set(session2.tabId, {
       timer,
       deadline: Date.now() + TARGET_RECOVERY_TIMEOUT_MS
     });
@@ -17311,8 +17374,8 @@ var createTargetRecovery = (deps) => {
   };
   const retry = async (tabId) => {
     const recovery = recoveryByTabId.get(tabId);
-    const session = getCurrentSession();
-    if (!recovery || !session || session.tabId !== tabId) {
+    const session2 = getCurrentSession();
+    if (!recovery || !session2 || session2.tabId !== tabId) {
       clear(tabId);
       return;
     }
@@ -17326,32 +17389,32 @@ var createTargetRecovery = (deps) => {
       return;
     }
     try {
-      await refreshFrameTree(session);
+      await refreshFrameTree(session2);
     } catch {}
-    reconcileTargetSelection(session);
+    reconcileTargetSelection(session2);
     if (!needsTargetRecovery(getOrCreateFrameState(tabId))) {
       clear(tabId);
     }
   };
-  const kick = async (session) => {
-    const state2 = getOrCreateFrameState(session.tabId);
+  const kick = async (session2) => {
+    const state2 = getOrCreateFrameState(session2.tabId);
     if (!needsTargetRecovery(state2)) {
       return;
     }
-    sync(session, state2);
-    await retry(session.tabId);
+    sync(session2, state2);
+    await retry(session2.tabId);
   };
   const waitForSelectedFrameCommandTarget = async () => {
-    const session = getCurrentSession();
-    if (!session) {
+    const session2 = getCurrentSession();
+    if (!session2) {
       throw createNotAttachedError();
     }
-    const tabId = session.tabId;
+    const tabId = session2.tabId;
     const immediate = resolveSelectedFrameCommandState(getOrCreateFrameState(tabId));
     if (immediate.kind === "frame") {
       return buildFrameTargetContext(getOrCreateFrameState(tabId), immediate.frameId);
     }
-    await kick(session);
+    await kick(session2);
     const deadline = Date.now() + FRAME_COMMAND_READY_TIMEOUT_MS;
     while (Date.now() < deadline) {
       await delay(FRAME_COMMAND_READY_POLL_MS);
@@ -17372,11 +17435,11 @@ var needsTargetRecovery = (state2) => resolveSelectedFrameCommandState(state2).k
 var buildSelectedFrameNotReadyError = (tabId) => codedError("extension_frame_not_ready", `Selected iframe target on tab ${tabId} is not executable yet after reload. Try again in a few seconds or reattach the watcher if the problem persists.`);
 
 // ../argus-watcher/dist/sources/extension-frame-snapshot.js
-var applyExtensionFrameSnapshot = (session, state2, snapshot2, deps) => {
+var applyExtensionFrameSnapshot = (session2, state2, snapshot2, deps) => {
   const nextIds = new Set(snapshot2.frames.map((frame) => frame.frameId));
   for (const frameId of [...state2.frames.keys()]) {
     if (!nextIds.has(frameId)) {
-      deps.removeFrame(session.tabId, frameId);
+      deps.removeFrame(session2.tabId, frameId);
     }
   }
   let activeTargetTouched = false;
@@ -17407,29 +17470,29 @@ var applyExtensionFrameSnapshot = (session, state2, snapshot2, deps) => {
     const record2 = state2.frames.get(frame.frameId);
     const needsTitle = (!existing || urlChanged || record2.title == null) && frame.frameId !== snapshot2.topFrameId;
     if (needsTitle && state2.executionContexts.has(frame.frameId)) {
-      deps.refreshFrameTitle(session, frame.frameId);
+      deps.refreshFrameTitle(session2, frame.frameId);
     }
   }
   if (snapshot2.topFrameId != null) {
     state2.topFrameId = snapshot2.topFrameId;
     const topFrame = state2.frames.get(snapshot2.topFrameId);
     if (topFrame?.url) {
-      session.url = topFrame.url;
+      session2.url = topFrame.url;
     }
   }
-  const selectionChanged = deps.reconcileTargetSelection(session);
+  const selectionChanged = deps.reconcileTargetSelection(session2);
   if (!selectionChanged && activeTargetTouched) {
-    deps.emitTargetChanged(session);
+    deps.emitTargetChanged(session2);
   }
 };
 
 // ../argus-watcher/dist/sources/extension-frame-runtime.js
-var seedExtensionFrameState = (session, state2) => {
-  if (state2.frames.size > 0 || session.frames.length === 0) {
+var seedExtensionFrameState = (session2, state2) => {
+  if (state2.frames.size > 0 || session2.frames.length === 0) {
     return state2;
   }
-  state2.topFrameId = session.topFrameId;
-  for (const frame of session.frames) {
+  state2.topFrameId = session2.topFrameId;
+  for (const frame of session2.frames) {
     state2.frames.set(frame.frameId, {
       frameId: frame.frameId,
       parentFrameId: frame.parentFrameId,
@@ -17440,16 +17503,16 @@ var seedExtensionFrameState = (session, state2) => {
   }
   return state2;
 };
-var getSelectedExtensionTarget = (session, state2) => {
+var getSelectedExtensionTarget = (session2, state2) => {
   const frameId = state2?.requestedFrameId ?? state2?.activeFrameId;
   if (!state2 || !frameId) {
-    return buildPageTarget(session, { attached: true });
+    return buildPageTarget(session2, { attached: true });
   }
   const frame = state2.frames.get(frameId);
   if (frame) {
-    return frameToTarget(session.tabId, frame, { attached: true, faviconUrl: session.faviconUrl, topFrameId: state2.topFrameId });
+    return frameToTarget(session2.tabId, frame, { attached: true, faviconUrl: session2.faviconUrl, topFrameId: state2.topFrameId });
   }
-  return buildSelectedIframeFallbackTarget(session, state2);
+  return buildSelectedIframeFallbackTarget(session2, state2);
 };
 var setRequestedTargetSelection = (state2, frameId) => {
   if (state2.requestedFrameId !== frameId) {
@@ -17459,13 +17522,13 @@ var setRequestedTargetSelection = (state2, frameId) => {
   state2.requestedFrameId = frameId;
   state2.requestedFrameHint = frameId ? createRequestedFrameHint(state2.frames.get(frameId)) ?? previousHint : null;
 };
-var listExtensionTargets = (session, state2) => {
+var listExtensionTargets = (session2, state2) => {
   if (!state2) {
-    return [buildPageTarget(session, { attached: true })];
+    return [buildPageTarget(session2, { attached: true })];
   }
-  const selected = getSelectedExtensionTarget(session, state2);
+  const selected = getSelectedExtensionTarget(session2, state2);
   selected.targetReady = isSelectedTargetReady(state2);
-  const targets = [buildPageTarget(session, { attached: false }), ...buildFrameTargets(state2, session.tabId, null, session.faviconUrl)];
+  const targets = [buildPageTarget(session2, { attached: false }), ...buildFrameTargets(state2, session2.tabId, null, session2.faviconUrl)];
   const selectedIndex = targets.findIndex((target) => target.id === selected.id);
   if (selectedIndex < 0) {
     targets.push(selected);
@@ -17474,7 +17537,7 @@ var listExtensionTargets = (session, state2) => {
   }
   return targets;
 };
-var reconcileExtensionTargetSelection = (session, state2, onTargetChanged) => {
+var reconcileExtensionTargetSelection = (session2, state2, onTargetChanged) => {
   const resolution = resolveRequestedTarget(state2);
   if (resolution.kind === "page") {
     return activatePageTarget(state2, onTargetChanged);
@@ -17507,7 +17570,7 @@ var removeExtensionFrame = (state2, frameId) => {
   state2.executionContexts.delete(frameId);
   state2.pendingTitleLoads.delete(frameId);
 };
-var refreshExtensionFrameTitle = async (session, state2, frameId, onActiveFrameUpdated, contextId) => {
+var refreshExtensionFrameTitle = async (session2, state2, frameId, onActiveFrameUpdated, contextId) => {
   if (frameId === state2.topFrameId || state2.pendingTitleLoads.has(frameId)) {
     return;
   }
@@ -17521,7 +17584,7 @@ var refreshExtensionFrameTitle = async (session, state2, frameId, onActiveFrameU
   }
   state2.pendingTitleLoads.add(frameId);
   try {
-    const evaluated = await session.handle.sendAndWait("Runtime.evaluate", {
+    const evaluated = await session2.handle.sendAndWait("Runtime.evaluate", {
       expression: "document.title",
       contextId: executionContextId,
       returnByValue: true,
@@ -17568,19 +17631,19 @@ var syncRequestedFrameSelection = (state2, frameId) => {
   state2.requestedFrameId = frameId;
   state2.requestedFrameHint = createRequestedFrameHint(frame);
 };
-var buildSelectedIframeFallbackTarget = (session, state2) => {
+var buildSelectedIframeFallbackTarget = (session2, state2) => {
   const hint = state2.requestedFrameHint;
   const frameId = state2.requestedFrameId ?? state2.activeFrameId;
   if (!frameId) {
-    return buildPageTarget(session, { attached: true });
+    return buildPageTarget(session2, { attached: true });
   }
   return {
-    id: formatFrameTargetId(session.tabId, frameId),
+    id: formatFrameTargetId(session2.tabId, frameId),
     title: hint?.title ?? hint?.url ?? `iframe ${frameId}`,
-    url: hint?.url ?? session.url,
+    url: hint?.url ?? session2.url,
     type: "iframe",
-    parentId: formatPageTargetId(session.tabId),
-    faviconUrl: session.faviconUrl,
+    parentId: formatPageTargetId(session2.tabId),
+    faviconUrl: session2.faviconUrl,
     attached: true,
     targetReady: false
   };
@@ -17618,17 +17681,17 @@ var createExtensionSource = (options) => {
   });
   const frameSnapshotDeps = {
     removeFrame,
-    refreshFrameTitle: (session, frameId) => refreshFrameTitle(session, frameId),
+    refreshFrameTitle: (session2, frameId) => refreshFrameTitle(session2, frameId),
     reconcileTargetSelection,
     emitTargetChanged
   };
   const sessionManager = new SessionManager(messaging, {
-    onAttach: (session) => {
-      console.error(`[ExtensionSource] Tab attached: ${session.tabId} - ${session.url}`);
-      currentSession = session;
+    onAttach: (session2) => {
+      console.error(`[ExtensionSource] Tab attached: ${session2.tabId} - ${session2.url}`);
+      currentSession = session2;
       rebindDelegatingSessions();
-      seedFrameState(session);
-      bootstrapAttachedSession(session);
+      seedFrameState(session2);
+      bootstrapAttachedSession(session2);
     },
     onDetach: (tabId, reason) => {
       console.error(`[ExtensionSource] Tab detached: ${tabId} - ${reason}`);
@@ -17642,20 +17705,20 @@ var createExtensionSource = (options) => {
       events.onDetach?.(reason);
     },
     onTargetSelected: (tabId, frameId) => {
-      const session = currentSession;
-      if (!session || session.tabId !== tabId) {
+      const session2 = currentSession;
+      if (!session2 || session2.tabId !== tabId) {
         const state2 = getOrCreateFrameState(tabId);
         setRequestedTargetSelection(state2, frameId);
         return;
       }
-      requestTargetSelection(session, frameId);
+      requestTargetSelection(session2, frameId);
     },
     onFrameSnapshot: (snapshot2) => {
-      const session = currentSession;
-      if (!session || session.tabId !== snapshot2.tabId) {
+      const session2 = currentSession;
+      if (!session2 || session2.tabId !== snapshot2.tabId) {
         return;
       }
-      applyExtensionFrameSnapshot(session, getOrCreateFrameState(snapshot2.tabId), snapshot2, frameSnapshotDeps);
+      applyExtensionFrameSnapshot(session2, getOrCreateFrameState(snapshot2.tabId), snapshot2, frameSnapshotDeps);
     }
   });
   const { session: proxySession, controller: proxyController } = createDelegatingSession({
@@ -17710,70 +17773,70 @@ var createExtensionSource = (options) => {
     messaging.stop();
   };
   const listTargets = async () => {
-    const session = currentSession;
-    if (!session) {
+    const session2 = currentSession;
+    if (!session2) {
       return [];
     }
-    return listExtensionTargets(session, frameStateByTabId.get(session.tabId));
+    return listExtensionTargets(session2, frameStateByTabId.get(session2.tabId));
   };
   const attachTarget = async (targetId) => {
     const target = parseExtensionTargetId(targetId);
-    const session = currentSession;
-    if (!session) {
+    const session2 = currentSession;
+    if (!session2) {
       if (target.frameId) {
         throw new Error(`Cannot attach iframe ${target.frameId} before tab ${target.tabId} is attached`);
       }
       throw new Error(`Watcher ${hostInfo.watcherId} is a tab watcher. Use extension-control to attach tab ${target.tabId}.`);
     }
-    if (session.tabId !== target.tabId) {
-      throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session.tabId}, not tab ${target.tabId}`);
+    if (session2.tabId !== target.tabId) {
+      throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session2.tabId}, not tab ${target.tabId}`);
     }
-    requestTargetSelection(session, target.frameId);
-    return { ok: true, tab: sessionToBrowserTab(session), watcherId: hostInfo.watcherId };
+    requestTargetSelection(session2, target.frameId);
+    return { ok: true, tab: sessionToBrowserTab(session2), watcherId: hostInfo.watcherId };
   };
   const detachTarget = async (targetId) => {
     const target = parseExtensionTargetId(targetId);
-    const session = currentSession;
-    if (!session || session.tabId === target.tabId) {
+    const session2 = currentSession;
+    if (!session2 || session2.tabId === target.tabId) {
       sessionManager.detachTab(target.tabId);
       return {
         ok: true,
-        tab: session ? { ...sessionToBrowserTab(session), attached: false, watcherId: undefined } : { tabId: target.tabId, url: "", title: "", attached: false }
+        tab: session2 ? { ...sessionToBrowserTab(session2), attached: false, watcherId: undefined } : { tabId: target.tabId, url: "", title: "", attached: false }
       };
     }
-    throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session.tabId}, not tab ${target.tabId}`);
+    throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session2.tabId}, not tab ${target.tabId}`);
   };
   return {
     session: proxySession,
     pageSession,
     readBrowserCookies: async ({ domain, url }) => {
-      const session = getCurrentExtensionSession();
-      return await sessionManager.getCookies(session.tabId, {
+      const session2 = getCurrentExtensionSession();
+      return await sessionManager.getCookies(session2.tabId, {
         domain: domain ?? undefined,
         url: url ?? undefined
       });
     },
     getNetFilterContext: () => {
-      const session = currentSession;
-      if (!session) {
+      const session2 = currentSession;
+      if (!session2) {
         return null;
       }
-      const state2 = frameStateByTabId.get(session.tabId);
-      const selectedTarget = getSelectedTarget(session);
+      const state2 = frameStateByTabId.get(session2.tabId);
+      const selectedTarget = getSelectedTarget(session2);
       return {
         sourceMode: "extension",
         selectedFrameId: state2?.activeFrameId ?? null,
-        topFrameId: state2?.topFrameId ?? session.topFrameId,
-        selectedTargetUrl: selectedTarget?.url ?? session.url,
-        pageUrl: session.url
+        topFrameId: state2?.topFrameId ?? session2.topFrameId,
+        selectedTargetUrl: selectedTarget?.url ?? session2.url,
+        pageUrl: session2.url
       };
     },
     getFrameSessionId: (frameId) => {
-      const session = currentSession;
-      if (!session) {
+      const session2 = currentSession;
+      if (!session2) {
         return null;
       }
-      const state2 = frameStateByTabId.get(session.tabId);
+      const state2 = frameStateByTabId.get(session2.tabId);
       return state2?.frames.get(frameId)?.sessionId ?? null;
     },
     syncWatcherInfo: (info) => {
@@ -17809,10 +17872,10 @@ var createExtensionSource = (options) => {
     }
     delegatingSessions.clear();
   }
-  async function bootstrapAttachedSession(session) {
+  async function bootstrapAttachedSession(session2) {
     try {
       registerExtensionSessionEventHandlers({
-        session,
+        session: session2,
         events,
         ignoreMatcher: ignoreMatcherObj,
         stripUrlPrefixes: stripUrlPrefixes2,
@@ -17826,34 +17889,34 @@ var createExtensionSource = (options) => {
           currentSession = nextSession;
         }
       });
-      await enableBootstrapDomains(session);
-      await refreshFrameTree(session);
-      if (currentSession?.tabId !== session.tabId) {
+      await enableBootstrapDomains(session2);
+      await refreshFrameTree(session2);
+      if (currentSession?.tabId !== session2.tabId) {
         return;
       }
-      const target = getSelectedTarget(session) ?? buildPageTarget(session, { attached: true });
+      const target = getSelectedTarget(session2) ?? buildPageTarget(session2, { attached: true });
       emitStatus(target, null);
-      await events.onAttach?.(session.handle, target);
-      reconcileTargetSelection(session);
+      await events.onAttach?.(session2.handle, target);
+      reconcileTargetSelection(session2);
     } catch (error) {
       const message = formatError(error);
-      console.error(`[ExtensionSource] Failed to bootstrap attached tab ${session.tabId}: ${message}`);
-      if (currentSession?.tabId === session.tabId) {
+      console.error(`[ExtensionSource] Failed to bootstrap attached tab ${session2.tabId}: ${message}`);
+      if (currentSession?.tabId === session2.tabId) {
         emitStatus(null, message);
         events.onDetach?.(message);
       }
     }
   }
-  async function enableBootstrapDomains(session) {
-    await session.handle.sendAndWait("Runtime.enable");
-    await session.handle.sendAndWait("Page.enable");
+  async function enableBootstrapDomains(session2) {
+    await session2.handle.sendAndWait("Runtime.enable");
+    await session2.handle.sendAndWait("Page.enable");
   }
   function getCurrentTargetContext() {
-    const session = currentSession;
-    if (!session) {
+    const session2 = currentSession;
+    if (!session2) {
       return null;
     }
-    const state2 = frameStateByTabId.get(session.tabId);
+    const state2 = frameStateByTabId.get(session2.tabId);
     const frameId = state2?.requestedFrameId ?? state2?.activeFrameId;
     if (!state2 || !frameId) {
       return { kind: "page" };
@@ -17869,13 +17932,13 @@ var createExtensionSource = (options) => {
     frameStateByTabId.set(tabId, created);
     return created;
   }
-  function seedFrameState(session) {
-    const state2 = getOrCreateFrameState(session.tabId);
-    return seedExtensionFrameState(session, state2);
+  function seedFrameState(session2) {
+    const state2 = getOrCreateFrameState(session2.tabId);
+    return seedExtensionFrameState(session2, state2);
   }
   function emitStatus(target, reason) {
-    const session = currentSession;
-    const targetReady = target == null ? null : session ? isTargetReady(session.tabId) : true;
+    const session2 = currentSession;
+    const targetReady = target == null ? null : session2 ? isTargetReady(session2.tabId) : true;
     events.onStatus({
       attached: Boolean(target),
       targetReady,
@@ -17888,16 +17951,16 @@ var createExtensionSource = (options) => {
       reason
     });
   }
-  function emitTargetChanged(session) {
-    const target = getSelectedTarget(session);
+  function emitTargetChanged(session2) {
+    const target = getSelectedTarget(session2);
     if (!target) {
       return;
     }
-    const state2 = getOrCreateFrameState(session.tabId);
+    const state2 = getOrCreateFrameState(session2.tabId);
     if (state2.activeAttachedAt == null) {
       state2.activeAttachedAt = Date.now();
     }
-    const targetReady = isTargetReady(session.tabId);
+    const targetReady = isTargetReady(session2.tabId);
     emitStatus(target, null);
     messaging.send({
       type: "target_info",
@@ -17907,46 +17970,46 @@ var createExtensionSource = (options) => {
       attachedAt: state2.activeAttachedAt,
       targetReady
     });
-    events.onTargetChanged?.(session.handle, target);
+    events.onTargetChanged?.(session2.handle, target);
   }
-  function getSelectedTarget(session) {
-    return getSelectedExtensionTarget(session, frameStateByTabId.get(session.tabId));
+  function getSelectedTarget(session2) {
+    return getSelectedExtensionTarget(session2, frameStateByTabId.get(session2.tabId));
   }
-  function requestTargetSelection(session, frameId) {
-    const state2 = getOrCreateFrameState(session.tabId);
+  function requestTargetSelection(session2, frameId) {
+    const state2 = getOrCreateFrameState(session2.tabId);
     setRequestedTargetSelection(state2, frameId);
-    reconcileTargetSelection(session);
+    reconcileTargetSelection(session2);
   }
-  function reconcileTargetSelection(session) {
-    const state2 = getOrCreateFrameState(session.tabId);
-    const changed = reconcileExtensionTargetSelection(session, state2, () => {
-      emitTargetChanged(session);
+  function reconcileTargetSelection(session2) {
+    const state2 = getOrCreateFrameState(session2.tabId);
+    const changed = reconcileExtensionTargetSelection(session2, state2, () => {
+      emitTargetChanged(session2);
     });
-    targetRecovery.sync(session, state2);
+    targetRecovery.sync(session2, state2);
     return changed;
   }
-  async function refreshFrameTree(session) {
-    await session.requestFrameSnapshot({ refresh: true });
+  async function refreshFrameTree(session2) {
+    await session2.requestFrameSnapshot({ refresh: true });
   }
   function removeFrame(tabId, frameId) {
     const state2 = getOrCreateFrameState(tabId);
     removeExtensionFrame(state2, frameId);
   }
-  async function refreshFrameTitle(session, frameId, contextId) {
-    const state2 = getOrCreateFrameState(session.tabId);
-    await refreshExtensionFrameTitle(session, state2, frameId, () => {
-      emitTargetChanged(session);
+  async function refreshFrameTitle(session2, frameId, contextId) {
+    const state2 = getOrCreateFrameState(session2.tabId);
+    await refreshExtensionFrameTitle(session2, state2, frameId, () => {
+      emitTargetChanged(session2);
     }, contextId);
   }
   function isTargetReady(tabId) {
     return isSelectedTargetReady(getOrCreateFrameState(tabId));
   }
 };
-var sessionToBrowserTab = (session) => ({
-  tabId: session.tabId,
-  url: session.url,
-  title: session.title,
-  faviconUrl: session.faviconUrl,
+var sessionToBrowserTab = (session2) => ({
+  tabId: session2.tabId,
+  url: session2.url,
+  title: session2.title,
+  faviconUrl: session2.faviconUrl,
   attached: true
 });
 
@@ -18075,19 +18138,19 @@ var createWatcherHandle = async (options, watcherId) => {
   const handlePageIntl = (info) => {
     fileLogger?.setPageIntl(info);
   };
-  const handleSourceAttach = async (session, target) => {
+  const handleSourceAttach = async (session2, target) => {
     elementRefs.reset();
     dialogTracker.clear();
     runtimeEditor?.rebind();
-    await emulationController.onAttach(session);
-    await throttleController.onAttach(session);
+    await emulationController.onAttach(session2);
+    await throttleController.onAttach(session2);
     await visibilityController.onAttach(getPageSession());
     await netMockController.onAttach();
     await networkCapture?.onAttached();
-    indicator.onAttach(session, target);
-    await injectOnAttach(session, target);
+    indicator.onAttach(session2, target);
+    await injectOnAttach(session2, target);
   };
-  const handleTargetChanged = (session, target) => {
+  const handleTargetChanged = (session2, target) => {
     elementRefs.reset();
     updateCdpStatus({
       attached: true,
@@ -18100,7 +18163,7 @@ var createWatcherHandle = async (options, watcherId) => {
       reason: null
     });
     netMockController.onTargetChanged();
-    indicator.onAttach(session, target);
+    indicator.onAttach(session2, target);
   };
   const handleSourceDetach = (reason) => {
     elementRefs.reset();
@@ -23629,14 +23692,14 @@ var parseCookieSetInput = (input, output) => {
   if (sameSite === "None" && input.secure !== true) {
     return writeCookieInputError(output, "sameSite=None requires --secure");
   }
-  const session = input.session === true || expires === undefined;
+  const session2 = input.session === true || expires === undefined;
   return {
     ...identity,
     value: input.value,
     secure: input.secure === true,
     httpOnly: input.httpOnly === true,
-    session,
-    expires: session ? null : expires,
+    session: session2,
+    expires: session2 ? null : expires,
     sameSite
   };
 };
@@ -51859,6 +51922,492 @@ var skillCommands = [
   }
 ];
 
+// dist/session/runSession.js
+import readline from "node:readline";
+
+// dist/session/sessionArgv.js
+var resolveSessionCommand = (program2, cmd) => {
+  const tokens = cmd.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return { ok: false, code: "session_invalid_request", message: "cmd must name a command" };
+  }
+  let current = program2;
+  const path25 = [];
+  for (const token of tokens) {
+    const next = current.commands.find((candidate) => candidate.name() === token || candidate.aliases().includes(token));
+    if (!next) {
+      const context = path25.length > 0 ? ` under "${path25.join(" ")}"` : "";
+      return { ok: false, code: "session_unknown_command", message: `Unknown command "${token}"${context}.` };
+    }
+    current = next;
+    path25.push(next.name());
+  }
+  return { ok: true, command: current, path: path25 };
+};
+var buildSessionArgv = (input) => {
+  const resolved = resolveSessionCommand(input.program, input.request.cmd);
+  if (!resolved.ok) {
+    return resolved;
+  }
+  const blocked = rejectNonSessionCommand(resolved.path);
+  if (blocked) {
+    return blocked;
+  }
+  const tail = input.request.argv ? [...input.request.argv] : buildArgvFromArgs(resolved.command, input.request.args ?? {});
+  if (isArgvFailure(tail)) {
+    return tail;
+  }
+  const argv = [...resolved.path];
+  if (takesWatcherId(resolved.command) && tail[0] !== input.watcherId) {
+    argv.push(input.watcherId);
+  }
+  argv.push(...tail);
+  if (declaresOption(resolved.command, "json") && !tail.some(isJsonFlag)) {
+    argv.push("--json");
+  }
+  const rejected = rejectStdinInput(argv, resolved.path);
+  if (rejected) {
+    return rejected;
+  }
+  return { ok: true, argv, resolved };
+};
+var NON_SESSION_COMMANDS = new Set(["session", "start", "chrome start", "watcher start", "watcher native-host", "logs tail", "net tail", "net sse"]);
+var rejectNonSessionCommand = (path25) => {
+  const name = path25.join(" ");
+  if (!NON_SESSION_COMMANDS.has(name)) {
+    return null;
+  }
+  return {
+    ok: false,
+    code: "session_command_rejected",
+    message: `"${name}" runs until interrupted and cannot be dispatched from a session; run it as its own process.`
+  };
+};
+var rejectStdinInput = (argv, path25) => {
+  const readsStdin = argv.includes("--stdin") || STDIN_DASH_COMMANDS.has(path25[0]) && argv.includes("-");
+  if (!readsStdin) {
+    return null;
+  }
+  return {
+    ok: false,
+    code: "session_command_rejected",
+    message: "stdin belongs to the session transport; pass the expression inline or with --file instead of reading stdin."
+  };
+};
+var STDIN_DASH_COMMANDS = new Set(["eval", "eval-until"]);
+var isArgvFailure = (value) => !Array.isArray(value);
+var isJsonFlag = (token) => token === "--json" || token === "--no-json" || token === "--json-full";
+var takesWatcherId = (command) => command.registeredArguments[0]?.name() === "id";
+var declaresOption = (command, name) => findOptions(command, name).length > 0;
+var buildArgvFromArgs = (command, args) => {
+  const names = positionalNames(command);
+  const tokens = [];
+  const positionals = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (value === undefined)
+      continue;
+    const options = findOptions(command, key);
+    if (options.length === 0) {
+      if (!names.includes(camelCase(key))) {
+        const path25 = commandPath(command);
+        return {
+          ok: false,
+          code: "session_invalid_request",
+          message: `Unknown argument "${key}" for command "${path25}". Run \`argus ${path25} --help\` for the accepted flags.`
+        };
+      }
+      positionals[camelCase(key)] = value;
+      continue;
+    }
+    const emitted = emitOption(options, key, value);
+    if (isArgvFailure(emitted)) {
+      return emitted;
+    }
+    tokens.push(...emitted);
+  }
+  const ordered = orderPositionals(names, positionals);
+  if (isArgvFailure(ordered)) {
+    return ordered;
+  }
+  return [...ordered, ...tokens];
+};
+var emitOption = (options, key, value) => {
+  const positive = options.find((option) => !option.negate);
+  const negated = options.find((option) => option.negate);
+  const valued = options.find((option) => option.required || option.optional);
+  if (valued) {
+    const values = Array.isArray(value) ? value : [value];
+    const tokens = [];
+    for (const entry of values) {
+      if (entry == null)
+        continue;
+      if (typeof entry === "object") {
+        return { ok: false, code: "session_invalid_request", message: `Argument "${key}" must be a string, number, or boolean.` };
+      }
+      tokens.push(flagOf(valued), String(entry));
+    }
+    return tokens;
+  }
+  if (typeof value !== "boolean") {
+    return { ok: false, code: "session_invalid_request", message: `Argument "${key}" is a switch and must be true or false.` };
+  }
+  const wanted = value ? positive : negated;
+  return wanted ? [flagOf(wanted)] : [];
+};
+var orderPositionals = (declaredNames, values) => {
+  const tokens = [];
+  let missing = null;
+  for (const name of declaredNames) {
+    if (name === "id")
+      continue;
+    const value = values[name];
+    if (value === undefined) {
+      missing ??= name;
+      continue;
+    }
+    if (missing) {
+      return {
+        ok: false,
+        code: "session_invalid_request",
+        message: `Argument "${name}" cannot be set without "${missing}"; positional arguments are filled in order.`
+      };
+    }
+    for (const entry of Array.isArray(value) ? value : [value]) {
+      if (entry != null && typeof entry === "object") {
+        return { ok: false, code: "session_invalid_request", message: `Argument "${name}" must be a string, number, or boolean.` };
+      }
+      tokens.push(String(entry));
+    }
+  }
+  return tokens;
+};
+var findOptions = (command, key) => {
+  const wanted = camelCase(key);
+  return commandChain(command).flatMap((current) => current.options).filter((option) => option.attributeName() === wanted || option.name() === key || option.short === `-${key}`);
+};
+var positionalNames = (command) => command.registeredArguments.map((argument) => camelCase(argument.name()));
+var flagOf = (option) => option.long ?? option.short ?? `--${option.name()}`;
+var commandPath = (command) => commandChain(command).map((current) => current.name()).reverse().join(" ");
+var commandChain = (command) => {
+  const chain = [];
+  for (let current = command;current?.parent; current = current.parent) {
+    chain.push(current);
+  }
+  return chain;
+};
+var camelCase = (value) => value.replace(/[-_]([a-z0-9])/g, (_4, character) => character.toUpperCase());
+
+// dist/session/sessionDispatch.js
+var dispatchSessionRequest = async (input) => {
+  const { request } = input;
+  const respond = createResponder(request, Date.now());
+  const timeoutMs = resolveTimeoutMs(request.timeout, input.defaultTimeoutMs);
+  if (timeoutMs == null) {
+    return respond.failure({ message: `Invalid timeout "${String(request.timeout)}".`, code: "session_invalid_request" }, 2);
+  }
+  const built = buildSessionArgv({ program: input.program, request, watcherId: input.watcherId });
+  if (!built.ok) {
+    return respond.failure({ message: built.message, code: built.code }, 2);
+  }
+  const sink = { stdout: [], stderr: [] };
+  process.exitCode = 0;
+  const running = input.capture.run(sink, async () => {
+    try {
+      await input.program.parseAsync(built.argv, { from: "user" });
+      return null;
+    } catch (error) {
+      return error;
+    }
+  });
+  const settled = await raceWithTimeout(running, timeoutMs);
+  const stderr = sink.stderr.join("");
+  if (settled.timedOut) {
+    return respond.failure({ message: `Request timed out after ${timeoutMs}ms.`, code: "session_request_timeout" }, 1, stderr);
+  }
+  const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
+  process.exitCode = 0;
+  const stdout = sink.stdout.join("");
+  if (settled.error) {
+    return fromThrownError(respond, settled.error, stdout, stderr);
+  }
+  if (exitCode !== 0) {
+    return respond.failure(errorDetailFrom(stdout, stderr), exitCode, stderr);
+  }
+  return respond.success(stdout, stderr);
+};
+var fromThrownError = (respond, error, stdout, stderr) => {
+  if (!(error instanceof CommanderError)) {
+    return respond.failure({ message: formatError(error), code: "session_command_failed" }, 1, stderr);
+  }
+  if (error.exitCode === 0) {
+    return respond.success(stdout, stderr);
+  }
+  return respond.failure({ message: error.message, code: "session_invalid_request" }, error.exitCode || 2, stderr);
+};
+var decodeStdout = (stdout) => {
+  const lines = stdout.split(`
+`).filter((line) => line.trim() !== "");
+  if (lines.length === 0) {
+    return { result: null };
+  }
+  const documents = [];
+  for (const line of lines) {
+    try {
+      documents.push(JSON.parse(line));
+    } catch {
+      return { result: stdout, raw: true };
+    }
+  }
+  return documents.length === 1 ? { result: documents[0] } : { result: documents, stream: true };
+};
+var errorDetailFrom = (stdout, stderr) => {
+  const document = decodeStdout(stdout).result;
+  if (document && typeof document === "object" && document.ok === false) {
+    const detail = document.error;
+    if (detail?.message) {
+      return detail;
+    }
+  }
+  const message = stderr.trim().split(`
+`).filter(Boolean).at(-1);
+  return { message: message ?? "Command failed.", code: "session_command_failed" };
+};
+var createResponder = (request, startedAt) => {
+  const id = request.id === undefined ? {} : { id: request.id };
+  const trailer = (stderr) => ({ durationMs: Date.now() - startedAt, ...stderr === "" ? {} : { stderr } });
+  return {
+    success: (stdout, stderr) => ({ ...id, ok: true, ...decodeStdout(stdout), ...trailer(stderr) }),
+    failure: (error, exitCode, stderr = "") => ({ ...id, ok: false, error, exitCode, ...trailer(stderr) })
+  };
+};
+var resolveTimeoutMs = (timeout, fallbackMs) => {
+  if (timeout == null) {
+    return fallbackMs;
+  }
+  if (typeof timeout === "number") {
+    return timeout;
+  }
+  return parseDurationMs(timeout, "ms");
+};
+var raceWithTimeout = async (running, timeoutMs) => {
+  if (timeoutMs <= 0) {
+    return { timedOut: false, error: await running };
+  }
+  let timer;
+  const watchdog = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2({ timedOut: true }), timeoutMs);
+  });
+  try {
+    return await Promise.race([running.then((error) => ({ timedOut: false, error })), watchdog]);
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+// dist/session/stdioCapture.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var installStdioCapture = () => {
+  const storage2 = new AsyncLocalStorage;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = createCapturingWrite(storage2, originalStdoutWrite, (sink) => sink.stdout, false);
+  process.stderr.write = createCapturingWrite(storage2, originalStderrWrite, (sink) => sink.stderr, true);
+  return {
+    run: (sink, body) => storage2.run(sink, body),
+    writeStdout: (text) => {
+      originalStdoutWrite(text);
+    },
+    restore: () => {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    }
+  };
+};
+var createCapturingWrite = (storage2, original, select, mirror) => {
+  const forward = original;
+  return (chunk, encoding, callback) => {
+    const sink = storage2.getStore();
+    if (!sink) {
+      return forward(chunk, encoding, callback);
+    }
+    select(sink).push(decodeChunk(chunk, encoding));
+    if (mirror) {
+      forward(chunk, encoding);
+    }
+    const done = typeof encoding === "function" ? encoding : callback;
+    if (typeof done === "function") {
+      done();
+    }
+    return true;
+  };
+};
+var decodeChunk = (chunk, encoding) => {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  const bufferEncoding = typeof encoding === "string" ? encoding : "utf8";
+  return Buffer.from(chunk).toString(bufferEncoding);
+};
+
+// dist/session/runSession.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 120000;
+var WATCHER_PROBE_TIMEOUT_MS = 1500;
+var runSession = async (id, options) => {
+  routeConsoleToStderr();
+  const output = createOutput({ json: true });
+  const defaultTimeoutMs = resolveDefaultTimeout(options, output);
+  if (defaultTimeoutMs == null)
+    return;
+  const resolved = await resolveWatcherOrExit({ id }, output);
+  if (!resolved)
+    return;
+  const program2 = await buildSessionProgram();
+  const capture = installStdioCapture();
+  const writeLine = (line) => capture.writeStdout(`${JSON.stringify(line)}
+`);
+  writeLine(readyEvent(resolved.watcher));
+  const exitCode = await serveRequests({
+    program: program2,
+    capture,
+    writeLine,
+    output,
+    watcher: resolved.watcher,
+    defaultTimeoutMs,
+    reconnect: options.reconnect === true
+  });
+  capture.restore();
+  await flushStdout();
+  process.exit(exitCode);
+};
+var serveRequests = async (input) => {
+  const lines = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      if (line.trim() === "")
+        continue;
+      const request = parseRequestLine(line);
+      if (!request.ok) {
+        input.writeLine(request.response);
+        continue;
+      }
+      if (request.value.cmd === "quit") {
+        input.writeLine(controlResponse(request.value.id, { closed: true }));
+        return 0;
+      }
+      if (request.value.cmd === "ping") {
+        input.writeLine(controlResponse(request.value.id, { pong: true, watcher: input.watcher.id }));
+        continue;
+      }
+      const response = await dispatchSessionRequest({
+        program: input.program,
+        capture: input.capture,
+        request: request.value,
+        watcherId: input.watcher.id,
+        defaultTimeoutMs: input.defaultTimeoutMs
+      });
+      input.writeLine(response);
+      if (await watcherLost(response, input)) {
+        input.output.writeWarn(`Watcher ${input.watcher.id} is no longer reachable; closing session.`);
+        return 1;
+      }
+    }
+  } finally {
+    lines.close();
+  }
+  return 0;
+};
+var watcherLost = async (response, input) => {
+  if (response.ok || input.reconnect)
+    return false;
+  if (response.error.code && FRAMING_ERROR_CODES.has(response.error.code))
+    return false;
+  return !await watcherReachable(input.watcher.id);
+};
+var FRAMING_ERROR_CODES = new Set(["session_invalid_request", "session_unknown_command", "session_command_rejected"]);
+var watcherReachable = async (id) => {
+  const resolved = await resolveWatcher({ id });
+  if (!resolved.ok)
+    return false;
+  try {
+    await fetchWatcherJson(resolved.watcher, { path: "/status", timeoutMs: WATCHER_PROBE_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var parseRequestLine = (line) => {
+  let decoded;
+  try {
+    decoded = JSON.parse(line);
+  } catch (error) {
+    return { ok: false, response: framingError(`Request is not valid JSON: ${error.message}`) };
+  }
+  const parsed = SESSION_REQUEST_SCHEMA.parse(decoded);
+  if (!parsed.ok) {
+    const id = decoded?.id;
+    return { ok: false, response: framingError(formatProtocolValidationIssues(parsed.issues), id) };
+  }
+  return { ok: true, value: parsed.value };
+};
+var framingError = (message, id) => ({
+  ...idOf(id),
+  ok: false,
+  error: { message, code: "session_invalid_request" },
+  exitCode: 2,
+  durationMs: 0
+});
+var controlResponse = (id, result) => ({ ...idOf(id), ok: true, result, durationMs: 0 });
+var idOf = (id) => id === undefined ? {} : { id };
+var buildSessionProgram = async () => {
+  const program2 = createProgram({ mode: "session" });
+  for (const registerProgramPart of coreProgramRegistrars) {
+    registerProgramPart(program2);
+  }
+  await registerPlugins(program2);
+  return program2;
+};
+var readyEvent = (watcher2) => ({
+  type: "ready",
+  protocolVersion: SESSION_PROTOCOL_VERSION,
+  argusVersion: package_default.version,
+  watcher: { id: watcher2.id, host: watcher2.host, port: watcher2.port }
+});
+var resolveDefaultTimeout = (options, output) => {
+  if (options.requestTimeout == null) {
+    return DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  const parsed = parseDurationMs(options.requestTimeout, "ms");
+  if (parsed == null || parsed < 0) {
+    usageError({ json: output.json }, `Invalid --request-timeout: ${options.requestTimeout}`);
+    return null;
+  }
+  return parsed;
+};
+var flushStdout = () => new Promise((resolve2) => process.stdout.write("", () => resolve2()));
+
+// dist/cli/register/sessionCommands.js
+var sessionCommands = [
+  {
+    name: "session",
+    description: "Serve JSONL commands over stdin/stdout against one watcher, in a single process",
+    arguments: [{ flags: "[id]", description: "Watcher id to pin the session to" }],
+    options: [
+      { flags: "--request-timeout <duration>", description: "Per-request watchdog when the request omits one (default: 120s; 0 disables)" },
+      { flags: "--reconnect", description: "Stay alive when the watcher disappears and re-resolve it by id on the next request" },
+      { ...jsonOption, description: "Accepted for symmetry; the transport is always JSONL" }
+    ],
+    examples: [
+      "argus session app",
+      "argus session app --request-timeout 30s",
+      "argus session app --reconnect",
+      `echo '{"id":1,"cmd":"eval","args":{"expression":"location.href"}}' | argus session app`
+    ],
+    action: async (id, options) => {
+      await runSession(id, options);
+    }
+  }
+];
+
 // dist/cli/register/index.js
 var coreCommandDefinitions = [
   ...quickAccessCommands,
@@ -51885,6 +52434,7 @@ var coreCommandDefinitions = [
   ...recordCommands,
   ...traceCommands,
   ...configCommands,
+  ...sessionCommands,
   ...pluginCommands,
   ...skillCommands,
   ...extensionCommands