@vforsh/argus 0.1.10 → 0.1.11

package/dist/argus.js

@@ -2131,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") {
@@ -2606,38 +2606,7 @@ var getOriginHost = (origin) => {
 };
 var isTrackingCookieName = (name) => TRACKING_COOKIE_PATTERNS.some((pattern) => pattern.test(name));
 var normalizeCookieDomain = (domain) => domain.trim().toLowerCase().replace(/^\./, "");
-// dist/registry.js
-var loadRegistry = async () => {
-  const { registry: registry2, warnings } = await readRegistry();
-  for (const warning of warnings) {
-    console.error(warning);
-  }
-  return registry2;
-};
-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 updateRegistry((registry2) => {
-    let next = registry2;
-    for (const id of ids) {
-      next = removeWatcherEntry(next, id);
-    }
-    return next;
-  });
-};
-
-// dist/httpClient.js
+// ../argus-core/dist/http/fetch.js
 var fetchJson = async (url, options = {}) => {
   const controller = new AbortController;
   const timeoutMs = options.timeoutMs ?? 5000;
@@ -2667,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;
@@ -2710,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
@@ -2847,151 +2801,49 @@ var createOutput = (options) => {
     writeWarn
   };
 };
-
-// dist/commands/chrome.js
-import { execFile } from "node:child_process";
-
-// dist/cdp/resolveCdpEndpoint.js
-var parsePort = (value) => {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
-    return null;
-  }
-  return parsed;
-};
-var parseCdpOption = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return { error: "Invalid --cdp value: empty host:port." };
-  }
-  const separator = trimmed.lastIndexOf(":");
-  if (separator <= 0 || separator === trimmed.length - 1) {
-    return { error: `Invalid --cdp value "${value}": expected <host:port>.` };
-  }
-  const host = trimmed.slice(0, separator);
-  const portValue = trimmed.slice(separator + 1);
-  const port = parsePort(portValue);
-  if (port == null) {
-    return { error: `Invalid --cdp port: ${portValue}. Must be an integer 1-65535.` };
-  }
-  return { host, port };
-};
-var resolveCdpEndpoint = async (options) => {
-  if (options.cdp && options.id) {
-    return { ok: false, error: "Cannot combine --cdp with --id.", exitCode: 2 };
-  }
-  if (options.cdp) {
-    const parsed = parseCdpOption(options.cdp);
-    if ("error" in parsed) {
-      return { ok: false, error: parsed.error, exitCode: 2 };
-    }
-    return { ok: true, host: parsed.host, port: parsed.port };
+// dist/cli/parse.js
+var formatError = (error) => {
+  if (!error) {
+    return "unknown error";
   }
-  if (options.id != null) {
-    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 watcher = registry2.watchers[options.id];
-    if (!watcher) {
-      return { ok: false, error: `Watcher not found: ${options.id}`, exitCode: 2 };
-    }
-    if (!watcher.chrome) {
-      return { ok: false, error: `Watcher "${options.id}" has no chrome connection configured.`, exitCode: 2 };
-    }
-    return { ok: true, host: watcher.chrome.host, port: watcher.chrome.port };
+  if (error instanceof Error) {
+    return error.message;
   }
-  return { ok: true, host: "127.0.0.1", port: 9222 };
+  return String(error);
 };
-
-// dist/cdp/selectTarget.js
-var normalizeFilter = (value) => {
+var parseNumber = (value) => {
   if (!value) {
-    return null;
+    return;
   }
-  const trimmed = value.trim();
-  return trimmed ? trimmed.toLowerCase() : null;
-};
-var filterTargets = (targets, filters) => {
-  const title = normalizeFilter(filters.title);
-  const url = normalizeFilter(filters.url);
-  const match = normalizeFilter(filters.match);
-  if (!title && !url && !match) {
-    return targets;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return;
   }
-  return targets.filter((target) => {
-    const targetTitle = (target.title ?? "").toLowerCase();
-    const targetUrl = (target.url ?? "").toLowerCase();
-    const combined = `${targetTitle} ${targetUrl}`.trim();
-    if (title && !targetTitle.includes(title)) {
-      return false;
-    }
-    if (url && !targetUrl.includes(url)) {
-      return false;
-    }
-    if (match && !combined.includes(match)) {
-      return false;
-    }
-    return true;
-  });
+  return parsed;
 };
-var selectTargetFromCandidates = async (candidates, output, options) => {
-  if (candidates.length === 0) {
-    return { ok: false, error: options.messages.empty, exitCode: 2 };
-  }
-  if (candidates.length === 1) {
-    return { ok: true, target: candidates[0] };
-  }
-  if (!options.interactive) {
-    writeCandidateList(candidates, output);
-    return { ok: false, error: options.messages.ambiguous, exitCode: 2 };
-  }
-  writeCandidateList(candidates, output, true);
-  output.writeHuman("Select target by number or id:");
-  const selection = await readLineOnce();
-  if (!selection) {
-    return { ok: false, error: "No selection provided.", exitCode: 2 };
+var parsePositiveInt = (value, options) => {
+  if (value === undefined) {
+    return;
   }
-  const numeric = Number.parseInt(selection, 10);
-  if (Number.isFinite(numeric) && numeric >= 1 && numeric <= candidates.length) {
-    return { ok: true, target: candidates[numeric - 1] };
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+    return;
   }
-  const byId = candidates.find((candidate) => candidate.id === selection);
-  if (byId) {
-    return { ok: true, target: byId };
+  const min = options?.allowZero ? 0 : 1;
+  if (parsed < min) {
+    return;
   }
-  return { ok: false, error: "Invalid selection.", exitCode: 2 };
+  return parsed;
 };
-var writeCandidateList = (candidates, output, numbered = false) => {
-  for (const [index, target] of candidates.entries()) {
-    const indexLabel = numbered ? `[${index + 1}] ` : "";
-    const title = target.title ? ` ${target.title}` : "";
-    const targetUrl = target.url ? ` ${target.url}` : "";
-    output.writeHuman(`${indexLabel}${target.id} ${target.type}${title}${targetUrl}`);
+var normalizeQueryValue = (value) => {
+  if (value == null) {
+    return;
   }
-};
-var readLineOnce = async () => {
-  return await new Promise((resolve) => {
-    const onData = (data) => {
-      cleanup();
-      resolve(data.toString("utf8").trim());
-    };
-    const onError = () => {
-      cleanup();
-      resolve("");
-    };
-    const cleanup = () => {
-      process.stdin.off("data", onData);
-      process.stdin.off("error", onError);
-      process.stdin.pause();
-    };
-    process.stdin.setEncoding("utf8");
-    process.stdin.once("data", onData);
-    process.stdin.once("error", onError);
-    process.stdin.resume();
-  });
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return;
+  }
+  return trimmed;
 };
 
 // dist/watchers/resolveWatcher.js
@@ -3032,22 +2884,139 @@ var resolveWatcher = async (input) => {
   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 });
+    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
-var normalizeUrl = (url) => {
-  if (url.startsWith("http://") || url.startsWith("https://")) {
-    return url;
+import { execFile } from "node:child_process";
+
+// dist/cdp/resolveCdpEndpoint.js
+var parsePort = (value) => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+    return null;
   }
-  return `http://${url}`;
+  return parsed;
+};
+var parseCdpOption = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return { error: "Invalid --cdp value: empty host:port." };
+  }
+  const separator = trimmed.lastIndexOf(":");
+  if (separator <= 0 || separator === trimmed.length - 1) {
+    return { error: `Invalid --cdp value "${value}": expected <host:port>.` };
+  }
+  const host = trimmed.slice(0, separator);
+  const portValue = trimmed.slice(separator + 1);
+  const port = parsePort(portValue);
+  if (port == null) {
+    return { error: `Invalid --cdp port: ${portValue}. Must be an integer 1-65535.` };
+  }
+  return { host, port };
 };
+var resolveCdpEndpoint = async (options) => {
+  if (options.cdp && options.id) {
+    return { ok: false, error: "Cannot combine --cdp with --id.", exitCode: 2 };
+  }
+  if (options.cdp) {
+    const parsed = parseCdpOption(options.cdp);
+    if ("error" in parsed) {
+      return { ok: false, error: parsed.error, exitCode: 2 };
+    }
+    return { ok: true, host: parsed.host, port: parsed.port };
+  }
+  if (options.id != null) {
+    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 watcher = registry2.watchers[options.id];
+    if (!watcher) {
+      return { ok: false, error: `Watcher not found: ${options.id}`, exitCode: 2 };
+    }
+    if (!watcher.chrome) {
+      return { ok: false, error: `Watcher "${options.id}" has no chrome connection configured.`, exitCode: 2 };
+    }
+    return { ok: true, host: watcher.chrome.host, port: watcher.chrome.port };
+  }
+  return { ok: true, host: "127.0.0.1", port: 9222 };
+};
+
+// dist/cdp/sendCdpCommand.js
 var getWebSocketCtor = () => {
   const ctor = globalThis.WebSocket;
   return ctor ?? null;
@@ -3100,9 +3069,9 @@ var sendCdpCommand = async (wsUrl, payload, timeoutMs = 5000) => {
       } catch {}
       if (error) {
         reject(error);
-      } else {
-        resolve();
+        return;
       }
+      resolve();
     };
     const onOpen = () => {
       try {
@@ -3142,6 +3111,102 @@ var sendCdpCommand = async (wsUrl, payload, timeoutMs = 5000) => {
     ws.addEventListener("close", onClose);
   });
 };
+
+// dist/cdp/selectTarget.js
+var normalizeFilter = (value) => {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed.toLowerCase() : null;
+};
+var filterTargets = (targets, filters) => {
+  const title = normalizeFilter(filters.title);
+  const url = normalizeFilter(filters.url);
+  const match = normalizeFilter(filters.match);
+  if (!title && !url && !match) {
+    return targets;
+  }
+  return targets.filter((target) => {
+    const targetTitle = (target.title ?? "").toLowerCase();
+    const targetUrl = (target.url ?? "").toLowerCase();
+    const combined = `${targetTitle} ${targetUrl}`.trim();
+    if (title && !targetTitle.includes(title)) {
+      return false;
+    }
+    if (url && !targetUrl.includes(url)) {
+      return false;
+    }
+    if (match && !combined.includes(match)) {
+      return false;
+    }
+    return true;
+  });
+};
+var selectTargetFromCandidates = async (candidates, output, options) => {
+  if (candidates.length === 0) {
+    return { ok: false, error: options.messages.empty, exitCode: 2 };
+  }
+  if (candidates.length === 1) {
+    return { ok: true, target: candidates[0] };
+  }
+  if (!options.interactive) {
+    writeCandidateList(candidates, output);
+    return { ok: false, error: options.messages.ambiguous, exitCode: 2 };
+  }
+  writeCandidateList(candidates, output, true);
+  output.writeHuman("Select target by number or id:");
+  const selection = await readLineOnce();
+  if (!selection) {
+    return { ok: false, error: "No selection provided.", exitCode: 2 };
+  }
+  const numeric = Number.parseInt(selection, 10);
+  if (Number.isFinite(numeric) && numeric >= 1 && numeric <= candidates.length) {
+    return { ok: true, target: candidates[numeric - 1] };
+  }
+  const byId = candidates.find((candidate) => candidate.id === selection);
+  if (byId) {
+    return { ok: true, target: byId };
+  }
+  return { ok: false, error: "Invalid selection.", exitCode: 2 };
+};
+var writeCandidateList = (candidates, output, numbered = false) => {
+  for (const [index, target] of candidates.entries()) {
+    const indexLabel = numbered ? `[${index + 1}] ` : "";
+    const title = target.title ? ` ${target.title}` : "";
+    const targetUrl = target.url ? ` ${target.url}` : "";
+    output.writeHuman(`${indexLabel}${target.id} ${target.type}${title}${targetUrl}`);
+  }
+};
+var readLineOnce = async () => {
+  return await new Promise((resolve) => {
+    const onData = (data) => {
+      cleanup();
+      resolve(data.toString("utf8").trim());
+    };
+    const onError = () => {
+      cleanup();
+      resolve("");
+    };
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("error", onError);
+      process.stdin.pause();
+    };
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", onData);
+    process.stdin.once("error", onError);
+    process.stdin.resume();
+  });
+};
+
+// dist/commands/chrome.js
+var normalizeUrl = (url) => {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  return `http://${url}`;
+};
 var runChromeVersion = async (options) => {
   const output = createOutput(options);
   const endpoint = await resolveCdpEndpoint(options);
@@ -3590,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 });
     }
   }
@@ -3604,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;
@@ -4056,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;
@@ -5156,6 +5281,33 @@ var handle14 = 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);
@@ -5592,17 +5744,11 @@ var fillResolvedNodes = async (session, nodeIds, value) => {
 };
 // ../argus-watcher/dist/http/routes/postDomTree.js
 var handle15 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+  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, {
@@ -5613,13 +5759,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) {
@@ -5629,17 +5769,11 @@ var handle15 = async (req, res, _url, ctx) => {
 
 // ../argus-watcher/dist/http/routes/postDomInfo.js
 var handle16 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+  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, {
@@ -5649,13 +5783,7 @@ var handle16 = 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) {
@@ -5854,28 +5982,16 @@ var createNotInteractableError = (message) => {
 
 // ../argus-watcher/dist/http/routes/postDomHover.js
 var handle17 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+  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 };
@@ -5938,13 +6054,7 @@ var handle18 = 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 };
@@ -6210,17 +6320,11 @@ var selectDomAddNodeIds = (allNodeIds, options) => {
 
 // ../argus-watcher/dist/http/routes/postDomRemove.js
 var handle21 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+  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, {
@@ -6229,13 +6333,7 @@ var handle21 = 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);
@@ -6341,28 +6439,16 @@ var handle23 = async (req, res, _url, ctx) => {
 
 // ../argus-watcher/dist/http/routes/postDomFocus.js
 var handle24 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
+  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 };
@@ -6765,7 +6851,7 @@ var handle33 = async (req, res, _url, ctx) => {
   }
   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 };
@@ -6920,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";
@@ -10031,6 +10055,8 @@ class SessionManager {
 var createEmptyFrameState = () => ({
   topFrameId: null,
   requestedFrameId: null,
+  requestedFrameHint: null,
+  requestedFrameDetached: false,
   activeFrameId: null,
   activeAttachedAt: null,
   frames: new Map,
@@ -10129,13 +10155,114 @@ 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) => {
   const record = params;
@@ -10235,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;
@@ -10277,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();
@@ -10299,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(() => {
@@ -10336,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;
     }
@@ -10378,10 +10610,24 @@ var createExtensionSource = (options) => {
     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) {
@@ -10404,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) {
@@ -10585,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 (resolution.kind === "pending") {
+      return false;
     }
-    if (nextActiveFrameId == null || state.activeFrameId === nextActiveFrameId) {
+    state.requestedFrameDetached = false;
+    if (state.activeFrameId === resolution.frameId) {
       return false;
     }
-    state.activeFrameId = nextActiveFrameId;
+    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;
@@ -10625,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);
@@ -10666,53 +10836,6 @@ var createExtensionSource = (options) => {
       state.pendingTitleLoads.delete(frameId);
     }
   }
-  function createDelegatingSession(config) {
-    const subscriptions = new Set;
-    const rebindSubscriptions = () => {
-      for (const subscription of subscriptions) {
-        subscription.unbind();
-        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();
-        delegatingSessions.delete(controller);
-      }
-    };
-    delegatingSessions.add(controller);
-    controller.rebind();
-    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) => {
-        const subscription = createDelegatingEventSubscription(method, handler);
-        subscriptions.add(subscription);
-        controller.rebind();
-        return () => {
-          subscription.unbind();
-          subscriptions.delete(subscription);
-        };
-      },
-      getTargetContext: config.getTargetContext
-    };
-  }
 };
 var tabToTarget = (tab) => ({
   id: formatPageTargetId(tab.tabId),
@@ -10722,72 +10845,16 @@ var tabToTarget = (tab) => ({
   faviconUrl: tab.faviconUrl,
   attached: tab.attached
 });
-var createDelegatingEventSubscription = (method, handler) => ({
-  method,
-  handler,
-  off: null,
-  unbind() {
-    this.off?.();
-    this.off = null;
-  }
-});
 
-// ../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 = 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;
@@ -10996,6 +11063,7 @@ var startWatcher = async (options) => {
     netBuffer,
     getWatcher: () => record,
     getCdpStatus: () => cdpStatus,
+    pageCdpSession: sourceHandle.pageSession ?? sourceHandle.session,
     cdpSession: sourceHandle.session,
     traceRecorder,
     screenshotter,
@@ -11058,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() === "") {
@@ -11098,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";
@@ -11185,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 = () => {
@@ -11197,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") {
@@ -11211,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 {
@@ -11246,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)) {
@@ -11255,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;
@@ -11280,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) => {
@@ -11306,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";
@@ -11375,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) {
@@ -11475,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 {
@@ -11495,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 {
@@ -11527,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() === "") {
@@ -11565,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.");
@@ -11600,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();
@@ -11628,7 +11770,7 @@ var runStart = async (options) => {
     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,
@@ -11650,12 +11792,7 @@ var runStart = async (options) => {
     } 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 {
@@ -11708,7 +11845,7 @@ Stopping...`);
       }
     });
   }
-  await new Promise(() => {});
+  await waitForever();
 };
 
 // dist/commands/doctor.js
@@ -11837,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);
@@ -12397,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";
@@ -12471,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();
@@ -12482,29 +12539,14 @@ 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();
-  }
+  const inject = await resolveInjectScript(options.inject, output);
+  const match = sourceMode === "cdp" ? buildWatcherMatch(options) : undefined;
   let handle38;
   try {
     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,
@@ -12525,11 +12567,11 @@ var runWatcherStart = async (options) => {
     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
@@ -12539,12 +12581,7 @@ var runWatcherStart = async (options) => {
       await handle38.close();
     } catch {}
   };
-  process.on("SIGINT", () => {
-    cleanup().then(() => process.exit(0));
-  });
-  process.on("SIGTERM", () => {
-    cleanup().then(() => process.exit(0));
-  });
+  registerTerminationHandlers(cleanup);
   handle38.events.on("cdpAttached", ({ target }) => {
     const typeInfo = target?.type ? ` (type: ${target.type})` : "";
     output.writeHuman(`[${handle38.watcher.id}] CDP attached: ${target?.title} (${target?.url})${typeInfo}`);
@@ -12582,7 +12619,7 @@ var runWatcherStart = async (options) => {
       output.writeHuman(`  artifacts=${result.artifactsBaseDir}`);
     }
   }
-  await new Promise(() => {});
+  await waitForever();
 };
 var generateWatcherId = () => crypto2.randomBytes(3).toString("hex");
 
@@ -12918,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;
@@ -13115,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;
@@ -13171,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;
@@ -13571,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));
@@ -13583,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) {
@@ -13605,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,
@@ -13639,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) => {
@@ -13683,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;
     }
@@ -13733,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) {
@@ -13802,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,
@@ -13852,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;
@@ -13873,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;
     }
@@ -13900,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) {
@@ -14122,7 +14035,6 @@ var addCookieScopeOptions = (command, forOriginDescription) => command.option("-
 
 // 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,
@@ -14132,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
@@ -14141,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) {
@@ -14178,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";
@@ -14630,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,
@@ -14638,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);
@@ -15405,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() === "") {
@@ -15421,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;
@@ -16918,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,
@@ -16931,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;
   }
@@ -16995,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";
@@ -17029,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)}`);
@@ -17039,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") {
@@ -17054,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;
@@ -17107,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";
@@ -17145,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 {}
@@ -17158,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 {
@@ -17176,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;
@@ -17189,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;
@@ -17222,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();
@@ -17237,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 {
@@ -17278,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);
@@ -17298,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") {
@@ -17342,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;
@@ -17359,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;
@@ -17420,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;
@@ -17437,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) {
@@ -27757,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;
 }
@@ -27765,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;
@@ -29765,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} `);
@@ -33678,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));
   }
@@ -33777,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
@@ -33879,7 +33783,7 @@ var fe3 = w4((wx, zi3) => {
     ps3 = t;
   };
   z3.registerAtRule = (t) => {
-    fs20 = t;
+    fs19 = t;
   };
   z3.registerRoot = (t) => {
     Gi3 = t;
@@ -33887,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);
     });
   };
@@ -38851,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);
@@ -38875,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)