@vforsh/argus 0.1.9 → 0.1.11

package/dist/argus.js

@@ -5,29 +5,15 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -2145,7 +2131,7 @@ var {
 // dist/cli/program.js
 function createProgram() {
   const program2 = new Command;
-  program2.name("argus").description("Argus CLI for local watcher servers").version("0.1.0").configureOutput({
+  program2.name("argus").description("Argus CLI for local watcher servers").version("0.1.11").configureOutput({
     outputError: (str, write) => write(str)
   }).showSuggestionAfterError(true).exitOverride((error) => {
     if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
@@ -2595,38 +2581,32 @@ var findTextPatternMatch = (line, pattern) => {
     length: Math.max(1, matched[0]?.length ?? 0)
   };
 };
-// dist/registry.js
-var loadRegistry = async () => {
-  const { registry: registry2, warnings } = await readRegistry();
-  for (const warning of warnings) {
-    console.error(warning);
+// ../argus-core/dist/auth/cookies.js
+var TRACKING_COOKIE_PATTERNS = [/^_ga/i, /^_gid$/i, /^_ym/i, /^_fbp$/i, /^_hj/i, /^amplitude/i, /^mp_/i];
+var normalizeCookieDomainFilter = (domain) => {
+  if (!domain) {
+    return null;
   }
-  return registry2;
+  const normalized = normalizeCookieDomain(domain);
+  return normalized || null;
 };
-var pruneRegistry = async (ttlMs = DEFAULT_TTL_MS) => {
-  return updateRegistry((registry2) => {
-    const { registry: pruned } = pruneStaleWatchers(registry2, Date.now(), ttlMs);
-    return pruned;
-  });
-};
-var removeWatcherAndPersist = async (id) => {
-  return updateRegistry((registry2) => removeWatcherEntry(registry2, id));
+var matchesCookieDomain = (cookieDomain, domain) => {
+  if (!domain) {
+    return true;
+  }
+  const normalizedDomain = normalizeCookieDomain(cookieDomain);
+  return normalizedDomain === domain || normalizedDomain.endsWith(`.${domain}`);
 };
-var removeWatchersAndPersist = async (ids) => {
-  if (ids.length === 0) {
-    const { registry: registry2 } = await readRegistry();
-    return registry2;
+var getOriginHost = (origin) => {
+  try {
+    return new URL(origin).hostname;
+  } catch {
+    return null;
   }
-  return updateRegistry((registry2) => {
-    let next = registry2;
-    for (const id of ids) {
-      next = removeWatcherEntry(next, id);
-    }
-    return next;
-  });
 };
-
-// dist/httpClient.js
+var isTrackingCookieName = (name) => TRACKING_COOKIE_PATTERNS.some((pattern) => pattern.test(name));
+var normalizeCookieDomain = (domain) => domain.trim().toLowerCase().replace(/^\./, "");
+// ../argus-core/dist/http/fetch.js
 var fetchJson = async (url, options = {}) => {
   const controller = new AbortController;
   const timeoutMs = options.timeoutMs ?? 5000;
@@ -2656,24 +2636,6 @@ var fetchJson = async (url, options = {}) => {
     clearTimeout(timer);
   }
 };
-var isAbortError = (error) => {
-  if (!error || typeof error !== "object" || !("name" in error)) {
-    return false;
-  }
-  return error.name === "AbortError";
-};
-var extractErrorMessage = async (response) => {
-  try {
-    const body = await response.json();
-    if (body && typeof body === "object" && "error" in body) {
-      const error = body.error;
-      if (error && typeof error === "object" && "message" in error) {
-        return error.message;
-      }
-    }
-  } catch {}
-  return null;
-};
 var fetchText = async (url, options = {}) => {
   const controller = new AbortController;
   const timeoutMs = options.timeoutMs ?? 5000;
@@ -2699,50 +2661,53 @@ var fetchText = async (url, options = {}) => {
     clearTimeout(timer);
   }
 };
-
-// dist/cli/parse.js
-var formatError = (error) => {
-  if (!error) {
-    return "unknown error";
-  }
-  if (error instanceof Error) {
-    return error.message;
+var isAbortError = (error) => {
+  if (!error || typeof error !== "object" || !("name" in error)) {
+    return false;
   }
-  return String(error);
+  return error.name === "AbortError";
 };
-var parseNumber = (value) => {
-  if (!value) {
-    return;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    return;
-  }
-  return parsed;
+var extractErrorMessage = async (response) => {
+  try {
+    const body = await response.json();
+    if (body && typeof body === "object" && "error" in body) {
+      const error = body.error;
+      if (error && typeof error === "object" && "message" in error) {
+        return error.message;
+      }
+    }
+  } catch {}
+  return null;
 };
-var parsePositiveInt = (value, options) => {
-  if (value === undefined) {
-    return;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
-    return;
-  }
-  const min = options?.allowZero ? 0 : 1;
-  if (parsed < min) {
-    return;
+// dist/registry.js
+var loadRegistry = async () => {
+  const { registry: registry2, warnings } = await readRegistry();
+  for (const warning of warnings) {
+    console.error(warning);
   }
-  return parsed;
+  return registry2;
 };
-var normalizeQueryValue = (value) => {
-  if (value == null) {
-    return;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return;
+var pruneRegistry = async (ttlMs = DEFAULT_TTL_MS) => {
+  return updateRegistry((registry2) => {
+    const { registry: pruned } = pruneStaleWatchers(registry2, Date.now(), ttlMs);
+    return pruned;
+  });
+};
+var removeWatcherAndPersist = async (id) => {
+  return updateRegistry((registry2) => removeWatcherEntry(registry2, id));
+};
+var removeWatchersAndPersist = async (ids) => {
+  if (ids.length === 0) {
+    const { registry: registry2 } = await readRegistry();
+    return registry2;
   }
-  return trimmed;
+  return updateRegistry((registry2) => {
+    let next = registry2;
+    for (const id of ids) {
+      next = removeWatcherEntry(next, id);
+    }
+    return next;
+  });
 };
 
 // dist/output/format.js
@@ -2836,6 +2801,162 @@ var createOutput = (options) => {
     writeWarn
   };
 };
+// dist/cli/parse.js
+var formatError = (error) => {
+  if (!error) {
+    return "unknown error";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var parseNumber = (value) => {
+  if (!value) {
+    return;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return;
+  }
+  return parsed;
+};
+var parsePositiveInt = (value, options) => {
+  if (value === undefined) {
+    return;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+    return;
+  }
+  const min = options?.allowZero ? 0 : 1;
+  if (parsed < min) {
+    return;
+  }
+  return parsed;
+};
+var normalizeQueryValue = (value) => {
+  if (value == null) {
+    return;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return;
+  }
+  return trimmed;
+};
+
+// dist/watchers/resolveWatcher.js
+var resolveWatcher = async (input) => {
+  let registry2;
+  try {
+    registry2 = await pruneRegistry();
+  } catch (error) {
+    return { ok: false, error: `Failed to load registry: ${error instanceof Error ? error.message : error}`, exitCode: 1 };
+  }
+  const watchers = Object.values(registry2.watchers);
+  if (input.id) {
+    const watcher = registry2.watchers[input.id];
+    if (!watcher) {
+      return { ok: false, error: `Watcher not found: ${input.id}`, exitCode: 2, candidates: watchers };
+    }
+    return { ok: true, watcher, registry: registry2 };
+  }
+  if (watchers.length === 0) {
+    return { ok: false, error: "Watcher id required.", exitCode: 2 };
+  }
+  const cwd = process.cwd();
+  const cwdMatches = watchers.filter((watcher) => watcher.cwd === cwd);
+  if (cwdMatches.length === 1) {
+    return { ok: true, watcher: cwdMatches[0], registry: registry2 };
+  }
+  if (cwdMatches.length > 1) {
+    return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: cwdMatches };
+  }
+  const reachability = await Promise.all(watchers.map(async (watcher) => ({
+    watcher,
+    status: await checkWatcherStatus(watcher)
+  })));
+  const reachable = reachability.filter((entry) => entry.status.ok);
+  if (reachable.length === 1) {
+    return { ok: true, watcher: reachable[0].watcher, registry: registry2 };
+  }
+  return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: watchers };
+};
+var checkWatcherStatus = async (watcher) => {
+  try {
+    const status = await fetchWatcherJson(watcher, { path: "/status", timeoutMs: 1500 });
+    return { ok: true, status };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+};
+
+// dist/watchers/requestWatcher.js
+var buildWatcherUrl = (watcher, path4, query) => {
+  const qs = query?.toString();
+  return `http://${watcher.host}:${watcher.port}${path4}${qs ? `?${qs}` : ""}`;
+};
+var formatWatcherTransportError = (watcher, error) => `${watcher.id}: failed to reach watcher (${formatError(error)})`;
+async function fetchWatcherJson(watcher, input) {
+  return fetchJson(buildWatcherUrl(watcher, input.path, input.query), {
+    method: input.method,
+    body: input.body,
+    timeoutMs: input.timeoutMs,
+    returnErrorResponse: input.returnErrorResponse
+  });
+}
+async function requestWatcherJson(input) {
+  const resolved = await resolveWatcher({ id: input.id });
+  if (!resolved.ok) {
+    return {
+      ok: false,
+      exitCode: resolved.exitCode,
+      message: resolved.error,
+      candidates: resolved.candidates
+    };
+  }
+  const { watcher } = resolved;
+  try {
+    const data = await fetchWatcherJson(watcher, input);
+    return { ok: true, watcher, data };
+  } catch (error) {
+    return {
+      ok: false,
+      watcher,
+      exitCode: 1,
+      message: formatWatcherTransportError(watcher, error)
+    };
+  }
+}
+async function resolveWatcherOrExit(input, output) {
+  const resolved = await resolveWatcher(input);
+  if (!resolved.ok) {
+    writeResolveError(resolved, output);
+    return null;
+  }
+  return { watcher: resolved.watcher };
+}
+function writeRequestError(result, output) {
+  output.writeWarn(result.message);
+  if (result.candidates && result.candidates.length > 0) {
+    for (const watcher of result.candidates) {
+      output.writeWarn(formatWatcherLine(watcher));
+    }
+    output.writeWarn("Hint: run `argus list` to see all watchers.");
+  }
+  process.exitCode = result.exitCode;
+}
+function writeResolveError(resolved, output) {
+  output.writeWarn(resolved.error);
+  if (resolved.candidates && resolved.candidates.length > 0) {
+    for (const watcher of resolved.candidates) {
+      output.writeWarn(formatWatcherLine(watcher));
+    }
+    output.writeWarn("Hint: run `argus list` to see all watchers.");
+  }
+  process.exitCode = resolved.exitCode;
+}
 
 // dist/commands/chrome.js
 import { execFile } from "node:child_process";
@@ -2895,6 +3016,102 @@ var resolveCdpEndpoint = async (options) => {
   return { ok: true, host: "127.0.0.1", port: 9222 };
 };
 
+// dist/cdp/sendCdpCommand.js
+var getWebSocketCtor = () => {
+  const ctor = globalThis.WebSocket;
+  return ctor ?? null;
+};
+var toMessageText = (data) => {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (Buffer.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  return null;
+};
+var sendCdpCommand = async (wsUrl, payload, timeoutMs = 5000) => {
+  const WebSocketConstructor = getWebSocketCtor();
+  if (!WebSocketConstructor) {
+    throw new Error("WebSocket unavailable. Node 18+ required.");
+  }
+  const ws = new WebSocketConstructor(wsUrl);
+  const requestId = payload.id;
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        try {
+          ws.close();
+        } catch {}
+        reject(new Error(`CDP command timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      ws.removeEventListener?.("open", onOpen);
+      ws.removeEventListener?.("message", onMessage);
+      ws.removeEventListener?.("error", onError);
+      ws.removeEventListener?.("close", onClose);
+    };
+    const finish = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      try {
+        ws.close();
+      } catch {}
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const onOpen = () => {
+      try {
+        ws.send(JSON.stringify(payload));
+      } catch (error) {
+        finish(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    const onMessage = (event) => {
+      const text = toMessageText(event.data);
+      if (!text) {
+        return;
+      }
+      try {
+        const message = JSON.parse(text);
+        if (message.id !== requestId) {
+          return;
+        }
+        if (message.error?.message) {
+          finish(new Error(message.error.message));
+          return;
+        }
+        finish();
+      } catch (error) {
+        finish(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    const onError = () => {
+      finish(new Error("WebSocket error"));
+    };
+    const onClose = () => {
+      finish(new Error("WebSocket closed before response"));
+    };
+    ws.addEventListener("open", onOpen);
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("error", onError);
+    ws.addEventListener("close", onClose);
+  });
+};
+
 // dist/cdp/selectTarget.js
 var normalizeFilter = (value) => {
   if (!value) {
@@ -2983,53 +3200,6 @@ var readLineOnce = async () => {
   });
 };
 
-// dist/watchers/resolveWatcher.js
-var resolveWatcher = async (input) => {
-  let registry2;
-  try {
-    registry2 = await pruneRegistry();
-  } catch (error) {
-    return { ok: false, error: `Failed to load registry: ${error instanceof Error ? error.message : error}`, exitCode: 1 };
-  }
-  const watchers = Object.values(registry2.watchers);
-  if (input.id) {
-    const watcher = registry2.watchers[input.id];
-    if (!watcher) {
-      return { ok: false, error: `Watcher not found: ${input.id}`, exitCode: 2, candidates: watchers };
-    }
-    return { ok: true, watcher, registry: registry2 };
-  }
-  if (watchers.length === 0) {
-    return { ok: false, error: "Watcher id required.", exitCode: 2 };
-  }
-  const cwd = process.cwd();
-  const cwdMatches = watchers.filter((watcher) => watcher.cwd === cwd);
-  if (cwdMatches.length === 1) {
-    return { ok: true, watcher: cwdMatches[0], registry: registry2 };
-  }
-  if (cwdMatches.length > 1) {
-    return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: cwdMatches };
-  }
-  const reachability = await Promise.all(watchers.map(async (watcher) => ({
-    watcher,
-    status: await checkWatcherStatus(watcher)
-  })));
-  const reachable = reachability.filter((entry) => entry.status.ok);
-  if (reachable.length === 1) {
-    return { ok: true, watcher: reachable[0].watcher, registry: registry2 };
-  }
-  return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: watchers };
-};
-var checkWatcherStatus = async (watcher) => {
-  const url = `http://${watcher.host}:${watcher.port}/status`;
-  try {
-    const status = await fetchJson(url, { timeoutMs: 1500 });
-    return { ok: true, status };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-};
-
 // dist/commands/chrome.js
 var normalizeUrl = (url) => {
   if (url.startsWith("http://") || url.startsWith("https://")) {
@@ -3037,100 +3207,6 @@ var normalizeUrl = (url) => {
   }
   return `http://${url}`;
 };
-var getWebSocketCtor = () => {
-  const ctor = globalThis.WebSocket;
-  return ctor ?? null;
-};
-var toMessageText = (data) => {
-  if (typeof data === "string") {
-    return data;
-  }
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data).toString("utf8");
-  }
-  if (Buffer.isBuffer(data)) {
-    return data.toString("utf8");
-  }
-  return null;
-};
-var sendCdpCommand = async (wsUrl, payload, timeoutMs = 5000) => {
-  const WebSocketConstructor = getWebSocketCtor();
-  if (!WebSocketConstructor) {
-    throw new Error("WebSocket unavailable. Node 18+ required.");
-  }
-  const ws = new WebSocketConstructor(wsUrl);
-  const requestId = payload.id;
-  await new Promise((resolve, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        try {
-          ws.close();
-        } catch {}
-        reject(new Error(`CDP command timed out after ${timeoutMs}ms`));
-      }
-    }, timeoutMs);
-    const cleanup = () => {
-      clearTimeout(timer);
-      ws.removeEventListener?.("open", onOpen);
-      ws.removeEventListener?.("message", onMessage);
-      ws.removeEventListener?.("error", onError);
-      ws.removeEventListener?.("close", onClose);
-    };
-    const finish = (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      try {
-        ws.close();
-      } catch {}
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    };
-    const onOpen = () => {
-      try {
-        ws.send(JSON.stringify(payload));
-      } catch (error) {
-        finish(error instanceof Error ? error : new Error(String(error)));
-      }
-    };
-    const onMessage = (event) => {
-      const text = toMessageText(event.data);
-      if (!text) {
-        return;
-      }
-      try {
-        const message = JSON.parse(text);
-        if (message.id !== requestId) {
-          return;
-        }
-        if (message.error?.message) {
-          finish(new Error(message.error.message));
-          return;
-        }
-        finish();
-      } catch (error) {
-        finish(error instanceof Error ? error : new Error(String(error)));
-      }
-    };
-    const onError = () => {
-      finish(new Error("WebSocket error"));
-    };
-    const onClose = () => {
-      finish(new Error("WebSocket closed before response"));
-    };
-    ws.addEventListener("open", onOpen);
-    ws.addEventListener("message", onMessage);
-    ws.addEventListener("error", onError);
-    ws.addEventListener("close", onClose);
-  });
-};
 var runChromeVersion = async (options) => {
   const output = createOutput(options);
   const endpoint = await resolveCdpEndpoint(options);
@@ -3579,12 +3655,11 @@ var listWatchers = async (options, output) => {
     return [];
   const results = [];
   for (const watcher of watchers) {
-    const url = `http://${watcher.host}:${watcher.port}/status`;
     try {
-      const status = await fetchJson(url, { timeoutMs: 2000 });
+      const status = await fetchWatcherJson(watcher, { path: "/status", timeoutMs: 2000 });
       results.push({ watcher, status });
     } catch (error) {
-      output.writeWarn(`${watcher.id}: failed to reach watcher (${formatError(error)})`);
+      output.writeWarn(formatWatcherTransportError(watcher, error));
       results.push({ watcher });
     }
   }
@@ -3593,11 +3668,6 @@ var listWatchers = async (options, output) => {
 
 // dist/commands/start.js
 import { rmSync as rmSync2 } from "node:fs";
-import fs7 from "node:fs/promises";
-
-// ../argus-watcher/dist/index.js
-import os3 from "node:os";
-import path7 from "node:path";
 
 // ../../node_modules/.bun/emittery@1.2.0/node_modules/emittery/maps.js
 var anyMap = new WeakMap;
@@ -4045,6 +4115,72 @@ Object.defineProperty(Emittery, "listenerRemoved", {
   configurable: false
 });
 
+// ../argus-watcher/dist/registry/registry.js
+var resolveUniqueWatcherId = async (id) => {
+  const { registry: registry2 } = await readRegistry();
+  const staleIds = [];
+  const isIdAvailable = (candidate) => {
+    const existing = registry2.watchers[candidate];
+    if (!existing) {
+      return true;
+    }
+    if (existing.pid == null || !isProcessAlive(existing.pid)) {
+      staleIds.push(candidate);
+      return true;
+    }
+    return false;
+  };
+  let resolvedId = id;
+  if (!isIdAvailable(id)) {
+    let suffix = 2;
+    while (!isIdAvailable(`${id}-${suffix}`)) {
+      suffix++;
+    }
+    resolvedId = `${id}-${suffix}`;
+  }
+  if (staleIds.length > 0) {
+    await updateRegistry((reg) => {
+      let next = reg;
+      for (const staleId of staleIds) {
+        next = removeWatcherEntry(next, staleId);
+      }
+      return next;
+    });
+  }
+  return resolvedId;
+};
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var announceWatcher = async (watcher) => {
+  await updateRegistry((registry2) => setWatcherEntry(registry2, watcher));
+};
+var updateWatcherHeartbeat = async (watcher) => {
+  await announceWatcher(watcher);
+};
+var removeWatcher = async (id) => {
+  await updateRegistry((registry2) => removeWatcherEntry(registry2, id));
+};
+var startRegistryHeartbeat = (getWatcher, intervalMs = 15000) => {
+  const timer = setInterval(() => {
+    const watcher = getWatcher();
+    watcher.updatedAt = Date.now();
+    updateWatcherHeartbeat(watcher);
+  }, intervalMs);
+  return {
+    stop: () => clearInterval(timer)
+  };
+};
+
+// ../argus-watcher/dist/startWatcherRuntime.js
+import os3 from "node:os";
+import path7 from "node:path";
+
 // ../argus-watcher/dist/buffer/LogBuffer.js
 class LogBuffer {
   maxSize;
@@ -4156,6 +4292,10 @@ class NetBuffer {
     const filtered = this.events.filter((event) => event.id > after && matchesFilters2(event, filters));
     return filtered.slice(0, limit);
   }
+  list(filters, limit = this.maxSize) {
+    const filtered = this.events.filter((event) => matchesFilters2(event, filters));
+    return filtered.slice(0, limit);
+  }
   waitForAfter(after, filters, limit, timeoutMs) {
     const immediate = this.listAfter(after, filters, limit);
     if (immediate.length > 0) {
@@ -4501,6 +4641,77 @@ var handle5 = async (_req, res, url, ctx) => {
   respondJson(res, response);
 };
 
+// ../argus-watcher/dist/cdp/auth.js
+var inspectAuthCookies = async (session, options) => {
+  const [origin, cookies2] = await Promise.all([capturePageOrigin(session), readCookies(session, options.includeValues === true)]);
+  const normalizedDomain = normalizeCookieDomainFilter(options.domain);
+  return {
+    ok: true,
+    origin,
+    cookies: cookies2.filter((cookie) => matchesCookieDomain(cookie.domain, normalizedDomain))
+  };
+};
+var readCookies = async (session, includeValues) => {
+  const payload = await session.sendAndWait("Network.getCookies", {}, { timeoutMs: 5000 });
+  const cookies2 = payload.cookies ?? [];
+  return cookies2.map((cookie) => normalizeCookie(cookie, includeValues)).sort(compareCookies);
+};
+var normalizeCookie = (cookie, includeValues) => {
+  const value = cookie.value ?? null;
+  return {
+    name: cookie.name ?? "",
+    domain: cookie.domain ?? "",
+    path: cookie.path ?? "/",
+    value: includeValues ? value : undefined,
+    valuePreview: value != null ? previewSecret(value) : null,
+    secure: cookie.secure === true,
+    httpOnly: cookie.httpOnly === true,
+    session: cookie.session === true,
+    expires: typeof cookie.expires === "number" && Number.isFinite(cookie.expires) ? cookie.expires : null,
+    sameSite: cookie.sameSite ?? null
+  };
+};
+var capturePageOrigin = async (session) => {
+  const payload = await session.sendAndWait("Runtime.evaluate", {
+    expression: `(() => {
+				try {
+					return new URL(location.href).origin
+				} catch {
+					throw new Error('Cannot determine origin: page is on a non-http URL (e.g., about:blank)')
+				}
+			})()`,
+    awaitPromise: false,
+    returnByValue: true
+  }, { timeoutMs: 5000 });
+  if (payload.exceptionDetails) {
+    throw new Error(payload.exceptionDetails.exception?.description ?? payload.exceptionDetails.text ?? "Failed to inspect page auth cookies");
+  }
+  return String(payload.result?.value ?? "");
+};
+var previewSecret = (value) => {
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+};
+var compareCookies = (a, b) => a.domain.localeCompare(b.domain) || a.path.localeCompare(b.path) || a.name.localeCompare(b.name);
+
+// ../argus-watcher/dist/http/routes/getAuthCookies.js
+var handle6 = async (_req, res, url, ctx) => {
+  const domain = normalizeQueryValue2(url.searchParams.get("domain"));
+  const includeValues = url.searchParams.get("includeValues") === "true";
+  emitRequest(ctx, res, "auth/cookies", { domain, includeValues });
+  try {
+    const response = await inspectAuthCookies(ctx.cdpSession, {
+      domain: domain ?? undefined,
+      includeValues
+    });
+    respondJson(res, response);
+  } catch (error) {
+    respondError(res, error);
+  }
+};
+
 // ../argus-watcher/dist/cdp/remoteObject.js
 var serializeRemoteObjects = async (values, cdp) => {
   if (!cdp) {
@@ -4667,7 +4878,7 @@ var shouldMaterializeByValue = (record) => {
 };
 
 // ../argus-watcher/dist/http/routes/postEval.js
-var handle6 = async (req, res, _url, ctx) => {
+var handle7 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -4691,7 +4902,7 @@ var handle6 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postTraceStart.js
-var handle7 = async (req, res, _url, ctx) => {
+var handle8 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -4706,7 +4917,7 @@ var handle7 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postTraceStop.js
-var handle8 = async (req, res, _url, ctx) => {
+var handle9 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -4721,7 +4932,7 @@ var handle8 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postScreenshot.js
-var handle9 = async (req, res, _url, ctx) => {
+var handle10 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -4976,7 +5187,7 @@ var countNodes = (nodes) => {
 };
 
 // ../argus-watcher/dist/http/routes/postSnapshot.js
-var handle10 = async (req, res, _url, ctx) => {
+var handle11 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -5001,7 +5212,7 @@ var handle10 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postCodeList.js
-var handle11 = async (req, res, _url, ctx) => {
+var handle12 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -5019,7 +5230,7 @@ var handle11 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postCodeRead.js
-var handle12 = async (req, res, _url, ctx) => {
+var handle13 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -5047,7 +5258,7 @@ var handle12 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postCodeGrep.js
-var handle13 = async (req, res, _url, ctx) => {
+var handle14 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -5070,6 +5281,33 @@ var handle13 = async (req, res, _url, ctx) => {
   }
 };
 
+// ../argus-watcher/dist/http/routes/domSelectorRoute.js
+var readDomSelectorPayload = async (req, res) => {
+  const payload = await readJsonBody(req, res);
+  if (!payload) {
+    return null;
+  }
+  if (!payload.selector || typeof payload.selector !== "string") {
+    respondInvalidBody(res, "selector is required");
+    return null;
+  }
+  const all = payload.all ?? false;
+  if (typeof all !== "boolean") {
+    respondInvalidBody(res, "all must be a boolean");
+    return null;
+  }
+  return { payload, all };
+};
+var respondMultipleMatches = (res, matches, action) => {
+  respondJson(res, {
+    ok: false,
+    error: {
+      message: `Selector matched ${matches} elements; pass all=true to ${action} all matches`,
+      code: "multiple_matches"
+    }
+  }, 400);
+};
+
 // ../argus-watcher/dist/cdp/text-filter.js
 var filterNodesByText = async (session, nodeIds, text) => {
   const pattern = parseTextPattern(text);
@@ -5505,18 +5743,12 @@ var fillResolvedNodes = async (session, nodeIds, value) => {
   return nodeIds.length;
 };
 // ../argus-watcher/dist/http/routes/postDomTree.js
-var handle14 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+var handle15 = async (req, res, _url, ctx) => {
+  const parsed = await readDomSelectorPayload(req, res);
+  if (!parsed) {
     return;
   }
-  if (!payload.selector || typeof payload.selector !== "string") {
-    return respondInvalidBody(res, "selector is required");
-  }
-  const all = payload.all ?? false;
-  if (typeof all !== "boolean") {
-    return respondInvalidBody(res, "all must be a boolean");
-  }
+  const { payload, all } = parsed;
   emitRequest(ctx, res, "dom/tree");
   try {
     const response = await fetchDomSubtreeBySelector(ctx.cdpSession, {
@@ -5527,13 +5759,7 @@ var handle14 = async (req, res, _url, ctx) => {
       text: payload.text
     });
     if (!all && response.matches > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${response.matches} elements; pass all=true to return all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, response.matches, "return");
     }
     respondJson(res, response);
   } catch (error) {
@@ -5542,18 +5768,12 @@ var handle14 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomInfo.js
-var handle15 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+var handle16 = async (req, res, _url, ctx) => {
+  const parsed = await readDomSelectorPayload(req, res);
+  if (!parsed) {
     return;
   }
-  if (!payload.selector || typeof payload.selector !== "string") {
-    return respondInvalidBody(res, "selector is required");
-  }
-  const all = payload.all ?? false;
-  if (typeof all !== "boolean") {
-    return respondInvalidBody(res, "all must be a boolean");
-  }
+  const { payload, all } = parsed;
   emitRequest(ctx, res, "dom/info");
   try {
     const response = await fetchDomInfoBySelector(ctx.cdpSession, {
@@ -5563,13 +5783,7 @@ var handle15 = async (req, res, _url, ctx) => {
       text: payload.text
     });
     if (!all && response.matches > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${response.matches} elements; pass all=true to return all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, response.matches, "return");
     }
     respondJson(res, response);
   } catch (error) {
@@ -5767,29 +5981,17 @@ var createNotInteractableError = (message) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomHover.js
-var handle16 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+var handle17 = async (req, res, _url, ctx) => {
+  const parsed = await readDomSelectorPayload(req, res);
+  if (!parsed) {
     return;
   }
-  if (!payload.selector || typeof payload.selector !== "string") {
-    return respondInvalidBody(res, "selector is required");
-  }
-  const all = payload.all ?? false;
-  if (typeof all !== "boolean") {
-    return respondInvalidBody(res, "all must be a boolean");
-  }
+  const { payload, all } = parsed;
   emitRequest(ctx, res, "dom/hover");
   try {
     const { allNodeIds, nodeIds } = await resolveDomSelectorMatches(ctx.cdpSession, payload.selector, all, payload.text);
     if (!all && allNodeIds.length > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${allNodeIds.length} elements; pass all=true to hover all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, allNodeIds.length, "hover");
     }
     if (allNodeIds.length === 0) {
       const response2 = { ok: true, matches: 0, hovered: 0 };
@@ -5804,7 +6006,7 @@ var handle16 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomClick.js
-var handle17 = async (req, res, _url, ctx) => {
+var handle18 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -5852,13 +6054,7 @@ var handle17 = async (req, res, _url, ctx) => {
       nodeIds = result.nodeIds;
     }
     if (!all && allNodeIds.length > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${allNodeIds.length} elements; pass all=true to click all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, allNodeIds.length, "click");
     }
     if (allNodeIds.length === 0) {
       const response2 = { ok: true, matches: 0, clicked: 0 };
@@ -5998,7 +6194,7 @@ var dispatchKeydown = async (session, options) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomKeydown.js
-var handle18 = async (req, res, _url, ctx) => {
+var handle19 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6030,7 +6226,7 @@ var handle18 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomAdd.js
-var handle19 = async (req, res, _url, ctx) => {
+var handle20 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6123,18 +6319,12 @@ var selectDomAddNodeIds = (allNodeIds, options) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomRemove.js
-var handle20 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+var handle21 = async (req, res, _url, ctx) => {
+  const parsed = await readDomSelectorPayload(req, res);
+  if (!parsed) {
     return;
   }
-  if (!payload.selector || typeof payload.selector !== "string") {
-    return respondInvalidBody(res, "selector is required");
-  }
-  const all = payload.all ?? false;
-  if (typeof all !== "boolean") {
-    return respondInvalidBody(res, "all must be a boolean");
-  }
+  const { payload, all } = parsed;
   emitRequest(ctx, res, "dom/remove");
   try {
     const { allNodeIds, removedCount } = await removeElements(ctx.cdpSession, {
@@ -6143,13 +6333,7 @@ var handle20 = async (req, res, _url, ctx) => {
       text: payload.text
     });
     if (!all && allNodeIds.length > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${allNodeIds.length} elements; pass all=true to remove all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, allNodeIds.length, "remove");
     }
     const response = { ok: true, matches: allNodeIds.length, removed: removedCount };
     respondJson(res, response);
@@ -6159,7 +6343,7 @@ var handle20 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomModify.js
-var handle21 = async (req, res, _url, ctx) => {
+var handle22 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6201,7 +6385,7 @@ var handle21 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomSetFile.js
-var handle22 = async (req, res, _url, ctx) => {
+var handle23 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6254,29 +6438,17 @@ var handle22 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomFocus.js
-var handle23 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+var handle24 = async (req, res, _url, ctx) => {
+  const parsed = await readDomSelectorPayload(req, res);
+  if (!parsed) {
     return;
   }
-  if (!payload.selector || typeof payload.selector !== "string") {
-    return respondInvalidBody(res, "selector is required");
-  }
-  const all = payload.all ?? false;
-  if (typeof all !== "boolean") {
-    return respondInvalidBody(res, "all must be a boolean");
-  }
+  const { payload, all } = parsed;
   emitRequest(ctx, res, "dom/focus");
   try {
     const { allNodeIds, nodeIds } = await resolveDomSelectorMatches(ctx.cdpSession, payload.selector, all, payload.text);
     if (!all && allNodeIds.length > 1) {
-      return respondJson(res, {
-        ok: false,
-        error: {
-          message: `Selector matched ${allNodeIds.length} elements; pass all=true to focus all matches`,
-          code: "multiple_matches"
-        }
-      }, 400);
+      return respondMultipleMatches(res, allNodeIds.length, "focus");
     }
     if (allNodeIds.length === 0) {
       const response2 = { ok: true, matches: 0, focused: 0 };
@@ -6291,7 +6463,7 @@ var handle23 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomFill.js
-var handle24 = async (req, res, _url, ctx) => {
+var handle25 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6344,7 +6516,7 @@ var handle24 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomScroll.js
-var handle25 = async (req, res, _url, ctx) => {
+var handle26 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6413,7 +6585,7 @@ var getViewportSize = async (session) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomScrollTo.js
-var handle26 = async (req, res, _url, ctx) => {
+var handle27 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6472,14 +6644,14 @@ var handle26 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/getEmulation.js
-var handle27 = (_req, res, _url, ctx) => {
+var handle28 = (_req, res, _url, ctx) => {
   emitRequest(ctx, res, "emulation");
   const status = ctx.emulationController.getStatus({ attached: ctx.getCdpStatus().attached });
   respondJson(res, status);
 };
 
 // ../argus-watcher/dist/http/routes/postEmulation.js
-var handle28 = async (req, res, _url, ctx) => {
+var handle29 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6542,14 +6714,14 @@ var handle28 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/getThrottle.js
-var handle29 = (_req, res, _url, ctx) => {
+var handle30 = (_req, res, _url, ctx) => {
   emitRequest(ctx, res, "throttle");
   const status = ctx.throttleController.getStatus({ attached: ctx.getCdpStatus().attached });
   respondJson(res, status);
 };
 
 // ../argus-watcher/dist/http/routes/postThrottle.js
-var handle30 = async (req, res, _url, ctx) => {
+var handle31 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6647,7 +6819,7 @@ var buildActionCode = (action, key, value) => {
 };
 
 // ../argus-watcher/dist/http/routes/postStorageLocal.js
-var handle31 = async (req, res, _url, ctx) => {
+var handle32 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
@@ -6672,14 +6844,14 @@ var handle31 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postReload.js
-var handle32 = async (req, res, _url, ctx) => {
+var handle33 = async (req, res, _url, ctx) => {
   const payload = await readJsonBody(req, res);
   if (!payload) {
     return;
   }
   emitRequest(ctx, res, "reload");
   try {
-    await ctx.cdpSession.sendAndWait("Page.reload", {
+    await ctx.pageCdpSession.sendAndWait("Page.reload", {
       ignoreCache: payload.ignoreCache ?? false
     });
     const response = { ok: true };
@@ -6690,7 +6862,7 @@ var handle32 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postShutdown.js
-var handle33 = (_req, res, _url, ctx) => {
+var handle34 = (_req, res, _url, ctx) => {
   emitRequest(ctx, res, "shutdown");
   const response = { ok: true };
   respondJson(res, response);
@@ -6702,7 +6874,7 @@ var handle33 = (_req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/getTargets.js
-var handle34 = async (_req, res, _url, ctx) => {
+var handle35 = async (_req, res, _url, ctx) => {
   if (!ctx.sourceHandle?.listTargets) {
     return respondJson(res, { ok: false, error: { message: "Not available", code: "not_available" } }, 400);
   }
@@ -6716,7 +6888,7 @@ var handle34 = async (_req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postAttach.js
-var handle35 = async (req, res, _url, ctx) => {
+var handle36 = async (req, res, _url, ctx) => {
   if (!ctx.sourceHandle?.attachTarget) {
     return respondJson(res, { ok: false, error: { message: "Not available", code: "not_available" } }, 400);
   }
@@ -6738,7 +6910,7 @@ var handle35 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDetach.js
-var handle36 = async (req, res, _url, ctx) => {
+var handle37 = async (req, res, _url, ctx) => {
   if (!ctx.sourceHandle?.detachTarget) {
     return respondJson(res, { ok: false, error: { message: "Not available", code: "not_available" } }, 400);
   }
@@ -6766,37 +6938,38 @@ var routes = {
   "GET /tail": { handler: handle3 },
   "GET /net": { handler: handle4 },
   "GET /net/tail": { handler: handle5 },
-  "POST /eval": { handler: handle6 },
-  "POST /trace/start": { handler: handle7 },
-  "POST /trace/stop": { handler: handle8 },
-  "POST /screenshot": { handler: handle9 },
-  "POST /snapshot": { handler: handle10 },
-  "POST /code/list": { handler: handle11 },
-  "POST /code/read": { handler: handle12 },
-  "POST /code/grep": { handler: handle13 },
-  "POST /dom/tree": { handler: handle14 },
-  "POST /dom/info": { handler: handle15 },
-  "POST /dom/hover": { handler: handle16 },
-  "POST /dom/click": { handler: handle17 },
-  "POST /dom/keydown": { handler: handle18 },
-  "POST /dom/add": { handler: handle19 },
-  "POST /dom/remove": { handler: handle20 },
-  "POST /dom/modify": { handler: handle21 },
-  "POST /dom/set-file": { handler: handle22 },
-  "POST /dom/focus": { handler: handle23 },
-  "POST /dom/fill": { handler: handle24 },
-  "POST /dom/scroll": { handler: handle25 },
-  "POST /dom/scroll-to": { handler: handle26 },
-  "GET /emulation": { handler: handle27 },
-  "POST /emulation": { handler: handle28 },
-  "GET /throttle": { handler: handle29 },
-  "POST /throttle": { handler: handle30 },
-  "POST /storage/local": { handler: handle31 },
-  "POST /reload": { handler: handle32 },
-  "POST /shutdown": { handler: handle33 },
-  "GET /targets": { handler: handle34, extensionOnly: true },
-  "POST /attach": { handler: handle35, extensionOnly: true },
-  "POST /detach": { handler: handle36, extensionOnly: true }
+  "GET /auth/cookies": { handler: handle6 },
+  "POST /eval": { handler: handle7 },
+  "POST /trace/start": { handler: handle8 },
+  "POST /trace/stop": { handler: handle9 },
+  "POST /screenshot": { handler: handle10 },
+  "POST /snapshot": { handler: handle11 },
+  "POST /code/list": { handler: handle12 },
+  "POST /code/read": { handler: handle13 },
+  "POST /code/grep": { handler: handle14 },
+  "POST /dom/tree": { handler: handle15 },
+  "POST /dom/info": { handler: handle16 },
+  "POST /dom/hover": { handler: handle17 },
+  "POST /dom/click": { handler: handle18 },
+  "POST /dom/keydown": { handler: handle19 },
+  "POST /dom/add": { handler: handle20 },
+  "POST /dom/remove": { handler: handle21 },
+  "POST /dom/modify": { handler: handle22 },
+  "POST /dom/set-file": { handler: handle23 },
+  "POST /dom/focus": { handler: handle24 },
+  "POST /dom/fill": { handler: handle25 },
+  "POST /dom/scroll": { handler: handle26 },
+  "POST /dom/scroll-to": { handler: handle27 },
+  "GET /emulation": { handler: handle28 },
+  "POST /emulation": { handler: handle29 },
+  "GET /throttle": { handler: handle30 },
+  "POST /throttle": { handler: handle31 },
+  "POST /storage/local": { handler: handle32 },
+  "POST /reload": { handler: handle33 },
+  "POST /shutdown": { handler: handle34 },
+  "GET /targets": { handler: handle35, extensionOnly: true },
+  "POST /attach": { handler: handle36, extensionOnly: true },
+  "POST /detach": { handler: handle37, extensionOnly: true }
 };
 var dispatch = (req, res, url, ctx) => {
   const entry = routes[`${req.method} ${url.pathname}`];
@@ -6833,68 +7006,6 @@ var startHttpServer = async (options) => {
   };
 };
 
-// ../argus-watcher/dist/registry/registry.js
-var resolveUniqueWatcherId = async (id) => {
-  const { registry: registry2 } = await readRegistry();
-  const staleIds = [];
-  const isIdAvailable = (candidate) => {
-    const existing = registry2.watchers[candidate];
-    if (!existing) {
-      return true;
-    }
-    if (existing.pid == null || !isProcessAlive(existing.pid)) {
-      staleIds.push(candidate);
-      return true;
-    }
-    return false;
-  };
-  let resolvedId = id;
-  if (!isIdAvailable(id)) {
-    let suffix = 2;
-    while (!isIdAvailable(`${id}-${suffix}`)) {
-      suffix++;
-    }
-    resolvedId = `${id}-${suffix}`;
-  }
-  if (staleIds.length > 0) {
-    await updateRegistry((reg) => {
-      let next = reg;
-      for (const staleId of staleIds) {
-        next = removeWatcherEntry(next, staleId);
-      }
-      return next;
-    });
-  }
-  return resolvedId;
-};
-var isProcessAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var announceWatcher = async (watcher) => {
-  await updateRegistry((registry2) => setWatcherEntry(registry2, watcher));
-};
-var updateWatcherHeartbeat = async (watcher) => {
-  await announceWatcher(watcher);
-};
-var removeWatcher = async (id) => {
-  await updateRegistry((registry2) => removeWatcherEntry(registry2, id));
-};
-var startRegistryHeartbeat = (getWatcher, intervalMs = 15000) => {
-  const timer = setInterval(() => {
-    const watcher = getWatcher();
-    watcher.updatedAt = Date.now();
-    updateWatcherHeartbeat(watcher);
-  }, intervalMs);
-  return {
-    stop: () => clearInterval(timer)
-  };
-};
-
 // ../argus-watcher/dist/fileLogs/WatcherFileLogger.js
 import fs3 from "node:fs";
 import fsPromises from "node:fs/promises";
@@ -7198,6 +7309,17 @@ var compileRule = (pattern) => {
 
 // ../argus-watcher/dist/cdp/redaction.js
 var SENSITIVE_KEYS = new Set(["token", "access_token", "auth", "authorization", "code", "password", "pass"]);
+var AUTH_HEADER_NAMES = new Set([
+  "authorization",
+  "cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-csrf-token",
+  "x-csrftoken",
+  "x-xsrf-token",
+  "csrf-token",
+  "xsrf-token"
+]);
 var redactUrl = (value) => {
   if (!value) {
     return value;
@@ -7229,6 +7351,76 @@ var redactUrl = (value) => {
   url.search = search ? `?${search}` : "";
   return url.toString();
 };
+var pickCapturedAuthHeaders = (headers) => {
+  if (!headers) {
+    return;
+  }
+  const captured = {};
+  for (const [name, rawValue] of Object.entries(headers)) {
+    const normalizedName = name.trim().toLowerCase();
+    if (!normalizedName || !AUTH_HEADER_NAMES.has(normalizedName)) {
+      continue;
+    }
+    const value = normalizeHeaderValue(rawValue);
+    if (!value) {
+      continue;
+    }
+    captured[normalizedName] = redactHeaderValue(normalizedName, value);
+  }
+  return Object.keys(captured).length > 0 ? captured : undefined;
+};
+var mergeCapturedAuthHeaders = (current, incoming) => {
+  if (!current) {
+    return incoming;
+  }
+  if (!incoming) {
+    return current;
+  }
+  return { ...current, ...incoming };
+};
+var normalizeHeaderValue = (value) => {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || null;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const joined = value.map((item) => normalizeHeaderValue(item)).filter((item) => Boolean(item)).join(", ");
+    return joined || null;
+  }
+  return null;
+};
+var redactHeaderValue = (name, value) => {
+  if (name === "authorization") {
+    return redactAuthorizationHeader(value);
+  }
+  if (name === "cookie") {
+    return redactCookieHeader(value);
+  }
+  return redactToken(value);
+};
+var redactAuthorizationHeader = (value) => {
+  const match = value.match(/^([A-Za-z]+)\s+(.+)$/);
+  if (!match) {
+    return redactToken(value);
+  }
+  return `${match[1]} ${redactToken(match[2])}`;
+};
+var redactCookieHeader = (value) => {
+  const parts = value.split(";").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const [name] = entry.split("=");
+    return name ? `${name}=<redacted>` : null;
+  }).filter((entry) => Boolean(entry));
+  return parts.join("; ");
+};
+var redactToken = (value) => {
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+};
 
 // ../argus-watcher/dist/cdp/networkCapture.js
 var createNetworkCapture = (options) => {
@@ -7242,6 +7434,7 @@ var createNetworkCapture = (options) => {
       requestId,
       url: "",
       method: "GET",
+      requestHeaders: undefined,
       resourceType: null,
       status: null,
       encodedDataLength: null,
@@ -7264,6 +7457,7 @@ var createNetworkCapture = (options) => {
       requestId: record.requestId,
       url: redactUrl(record.url),
       method: record.method,
+      requestHeaders: record.requestHeaders,
       resourceType: record.resourceType,
       status: record.status,
       encodedDataLength: record.encodedDataLength,
@@ -7281,9 +7475,19 @@ var createNetworkCapture = (options) => {
     const entry = getOrCreate(requestId);
     entry.url = payload.request?.url ?? entry.url;
     entry.method = payload.request?.method ?? entry.method;
+    entry.requestHeaders = mergeCapturedAuthHeaders(entry.requestHeaders, pickCapturedAuthHeaders(payload.request?.headers));
     entry.resourceType = payload.type ?? entry.resourceType;
     entry.startTime = typeof payload.timestamp === "number" ? payload.timestamp : entry.startTime;
   });
+  options.session.onEvent("Network.requestWillBeSentExtraInfo", (params) => {
+    const payload = params;
+    const requestId = payload.requestId;
+    if (!requestId) {
+      return;
+    }
+    const entry = getOrCreate(requestId);
+    entry.requestHeaders = mergeCapturedAuthHeaders(entry.requestHeaders, pickCapturedAuthHeaders(payload.headers));
+  });
   options.session.onEvent("Network.responseReceived", (params) => {
     const payload = params;
     const requestId = payload.requestId;
@@ -7292,6 +7496,7 @@ var createNetworkCapture = (options) => {
     }
     const entry = getOrCreate(requestId);
     entry.status = typeof payload.response?.status === "number" ? payload.response.status : entry.status;
+    entry.requestHeaders = mergeCapturedAuthHeaders(entry.requestHeaders, pickCapturedAuthHeaders(payload.response?.requestHeaders));
     entry.resourceType = payload.type ?? entry.resourceType;
   });
   options.session.onEvent("Network.loadingFinished", (params) => {
@@ -9735,7 +9940,7 @@ class SessionManager {
     const enabledDomains = new Set;
     const tabHandlers = new Map;
     this.eventHandlers.set(tabId, tabHandlers);
-    const handle37 = {
+    const handle38 = {
       isAttached: () => this.sessions.has(tabId),
       sendAndWait: async (method, params, options) => {
         if (!this.sessions.has(tabId)) {
@@ -9780,7 +9985,7 @@ class SessionManager {
       attachedAt: Date.now(),
       topFrameId: message.topFrameId ?? null,
       frames: message.frames ?? [],
-      handle: handle37,
+      handle: handle38,
       enabledDomains
     };
     this.sessions.set(tabId, session);
@@ -9850,6 +10055,8 @@ class SessionManager {
 var createEmptyFrameState = () => ({
   topFrameId: null,
   requestedFrameId: null,
+  requestedFrameHint: null,
+  requestedFrameDetached: false,
   activeFrameId: null,
   activeAttachedAt: null,
   frames: new Map,
@@ -9948,12 +10155,113 @@ var parseExecutionContext = (params) => {
     isDefault: record.context.auxData?.isDefault === true
   };
 };
-var resolveRequestedFrameId = (state, requestedFrameId) => {
+var createRequestedFrameHint = (frame) => {
+  if (!frame) {
+    return null;
+  }
+  return {
+    url: frame.url || null,
+    title: frame.title?.trim() || null
+  };
+};
+var resolveRequestedFrameId = (state, requestedFrameId, requestedFrameHint) => {
   if (!requestedFrameId) {
     return null;
   }
-  return state.frames.has(requestedFrameId) ? requestedFrameId : null;
+  if (state.frames.has(requestedFrameId)) {
+    return requestedFrameId;
+  }
+  if (!requestedFrameHint) {
+    return null;
+  }
+  const urlMatch = requestedFrameHint.url == null ? null : findSingleMatchingFrameId(state, (frame) => frame.url === requestedFrameHint.url);
+  if (urlMatch) {
+    return urlMatch;
+  }
+  if (requestedFrameHint.url != null || !requestedFrameHint.title) {
+    return null;
+  }
+  return findSingleMatchingFrameId(state, (frame) => frame.title?.trim() === requestedFrameHint.title);
+};
+var resolveRequestedTarget = (state) => {
+  if (state.requestedFrameId == null) {
+    return { kind: "page" };
+  }
+  const nextFrameId = resolveRequestedFrameId(state, state.requestedFrameId, state.requestedFrameHint);
+  if (nextFrameId) {
+    return { kind: "frame", frameId: nextFrameId };
+  }
+  return state.requestedFrameDetached ? { kind: "page" } : { kind: "pending" };
+};
+var findSingleMatchingFrameId = (state, predicate) => {
+  let matchId = null;
+  for (const frame of state.frames.values()) {
+    if (!predicate(frame)) {
+      continue;
+    }
+    if (matchId) {
+      return null;
+    }
+    matchId = frame.frameId;
+  }
+  return matchId;
+};
+
+// ../argus-watcher/dist/sources/extension-delegating-session.js
+var createDelegatingSession = (options) => {
+  const subscriptions = new Set;
+  const rebindSubscriptions = () => {
+    for (const subscription of subscriptions) {
+      subscription.unbind();
+      const currentSession = options.getCurrentSession();
+      if (!currentSession) {
+        continue;
+      }
+      subscription.off = currentSession.handle.onEvent(subscription.method, subscription.handler);
+    }
+  };
+  const disposeSubscriptions = () => {
+    for (const subscription of subscriptions) {
+      subscription.unbind();
+    }
+    subscriptions.clear();
+  };
+  const controller = {
+    rebind: rebindSubscriptions,
+    dispose: disposeSubscriptions
+  };
+  const session = {
+    isAttached: () => options.getCurrentSession()?.handle.isAttached() ?? false,
+    sendAndWait: async (method, params, commandOptions) => {
+      const currentSession = options.requireCurrentSession();
+      const targetContext = options.getTargetContext();
+      const nextParams = options.mapParams ? options.mapParams(method, params) : params;
+      const nextOptions = targetContext.kind === "frame" && targetContext.sessionId ? { ...commandOptions ?? {}, sessionId: targetContext.sessionId } : commandOptions;
+      return currentSession.handle.sendAndWait(method, nextParams, nextOptions);
+    },
+    onEvent: (method, handler) => {
+      const subscription = createDelegatingEventSubscription(method, handler);
+      subscriptions.add(subscription);
+      controller.rebind();
+      return () => {
+        subscription.unbind();
+        subscriptions.delete(subscription);
+      };
+    },
+    getTargetContext: options.getTargetContext
+  };
+  controller.rebind();
+  return { session, controller };
 };
+var createDelegatingEventSubscription = (method, handler) => ({
+  method,
+  handler,
+  off: null,
+  unbind() {
+    this.off?.();
+    this.off = null;
+  }
+});
 
 // ../argus-watcher/dist/sources/extension-log-events.js
 var toConsoleEvent2 = (params, session, config) => {
@@ -10054,6 +10362,103 @@ var applyStripPrefixes = (file, prefixes) => {
   return file;
 };
 
+// ../argus-watcher/dist/sources/extension-session-events.js
+var registerExtensionSessionEventHandlers = ({ session, events, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, getOrCreateFrameState, reconcileTargetSelection, removeFrame, refreshFrameTitle, emitTargetChanged, setCurrentSession }) => {
+  session.handle.onEvent("Runtime.executionContextCreated", (params, meta) => {
+    const context = parseExecutionContext(params);
+    if (!context?.isDefault || !context.frameId) {
+      return;
+    }
+    const state = getOrCreateFrameState(session.tabId);
+    state.executionContexts.set(context.frameId, context.id);
+    const frame = state.frames.get(context.frameId);
+    if (frame) {
+      frame.sessionId = meta.sessionId ?? null;
+    }
+    refreshFrameTitle(session, context.frameId, context.id);
+    reconcileTargetSelection(session);
+  });
+  session.handle.onEvent("Runtime.executionContextsCleared", () => {
+    const state = getOrCreateFrameState(session.tabId);
+    state.executionContexts.clear();
+    state.pendingTitleLoads.clear();
+  });
+  session.handle.onEvent("Runtime.executionContextDestroyed", (params) => {
+    const record = params;
+    if (record.executionContextId == null) {
+      return;
+    }
+    const state = getOrCreateFrameState(session.tabId);
+    for (const [frameId, contextId] of state.executionContexts.entries()) {
+      if (contextId === record.executionContextId) {
+        state.executionContexts.delete(frameId);
+        state.pendingTitleLoads.delete(frameId);
+      }
+    }
+  });
+  session.handle.onEvent("Page.frameNavigated", (params, meta) => {
+    const frame = parseFrame(params);
+    if (!frame) {
+      return;
+    }
+    const state = getOrCreateFrameState(session.tabId);
+    state.frames.set(frame.frameId, frame);
+    frame.sessionId = meta.sessionId ?? null;
+    if (!frame.parentFrameId) {
+      if (!meta.sessionId) {
+        state.topFrameId = frame.frameId;
+        session.url = frame.url;
+      } else if (state.topFrameId == null) {
+        state.topFrameId = frame.parentFrameId;
+      }
+    } else if (state.executionContexts.has(frame.frameId)) {
+      refreshFrameTitle(session, frame.frameId);
+    }
+    setCurrentSession(session);
+    if (!frame.parentFrameId && !meta.sessionId) {
+      events.onPageNavigation?.({ url: frame.url, title: session.title ?? null });
+    }
+    if (reconcileTargetSelection(session)) {
+      return;
+    }
+    if (!frame.parentFrameId && state.activeFrameId == null || state.activeFrameId === frame.frameId) {
+      emitTargetChanged(session);
+    }
+  });
+  session.handle.onEvent("Page.frameAttached", (params, meta) => {
+    const record = params;
+    if (!record.frameId) {
+      return;
+    }
+    const state = getOrCreateFrameState(session.tabId);
+    state.frames.set(record.frameId, {
+      frameId: record.frameId,
+      parentFrameId: record.parentFrameId ?? state.topFrameId ?? null,
+      url: "",
+      title: null,
+      sessionId: meta.sessionId ?? null
+    });
+    reconcileTargetSelection(session);
+  });
+  session.handle.onEvent("Page.frameDetached", (params) => {
+    const record = params;
+    if (!record.frameId) {
+      return;
+    }
+    removeFrame(session.tabId, record.frameId);
+    reconcileTargetSelection(session);
+  });
+  session.handle.onEvent("Page.domContentEventFired", () => {
+    events.onPageLoad?.();
+  });
+  session.handle.onEvent("Runtime.consoleAPICalled", (params) => {
+    events.onLog(toConsoleEvent2(params, session, { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2 }));
+  });
+  session.handle.onEvent("Runtime.exceptionThrown", (params) => {
+    events.onLog(toExceptionEvent2(params, session, { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2 }));
+  });
+};
+
 // ../argus-watcher/dist/sources/extension-source.js
 var createExtensionSource = (options) => {
   const { events, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, watcherId, watcherHost, watcherPort } = options;
@@ -10067,6 +10472,7 @@ var createExtensionSource = (options) => {
   let currentSession = null;
   let stopping = false;
   const frameStateByTabId = new Map;
+  const delegatingSessions = new Set;
   const getCurrentExtensionSession = () => {
     if (!currentSession) {
       throw createNotAttachedError();
@@ -10077,6 +10483,7 @@ var createExtensionSource = (options) => {
     onAttach: (session) => {
       console.error(`[ExtensionSource] Tab attached: ${session.tabId} - ${session.url}`);
       currentSession = session;
+      rebindDelegatingSessions();
       seedFrameState(session);
       bootstrapAttachedSession(session);
     },
@@ -10085,6 +10492,7 @@ var createExtensionSource = (options) => {
       if (currentSession?.tabId === tabId) {
         currentSession = null;
       }
+      rebindDelegatingSessions();
       frameStateByTabId.delete(tabId);
       emitStatus(null, reason);
       events.onDetach?.(reason);
@@ -10093,13 +10501,16 @@ var createExtensionSource = (options) => {
     onTargetSelected: (tabId, frameId) => {
       const session = currentSession;
       if (!session || session.tabId !== tabId) {
-        getOrCreateFrameState(tabId).requestedFrameId = frameId;
+        const state = getOrCreateFrameState(tabId);
+        setRequestedTargetSelection(state, frameId);
         return;
       }
       requestTargetSelection(session, frameId);
     }
   });
-  const proxySession = createDelegatingSession({
+  const { session: proxySession, controller: proxyController } = createDelegatingSession({
+    getCurrentSession: () => currentSession,
+    requireCurrentSession: getCurrentExtensionSession,
     getTargetContext: () => getCurrentTargetContext() ?? { kind: "page" },
     mapParams: (method, params) => {
       const targetContext = getCurrentTargetContext();
@@ -10115,9 +10526,13 @@ var createExtensionSource = (options) => {
       };
     }
   });
-  const pageSession = createDelegatingSession({
+  delegatingSessions.add(proxyController);
+  const { session: pageSession, controller: pageController } = createDelegatingSession({
+    getCurrentSession: () => currentSession,
+    requireCurrentSession: getCurrentExtensionSession,
     getTargetContext: () => ({ kind: "page" })
   });
+  delegatingSessions.add(pageController);
   messaging.start();
   sendHostInfo();
   messaging.onDisconnect(() => {
@@ -10129,6 +10544,7 @@ var createExtensionSource = (options) => {
   });
   const stop = async () => {
     stopping = true;
+    disposeDelegatingSessions();
     messaging.stop();
   };
   const listTargets = async () => {
@@ -10151,7 +10567,8 @@ var createExtensionSource = (options) => {
     const target = parseExtensionTargetId(targetId);
     const session = currentSession;
     if (!session || session.tabId !== target.tabId) {
-      getOrCreateFrameState(target.tabId).requestedFrameId = target.frameId;
+      const state = getOrCreateFrameState(target.tabId);
+      setRequestedTargetSelection(state, target.frameId);
       sessionManager.attachTab(target.tabId);
       return;
     }
@@ -10184,9 +10601,33 @@ var createExtensionSource = (options) => {
       pid: hostInfo.watcherPid
     });
   }
+  function rebindDelegatingSessions() {
+    for (const controller of delegatingSessions) {
+      controller.rebind();
+    }
+  }
+  function disposeDelegatingSessions() {
+    for (const controller of delegatingSessions) {
+      controller.dispose();
+    }
+    delegatingSessions.clear();
+  }
   async function bootstrapAttachedSession(session) {
     try {
-      registerSessionEventHandlers(session);
+      registerExtensionSessionEventHandlers({
+        session,
+        events,
+        ignoreMatcher,
+        stripUrlPrefixes: stripUrlPrefixes2,
+        getOrCreateFrameState,
+        reconcileTargetSelection,
+        removeFrame,
+        refreshFrameTitle,
+        emitTargetChanged,
+        setCurrentSession: (nextSession) => {
+          currentSession = nextSession;
+        }
+      });
       await enableBootstrapDomains(session);
       await refreshFrameTree(session);
       if (currentSession?.tabId !== session.tabId) {
@@ -10209,101 +10650,6 @@ var createExtensionSource = (options) => {
     await session.handle.sendAndWait("Runtime.enable");
     await session.handle.sendAndWait("Page.enable");
   }
-  function registerSessionEventHandlers(session) {
-    session.handle.onEvent("Runtime.executionContextCreated", (params, meta) => {
-      const context = parseExecutionContext(params);
-      if (!context?.isDefault || !context.frameId) {
-        return;
-      }
-      const state = getOrCreateFrameState(session.tabId);
-      state.executionContexts.set(context.frameId, context.id);
-      const frame = state.frames.get(context.frameId);
-      if (frame) {
-        frame.sessionId = meta.sessionId ?? null;
-      }
-      refreshFrameTitle(session, context.frameId, context.id);
-      reconcileTargetSelection(session);
-    });
-    session.handle.onEvent("Runtime.executionContextsCleared", () => {
-      const state = getOrCreateFrameState(session.tabId);
-      state.executionContexts.clear();
-      state.pendingTitleLoads.clear();
-    });
-    session.handle.onEvent("Runtime.executionContextDestroyed", (params) => {
-      const record = params;
-      if (record.executionContextId == null) {
-        return;
-      }
-      const state = getOrCreateFrameState(session.tabId);
-      for (const [frameId, contextId] of state.executionContexts.entries()) {
-        if (contextId === record.executionContextId) {
-          state.executionContexts.delete(frameId);
-          state.pendingTitleLoads.delete(frameId);
-        }
-      }
-    });
-    session.handle.onEvent("Page.frameNavigated", (params, meta) => {
-      const frame = parseFrame(params);
-      if (!frame) {
-        return;
-      }
-      const state = getOrCreateFrameState(session.tabId);
-      state.frames.set(frame.frameId, frame);
-      frame.sessionId = meta.sessionId ?? null;
-      if (!frame.parentFrameId) {
-        if (!meta.sessionId) {
-          state.topFrameId = frame.frameId;
-          session.url = frame.url;
-        } else if (state.topFrameId == null) {
-          state.topFrameId = frame.parentFrameId;
-        }
-      } else if (state.executionContexts.has(frame.frameId)) {
-        refreshFrameTitle(session, frame.frameId);
-      }
-      currentSession = session;
-      if (!frame.parentFrameId && !meta.sessionId) {
-        events.onPageNavigation?.({ url: frame.url, title: session.title ?? null });
-      }
-      if (reconcileTargetSelection(session)) {
-        return;
-      }
-      if (!frame.parentFrameId && state.activeFrameId == null || state.activeFrameId === frame.frameId) {
-        emitTargetChanged(session);
-      }
-    });
-    session.handle.onEvent("Page.frameAttached", (params, meta) => {
-      const record = params;
-      if (!record.frameId) {
-        return;
-      }
-      const state = getOrCreateFrameState(session.tabId);
-      state.frames.set(record.frameId, {
-        frameId: record.frameId,
-        parentFrameId: record.parentFrameId ?? state.topFrameId ?? null,
-        url: "",
-        title: null,
-        sessionId: meta.sessionId ?? null
-      });
-      reconcileTargetSelection(session);
-    });
-    session.handle.onEvent("Page.frameDetached", (params) => {
-      const record = params;
-      if (!record.frameId) {
-        return;
-      }
-      removeFrame(session.tabId, record.frameId);
-      reconcileTargetSelection(session);
-    });
-    session.handle.onEvent("Page.domContentEventFired", () => {
-      events.onPageLoad?.();
-    });
-    session.handle.onEvent("Runtime.consoleAPICalled", (params) => {
-      events.onLog(toConsoleEvent2(params, session, { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2 }));
-    });
-    session.handle.onEvent("Runtime.exceptionThrown", (params) => {
-      events.onLog(toExceptionEvent2(params, session, { ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2 }));
-    });
-  }
   function getCurrentTargetContext() {
     const session = currentSession;
     if (!session) {
@@ -10390,30 +10736,47 @@ var createExtensionSource = (options) => {
   }
   function requestTargetSelection(session, frameId) {
     const state = getOrCreateFrameState(session.tabId);
-    state.requestedFrameId = frameId;
+    setRequestedTargetSelection(state, frameId);
     reconcileTargetSelection(session);
   }
+  function setRequestedTargetSelection(state, frameId) {
+    const frame = frameId ? state.frames.get(frameId) : null;
+    state.requestedFrameId = frameId;
+    state.requestedFrameHint = createRequestedFrameHint(frame);
+    state.requestedFrameDetached = false;
+  }
   function reconcileTargetSelection(session) {
     const state = getOrCreateFrameState(session.tabId);
-    const nextActiveFrameId = resolveRequestedFrameId(state, state.requestedFrameId);
-    if (state.requestedFrameId == null) {
-      if (state.activeFrameId == null) {
-        if (state.activeAttachedAt == null) {
-          state.activeAttachedAt = Date.now();
-          emitTargetChanged(session);
-          return true;
-        }
-        return false;
-      }
-      state.activeFrameId = null;
-      state.activeAttachedAt = Date.now();
-      emitTargetChanged(session);
-      return true;
+    const resolution = resolveRequestedTarget(state);
+    if (resolution.kind === "page") {
+      state.requestedFrameDetached = false;
+      return activatePageTarget(session, state);
     }
-    if (nextActiveFrameId == null || state.activeFrameId === nextActiveFrameId) {
+    if (resolution.kind === "pending") {
       return false;
     }
-    state.activeFrameId = nextActiveFrameId;
+    state.requestedFrameDetached = false;
+    if (state.activeFrameId === resolution.frameId) {
+      return false;
+    }
+    return activateFrameTarget(session, state, resolution.frameId);
+  }
+  function activatePageTarget(session, state) {
+    if (state.activeFrameId == null) {
+      if (state.activeAttachedAt == null) {
+        state.activeAttachedAt = Date.now();
+        emitTargetChanged(session);
+        return true;
+      }
+      return false;
+    }
+    state.activeFrameId = null;
+    state.activeAttachedAt = Date.now();
+    emitTargetChanged(session);
+    return true;
+  }
+  function activateFrameTarget(session, state, frameId) {
+    state.activeFrameId = frameId;
     state.activeAttachedAt = Date.now();
     emitTargetChanged(session);
     return true;
@@ -10430,8 +10793,10 @@ var createExtensionSource = (options) => {
     for (const childId of childIds) {
       removeFrame(tabId, childId);
     }
-    if (state.requestedFrameId === frameId) {
-      state.requestedFrameId = null;
+    if (state.activeFrameId === frameId) {
+      state.requestedFrameDetached = state.requestedFrameId === frameId;
+      state.activeFrameId = null;
+      state.activeAttachedAt = null;
     }
     state.frames.delete(frameId);
     state.executionContexts.delete(frameId);
@@ -10471,25 +10836,6 @@ var createExtensionSource = (options) => {
       state.pendingTitleLoads.delete(frameId);
     }
   }
-  function createDelegatingSession(config) {
-    return {
-      isAttached: () => currentSession?.handle.isAttached() ?? false,
-      sendAndWait: async (method, params, options2) => {
-        const session = getCurrentExtensionSession();
-        const targetContext = config.getTargetContext();
-        const nextParams = config.mapParams ? config.mapParams(method, params) : params;
-        const nextOptions = targetContext.kind === "frame" && targetContext.sessionId ? { ...options2 ?? {}, sessionId: targetContext.sessionId } : options2;
-        return session.handle.sendAndWait(method, nextParams, nextOptions);
-      },
-      onEvent: (method, handler) => {
-        if (!currentSession) {
-          return () => {};
-        }
-        return currentSession.handle.onEvent(method, handler);
-      },
-      getTargetContext: config.getTargetContext
-    };
-  }
 };
 var tabToTarget = (tab) => ({
   id: formatPageTargetId(tab.tabId),
@@ -10500,62 +10846,15 @@ var tabToTarget = (tab) => ({
   attached: tab.attached
 });
 
-// ../argus-watcher/dist/index.js
-var startWatcher = async (options) => {
-  if (!options.id) {
-    throw new Error("Watcher id is required");
-  }
-  const watcherId = await resolveUniqueWatcherId(options.id);
-  const sourceMode = options.source ?? "cdp";
-  const host = options.host ?? "127.0.0.1";
-  const port = options.port ?? 0;
-  const chrome = options.chrome ?? { host: "127.0.0.1", port: 9222 };
-  const bufferSize = options.bufferSize ?? 50000;
-  const netBufferSize = options.bufferSize ?? 50000;
-  const startedAt = Date.now();
-  const ignoreMatcher = buildIgnoreMatcher(options.ignoreList);
-  const stripUrlPrefixes2 = options.location?.stripUrlPrefixes;
-  const artifactsBaseDir = resolveArtifactsBaseDir(options.artifacts?.base, watcherId);
-  const logsEnabled = options.artifacts?.logs?.enabled === true;
-  const logsDir = path7.join(artifactsBaseDir, "logs");
-  const includeTimestamps = options.artifacts?.logs?.includeTimestamps ?? false;
-  const maxFiles = resolveMaxFiles(options.artifacts?.logs?.maxFiles);
-  const netEnabled = sourceMode === "cdp" && options.net?.enabled === true;
-  const pageConsoleLogging = options.pageConsoleLogging ?? "minimal";
-  const events = new Emittery;
-  const buffer = new LogBuffer(bufferSize);
-  const netBuffer = netEnabled ? new NetBuffer(netBufferSize) : null;
+// ../argus-watcher/dist/startWatcherRuntime.js
+var createWatcherHandle = async (options, watcherId) => {
+  const setup = normalizeWatcherSetup(options, watcherId);
+  const { sourceMode, host, port, chrome, artifactsBaseDir, pageConsoleLogging, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, events, buffer, netBuffer, record, fileLogger, sessionHandle, emulationController, throttleController } = setup;
   let closing = false;
   let readyForShutdown = false;
   let shutdownRequested = false;
   let closeOnce = null;
   let cdpStatus = { attached: false, target: null };
-  const fileLogger = logsEnabled ? new WatcherFileLogger({
-    watcherId,
-    startedAt,
-    logsDir,
-    chrome: sourceMode === "cdp" ? chrome : undefined,
-    match: options.match,
-    maxFiles,
-    includeTimestamps,
-    buildFilename: options.artifacts?.logs?.buildFilename
-  }) : null;
-  const record = {
-    id: watcherId,
-    host,
-    port,
-    pid: process.pid,
-    cwd: process.cwd(),
-    startedAt,
-    updatedAt: Date.now(),
-    match: sourceMode === "cdp" ? options.match : undefined,
-    chrome: sourceMode === "cdp" ? chrome : undefined,
-    includeTimestamps,
-    source: sourceMode
-  };
-  const sessionHandle = createCdpSessionHandle();
-  const emulationController = createEmulationController();
-  const throttleController = createThrottleController();
   const logToPageConsole = (message) => {
     if (pageConsoleLogging === "none") {
       return;
@@ -10672,6 +10971,37 @@ var startWatcher = async (options) => {
       console.warn(`[Watcher] Failed to run inject script for watcher ${record.id}: ${formatError4(error)}`);
     }
   };
+  const handleSourceLog = (event) => {
+    buffer.add(event);
+    fileLogger?.writeEvent(event);
+  };
+  const handlePageNavigation = (info) => {
+    fileLogger?.rotate(info);
+    onIndicatorNavigation(getIndicatorSession(), info);
+    runtimeEditor?.reset();
+  };
+  const handlePageIntl = (info) => {
+    fileLogger?.setPageIntl(info);
+  };
+  const handleSourceAttach = async (session, target) => {
+    runtimeEditor?.rebind();
+    await emulationController.onAttach(session);
+    await throttleController.onAttach(session);
+    await networkCapture?.onAttached();
+    onIndicatorAttach(session, target);
+    await maybeInjectOnAttach(session, target);
+  };
+  const handleTargetChanged = (session, target) => {
+    onIndicatorAttach(session, target);
+  };
+  const handleSourceDetach = (reason) => {
+    runtimeEditor?.rebind();
+    networkCapture?.onDetached();
+    indicatorController?.onDetach();
+    if (reason != null) {
+      traceRecorder.onDetached(reason);
+    }
+  };
   let sourceHandle;
   let networkCapture = null;
   let traceRecorder;
@@ -10680,33 +11010,15 @@ var startWatcher = async (options) => {
   if (sourceMode === "extension") {
     sourceHandle = createExtensionSource({
       events: {
-        onLog: (event) => {
-          buffer.add(event);
-          fileLogger?.writeEvent(event);
-        },
+        onLog: handleSourceLog,
         onStatus: updateCdpStatus,
-        onPageNavigation: (info) => {
-          fileLogger?.rotate(info);
-          onIndicatorNavigation(getIndicatorSession(), info);
-          runtimeEditor?.reset();
-        },
+        onPageNavigation: handlePageNavigation,
         onPageLoad: onIndicatorLoad,
-        onPageIntl: (info) => {
-          fileLogger?.setPageIntl(info);
-        },
-        onAttach: async (session, target) => {
-          runtimeEditor?.rebind();
-          await emulationController.onAttach(session);
-          await throttleController.onAttach(session);
-          onIndicatorAttach(session, target);
-          await maybeInjectOnAttach(session, target);
-        },
-        onTargetChanged: (session, target) => {
-          onIndicatorAttach(session, target);
-        },
+        onPageIntl: handlePageIntl,
+        onAttach: handleSourceAttach,
+        onTargetChanged: handleTargetChanged,
         onDetach: () => {
-          runtimeEditor?.rebind();
-          indicatorController?.onDetach();
+          handleSourceDetach();
         }
       },
       watcherId,
@@ -10715,6 +11027,7 @@ var startWatcher = async (options) => {
       ignoreMatcher: ignoreMatcher ? (url) => ignoreMatcher.matches(url) : null,
       stripUrlPrefixes: stripUrlPrefixes2
     });
+    networkCapture = netBuffer ? createNetworkCapture({ session: sourceHandle.pageSession ?? sourceHandle.session, buffer: netBuffer }) : null;
     traceRecorder = createTraceRecorder({ session: sourceHandle.session, artifactsDir: artifactsBaseDir });
     screenshotter = createScreenshotter({ session: sourceHandle.session, artifactsDir: artifactsBaseDir });
     runtimeEditor = createRuntimeEditor(sourceHandle.session);
@@ -10728,33 +11041,14 @@ var startWatcher = async (options) => {
       match: options.match,
       sessionHandle,
       events: {
-        onLog: (event) => {
-          buffer.add(event);
-          fileLogger?.writeEvent(event);
-        },
+        onLog: handleSourceLog,
         onStatus: updateCdpStatus,
-        onPageNavigation: (info) => {
-          fileLogger?.rotate(info);
-          onIndicatorNavigation(sessionHandle.session, info);
-          runtimeEditor?.reset();
-        },
+        onPageNavigation: handlePageNavigation,
         onPageLoad: onIndicatorLoad,
-        onPageIntl: (info) => {
-          fileLogger?.setPageIntl(info);
-        },
-        onAttach: async (session, target) => {
-          runtimeEditor?.rebind();
-          await emulationController.onAttach(session);
-          await throttleController.onAttach(session);
-          await networkCapture?.onAttached();
-          onIndicatorAttach(session, target);
-          await maybeInjectOnAttach(session, target);
-        },
+        onPageIntl: handlePageIntl,
+        onAttach: handleSourceAttach,
         onDetach: (reason) => {
-          runtimeEditor?.rebind();
-          networkCapture?.onDetached();
-          traceRecorder.onDetached(reason);
-          indicatorController?.onDetach();
+          handleSourceDetach(reason);
         }
       },
       watcherId,
@@ -10769,6 +11063,7 @@ var startWatcher = async (options) => {
     netBuffer,
     getWatcher: () => record,
     getCdpStatus: () => cdpStatus,
+    pageCdpSession: sourceHandle.pageSession ?? sourceHandle.session,
     cdpSession: sourceHandle.session,
     traceRecorder,
     screenshotter,
@@ -10831,6 +11126,71 @@ var startWatcher = async (options) => {
     }
   };
 };
+var normalizeWatcherSetup = (options, watcherId) => {
+  const sourceMode = options.source ?? "cdp";
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  const chrome = options.chrome ?? { host: "127.0.0.1", port: 9222 };
+  const bufferSize = options.bufferSize ?? 50000;
+  const startedAt = Date.now();
+  const ignoreMatcher = buildIgnoreMatcher(options.ignoreList);
+  const stripUrlPrefixes2 = options.location?.stripUrlPrefixes;
+  const artifactsBaseDir = resolveArtifactsBaseDir(options.artifacts?.base, watcherId);
+  const logsEnabled = options.artifacts?.logs?.enabled === true;
+  const logsDir = path7.join(artifactsBaseDir, "logs");
+  const includeTimestamps = options.artifacts?.logs?.includeTimestamps ?? false;
+  const maxFiles = resolveMaxFiles(options.artifacts?.logs?.maxFiles);
+  const netEnabled = options.net?.enabled === true;
+  const pageConsoleLogging = options.pageConsoleLogging ?? "minimal";
+  const events = new Emittery;
+  const buffer = new LogBuffer(bufferSize);
+  const netBuffer = netEnabled ? new NetBuffer(bufferSize) : null;
+  const fileLogger = logsEnabled ? new WatcherFileLogger({
+    watcherId,
+    startedAt,
+    logsDir,
+    chrome: sourceMode === "cdp" ? chrome : undefined,
+    match: options.match,
+    maxFiles,
+    includeTimestamps,
+    buildFilename: options.artifacts?.logs?.buildFilename
+  }) : null;
+  const record = {
+    id: watcherId,
+    host,
+    port,
+    pid: process.pid,
+    cwd: process.cwd(),
+    startedAt,
+    updatedAt: Date.now(),
+    match: sourceMode === "cdp" ? options.match : undefined,
+    chrome: sourceMode === "cdp" ? chrome : undefined,
+    includeTimestamps,
+    source: sourceMode
+  };
+  return {
+    sourceMode,
+    host,
+    port,
+    chrome,
+    watcherId,
+    startedAt,
+    artifactsBaseDir,
+    includeTimestamps,
+    netEnabled,
+    pageConsoleLogging,
+    ignoreMatcher,
+    stripUrlPrefixes: stripUrlPrefixes2,
+    events,
+    buffer,
+    netBuffer,
+    record,
+    fileLogger,
+    sessionHandle: createCdpSessionHandle(),
+    emulationController: createEmulationController(),
+    throttleController: createThrottleController()
+  };
+};
 var resolveArtifactsBaseDir = (base, watcherId) => {
   if (base !== undefined && base !== null) {
     if (typeof base !== "string" || base.trim() === "") {
@@ -10871,11 +11231,20 @@ var formatError4 = (error) => {
   return String(error);
 };
 
+// ../argus-watcher/dist/index.js
+var startWatcher = async (options) => {
+  if (!options.id) {
+    throw new Error("Watcher id is required");
+  }
+  const watcherId = await resolveUniqueWatcherId(options.id);
+  return createWatcherHandle(options, watcherId);
+};
+
 // dist/commands/chromeStart.js
 import { spawn } from "node:child_process";
 import { copyFileSync, cpSync, existsSync as existsSync2, mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path8 from "node:path";
+import { homedir as homedir2, tmpdir } from "node:os";
+import path9 from "node:path";
 
 // dist/utils/chromeBin.js
 import { existsSync } from "node:fs";
@@ -10958,6 +11327,80 @@ var getCdpPort = async () => {
   return getEphemeralPort();
 };
 
+// dist/commands/startShared.js
+import fs7 from "node:fs/promises";
+
+// dist/utils/paths.js
+import { homedir } from "node:os";
+import path8 from "node:path";
+var resolvePath = (input) => {
+  const expanded = input.startsWith("~/") || input === "~" ? path8.join(homedir(), input.slice(1)) : input;
+  return path8.resolve(expanded);
+};
+
+// dist/commands/startShared.js
+var resolveInjectScript = async (inject, output) => {
+  if (!inject) {
+    return;
+  }
+  const resolvedPath = resolvePath(inject.file);
+  let script;
+  try {
+    script = await fs7.readFile(resolvedPath, "utf8");
+  } catch (error) {
+    output.writeWarn(`Failed to read inject script at ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}. Skipping injection.`);
+    return;
+  }
+  if (script.trim() === "") {
+    output.writeWarn(`Inject script at ${resolvedPath} is empty. Skipping injection.`);
+    return;
+  }
+  return { script, exposeArgus: inject.exposeArgus };
+};
+var normalizeHttpUrl2 = (value) => {
+  if (!value) {
+    return null;
+  }
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return value;
+  }
+  return `http://${value}`;
+};
+var buildWatcherMatch = (options) => {
+  const match = {};
+  const url = options.url?.trim();
+  if (url) {
+    match.url = url;
+  }
+  const type = options.type?.trim();
+  if (type) {
+    match.type = type;
+  }
+  const origin = options.origin?.trim();
+  if (origin) {
+    match.origin = origin;
+  }
+  const targetId = options.target?.trim();
+  if (targetId) {
+    match.targetId = targetId;
+  }
+  const parent = options.parent?.trim();
+  if (parent) {
+    match.parent = parent;
+  }
+  return Object.keys(match).length > 0 ? match : undefined;
+};
+var registerTerminationHandlers = (terminate) => {
+  const handleTermination = () => {
+    terminate().then(() => process.exit(0));
+  };
+  process.on("SIGINT", handleTermination);
+  process.on("SIGTERM", handleTermination);
+};
+var waitForever = async () => {
+  await new Promise(() => {});
+};
+
 // dist/commands/chromeStart.js
 var delay2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var resolveChromeUserDataDir = () => {
@@ -10970,13 +11413,13 @@ var resolveChromeUserDataDir = () => {
   const platform = process.platform;
   if (platform === "darwin") {
     const candidates = [
-      path8.join(homedir(), "Library/Application Support/Google/Chrome"),
-      path8.join(homedir(), "Library/Application Support/Chromium")
+      path9.join(homedir2(), "Library/Application Support/Google/Chrome"),
+      path9.join(homedir2(), "Library/Application Support/Chromium")
     ];
     return candidates.find((candidate) => existsSync2(candidate)) ?? null;
   }
   if (platform === "linux") {
-    const candidates = [path8.join(homedir(), ".config/google-chrome"), path8.join(homedir(), ".config/chromium")];
+    const candidates = [path9.join(homedir2(), ".config/google-chrome"), path9.join(homedir2(), ".config/chromium")];
     return candidates.find((candidate) => existsSync2(candidate)) ?? null;
   }
   if (platform === "win32") {
@@ -10984,21 +11427,21 @@ var resolveChromeUserDataDir = () => {
     if (!base) {
       return null;
     }
-    const candidates = [path8.join(base, "Google/Chrome/User Data"), path8.join(base, "Chromium/User Data")];
+    const candidates = [path9.join(base, "Google/Chrome/User Data"), path9.join(base, "Chromium/User Data")];
     return candidates.find((candidate) => existsSync2(candidate)) ?? null;
   }
   return null;
 };
 var copyDefaultProfile = (sourceDir) => {
-  const destRoot = mkdtempSync(path8.join(tmpdir(), "argus-chrome-profile-"));
+  const destRoot = mkdtempSync(path9.join(tmpdir(), "argus-chrome-profile-"));
   mkdirSync(destRoot, { recursive: true });
   const entries = ["Default", "Local State", "First Run", "Last Version"];
   for (const entry of entries) {
-    const source = path8.join(sourceDir, entry);
+    const source = path9.join(sourceDir, entry);
     if (!existsSync2(source)) {
       continue;
     }
-    const dest = path8.join(destRoot, entry);
+    const dest = path9.join(destRoot, entry);
     if (entry === "Default") {
       cpSync(source, dest, { recursive: true });
     } else {
@@ -11019,8 +11462,8 @@ var stripExtensionsFromPrefs = (prefsPath) => {
   } catch {}
 };
 var copyDefaultProfileLite = (sourceDir) => {
-  const destRoot = mkdtempSync(path8.join(tmpdir(), "argus-chrome-profile-lite-"));
-  const defaultDir = path8.join(destRoot, "Default");
+  const destRoot = mkdtempSync(path9.join(tmpdir(), "argus-chrome-profile-lite-"));
+  const defaultDir = path9.join(destRoot, "Default");
   mkdirSync(defaultDir, { recursive: true });
   const copyIfExists = (source, dest) => {
     if (!existsSync2(source)) {
@@ -11028,20 +11471,20 @@ var copyDefaultProfileLite = (sourceDir) => {
     }
     copyFileSync(source, dest);
   };
-  copyIfExists(path8.join(sourceDir, "Local State"), path8.join(destRoot, "Local State"));
-  copyIfExists(path8.join(sourceDir, "Default", "Cookies"), path8.join(defaultDir, "Cookies"));
-  copyIfExists(path8.join(sourceDir, "Default", "Cookies-journal"), path8.join(defaultDir, "Cookies-journal"));
-  copyIfExists(path8.join(sourceDir, "Default", "Login Data"), path8.join(defaultDir, "Login Data"));
-  copyIfExists(path8.join(sourceDir, "Default", "Login Data-journal"), path8.join(defaultDir, "Login Data-journal"));
-  copyIfExists(path8.join(sourceDir, "Default", "Preferences"), path8.join(defaultDir, "Preferences"));
-  copyIfExists(path8.join(sourceDir, "Default", "Secure Preferences"), path8.join(defaultDir, "Secure Preferences"));
-  stripExtensionsFromPrefs(path8.join(defaultDir, "Preferences"));
-  stripExtensionsFromPrefs(path8.join(defaultDir, "Secure Preferences"));
+  copyIfExists(path9.join(sourceDir, "Local State"), path9.join(destRoot, "Local State"));
+  copyIfExists(path9.join(sourceDir, "Default", "Cookies"), path9.join(defaultDir, "Cookies"));
+  copyIfExists(path9.join(sourceDir, "Default", "Cookies-journal"), path9.join(defaultDir, "Cookies-journal"));
+  copyIfExists(path9.join(sourceDir, "Default", "Login Data"), path9.join(defaultDir, "Login Data"));
+  copyIfExists(path9.join(sourceDir, "Default", "Login Data-journal"), path9.join(defaultDir, "Login Data-journal"));
+  copyIfExists(path9.join(sourceDir, "Default", "Preferences"), path9.join(defaultDir, "Preferences"));
+  copyIfExists(path9.join(sourceDir, "Default", "Secure Preferences"), path9.join(defaultDir, "Secure Preferences"));
+  stripExtensionsFromPrefs(path9.join(defaultDir, "Preferences"));
+  stripExtensionsFromPrefs(path9.join(defaultDir, "Secure Preferences"));
   return destRoot;
 };
 var copyDefaultProfileMedium = (sourceDir) => {
   const destRoot = copyDefaultProfileLite(sourceDir);
-  const defaultDir = path8.join(destRoot, "Default");
+  const defaultDir = path9.join(destRoot, "Default");
   const copyPathIfExists = (source, dest) => {
     if (!existsSync2(source)) {
       return;
@@ -11053,9 +11496,9 @@ var copyDefaultProfileMedium = (sourceDir) => {
     }
     copyFileSync(source, dest);
   };
-  copyPathIfExists(path8.join(sourceDir, "Default", "History"), path8.join(defaultDir, "History"));
-  copyPathIfExists(path8.join(sourceDir, "Default", "Local Storage"), path8.join(defaultDir, "Local Storage"));
-  copyPathIfExists(path8.join(sourceDir, "Default", "IndexedDB"), path8.join(defaultDir, "IndexedDB"));
+  copyPathIfExists(path9.join(sourceDir, "Default", "History"), path9.join(defaultDir, "History"));
+  copyPathIfExists(path9.join(sourceDir, "Default", "Local Storage"), path9.join(defaultDir, "Local Storage"));
+  copyPathIfExists(path9.join(sourceDir, "Default", "IndexedDB"), path9.join(defaultDir, "IndexedDB"));
   return destRoot;
 };
 var waitForCdpReady = async (host, port, chrome) => {
@@ -11079,35 +11522,11 @@ var waitForCdpReady = async (host, port, chrome) => {
   }
   return { ready: false, error: lastError ?? "Timed out waiting for CDP." };
 };
-var sendBrowserClose = (wsUrl, timeoutMs = 3000) => new Promise((resolve2) => {
-  const ws = new WebSocket(wsUrl);
-  const timer = setTimeout(() => {
-    try {
-      ws.close();
-    } catch {}
-    resolve2();
-  }, timeoutMs);
-  ws.addEventListener("open", () => {
-    try {
-      ws.send(JSON.stringify({ id: 1, method: "Browser.close" }));
-    } catch {}
-  });
-  ws.addEventListener("message", () => {
-    clearTimeout(timer);
-    try {
-      ws.close();
-    } catch {}
-    resolve2();
-  });
-  ws.addEventListener("error", () => {
-    clearTimeout(timer);
-    resolve2();
-  });
-  ws.addEventListener("close", () => {
-    clearTimeout(timer);
-    resolve2();
-  });
-});
+var sendBrowserClose = async (wsUrl, timeoutMs = 3000) => {
+  try {
+    await sendCdpCommand(wsUrl, { id: 1, method: "Browser.close" }, timeoutMs);
+  } catch {}
+};
 var normalizeProfile = (profile) => {
   if (!profile) {
     return "default-lite";
@@ -11148,7 +11567,7 @@ var launchChrome = async (options) => {
   const cdpPort = await getCdpPort();
   const cdpHost = "127.0.0.1";
   if (!userDataDir) {
-    userDataDir = mkdtempSync(path8.join(tmpdir(), "argus-chrome-"));
+    userDataDir = mkdtempSync(path9.join(tmpdir(), "argus-chrome-"));
   }
   const cleanupDir = () => {
     if (userDataDir) {
@@ -11248,12 +11667,9 @@ var runChromeStart = async (options) => {
       process.exitCode = 2;
       return;
     }
-    startupUrl = watcher.match.url;
-    if (!startupUrl.startsWith("http://") && !startupUrl.startsWith("https://")) {
-      startupUrl = `http://${startupUrl}`;
-    }
+    startupUrl = normalizeHttpUrl2(watcher.match.url);
   } else if (options.url) {
-    startupUrl = options.url;
+    startupUrl = normalizeHttpUrl2(options.url);
   }
   let result;
   try {
@@ -11268,12 +11684,7 @@ var runChromeStart = async (options) => {
     process.exitCode = 1;
     return;
   }
-  process.on("SIGINT", () => {
-    result.closeGracefully().then(() => process.exit(0));
-  });
-  process.on("SIGTERM", () => {
-    result.closeGracefully().then(() => process.exit(0));
-  });
+  registerTerminationHandlers(() => result.closeGracefully());
   result.chrome.on("exit", () => {
     if (result.userDataDir) {
       try {
@@ -11300,36 +11711,10 @@ var runChromeStart = async (options) => {
       output.writeHuman(`  url=${info.startupUrl}`);
     }
   }
-  await new Promise(() => {});
-};
-
-// dist/utils/paths.js
-import { homedir as homedir2 } from "node:os";
-import path9 from "node:path";
-var resolvePath = (input) => {
-  const expanded = input.startsWith("~/") || input === "~" ? path9.join(homedir2(), input.slice(1)) : input;
-  return path9.resolve(expanded);
+  await waitForever();
 };
 
 // dist/commands/start.js
-var resolveInjectScript = async (inject, output) => {
-  if (!inject) {
-    return null;
-  }
-  const resolvedPath = resolvePath(inject.file);
-  let script;
-  try {
-    script = await fs7.readFile(resolvedPath, "utf8");
-  } catch (error) {
-    output.writeWarn(`Failed to read inject script at ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}. Skipping injection.`);
-    return null;
-  }
-  if (script.trim() === "") {
-    output.writeWarn(`Inject script at ${resolvedPath} is empty. Skipping injection.`);
-    return null;
-  }
-  return { script, exposeArgus: inject.exposeArgus };
-};
 var runStart = async (options) => {
   const output = createOutput(options);
   if (!options.id || options.id.trim() === "") {
@@ -11338,13 +11723,7 @@ var runStart = async (options) => {
     return;
   }
   const watcherId = options.id.trim();
-  let chromeUrl = null;
-  if (options.url) {
-    chromeUrl = options.url;
-    if (!chromeUrl.startsWith("http://") && !chromeUrl.startsWith("https://")) {
-      chromeUrl = `http://${chromeUrl}`;
-    }
-  }
+  const chromeUrl = normalizeHttpUrl2(options.url);
   const hasTargeting = options.url?.trim() || options.target?.trim() || options.origin?.trim() || options.type?.trim();
   if (!hasTargeting) {
     output.writeWarn("At least one targeting option is required: --url, --target, --origin, or --type.");
@@ -11373,17 +11752,7 @@ var runStart = async (options) => {
   if (!options.json) {
     output.writeHuman("Attaching watcher...");
   }
-  const match = {};
-  if (options.url?.trim())
-    match.url = options.url.trim();
-  if (options.type?.trim())
-    match.type = options.type.trim();
-  if (options.origin?.trim())
-    match.origin = options.origin.trim();
-  if (options.target?.trim())
-    match.targetId = options.target.trim();
-  if (options.parent?.trim())
-    match.parent = options.parent.trim();
+  const match = buildWatcherMatch(options);
   let artifactsBaseDir;
   if (options.artifacts != null) {
     const trimmed = options.artifacts.trim();
@@ -11396,15 +11765,16 @@ var runStart = async (options) => {
     artifactsBaseDir = resolvePath(trimmed);
   }
   const inject = await resolveInjectScript(options.inject, output);
-  let handle37;
+  let handle38;
   try {
-    handle37 = await startWatcher({
+    handle38 = await startWatcher({
       id: watcherId,
       source: "cdp",
-      match: Object.keys(match).length > 0 ? match : undefined,
+      match,
       chrome: { host: chrome.cdpHost, port: chrome.cdpPort },
       host: "127.0.0.1",
       port: 0,
+      net: { enabled: true },
       pageIndicator: options.pageIndicator === false ? { enabled: false } : { enabled: true },
       artifacts: artifactsBaseDir ? { base: artifactsBaseDir } : undefined,
       pageConsoleLogging: options.pageConsoleLogging,
@@ -11418,39 +11788,34 @@ var runStart = async (options) => {
   }
   const shutdown = async () => {
     try {
-      await handle37.close();
+      await handle38.close();
     } catch {}
     await chrome.closeGracefully();
   };
-  process.on("SIGINT", () => {
-    shutdown().then(() => process.exit(0));
-  });
-  process.on("SIGTERM", () => {
-    shutdown().then(() => process.exit(0));
-  });
+  registerTerminationHandlers(shutdown);
   chrome.chrome.on("exit", () => {
     if (chrome.userDataDir) {
       try {
         rmSync2(chrome.userDataDir, { recursive: true, force: true });
       } catch {}
     }
-    handle37.close().then(() => process.exit(0));
+    handle38.close().then(() => process.exit(0));
   });
-  handle37.events.on("cdpAttached", ({ target }) => {
+  handle38.events.on("cdpAttached", ({ target }) => {
     const typeInfo = target?.type ? ` (type: ${target.type})` : "";
     output.writeHuman(`[${watcherId}] CDP attached: ${target?.title} (${target?.url})${typeInfo}`);
   });
-  handle37.events.on("cdpDetached", ({ reason, target }) => {
+  handle38.events.on("cdpDetached", ({ reason, target }) => {
     output.writeHuman(`[${watcherId}] CDP detached: ${reason} (last target: ${target?.title})`);
   });
   const result = {
-    id: handle37.watcher.id,
+    id: handle38.watcher.id,
     chromePid: chrome.chrome.pid,
     cdpHost: chrome.cdpHost,
     cdpPort: chrome.cdpPort,
-    watcherHost: handle37.watcher.host,
-    watcherPort: handle37.watcher.port,
-    watcherPid: handle37.watcher.pid
+    watcherHost: handle38.watcher.host,
+    watcherPort: handle38.watcher.port,
+    watcherPid: handle38.watcher.pid
   };
   if (options.json) {
     output.writeJson(result);
@@ -11480,7 +11845,7 @@ Stopping...`);
       }
     });
   }
-  await new Promise(() => {});
+  await waitForever();
 };
 
 // dist/commands/doctor.js
@@ -11609,66 +11974,6 @@ var formatStatus = (status) => {
   return "WARN";
 };
 
-// dist/watchers/requestWatcher.js
-async function requestWatcherJson(input) {
-  const resolved = await resolveWatcher({ id: input.id });
-  if (!resolved.ok) {
-    return {
-      ok: false,
-      exitCode: resolved.exitCode,
-      message: resolved.error,
-      candidates: resolved.candidates
-    };
-  }
-  const { watcher } = resolved;
-  const qs = input.query?.toString();
-  const url = `http://${watcher.host}:${watcher.port}${input.path}${qs ? `?${qs}` : ""}`;
-  try {
-    const data = await fetchJson(url, {
-      method: input.method,
-      body: input.body,
-      timeoutMs: input.timeoutMs,
-      returnErrorResponse: input.returnErrorResponse
-    });
-    return { ok: true, watcher, data };
-  } catch (error) {
-    return {
-      ok: false,
-      watcher,
-      exitCode: 1,
-      message: `${watcher.id}: failed to reach watcher (${formatError(error)})`
-    };
-  }
-}
-async function resolveWatcherOrExit(input, output) {
-  const resolved = await resolveWatcher(input);
-  if (!resolved.ok) {
-    writeResolveError(resolved, output);
-    return null;
-  }
-  return { watcher: resolved.watcher };
-}
-function writeRequestError(result, output) {
-  output.writeWarn(result.message);
-  if (result.candidates && result.candidates.length > 0) {
-    for (const watcher of result.candidates) {
-      output.writeWarn(formatWatcherLine(watcher));
-    }
-    output.writeWarn("Hint: run `argus list` to see all watchers.");
-  }
-  process.exitCode = result.exitCode;
-}
-function writeResolveError(resolved, output) {
-  output.writeWarn(resolved.error);
-  if (resolved.candidates && resolved.candidates.length > 0) {
-    for (const watcher of resolved.candidates) {
-      output.writeWarn(formatWatcherLine(watcher));
-    }
-    output.writeWarn("Hint: run `argus list` to see all watchers.");
-  }
-  process.exitCode = resolved.exitCode;
-}
-
 // dist/commands/reload.js
 var runReload = async (id, options) => {
   const output = createOutput(options);
@@ -12169,30 +12474,11 @@ Examples:
 
 // dist/commands/watcherStart.js
 import crypto2 from "node:crypto";
-import fs9 from "node:fs/promises";
 var isValidPort = (port) => Number.isFinite(port) && port >= 1 && port <= 65535;
 var parsePort2 = (value) => {
   const port = typeof value === "string" ? parseInt(value, 10) : value;
   return isValidPort(port) ? port : null;
 };
-var resolveInjectScript2 = async (inject, output) => {
-  if (!inject) {
-    return null;
-  }
-  const resolvedPath = resolvePath(inject.file);
-  let script;
-  try {
-    script = await fs9.readFile(resolvedPath, "utf8");
-  } catch (error) {
-    output.writeWarn(`Failed to read inject script at ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}. Skipping injection.`);
-    return null;
-  }
-  if (script.trim() === "") {
-    output.writeWarn(`Inject script at ${resolvedPath} is empty. Skipping injection.`);
-    return null;
-  }
-  return { script, exposeArgus: inject.exposeArgus };
-};
 var runWatcherStart = async (options) => {
   const output = createOutput(options);
   const sourceMode = options.source ?? "cdp";
@@ -12243,7 +12529,6 @@ var runWatcherStart = async (options) => {
     }
   }
   const watcherId = options.id?.trim() || generateWatcherId();
-  const matchUrl = options.url?.trim();
   let artifactsBaseDir;
   if (options.artifacts != null) {
     const trimmed = options.artifacts.trim();
@@ -12254,32 +12539,18 @@ var runWatcherStart = async (options) => {
     }
     artifactsBaseDir = resolvePath(trimmed);
   }
-  const inject = await resolveInjectScript2(options.inject, output);
-  const match = {};
-  if (matchUrl) {
-    match.url = matchUrl;
-  }
-  if (options.type?.trim()) {
-    match.type = options.type.trim();
-  }
-  if (options.origin?.trim()) {
-    match.origin = options.origin.trim();
-  }
-  if (options.target?.trim()) {
-    match.targetId = options.target.trim();
-  }
-  if (options.parent?.trim()) {
-    match.parent = options.parent.trim();
-  }
-  let handle37;
+  const inject = await resolveInjectScript(options.inject, output);
+  const match = sourceMode === "cdp" ? buildWatcherMatch(options) : undefined;
+  let handle38;
   try {
-    handle37 = await startWatcher({
+    handle38 = await startWatcher({
       id: watcherId,
       source: sourceMode,
-      match: sourceMode === "cdp" && Object.keys(match).length > 0 ? match : undefined,
+      match,
       chrome: sourceMode === "cdp" ? { host: chromeHost, port: chromePort } : undefined,
       host: "127.0.0.1",
       port: 0,
+      net: { enabled: true },
       pageIndicator: options.pageIndicator === false ? { enabled: false } : { enabled: true },
       artifacts: artifactsBaseDir ? { base: artifactsBaseDir } : undefined,
       pageConsoleLogging: options.pageConsoleLogging,
@@ -12291,37 +12562,32 @@ var runWatcherStart = async (options) => {
     return;
   }
   const result = {
-    id: handle37.watcher.id,
-    host: handle37.watcher.host,
-    port: handle37.watcher.port,
-    pid: handle37.watcher.pid,
+    id: handle38.watcher.id,
+    host: handle38.watcher.host,
+    port: handle38.watcher.port,
+    pid: handle38.watcher.pid,
     source: sourceMode,
-    matchUrl: match.url,
-    matchType: match.type,
-    matchOrigin: match.origin,
-    matchTarget: match.targetId,
-    matchParent: match.parent,
+    matchUrl: match?.url,
+    matchType: match?.type,
+    matchOrigin: match?.origin,
+    matchTarget: match?.targetId,
+    matchParent: match?.parent,
     chromeHost,
     chromePort,
     artifactsBaseDir
   };
   const cleanup = async () => {
     try {
-      await handle37.close();
+      await handle38.close();
     } catch {}
   };
-  process.on("SIGINT", () => {
-    cleanup().then(() => process.exit(0));
-  });
-  process.on("SIGTERM", () => {
-    cleanup().then(() => process.exit(0));
-  });
-  handle37.events.on("cdpAttached", ({ target }) => {
+  registerTerminationHandlers(cleanup);
+  handle38.events.on("cdpAttached", ({ target }) => {
     const typeInfo = target?.type ? ` (type: ${target.type})` : "";
-    output.writeHuman(`[${handle37.watcher.id}] CDP attached: ${target?.title} (${target?.url})${typeInfo}`);
+    output.writeHuman(`[${handle38.watcher.id}] CDP attached: ${target?.title} (${target?.url})${typeInfo}`);
   });
-  handle37.events.on("cdpDetached", ({ reason, target }) => {
-    output.writeHuman(`[${handle37.watcher.id}] CDP detached: ${reason} (last target: ${target?.title})`);
+  handle38.events.on("cdpDetached", ({ reason, target }) => {
+    output.writeHuman(`[${handle38.watcher.id}] CDP detached: ${reason} (last target: ${target?.title})`);
   });
   if (options.json) {
     output.writeJson(result);
@@ -12353,7 +12619,7 @@ var runWatcherStart = async (options) => {
       output.writeHuman(`  artifacts=${result.artifactsBaseDir}`);
     }
   }
-  await new Promise(() => {});
+  await waitForever();
 };
 var generateWatcherId = () => crypto2.randomBytes(3).toString("hex");
 
@@ -12533,23 +12799,24 @@ var checkWatcherReachable = async (watcher) => {
 // dist/commands/watcherNativeHost.js
 var runWatcherNativeHost = async (options) => {
   const watcherId = options.id?.trim() || "extension";
-  let handle37;
+  let handle38;
   try {
-    handle37 = await startWatcher({
+    handle38 = await startWatcher({
       id: watcherId,
       source: "extension",
       host: "127.0.0.1",
       port: 0,
+      net: { enabled: true },
       pageIndicator: { enabled: true }
     });
   } catch (error) {
     console.error(`Failed to start watcher: ${error instanceof Error ? error.message : error}`);
     process.exit(1);
   }
-  console.error(`[NativeHost] Watcher started: id=${handle37.watcher.id} port=${handle37.watcher.port}`);
+  console.error(`[NativeHost] Watcher started: id=${handle38.watcher.id} port=${handle38.watcher.port}`);
   const cleanup = async () => {
     try {
-      await handle37.close();
+      await handle38.close();
     } catch {}
   };
   process.on("SIGINT", () => {
@@ -12688,100 +12955,6 @@ var parseParamsString = (value) => {
 var isHttpUrl = (url) => {
   return url.startsWith("http://") || url.startsWith("https://");
 };
-var getWebSocketCtor2 = () => {
-  const ctor = globalThis.WebSocket;
-  return ctor ?? null;
-};
-var toMessageText2 = (data) => {
-  if (typeof data === "string") {
-    return data;
-  }
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data).toString("utf8");
-  }
-  if (Buffer.isBuffer(data)) {
-    return data.toString("utf8");
-  }
-  return null;
-};
-var sendCdpCommand2 = async (wsUrl, payload, timeoutMs = 5000) => {
-  const WebSocketConstructor = getWebSocketCtor2();
-  if (!WebSocketConstructor) {
-    throw new Error("WebSocket unavailable. Node 18+ required.");
-  }
-  const ws = new WebSocketConstructor(wsUrl);
-  const requestId = payload.id;
-  await new Promise((resolve2, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        try {
-          ws.close();
-        } catch {}
-        reject(new Error(`CDP command timed out after ${timeoutMs}ms`));
-      }
-    }, timeoutMs);
-    const cleanup = () => {
-      clearTimeout(timer);
-      ws.removeEventListener?.("open", onOpen);
-      ws.removeEventListener?.("message", onMessage);
-      ws.removeEventListener?.("error", onError);
-      ws.removeEventListener?.("close", onClose);
-    };
-    const finish = (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      try {
-        ws.close();
-      } catch {}
-      if (error) {
-        reject(error);
-      } else {
-        resolve2();
-      }
-    };
-    const onOpen = () => {
-      try {
-        ws.send(JSON.stringify(payload));
-      } catch (error) {
-        finish(error instanceof Error ? error : new Error(String(error)));
-      }
-    };
-    const onMessage = (event) => {
-      const text = toMessageText2(event.data);
-      if (!text) {
-        return;
-      }
-      try {
-        const message = JSON.parse(text);
-        if (message.id !== requestId) {
-          return;
-        }
-        if (message.error?.message) {
-          finish(new Error(message.error.message));
-          return;
-        }
-        finish();
-      } catch (error) {
-        finish(error instanceof Error ? error : new Error(String(error)));
-      }
-    };
-    const onError = () => {
-      finish(new Error("WebSocket error"));
-    };
-    const onClose = () => {
-      finish(new Error("WebSocket closed before response"));
-    };
-    ws.addEventListener("open", onOpen);
-    ws.addEventListener("message", onMessage);
-    ws.addEventListener("error", onError);
-    ws.addEventListener("close", onClose);
-  });
-};
 var runPageReload = async (options) => {
   const output = createOutput(options);
   const hasParamFlag = (options.param?.length ?? 0) > 0;
@@ -12885,7 +13058,7 @@ var reloadTarget = async (target, context) => {
   }
   if (!context.hasParamFlag && !context.hasParamsFlag) {
     try {
-      await sendCdpCommand2(target.webSocketDebuggerUrl, { id: 1, method: "Page.reload" });
+      await sendCdpCommand(target.webSocketDebuggerUrl, { id: 1, method: "Page.reload" });
     } catch (error) {
       output.writeWarn(`Failed to reload target ${target.id}: ${error instanceof Error ? error.message : error}`);
       process.exitCode = 1;
@@ -12941,7 +13114,7 @@ var reloadTarget = async (target, context) => {
   }
   const nextUrl = parsedUrl.toString();
   try {
-    await sendCdpCommand2(target.webSocketDebuggerUrl, { id: 1, method: "Page.navigate", params: { url: nextUrl } });
+    await sendCdpCommand(target.webSocketDebuggerUrl, { id: 1, method: "Page.navigate", params: { url: nextUrl } });
   } catch (error) {
     output.writeWarn(`Failed to navigate target ${target.id}: ${error instanceof Error ? error.message : error}`);
     process.exitCode = 1;
@@ -13341,10 +13514,8 @@ var parseDurationMs = (value) => {
   return amount * multiplier;
 };
 
-// dist/commands/logs.js
-var runLogs = async (id, options) => {
-  const output = createOutput(options);
-  const params = new URLSearchParams;
+// dist/watchers/queryParams.js
+var appendAfterLimitParams = (params, options) => {
   const after = parseNumber(options.after);
   if (after != null) {
     params.set("after", String(after));
@@ -13353,19 +13524,38 @@ var runLogs = async (id, options) => {
   if (limit != null) {
     params.set("limit", String(limit));
   }
+};
+var appendSinceParam = (params, since) => {
+  const resolved = resolveSinceTimestamp(since);
+  if (resolved.error) {
+    return resolved;
+  }
+  if (resolved.sinceTs == null) {
+    return {};
+  }
+  params.set("sinceTs", String(resolved.sinceTs));
+  return {};
+};
+var resolveSinceTimestamp = (since) => {
+  if (!since) {
+    return { sinceTs: null };
+  }
+  const duration = parseDurationMs(since);
+  if (!duration) {
+    return { sinceTs: null, error: `Invalid --since value: ${since}` };
+  }
+  return { sinceTs: Date.now() - duration };
+};
+var appendLogFilterParams = (params, options) => {
   if (options.levels) {
     params.set("levels", options.levels);
   }
-  const normalizedMatch = normalizeMatch(options.match);
+  const normalizedMatch = normalizeMatchPatterns2(options.match);
   if (normalizedMatch.error) {
-    output.writeWarn(normalizedMatch.error);
-    process.exitCode = 2;
-    return;
+    return normalizedMatch;
   }
-  if (normalizedMatch.match) {
-    for (const pattern of normalizedMatch.match) {
-      params.append("match", pattern);
-    }
+  for (const pattern of normalizedMatch.patterns) {
+    params.append("match", pattern);
   }
   const matchCase = resolveMatchCase2(options);
   if (matchCase) {
@@ -13375,14 +13565,50 @@ var runLogs = async (id, options) => {
   if (source) {
     params.set("source", source);
   }
-  if (options.since) {
-    const duration = parseDurationMs(options.since);
-    if (!duration) {
-      output.writeWarn(`Invalid --since value: ${options.since}`);
-      process.exitCode = 2;
-      return;
-    }
-    params.set("sinceTs", String(Date.now() - duration));
+  return {};
+};
+var appendNetFilterParams = (params, options) => {
+  const grep = normalizeQueryValue(options.grep);
+  if (grep) {
+    params.set("grep", grep);
+  }
+};
+var normalizeMatchPatterns2 = (match) => {
+  if (!match || match.length === 0) {
+    return { patterns: [] };
+  }
+  const patterns = match.map((value) => value.trim());
+  if (patterns.some((value) => value.length === 0)) {
+    return { patterns: [], error: "Invalid --match value: empty pattern." };
+  }
+  return { patterns };
+};
+var resolveMatchCase2 = (options) => {
+  if (options.caseSensitive) {
+    return "sensitive";
+  }
+  if (options.ignoreCase) {
+    return "insensitive";
+  }
+  return;
+};
+
+// dist/commands/logs.js
+var runLogs = async (id, options) => {
+  const output = createOutput(options);
+  const params = new URLSearchParams;
+  appendAfterLimitParams(params, options);
+  const filters = appendLogFilterParams(params, options);
+  if (filters.error) {
+    output.writeWarn(filters.error);
+    process.exitCode = 2;
+    return;
+  }
+  const since = appendSinceParam(params, options.since);
+  if (since.error) {
+    output.writeWarn(since.error);
+    process.exitCode = 2;
+    return;
   }
   const result = await requestWatcherJson({
     id,
@@ -13409,26 +13635,6 @@ var runLogs = async (id, options) => {
     }));
   }
 };
-var normalizeMatch = (match) => {
-  if (!match || match.length === 0) {
-    return {};
-  }
-  const normalized = match.map((value) => value.trim());
-  const invalid = normalized.find((value) => value.length === 0);
-  if (invalid != null) {
-    return { error: "Invalid --match value: empty pattern." };
-  }
-  return { match: normalized };
-};
-var resolveMatchCase2 = (options) => {
-  if (options.caseSensitive) {
-    return "sensitive";
-  }
-  if (options.ignoreCase) {
-    return "insensitive";
-  }
-  return;
-};
 
 // dist/commands/tail.js
 var runTail = async (id, options) => {
@@ -13453,34 +13659,18 @@ var runTail = async (id, options) => {
     if (limit != null) {
       params.set("limit", String(limit));
     }
-    if (options.levels) {
-      params.set("levels", options.levels);
-    }
-    const normalizedMatch = normalizeMatch2(options.match);
-    if (normalizedMatch.error) {
-      output.writeWarn(normalizedMatch.error);
+    const filters = appendLogFilterParams(params, options);
+    if (filters.error) {
+      output.writeWarn(filters.error);
       process.exitCode = 2;
       return;
     }
-    if (normalizedMatch.match) {
-      for (const pattern of normalizedMatch.match) {
-        params.append("match", pattern);
-      }
-    }
-    const matchCase = resolveMatchCase3(options);
-    if (matchCase) {
-      params.set("matchCase", matchCase);
-    }
-    const source = normalizeQueryValue(options.source);
-    if (source) {
-      params.set("source", source);
-    }
-    const url = `http://${watcher.host}:${watcher.port}/tail?${params.toString()}`;
+    const url = buildWatcherUrl(watcher, "/tail", params);
     let response;
     try {
       response = await fetchJson(url, { timeoutMs: timeoutMs + 5000 });
     } catch (error) {
-      output.writeWarn(`${watcher.id}: failed to reach watcher (${formatError(error)})`);
+      output.writeWarn(formatWatcherTransportError(watcher, error));
       process.exitCode = 1;
       return;
     }
@@ -13503,26 +13693,6 @@ var runTail = async (id, options) => {
     after = response.nextAfter;
   }
 };
-var normalizeMatch2 = (match) => {
-  if (!match || match.length === 0) {
-    return {};
-  }
-  const normalized = match.map((value) => value.trim());
-  const invalid = normalized.find((value) => value.length === 0);
-  if (invalid != null) {
-    return { error: "Invalid --match value: empty pattern." };
-  }
-  return { match: normalized };
-};
-var resolveMatchCase3 = (options) => {
-  if (options.caseSensitive) {
-    return "sensitive";
-  }
-  if (options.ignoreCase) {
-    return "insensitive";
-  }
-  return;
-};
 
 // dist/cli/register/registerLogs.js
 function registerLogs(program2) {
@@ -13572,26 +13742,13 @@ Examples:
 var runNet = async (id, options) => {
   const output = createOutput(options);
   const params = new URLSearchParams;
-  const after = parseNumber(options.after);
-  if (after != null) {
-    params.set("after", String(after));
-  }
-  const limit = parseNumber(options.limit);
-  if (limit != null) {
-    params.set("limit", String(limit));
-  }
-  if (options.since) {
-    const duration = parseDurationMs(options.since);
-    if (!duration) {
-      output.writeWarn(`Invalid --since value: ${options.since}`);
-      process.exitCode = 2;
-      return;
-    }
-    params.set("sinceTs", String(Date.now() - duration));
-  }
-  const grep = normalizeQueryValue(options.grep);
-  if (grep) {
-    params.set("grep", grep);
+  appendAfterLimitParams(params, options);
+  appendNetFilterParams(params, options);
+  const since = appendSinceParam(params, options.since);
+  if (since.error) {
+    output.writeWarn(since.error);
+    process.exitCode = 2;
+    return;
   }
   const result = await requestWatcherJson({
     id,
@@ -13622,14 +13779,12 @@ var runNetTail = async (id, options) => {
   let after = parseNumber(options.after) ?? 0;
   const timeoutMs = parseNumber(options.timeout) ?? 25000;
   const limit = parseNumber(options.limit);
-  const sinceTsResult = resolveSinceTs(options.since);
-  if (sinceTsResult.error) {
-    output.writeWarn(sinceTsResult.error);
+  const since = resolveSinceTimestamp(options.since);
+  if (since.error) {
+    output.writeWarn(since.error);
     process.exitCode = 2;
     return;
   }
-  const sinceTs = sinceTsResult.value;
-  const grep = normalizeQueryValue(options.grep);
   let running = true;
   const stop = () => {
     running = false;
@@ -13643,18 +13798,16 @@ var runNetTail = async (id, options) => {
     if (limit != null) {
       params.set("limit", String(limit));
     }
-    if (sinceTs != null) {
-      params.set("sinceTs", String(sinceTs));
-    }
-    if (grep) {
-      params.set("grep", grep);
+    if (since.sinceTs != null) {
+      params.set("sinceTs", String(since.sinceTs));
     }
-    const url = `http://${watcher.host}:${watcher.port}/net/tail?${params.toString()}`;
+    appendNetFilterParams(params, options);
+    const url = buildWatcherUrl(watcher, "/net/tail", params);
     let response;
     try {
       response = await fetchJson(url, { timeoutMs: timeoutMs + 5000 });
     } catch (error) {
-      output.writeWarn(`${watcher.id}: failed to reach watcher (${formatError(error)})`);
+      output.writeWarn(formatWatcherTransportError(watcher, error));
       process.exitCode = 1;
       return;
     }
@@ -13670,16 +13823,6 @@ var runNetTail = async (id, options) => {
     after = response.nextAfter;
   }
 };
-var resolveSinceTs = (value) => {
-  if (!value) {
-    return { value: null };
-  }
-  const duration = parseDurationMs(value);
-  if (!duration) {
-    return { value: null, error: `Invalid --since value: ${value}` };
-  }
-  return { value: Date.now() - duration };
-};
 
 // dist/cli/register/registerNet.js
 function registerNet(program2) {
@@ -13701,9 +13844,197 @@ Examples:
   });
 }
 
+// dist/commands/auth.js
+import { writeFile } from "node:fs/promises";
+var COOKIE_EXPORT_FORMATS = new Set(["netscape", "json", "header"]);
+var runAuthCookies = async (id, options) => {
+  const output = createOutput(options);
+  const includeValues = options.showValues === true;
+  const response = await fetchAuthCookies(id, { domain: options.domain, includeValues }, output);
+  if (!response) {
+    return;
+  }
+  const cookies2 = filterCookies(response.origin, response.cookies, options);
+  if (options.json) {
+    output.writeJson({ ...response, cookies: cookies2 });
+    return;
+  }
+  if (cookies2.length === 0) {
+    output.writeHuman("No cookies matched.");
+    return;
+  }
+  for (const cookie of cookies2) {
+    output.writeHuman(formatCookieLine(cookie, includeValues));
+  }
+};
+var runAuthExportCookies = async (id, options) => {
+  const output = createOutput({});
+  const format = normalizeExportFormat(options.format);
+  if (!format) {
+    output.writeWarn(`Invalid --format value: ${options.format}. Expected one of: netscape, json, header.`);
+    process.exitCode = 2;
+    return;
+  }
+  const response = await fetchAuthCookies(id, { domain: options.domain, includeValues: true }, output);
+  if (!response) {
+    return;
+  }
+  const serialized = serializeCookies(filterCookies(response.origin, response.cookies, options), format);
+  await writeOutput(serialized, options.out);
+};
+var fetchAuthCookies = async (id, input, output) => {
+  const result = await requestWatcherJson({
+    id,
+    path: "/auth/cookies",
+    query: buildCookieQuery(input),
+    timeoutMs: 1e4
+  });
+  if (!result.ok) {
+    writeRequestError(result, output);
+    return null;
+  }
+  return result.data;
+};
+var buildCookieQuery = (input) => {
+  const params = new URLSearchParams;
+  if (input.domain?.trim()) {
+    params.set("domain", input.domain.trim());
+  }
+  if (input.includeValues) {
+    params.set("includeValues", "true");
+  }
+  return params;
+};
+var filterCookies = (origin, cookies2, options) => {
+  const originHost = options.forOrigin ? getOriginHost(origin) : null;
+  return cookies2.filter((cookie) => matchesCookieFilters(cookie, originHost, options));
+};
+var matchesCookieFilters = (cookie, originHost, options) => {
+  if (options.sessionOnly && !cookie.session) {
+    return false;
+  }
+  if (options.httpOnly && !cookie.httpOnly) {
+    return false;
+  }
+  if (options.secure && !cookie.secure) {
+    return false;
+  }
+  if (originHost && !matchesCookieDomain(cookie.domain, originHost)) {
+    return false;
+  }
+  if (options.excludeTracking && isTrackingCookieName(cookie.name)) {
+    return false;
+  }
+  return true;
+};
+var formatCookieLine = (cookie, showValues) => {
+  const flags = [formatExpiryFlag(cookie), cookie.httpOnly ? "httpOnly" : null, cookie.secure ? "secure" : null, formatSameSiteFlag(cookie)].filter(Boolean).join(",");
+  const value = resolveCookieValue(cookie, showValues);
+  const flagSuffix = flags ? ` [${flags}]` : "";
+  const valueSuffix = value ? ` ${value}` : "";
+  return `${cookie.name} ${cookie.domain}${cookie.path}${flagSuffix}${valueSuffix}`.trim();
+};
+var formatExpiryFlag = (cookie) => {
+  if (cookie.session) {
+    return "session";
+  }
+  if (cookie.expires != null) {
+    return `exp=${Math.trunc(cookie.expires)}`;
+  }
+  return null;
+};
+var formatSameSiteFlag = (cookie) => {
+  if (!cookie.sameSite) {
+    return null;
+  }
+  return `sameSite=${cookie.sameSite}`;
+};
+var resolveCookieValue = (cookie, showValues) => {
+  if (showValues && cookie.value != null) {
+    return cookie.value;
+  }
+  return cookie.valuePreview ?? "";
+};
+var normalizeExportFormat = (format) => {
+  if (!format)
+    return "netscape";
+  if (!COOKIE_EXPORT_FORMATS.has(format)) {
+    return null;
+  }
+  switch (format) {
+    case "netscape":
+    case "json":
+    case "header":
+      return format;
+    default:
+      return null;
+  }
+};
+var formatCookiesAsNetscape = (cookies2) => {
+  const lines = ["# Netscape HTTP Cookie File", "# This file was generated by Argus.", ""];
+  for (const cookie of cookies2) {
+    lines.push([
+      formatNetscapeDomain(cookie),
+      cookie.domain.startsWith(".") ? "TRUE" : "FALSE",
+      cookie.path,
+      cookie.secure ? "TRUE" : "FALSE",
+      String(cookie.session ? 0 : Math.max(0, Math.trunc(cookie.expires ?? 0))),
+      cookie.name,
+      cookie.value ?? ""
+    ].join("\t"));
+  }
+  return lines.join(`
+`);
+};
+var formatNetscapeDomain = (cookie) => cookie.httpOnly ? `#HttpOnly_${cookie.domain}` : cookie.domain;
+var formatCookiesAsHeader = (cookies2) => `Cookie: ${cookies2.map((cookie) => `${cookie.name}=${cookie.value ?? ""}`).join("; ")}`;
+var serializeCookies = (cookies2, format) => {
+  switch (format) {
+    case "netscape":
+      return formatCookiesAsNetscape(cookies2);
+    case "json":
+      return JSON.stringify(cookies2, null, 2);
+    case "header":
+      return formatCookiesAsHeader(cookies2);
+  }
+};
+var writeOutput = async (content, outPath) => {
+  const withTrailingNewline = content.endsWith(`
+`) ? content : `${content}
+`;
+  if (outPath) {
+    await writeFile(outPath, withTrailingNewline, "utf8");
+    return;
+  }
+  process.stdout.write(withTrailingNewline);
+};
+
+// dist/cli/register/registerAuth.js
+function registerAuth(program2) {
+  const auth = program2.command("auth").description("List and export browser auth cookies");
+  addCookieScopeOptions(auth.command("cookies"), "Only include first-party cookies for the attached page origin").argument("[id]", "Watcher id").description("List cookies for the attached page").option("--domain <domain>", "Filter cookies by domain suffix").option("--session-only", "Show only session cookies").option("--http-only", "Show only HttpOnly cookies").option("--secure", "Show only Secure cookies").option("--show-values", "Reveal raw cookie values instead of previews").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus auth cookies app
+  $ argus auth cookies app --for-origin --exclude-tracking
+  $ argus auth cookies app --domain example.com
+  $ argus auth cookies app --session-only --show-values
+`).action(async (id, options) => {
+    await runAuthCookies(id, options);
+  });
+  addCookieScopeOptions(auth.command("export-cookies"), "Only include first-party cookies for the attached page origin").argument("[id]", "Watcher id").description("Export cookies for companion CLIs and HTTP clients").option("--format <format>", "Export format: netscape (default), json, or header").option("--domain <domain>", "Filter cookies by domain suffix").option("--out <path>", "Write the export to a file instead of stdout").addHelpText("after", `
+Examples:
+  $ argus auth export-cookies app --format netscape
+  $ argus auth export-cookies app --for-origin --exclude-tracking
+  $ argus auth export-cookies app --format header
+  $ argus auth export-cookies app --out cookies.txt
+`).action(async (id, options) => {
+    await runAuthExportCookies(id, options);
+  });
+}
+var addCookieScopeOptions = (command, forOriginDescription) => command.option("--for-origin", forOriginDescription).option("--exclude-tracking", "Hide common analytics/tracking cookies such as _ga and _ym");
+
 // dist/eval/evalClient.js
 var evalOnce = async (input) => {
-  const url = `http://${input.watcher.host}:${input.watcher.port}/eval`;
   const body = {
     expression: input.expression,
     awaitPromise: input.awaitPromise,
@@ -13713,7 +14044,8 @@ var evalOnce = async (input) => {
   };
   let response;
   try {
-    response = await fetchJson(url, {
+    response = await fetchWatcherJson(input.watcher, {
+      path: "/eval",
       method: "POST",
       body,
       timeoutMs: input.timeoutMs ? input.timeoutMs + 5000 : 1e4
@@ -13722,7 +14054,7 @@ var evalOnce = async (input) => {
     return {
       ok: false,
       kind: "transport",
-      error: `${input.watcher.id}: failed to reach watcher (${formatError5(error)})`
+      error: formatWatcherTransportError(input.watcher, error)
     };
   }
   if (response.exception && input.failOnException) {
@@ -13759,19 +14091,10 @@ var evalWithRetries = async (input) => {
   return {
     ok: false,
     kind: "transport",
-    error: `${input.watcher.id}: failed to reach watcher (unknown error)`,
+    error: formatWatcherTransportError(input.watcher, "unknown error"),
     attempt
   };
 };
-var formatError5 = (error) => {
-  if (!error) {
-    return "unknown error";
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-};
 
 // dist/commands/evalShared.js
 import { readFile } from "node:fs/promises";
@@ -14211,7 +14534,7 @@ var parseTotalTimeout = (value) => {
 };
 
 // dist/commands/iframeHelper.js
-import * as fs10 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 var runIframeHelper = async (options) => {
   const script = generateIframeHelperScript({
     log: options.log ?? true,
@@ -14219,7 +14542,7 @@ var runIframeHelper = async (options) => {
     namespace: options.namespace ?? "argus"
   });
   if (options.out) {
-    await fs10.writeFile(options.out, script, "utf-8");
+    await fs9.writeFile(options.out, script, "utf-8");
     console.error(`Written to ${options.out}`);
   } else {
     process.stdout.write(script);
@@ -14986,7 +15309,7 @@ var runDomRemove = async (id, options) => {
 };
 
 // dist/commands/domSetFile.js
-import fs11 from "node:fs";
+import fs10 from "node:fs";
 var runDomSetFile = async (id, options) => {
   const output = createOutput(options);
   if (!options.selector || options.selector.trim() === "") {
@@ -15002,7 +15325,7 @@ var runDomSetFile = async (id, options) => {
   const files = [];
   for (const f of options.file) {
     const absolute = resolvePath(f);
-    if (!fs11.existsSync(absolute)) {
+    if (!fs10.existsSync(absolute)) {
       output.writeWarn(`File not found: ${absolute}`);
       process.exitCode = 2;
       return;
@@ -16499,9 +16822,9 @@ var runTraceStop = async (id, options) => {
   output.writeHuman(`Trace saved: ${stop.outFile} (${stop.eventCount} events, ${formatDurationMs(stop.durationMs)})`);
 };
 var runTraceStartInternal = async (watcher, options, output) => {
-  const url = `http://${watcher.host}:${watcher.port}/trace/start`;
   try {
-    const response = await fetchJson(url, {
+    const response = await fetchWatcherJson(watcher, {
+      path: "/trace/start",
       method: "POST",
       body: {
         outFile: options.out,
@@ -16512,22 +16835,22 @@ var runTraceStartInternal = async (watcher, options, output) => {
     });
     return response;
   } catch (error) {
-    output.writeWarn(`${watcher.id}: failed to reach watcher (${formatError(error)})`);
+    output.writeWarn(formatWatcherTransportError(watcher, error));
     process.exitCode = 1;
     return null;
   }
 };
 var runTraceStopInternal = async (watcher, options, output) => {
-  const url = `http://${watcher.host}:${watcher.port}/trace/stop`;
   try {
-    const response = await fetchJson(url, {
+    const response = await fetchWatcherJson(watcher, {
+      path: "/trace/stop",
       method: "POST",
       body: { traceId: options.traceId, outFile: options.outFile },
       timeoutMs: 20000
     });
     return response;
   } catch (error) {
-    output.writeWarn(`${watcher.id}: failed to reach watcher (${formatError(error)})`);
+    output.writeWarn(formatWatcherTransportError(watcher, error));
     process.exitCode = 1;
     return null;
   }
@@ -16576,7 +16899,7 @@ function resolveActionOptions(options, command) {
 }
 
 // dist/commands/configInit.js
-import fs12 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 import path11 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_CONFIG_PATH = ".argus/config.json";
@@ -16610,7 +16933,7 @@ var resolveConfigPath = (cwd, targetPath) => {
 var ensureParentDir2 = async (filePath) => {
   const dir = path11.dirname(filePath);
   try {
-    await fs12.mkdir(dir, { recursive: true });
+    await fs11.mkdir(dir, { recursive: true });
     return true;
   } catch (error) {
     console.error(`Failed to create config directory ${dir}: ${error instanceof Error ? error.message : String(error)}`);
@@ -16620,7 +16943,7 @@ var ensureParentDir2 = async (filePath) => {
 };
 var writeConfigFile = async (filePath, contents, force) => {
   try {
-    await fs12.writeFile(filePath, contents, { encoding: "utf8", flag: force ? "w" : "wx" });
+    await fs11.writeFile(filePath, contents, { encoding: "utf8", flag: force ? "w" : "wx" });
     return true;
   } catch (error) {
     if (error.code === "EEXIST") {
@@ -16635,7 +16958,7 @@ var writeConfigFile = async (filePath, contents, force) => {
 };
 var ensureSchemaFile = async (schemaPath) => {
   try {
-    const stats = await fs12.stat(schemaPath);
+    const stats = await fs11.stat(schemaPath);
     if (!stats.isFile()) {
       console.error(`Schema path is not a file: ${schemaPath}`);
       process.exitCode = 2;
@@ -16688,11 +17011,11 @@ Examples:
 }
 
 // dist/commands/extension/setup.js
-import fs14 from "node:fs";
+import fs13 from "node:fs";
 import { execSync as execSync2 } from "node:child_process";
 
 // dist/commands/extension/nativeHost.js
-import fs13 from "node:fs";
+import fs12 from "node:fs";
 import path12 from "node:path";
 import os4 from "node:os";
 import { execSync } from "node:child_process";
@@ -16726,7 +17049,7 @@ var findArgusExecutable = () => {
   try {
     const npmGlobalPrefix = execSync("npm config get prefix", { encoding: "utf8" }).trim();
     const globalBinPath = path12.join(npmGlobalPrefix, "bin", "argus");
-    if (fs13.existsSync(globalBinPath)) {
+    if (fs12.existsSync(globalBinPath)) {
       return globalBinPath;
     }
   } catch {}
@@ -16739,7 +17062,7 @@ var findArgusExecutable = () => {
   throw new Error("Could not find argus executable. Please install argus globally (npm install -g @vforsh/argus) or ensure it is in your PATH.");
 };
 var findNodePath = () => {
-  return fs13.realpathSync(process.execPath);
+  return fs12.realpathSync(process.execPath);
 };
 var createManifest = (extensionId, executablePath) => {
   return {
@@ -16757,12 +17080,12 @@ var createWrapperScript = (platform, executablePath) => {
   const script = `#!/bin/bash
 exec "${nodePath}" "${executablePath}" watcher native-host
 `;
-  fs13.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs12.writeFileSync(wrapperPath, script, { mode: 493 });
   return wrapperPath;
 };
 var readManifest = (manifestPath) => {
   try {
-    const content = fs13.readFileSync(manifestPath, "utf8");
+    const content = fs12.readFileSync(manifestPath, "utf8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -16770,7 +17093,7 @@ var readManifest = (manifestPath) => {
 };
 var isWrapperExecutable = (wrapperPath) => {
   try {
-    fs13.accessSync(wrapperPath, fs13.constants.X_OK);
+    fs12.accessSync(wrapperPath, fs12.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -16803,7 +17126,7 @@ var runExtensionSetup = async (options) => {
   const manifestDir = getManifestDir(platform);
   const manifestPath = getManifestPath(platform);
   const wrapperPath = getWrapperPath(platform);
-  fs14.mkdirSync(manifestDir, { recursive: true });
+  fs13.mkdirSync(manifestDir, { recursive: true });
   let executablePath;
   try {
     executablePath = findArgusExecutable();
@@ -16818,7 +17141,7 @@ var runExtensionSetup = async (options) => {
   }
   createWrapperScript(platform, executablePath);
   const manifest = createManifest(extensionId, wrapperPath);
-  fs14.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  fs13.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   if (platform === "win32") {
     const regKey = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${HOST_NAME}`;
     try {
@@ -16859,7 +17182,7 @@ var runExtensionSetup = async (options) => {
 };
 
 // dist/commands/extension/remove.js
-import fs15 from "node:fs";
+import fs14 from "node:fs";
 import { execSync as execSync3 } from "node:child_process";
 var runExtensionRemove = async (options) => {
   const output = createOutput(options);
@@ -16879,12 +17202,12 @@ var runExtensionRemove = async (options) => {
   const wrapperPath = getWrapperPath(platform);
   let manifestRemoved = false;
   let wrapperRemoved = false;
-  if (fs15.existsSync(manifestPath)) {
-    fs15.unlinkSync(manifestPath);
+  if (fs14.existsSync(manifestPath)) {
+    fs14.unlinkSync(manifestPath);
     manifestRemoved = true;
   }
-  if (fs15.existsSync(wrapperPath)) {
-    fs15.unlinkSync(wrapperPath);
+  if (fs14.existsSync(wrapperPath)) {
+    fs14.unlinkSync(wrapperPath);
     wrapperRemoved = true;
   }
   if (platform === "win32") {
@@ -16923,7 +17246,7 @@ var runExtensionRemove = async (options) => {
 };
 
 // dist/commands/extension/status.js
-import fs16 from "node:fs";
+import fs15 from "node:fs";
 var runExtensionStatus = async (options) => {
   const output = createOutput(options);
   let platform;
@@ -16940,8 +17263,8 @@ var runExtensionStatus = async (options) => {
   }
   const manifestPath = getManifestPath(platform);
   const wrapperPath = getWrapperPath(platform);
-  const manifestExists = fs16.existsSync(manifestPath);
-  const wrapperExists = fs16.existsSync(wrapperPath);
+  const manifestExists = fs15.existsSync(manifestPath);
+  const wrapperExists = fs15.existsSync(wrapperPath);
   const wrapperExecutable = wrapperExists && isWrapperExecutable(wrapperPath);
   let manifest = null;
   let manifestValid = false;
@@ -17001,7 +17324,7 @@ var runExtensionStatus = async (options) => {
 };
 
 // dist/commands/extension/info.js
-import fs17 from "node:fs";
+import fs16 from "node:fs";
 var runExtensionInfo = async (options) => {
   const output = createOutput(options);
   let platform;
@@ -17018,8 +17341,8 @@ var runExtensionInfo = async (options) => {
   }
   const manifestPath = getManifestPath(platform);
   const wrapperPath = getWrapperPath(platform);
-  const manifestExists = fs17.existsSync(manifestPath);
-  const wrapperExists = fs17.existsSync(wrapperPath);
+  const manifestExists = fs16.existsSync(manifestPath);
+  const wrapperExists = fs16.existsSync(wrapperPath);
   let extensionId = null;
   let argusPath = null;
   if (manifestExists) {
@@ -27338,7 +27661,7 @@ function hr2(a2, t, e) {
   }
   return t;
 }
-var fs18 = hr2;
+var fs17 = hr2;
 function cr2(a2, t) {
   return t === false ? false : a2.charAt(t) === "/" && a2.charAt(t + 1) === "/" ? ls(a2, t) : t;
 }
@@ -27346,7 +27669,7 @@ var ds = cr2;
 function lr2(a2, t) {
   let e = null, s = t;
   for (;s !== e; )
-    e = s, s = cs(a2, s), s = ps(a2, s), s = ds(a2, s), s = fs18(a2, s);
+    e = s, s = cs(a2, s), s = ps(a2, s), s = ds(a2, s), s = fs17(a2, s);
   return s;
 }
 var ms = lr2;
@@ -29346,13 +29669,13 @@ function kc({ node: e, parent: t }) {
   let r = /^[fx]?(?:describe|it|test)$/u;
   return t.type === "TaggedTemplateExpression" && t.quasi === e && t.tag.type === "MemberExpression" && t.tag.property.type === "Identifier" && t.tag.property.name === "each" && (t.tag.object.type === "Identifier" && r.test(t.tag.object.name) || t.tag.object.type === "MemberExpression" && t.tag.object.property.type === "Identifier" && (t.tag.object.property.name === "only" || t.tag.object.property.name === "skip") && t.tag.object.object.type === "Identifier" && r.test(t.tag.object.object.name));
 }
-var fs19 = [(e, t) => e.type === "ObjectExpression" && t === "properties", (e, t) => e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component" && t === "arguments", (e, t) => e.type === "Decorator" && t === "expression"];
+var fs18 = [(e, t) => e.type === "ObjectExpression" && t === "properties", (e, t) => e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component" && t === "arguments", (e, t) => e.type === "Decorator" && t === "expression"];
 function oo2(e) {
   let t = (n) => n.type === "TemplateLiteral", r = (n, s) => Oe3(n) && !n.computed && n.key.type === "Identifier" && n.key.name === "styles" && s === "value";
-  return e.match(t, (n, s) => q3(n) && s === "elements", r, ...fs19) || e.match(t, r, ...fs19);
+  return e.match(t, (n, s) => q3(n) && s === "elements", r, ...fs18) || e.match(t, r, ...fs18);
 }
 function ys2(e) {
-  return e.match((t) => t.type === "TemplateLiteral", (t, r) => Oe3(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...fs19);
+  return e.match((t) => t.type === "TemplateLiteral", (t, r) => Oe3(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...fs18);
 }
 function Ds2(e, t) {
   return T3(e, x2.Block | x2.Leading, ({ value: r }) => r === ` ${t} `);
@@ -33259,7 +33582,7 @@ var ft4 = w4((gx, Mi3) => {
   ct4.default = ct4;
 });
 var fe3 = w4((wx, zi3) => {
-  var Bi3 = Me4(), Ui3 = ft4(), Fc2 = ut4(), { isClean: Fi3, my: $i3 } = Ht4(), fs20, Wi3, Gi3, ps3;
+  var Bi3 = Me4(), Ui3 = ft4(), Fc2 = ut4(), { isClean: Fi3, my: $i3 } = Ht4(), fs19, Wi3, Gi3, ps3;
   function Yi3(t) {
     return t.map((e) => (e.nodes && (e.nodes = Yi3(e.nodes)), delete e.source, e));
   }
@@ -33358,7 +33681,7 @@ var fe3 = w4((wx, zi3) => {
       } else if (e.selector || e.selectors)
         e = [new ps3(e)];
       else if (e.name)
-        e = [new fs20(e)];
+        e = [new fs19(e)];
       else if (e.text)
         e = [new Bi3(e)];
       else
@@ -33460,7 +33783,7 @@ var fe3 = w4((wx, zi3) => {
     ps3 = t;
   };
   z3.registerAtRule = (t) => {
-    fs20 = t;
+    fs19 = t;
   };
   z3.registerRoot = (t) => {
     Gi3 = t;
@@ -33468,7 +33791,7 @@ var fe3 = w4((wx, zi3) => {
   zi3.exports = z3;
   z3.default = z3;
   z3.rebuild = (t) => {
-    t.type === "atrule" ? Object.setPrototypeOf(t, fs20.prototype) : t.type === "rule" ? Object.setPrototypeOf(t, ps3.prototype) : t.type === "decl" ? Object.setPrototypeOf(t, Ui3.prototype) : t.type === "comment" ? Object.setPrototypeOf(t, Bi3.prototype) : t.type === "root" && Object.setPrototypeOf(t, Gi3.prototype), t[$i3] = true, t.nodes && t.nodes.forEach((e) => {
+    t.type === "atrule" ? Object.setPrototypeOf(t, fs19.prototype) : t.type === "rule" ? Object.setPrototypeOf(t, ps3.prototype) : t.type === "decl" ? Object.setPrototypeOf(t, Ui3.prototype) : t.type === "comment" ? Object.setPrototypeOf(t, Bi3.prototype) : t.type === "root" && Object.setPrototypeOf(t, Gi3.prototype), t[$i3] = true, t.nodes && t.nodes.forEach((e) => {
       z3.rebuild(e);
     });
   };
@@ -38432,7 +38755,7 @@ var readQuotedLiteral = (source, startIndex, startLineNumber, quote) => {
   return { value: null, nextIndex: index, lineNumber, startLineNumber };
 };
 var classifyCodeString = (value, includeAll) => {
-  if (/[\u0000-\u001f]/.test(value)) {
+  if (hasControlChars(value)) {
     return null;
   }
   const kind = detectInterestingKind(value);
@@ -38456,6 +38779,14 @@ var detectInterestingKind = (value) => {
   }
   return null;
 };
+var hasControlChars = (value) => {
+  for (let index = 0;index < value.length; index += 1) {
+    if (value.charCodeAt(index) < 32) {
+      return true;
+    }
+  }
+  return false;
+};
 var rankCodeStrings = (matches) => matches.map((match) => ({
   ...match,
   score: scoreCodeString(match)
@@ -39007,6 +39338,7 @@ registerWatcher(program2);
 registerPage(program2);
 registerLogs(program2);
 registerNet(program2);
+registerAuth(program2);
 registerEval(program2);
 registerCode(program2);
 registerDom(program2);