@vforsh/argus 0.1.22 → 0.2.0

package/dist/argus.js

@@ -5,29 +5,15 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -2144,7 +2130,7 @@ var {
 // package.json
 var package_default = {
   name: "@vforsh/argus",
-  version: "0.1.22",
+  version: "0.2.0",
   repository: {
     type: "git",
     url: "git+https://github.com/vforsh/argus.git",
@@ -2170,9 +2156,9 @@ var package_default = {
     access: "public"
   },
   dependencies: {
-    "@vforsh/argus-core": "^0.1.10",
-    "@vforsh/argus-plugin-api": "^0.1.4",
-    "@vforsh/argus-watcher": "^0.1.15",
+    "@vforsh/argus-core": "^0.2.0",
+    "@vforsh/argus-plugin-api": "^0.2.0",
+    "@vforsh/argus-watcher": "^0.2.0",
     commander: "14.0.2",
     esbuild: "0.25.12",
     prettier: "3.7.4"
@@ -2270,6 +2256,7 @@ ${examples.map((example) => `  $ ${example}`).join(`
 `;
 
 // ../argus-core/dist/protocol/logs.js
+var LOG_LEVELS = ["log", "info", "warning", "error", "debug", "exception"];
 var formatLogLevelTag = (level) => {
   switch (level) {
     case "log":
@@ -2461,7 +2448,7 @@ var optionalPoint = (value, key) => {
 // ../argus-core/dist/protocol/http/auth.js
 var AUTH_STATE_METADATA_SCHEMA_VERSION = 1;
 // ../argus-core/dist/protocol/version.js
-var ARGUS_PROTOCOL_VERSION = 1;
+var ARGUS_PROTOCOL_VERSION = 2;
 // ../argus-core/dist/registry/registry.js
 import fs2 from "node:fs/promises";
 import path3 from "node:path";
@@ -3205,12 +3192,29 @@ var extractErrorMessage = async (response) => {
 var ensureTrailingNewline = (value) => value.endsWith(`
 `) ? value : `${value}
 `;
+var configureMachineSafeConsole = (argv) => {
+  if (!argv.includes("--json") && !argv.includes("--json-full")) {
+    return;
+  }
+  const writeConsoleError = console.error.bind(console);
+  console.log = writeConsoleError;
+  console.info = writeConsoleError;
+  console.debug = writeConsoleError;
+};
 var createOutput = (options) => {
   const json = options.json === true;
+  let wroteJsonDocument = false;
   const writeJsonLine = (value) => {
     process.stdout.write(JSON.stringify(value) + `
 `);
   };
+  const writeJson = (value) => {
+    if (wroteJsonDocument) {
+      throw new Error("Attempted to write more than one JSON document to stdout");
+    }
+    wroteJsonDocument = true;
+    writeJsonLine(value);
+  };
   const writeHuman = (text) => {
     const line = ensureTrailingNewline(text);
     if (json) {
@@ -3224,7 +3228,7 @@ var createOutput = (options) => {
   };
   return {
     json,
-    writeJson: writeJsonLine,
+    writeJson,
     writeJsonLine,
     writeHuman,
     writeWarn
@@ -6089,12 +6093,279 @@ var buildStatus = (ctx) => {
   };
 };
 
+// ../argus-watcher/dist/buffer/LogBuffer.js
+import { randomUUID } from "node:crypto";
+
+class LogEpochError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "LogEpochError";
+    this.code = code;
+  }
+}
+var EPOCH_PREFIX = "argus-log-epoch-v1.";
+
+class LogBuffer {
+  maxSize;
+  streamId = randomUUID();
+  events = [];
+  nextId = 1;
+  waiters = [];
+  epochWaiters = [];
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  add(event) {
+    const entry = {
+      ...event,
+      id: this.nextId++
+    };
+    this.events.push(entry);
+    this.trim();
+    this.flushWaiters();
+    this.flushEpochWaiters();
+    return entry;
+  }
+  listAfter(after, filters, limit) {
+    return this.listAfterPosition(after, filters, limit);
+  }
+  getCursor() {
+    return this.beginLogEpoch();
+  }
+  beginLogEpoch() {
+    return encodeEpoch({ v: 1, s: this.streamId, p: this.currentPosition() });
+  }
+  getEpoch() {
+    return this.beginLogEpoch();
+  }
+  getEpochAt(position) {
+    return encodeEpoch({ v: 1, s: this.streamId, p: position });
+  }
+  listAfterEpoch(epoch, filters, limit) {
+    const position = this.resolveEpoch(epoch);
+    const events = this.listAfterPosition(position, filters, limit);
+    return {
+      events,
+      nextCursor: events.length > 0 ? this.getEpochAt(events[events.length - 1]?.id ?? position) : epoch
+    };
+  }
+  waitForAfter(after, filters, limit, timeoutMs) {
+    const immediate = this.listAfter(after, filters, limit);
+    if (immediate.length > 0) {
+      return Promise.resolve(immediate);
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.waiters = this.waiters.filter((waiter) => waiter.timer !== timer);
+        resolve([]);
+      }, timeoutMs);
+      this.waiters.push({ after, filters, limit, resolve, timer });
+    });
+  }
+  async waitForAfterEpoch(epoch, filters, limit, timeoutMs) {
+    const position = this.resolveEpoch(epoch);
+    const immediate = this.listAfterPosition(position, filters, limit);
+    if (immediate.length > 0) {
+      return { events: immediate, nextCursor: this.getEpochAt(immediate[immediate.length - 1]?.id ?? position) };
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.epochWaiters = this.epochWaiters.filter((waiter) => waiter.timer !== timer);
+        resolve({ events: [], nextCursor: epoch });
+      }, timeoutMs);
+      this.epochWaiters.push({ position, filters, limit, resolve, reject, timer });
+    });
+  }
+  getStats() {
+    if (this.events.length === 0) {
+      return { size: this.maxSize, count: 0, minId: null, maxId: null };
+    }
+    return {
+      size: this.maxSize,
+      count: this.events.length,
+      minId: this.events[0]?.id ?? null,
+      maxId: this.events[this.events.length - 1]?.id ?? null
+    };
+  }
+  trim() {
+    if (this.maxSize <= 0) {
+      this.events = [];
+      return;
+    }
+    if (this.events.length <= this.maxSize) {
+      return;
+    }
+    this.events = this.events.slice(this.events.length - this.maxSize);
+  }
+  flushWaiters() {
+    if (this.waiters.length === 0) {
+      return;
+    }
+    const remaining = [];
+    for (const waiter of this.waiters) {
+      const events = this.listAfter(waiter.after, waiter.filters, waiter.limit);
+      if (events.length > 0) {
+        clearTimeout(waiter.timer);
+        waiter.resolve(events);
+        continue;
+      }
+      remaining.push(waiter);
+    }
+    this.waiters = remaining;
+  }
+  flushEpochWaiters() {
+    if (this.epochWaiters.length === 0) {
+      return;
+    }
+    const remaining = [];
+    for (const waiter of this.epochWaiters) {
+      try {
+        this.validatePosition(waiter.position);
+      } catch (error) {
+        clearTimeout(waiter.timer);
+        waiter.reject(error);
+        continue;
+      }
+      const events = this.listAfterPosition(waiter.position, waiter.filters, waiter.limit);
+      if (events.length > 0) {
+        clearTimeout(waiter.timer);
+        waiter.resolve({
+          events,
+          nextCursor: this.getEpochAt(events[events.length - 1]?.id ?? waiter.position)
+        });
+        continue;
+      }
+      remaining.push(waiter);
+    }
+    this.epochWaiters = remaining;
+  }
+  listAfterPosition(position, filters, limit) {
+    return this.events.filter((event) => event.id > position && matchesFilters(event, filters)).slice(0, limit);
+  }
+  resolveEpoch(epoch) {
+    const payload = decodeEpoch(epoch);
+    if (!payload) {
+      throw new LogEpochError("invalid", "Invalid log epoch. Capture a new epoch from the watcher.");
+    }
+    if (payload.s !== this.streamId) {
+      throw new LogEpochError("mismatch", "Log epoch belongs to a different watcher session. Capture a new epoch.");
+    }
+    if (payload.p > this.currentPosition()) {
+      throw new LogEpochError("future", "Log epoch points past the current log stream.");
+    }
+    this.validatePosition(payload.p);
+    return payload.p;
+  }
+  validatePosition(position) {
+    if (this.events.length > 0 && position < (this.events[0]?.id ?? position + 1) - 1) {
+      throw new LogEpochError("evicted", "Log epoch is stale because the ring buffer evicted entries. Capture a new epoch.");
+    }
+    if (this.maxSize === 0 && this.currentPosition() > position) {
+      throw new LogEpochError("evicted", "Log epoch is stale because the ring buffer evicted entries. Capture a new epoch.");
+    }
+  }
+  currentPosition() {
+    return this.nextId - 1;
+  }
+}
+var encodeEpoch = (payload) => `${EPOCH_PREFIX}${Buffer.from(JSON.stringify(payload)).toString("base64url")}`;
+var decodeEpoch = (epoch) => {
+  if (typeof epoch !== "string" || !epoch.startsWith(EPOCH_PREFIX)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(Buffer.from(epoch.slice(EPOCH_PREFIX.length), "base64url").toString("utf8"));
+    if (parsed.v !== 1 || typeof parsed.s !== "string" || !parsed.s || typeof parsed.p !== "number" || !Number.isSafeInteger(parsed.p) || parsed.p < 0) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var matchesFilters = (event, filters) => {
+  if (filters.sinceTs && event.ts < filters.sinceTs) {
+    return false;
+  }
+  if (filters.levels && filters.levels.length > 0 && !filters.levels.includes(event.level)) {
+    return false;
+  }
+  if (filters.source && !event.source.toLowerCase().includes(filters.source.toLowerCase())) {
+    return false;
+  }
+  if (filters.match && filters.match.length > 0) {
+    for (const pattern of filters.match) {
+      if (pattern.test(event.text)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return true;
+};
+
+// ../argus-watcher/dist/http/routes/logEpochQuery.js
+var parseLogPosition = (url) => {
+  const after = normalizeQueryValue2(url.searchParams.get("after") ?? null);
+  const sinceEpoch = normalizeQueryValue2(url.searchParams.get("sinceEpoch"));
+  if (after && sinceEpoch) {
+    return { error: "Use either after or sinceEpoch, not both." };
+  }
+  if (sinceEpoch) {
+    return { kind: "epoch", epoch: sinceEpoch };
+  }
+  if (after) {
+    return { kind: "epoch", epoch: after };
+  }
+  return { kind: "all" };
+};
+var respondLogEpochError = (res, error) => {
+  const status = error.code === "invalid" || error.code === "future" ? 400 : 409;
+  respondJson(res, {
+    ok: false,
+    error: {
+      message: error.message,
+      code: `log_epoch_${error.code}`
+    }
+  }, status);
+};
+var listLogsFromPosition = (buffer, position, filters, limit) => {
+  if (position.kind === "epoch") {
+    return buffer.listAfterEpoch(position.epoch, filters, limit);
+  }
+  return createQueryResult(buffer, position, buffer.listAfter(0, filters, limit));
+};
+var waitForLogsFromPosition = async (buffer, position, filters, limit, timeoutMs) => {
+  if (position.kind === "epoch") {
+    return buffer.waitForAfterEpoch(position.epoch, filters, limit, timeoutMs);
+  }
+  const events = await buffer.waitForAfter(0, filters, limit, timeoutMs);
+  return createQueryResult(buffer, position, events);
+};
+var createQueryResult = (buffer, position, events) => ({
+  events,
+  nextCursor: resolveNextCursor(buffer, position, events)
+});
+var resolveNextCursor = (buffer, position, events) => {
+  if (events.length > 0) {
+    return buffer.getEpochAt(events[events.length - 1]?.id ?? 0);
+  }
+  if (position.kind === "epoch") {
+    return position.epoch;
+  }
+  return buffer.getEpoch();
+};
+
 // ../argus-watcher/dist/http/routes/getLogs.js
 var route2 = defineJsonRoute({
   method: "GET",
   path: "/logs",
   handle: ({ res, url, ctx }) => {
-    const after = clampNumber(url.searchParams.get("after"), 0);
+    const position = parseLogPosition(url);
+    if ("error" in position) {
+      return respondLogEpochError(res, new LogEpochError("invalid", position.error));
+    }
     const limit = clampNumber(url.searchParams.get("limit"), 500, 1, 5000);
     const levels = parseLevels(url.searchParams.get("levels"));
     const match = url.searchParams.getAll("match");
@@ -6112,19 +6383,51 @@ var route2 = defineJsonRoute({
     if (compiledMatch.error) {
       return respondInvalidMatch(res, compiledMatch.error);
     }
-    emitRequest(ctx, res, "logs", { after, limit, levels, match: matchPatterns.patterns, matchCase, source, sinceTs });
-    const events = ctx.buffer.listAfter(after, { levels, match: compiledMatch.match, source, sinceTs }, limit);
-    const nextAfter = events.length > 0 ? events[events.length - 1]?.id ?? after : after;
-    return { ok: true, events, nextAfter };
+    emitRequest(ctx, res, "logs", {
+      after: position.kind === "epoch" && url.searchParams.has("after") ? position.epoch : undefined,
+      sinceEpoch: position.kind === "epoch" ? position.epoch : undefined,
+      limit,
+      levels,
+      match: matchPatterns.patterns,
+      matchCase,
+      source,
+      sinceTs
+    });
+    try {
+      const result = listLogsFromPosition(ctx.buffer, position, { levels, match: compiledMatch.match, source, sinceTs }, limit);
+      return { ok: true, ...result };
+    } catch (error) {
+      if (error instanceof LogEpochError) {
+        return respondLogEpochError(res, error);
+      }
+      throw error;
+    }
   }
 });
 
-// ../argus-watcher/dist/http/routes/getTail.js
+// ../argus-watcher/dist/http/routes/getLogCursor.js
 var route3 = defineJsonRoute({
+  method: "GET",
+  path: "/logs/cursor",
+  handle: ({ ctx }) => ({ ok: true, cursor: ctx.buffer.getCursor() })
+});
+
+// ../argus-watcher/dist/http/routes/getLogEpoch.js
+var route4 = defineJsonRoute({
+  method: "GET",
+  path: "/logs/epoch",
+  handle: ({ ctx }) => ({ ok: true, epoch: ctx.buffer.beginLogEpoch() })
+});
+
+// ../argus-watcher/dist/http/routes/getTail.js
+var route5 = defineJsonRoute({
   method: "GET",
   path: "/tail",
   handle: async ({ res, url, ctx }) => {
-    const after = clampNumber(url.searchParams.get("after"), 0);
+    const position = parseLogPosition(url);
+    if ("error" in position) {
+      return respondLogEpochError(res, new LogEpochError("invalid", position.error));
+    }
     const limit = clampNumber(url.searchParams.get("limit"), 500, 1, 5000);
     const timeoutMs = clampNumber(url.searchParams.get("timeoutMs"), 25000, 1000, 120000);
     const levels = parseLevels(url.searchParams.get("levels"));
@@ -6142,10 +6445,25 @@ var route3 = defineJsonRoute({
     if (compiledMatch.error) {
       return respondInvalidMatch(res, compiledMatch.error);
     }
-    emitRequest(ctx, res, "tail", { after, limit, levels, match: matchPatterns.patterns, matchCase, source, timeoutMs });
-    const events = await ctx.buffer.waitForAfter(after, { levels, match: compiledMatch.match, source }, limit, timeoutMs);
-    const nextAfter = events.length > 0 ? events[events.length - 1]?.id ?? after : after;
-    return { ok: true, events, nextAfter, timedOut: events.length === 0 };
+    emitRequest(ctx, res, "tail", {
+      after: position.kind === "epoch" ? position.epoch : undefined,
+      sinceEpoch: position.kind === "epoch" ? position.epoch : undefined,
+      limit,
+      levels,
+      match: matchPatterns.patterns,
+      matchCase,
+      source,
+      timeoutMs
+    });
+    try {
+      const result = await waitForLogsFromPosition(ctx.buffer, position, { levels, match: compiledMatch.match, source }, limit, timeoutMs);
+      return { ok: true, ...result, timedOut: result.events.length === 0 };
+    } catch (error) {
+      if (error instanceof LogEpochError) {
+        return respondLogEpochError(res, error);
+      }
+      throw error;
+    }
   }
 });
 
@@ -6460,7 +6778,7 @@ var hasTruthyFlag = (searchParams, key) => {
 var optionalClampNumber = (value, min) => value == null ? undefined : clampNumber(value, undefined, min);
 
 // ../argus-watcher/dist/http/routes/getNet.js
-var route4 = defineJsonRoute({
+var route6 = defineJsonRoute({
   method: "GET",
   path: "/net",
   handle: ({ res, url, ctx }) => {
@@ -6479,7 +6797,7 @@ var route4 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getNetRequests.js
-var route5 = defineJsonRoute({
+var route7 = defineJsonRoute({
   method: "GET",
   path: "/net/requests",
   handle: ({ res, url, ctx }) => {
@@ -6533,7 +6851,7 @@ var parsePositiveInt2 = (value) => {
 };
 
 // ../argus-watcher/dist/http/routes/getNetRequest.js
-var route6 = defineJsonRoute({
+var route8 = defineJsonRoute({
   method: "GET",
   path: "/net/request",
   handle: ({ res, url, ctx }) => {
@@ -6617,7 +6935,7 @@ var createNetBodyError = (message, code) => {
 var capitalizePart = (part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`;
 
 // ../argus-watcher/dist/http/routes/getNetRequestBody.js
-var route7 = defineJsonRoute({
+var route9 = defineJsonRoute({
   method: "GET",
   path: "/net/request/body",
   handle: async ({ res, url, ctx }) => {
@@ -6687,7 +7005,7 @@ var resolveBodySessionId = (ctx, frameId, storedSessionId) => {
 };
 
 // ../argus-watcher/dist/http/routes/getNetTail.js
-var route8 = defineJsonRoute({
+var route10 = defineJsonRoute({
   method: "GET",
   path: "/net/tail",
   handle: async ({ res, url, ctx }) => {
@@ -6723,7 +7041,7 @@ var pollNetBuffer = async (buffer, after, filters, limit, timeoutMs) => {
 var delay2 = (timeoutMs) => new Promise((resolve) => setTimeout(resolve, timeoutMs));
 
 // ../argus-watcher/dist/http/routes/getNetWebSockets.js
-var route9 = defineJsonRoute({
+var route11 = defineJsonRoute({
   method: "GET",
   path: "/net/ws",
   handle: ({ res, url, ctx }) => {
@@ -6742,7 +7060,7 @@ var route9 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getNetWebSocketConnection.js
-var route10 = defineJsonRoute({
+var route12 = defineJsonRoute({
   method: "GET",
   path: "/net/ws/connection",
   handle: ({ res, url, ctx }) => {
@@ -6764,7 +7082,7 @@ var route10 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getNetSse.js
-var route11 = defineJsonRoute({
+var route13 = defineJsonRoute({
   method: "GET",
   path: "/net/sse",
   handle: ({ res, url, ctx }) => {
@@ -6783,7 +7101,7 @@ var route11 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postNetClear.js
-var route12 = defineJsonRoute({
+var route14 = defineJsonRoute({
   method: "POST",
   path: "/net/clear",
   handle: ({ res, ctx }) => {
@@ -7268,7 +7586,7 @@ var normalizeStorageEntries = (entries) => entries.filter((entry) => typeof entr
 }));
 
 // ../argus-watcher/dist/http/routes/getAuthCookies.js
-var route13 = defineJsonRoute({
+var route15 = defineJsonRoute({
   method: "GET",
   path: "/auth/cookies",
   handle: ({ res, url, ctx }) => {
@@ -7283,7 +7601,7 @@ var route13 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getAuthState.js
-var route14 = defineJsonRoute({
+var route16 = defineJsonRoute({
   method: "GET",
   path: "/auth/state",
   handle: ({ res, url, ctx }) => {
@@ -7473,7 +7791,7 @@ var applyAuthStateToSession = async (input) => hydrateAuthState({
 });
 
 // ../argus-watcher/dist/http/routes/postAuthStateLoad.js
-var route15 = defineJsonRoute({
+var route17 = defineJsonRoute({
   method: "POST",
   path: "/auth/state/load",
   parseBody: true,
@@ -7591,14 +7909,305 @@ var expandRemoteObjectViaGetProperties = async (record2, cdp) => {
   return out;
 };
 
+// ../argus-watcher/dist/cdp/scenarioBridge.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+var SCENARIO_ACTION_TIMEOUT_MS = 30000;
+var DEFAULT_LOG_LIMIT = 500;
+var MAX_LOG_LIMIT = 5000;
+var installScenarioBridge = async (session, expression, args, services, timeoutMs) => {
+  const token = randomUUID2();
+  const suffix = token.replaceAll("-", "");
+  const bindingName = `__argusScenarioSend_${suffix}`;
+  const responseName = `__argusScenarioReceive_${suffix}`;
+  const off = session.onEvent("Runtime.bindingCalled", (rawEvent, meta) => {
+    const { name, payload, executionContextId } = rawEvent;
+    if (name !== bindingName || typeof payload !== "string" || typeof executionContextId !== "number" || !Number.isInteger(executionContextId)) {
+      return;
+    }
+    const request = parseBridgeRequest(payload, token);
+    if (!request) {
+      return;
+    }
+    respondToBridgeRequest(session, responseName, request, services, executionContextId, meta, timeoutMs);
+  });
+  try {
+    await session.sendAndWait("Runtime.addBinding", { name: bindingName }, { timeoutMs });
+  } catch (error) {
+    off();
+    throw error;
+  }
+  let disposed = false;
+  return {
+    expression: buildScenarioExpression(expression, { bindingName, responseName, token, args: args ?? {} }),
+    dispose: async () => {
+      if (disposed)
+        return;
+      disposed = true;
+      off();
+      try {
+        await session.sendAndWait("Runtime.removeBinding", { name: bindingName }, { timeoutMs });
+      } catch {}
+    }
+  };
+};
+var parseBridgeRequest = (payload, token) => {
+  try {
+    const parsed = JSON.parse(payload);
+    if (typeof parsed !== "object" || parsed == null || Array.isArray(parsed)) {
+      return null;
+    }
+    const { token: requestToken, id, action, payload: requestPayload } = parsed;
+    if (requestToken !== token || typeof id !== "number" || !Number.isInteger(id) || id < 1 || typeof action !== "string") {
+      return null;
+    }
+    return { token: requestToken, id, action, payload: requestPayload };
+  } catch {
+    return null;
+  }
+};
+var respondToBridgeRequest = async (session, responseName, request, services, executionContextId, meta, timeoutMs) => {
+  let response;
+  try {
+    response = { id: request.id, ok: true, result: await handleBridgeRequest(request, services) };
+  } catch (error) {
+    response = { id: request.id, ok: false, error: formatError3(error) };
+  }
+  try {
+    await sendBridgeResponse(session, responseName, response, executionContextId, meta, timeoutMs);
+  } catch {}
+};
+var handleBridgeRequest = async (request, services) => {
+  switch (request.action) {
+    case "screenshot": {
+      const options = parseScreenshotOptions(request.payload);
+      return services.screenshotter.capture(options);
+    }
+    case "checkpoint": {
+      const payload = requireRecord(request.payload, "checkpoint payload");
+      const name = parseCheckpointName(payload.name);
+      const options = parseScreenshotOptions(payload.options);
+      const fileName = name.endsWith(".png") ? name : `${name}.png`;
+      return services.screenshotter.capture({ ...options, outFile: `scenarios/checkpoints/${fileName}` });
+    }
+    case "logs.cursor":
+      return { cursor: services.buffer.getCursor() };
+    case "logs.read":
+      return readScenarioLogs(services.buffer, request.payload);
+    default:
+      throw new Error(`Unsupported scenario action: ${request.action}`);
+  }
+};
+var parseScreenshotOptions = (value) => {
+  if (value == null)
+    return {};
+  const record2 = requireRecord(value, "screenshot options");
+  const selector = record2.selector;
+  const clip = record2.clip;
+  if (selector != null && (typeof selector !== "string" || !selector.trim())) {
+    throw new Error("selector must be a non-empty string");
+  }
+  if (selector != null && clip != null) {
+    throw new Error("selector and clip are mutually exclusive");
+  }
+  return {
+    selector: typeof selector === "string" ? selector : undefined,
+    clip: clip == null ? undefined : parseClip(clip)
+  };
+};
+var parseClip = (value) => {
+  const clip = requireRecord(value, "clip");
+  const { x, y, width, height } = clip;
+  if (!isFiniteNumber2(x) || !isFiniteNumber2(y) || !isFiniteNumber2(width) || !isFiniteNumber2(height)) {
+    throw new Error("clip.x, clip.y, clip.width, and clip.height must be finite numbers");
+  }
+  if (width <= 0 || height <= 0) {
+    throw new Error("clip.width and clip.height must be greater than 0");
+  }
+  return { x, y, width, height };
+};
+var isFiniteNumber2 = (value) => typeof value === "number" && Number.isFinite(value);
+var parseCheckpointName = (value) => {
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(value)) {
+    throw new Error("checkpoint name must be 1-100 characters using letters, numbers, dot, underscore, or dash");
+  }
+  return value;
+};
+var readScenarioLogs = (buffer, value) => {
+  const payload = requireRecord(value, "logs.read payload");
+  const cursor = payload.cursor;
+  if (typeof cursor !== "string" || !cursor.trim()) {
+    throw new Error("log cursor must be a non-empty opaque cursor");
+  }
+  const { filters, limit } = parseLogOptions(payload.options);
+  return buffer.listAfterEpoch(cursor, filters, limit);
+};
+var parseLogOptions = (value) => {
+  if (value == null)
+    return { filters: {}, limit: DEFAULT_LOG_LIMIT };
+  const options = requireRecord(value, "log options");
+  const levels = parseLogLevels(options.levels);
+  const matchCase = parseLogMatchCase(options.matchCase);
+  const match = compileLogMatch(options.match, matchCase);
+  const source = parseLogSource(options.source);
+  const limit = parseLogLimit(options.limit);
+  return {
+    filters: { levels, match, source },
+    limit
+  };
+};
+var parseLogLevels = (value) => {
+  if (value == null)
+    return;
+  if (Array.isArray(value) && value.every(isLogLevel))
+    return value;
+  throw new Error(`levels must contain only: ${LOG_LEVELS.join(", ")}`);
+};
+var isLogLevel = (value) => typeof value === "string" && LOG_LEVELS.includes(value);
+var parseLogMatchCase = (value) => {
+  if (value == null || value === "sensitive")
+    return "sensitive";
+  if (value === "insensitive")
+    return value;
+  throw new Error("matchCase must be sensitive or insensitive");
+};
+var compileLogMatch = (value, matchCase) => {
+  if (value == null)
+    return;
+  const patterns = Array.isArray(value) ? value : [value];
+  if (patterns.length === 0)
+    return;
+  if (!patterns.every(isNonEmptyString)) {
+    throw new Error("match must be a non-empty string or array of non-empty strings");
+  }
+  try {
+    return patterns.map((pattern) => new RegExp(pattern, matchCase === "insensitive" ? "i" : undefined));
+  } catch (error) {
+    throw new Error(`invalid log match expression: ${formatError3(error)}`);
+  }
+};
+var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+var parseLogSource = (value) => {
+  if (value == null)
+    return;
+  if (typeof value === "string" && value.trim())
+    return value;
+  throw new Error("source must be a non-empty string");
+};
+var parseLogLimit = (value) => {
+  const limit = value ?? DEFAULT_LOG_LIMIT;
+  if (typeof limit === "number" && Number.isInteger(limit) && limit >= 1 && limit <= MAX_LOG_LIMIT)
+    return limit;
+  throw new Error(`limit must be an integer from 1 to ${MAX_LOG_LIMIT}`);
+};
+var requireRecord = (value, label) => {
+  if (typeof value !== "object" || value == null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+};
+var sendBridgeResponse = async (session, responseName, response, executionContextId, meta, timeoutMs) => {
+  await session.sendAndWait("Runtime.evaluate", {
+    expression: `globalThis[${JSON.stringify(responseName)}]?.(${JSON.stringify(response)})`,
+    contextId: executionContextId,
+    returnByValue: true,
+    silent: true
+  }, { timeoutMs, sessionId: meta.sessionId ?? undefined });
+};
+var buildScenarioExpression = (expression, options) => `(async () => {
+  const __argusBridge = (() => {
+    const send = globalThis[${JSON.stringify(options.bindingName)}];
+    if (typeof send !== 'function') throw new Error('Argus scenario bridge is unavailable');
+    const pending = new Map();
+    let nextId = 1;
+    const receiveName = ${JSON.stringify(options.responseName)};
+    Object.defineProperty(globalThis, receiveName, {
+      configurable: true,
+      value: (message) => {
+        const entry = pending.get(message?.id);
+        if (!entry) return;
+        pending.delete(message.id);
+        clearTimeout(entry.timeout);
+        if (message.ok) entry.resolve(message.result);
+        else entry.reject(new Error(message.error));
+      },
+    });
+    const request = (action, payload) => new Promise((resolve, reject) => {
+      const id = nextId++;
+      const timeout = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error('Argus scenario action timed out after ${SCENARIO_ACTION_TIMEOUT_MS}ms: ' + action));
+      }, ${SCENARIO_ACTION_TIMEOUT_MS});
+      pending.set(id, { resolve, reject, timeout });
+      try {
+        send(JSON.stringify({ token: ${JSON.stringify(options.token)}, id, action, payload }));
+      } catch (error) {
+        clearTimeout(timeout);
+        pending.delete(id);
+        reject(error);
+      }
+    });
+    const logs = Object.freeze({
+      cursor: async () => (await request('logs.cursor')).cursor,
+      read: (cursor, logOptions) => request('logs.read', { cursor, options: logOptions }),
+      session: async () => {
+        let cursor = (await request('logs.cursor')).cursor;
+        return Object.freeze({
+          get cursor() { return cursor; },
+          async read(logOptions) {
+            const result = await request('logs.read', { cursor, options: logOptions });
+            cursor = result.nextCursor;
+            return result;
+          },
+        });
+      },
+    });
+    const context = Object.freeze({
+      args: Object.freeze(${JSON.stringify(options.args)}),
+      screenshot: (screenshotOptions) => request('screenshot', screenshotOptions),
+      checkpoint: (name, screenshotOptions) => request('checkpoint', { name, options: screenshotOptions }),
+      logs,
+    });
+    return {
+      context,
+      dispose() {
+        delete globalThis[receiveName];
+        for (const entry of pending.values()) {
+          clearTimeout(entry.timeout);
+          entry.reject(new Error('Argus scenario finished before the action completed'));
+        }
+        pending.clear();
+      },
+    };
+  })();
+  const __argusScenarioContext = __argusBridge.context;
+  try {
+    return await (${expression}
+    );
+  } finally {
+    __argusBridge.dispose();
+  }
+})()`;
+var formatError3 = (error) => error instanceof Error ? error.message : String(error);
+
 // ../argus-watcher/dist/cdp/eval.js
 var evaluateExpression = async (session, options) => {
   const args = hasEvalArgs(options.args) ? options.args : undefined;
   if (args) {
     await installEvalArgs(session, args, options.timeoutMs);
   }
+  let scenarioBridge;
   try {
-    const recordResult = await evaluateAndAwaitRecord(session, options);
+    if (options.scenario) {
+      if (!options.scenarioServices) {
+        throw new Error("Scenario host services are unavailable");
+      }
+      scenarioBridge = await installScenarioBridge(session, options.expression, args, options.scenarioServices, options.timeoutMs);
+    }
+    const recordResult = await evaluateAndAwaitRecord(session, {
+      ...options,
+      expression: scenarioBridge?.expression ?? options.expression,
+      replMode: scenarioBridge ? false : options.replMode
+    });
     if (recordResult.exception)
       return recordResult.response;
     const record2 = recordResult.record;
@@ -7610,6 +8219,7 @@ var evaluateExpression = async (session, options) => {
       exception: null
     };
   } finally {
+    await scenarioBridge?.dispose();
     if (args) {
       await restoreEvalArgs(session, options.timeoutMs);
     }
@@ -7712,7 +8322,7 @@ var shouldMaterializeByValue = (record2) => {
 };
 
 // ../argus-watcher/dist/http/routes/postEval.js
-var route16 = defineJsonRoute({
+var route18 = defineJsonRoute({
   method: "POST",
   path: "/eval",
   parseBody: true,
@@ -7729,7 +8339,12 @@ var route16 = defineJsonRoute({
     awaitPromise: normalizeBoolean(payload.awaitPromise, true),
     replMode: normalizeBoolean(payload.replMode, true),
     returnByValue: normalizeBoolean(payload.returnByValue, true),
-    timeoutMs: normalizeTimeout(payload.timeoutMs)
+    timeoutMs: normalizeTimeout(payload.timeoutMs),
+    scenario: normalizeBoolean(payload.scenario, false),
+    scenarioServices: {
+      buffer: ctx.buffer,
+      screenshotter: ctx.screenshotter
+    }
   })
 });
 var normalizeEvalArgs = (args) => {
@@ -7746,7 +8361,7 @@ var normalizeEvalArgs = (args) => {
 };
 
 // ../argus-watcher/dist/http/routes/postTraceStart.js
-var route17 = defineJsonRoute({
+var route19 = defineJsonRoute({
   method: "POST",
   path: "/trace/start",
   parseBody: true,
@@ -7755,7 +8370,7 @@ var route17 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postTraceStop.js
-var route18 = defineJsonRoute({
+var route20 = defineJsonRoute({
   method: "POST",
   path: "/trace/stop",
   parseBody: true,
@@ -7851,7 +8466,7 @@ var validateClip = (clip) => {
 };
 
 // ../argus-watcher/dist/http/routes/postScreenshot.js
-var route19 = defineJsonRoute({
+var route21 = defineJsonRoute({
   method: "POST",
   path: "/screenshot",
   parseBody: true,
@@ -8363,7 +8978,7 @@ var countNodes = (nodes) => {
 };
 
 // ../argus-watcher/dist/http/routes/postSnapshot.js
-var route20 = defineJsonRoute({
+var route22 = defineJsonRoute({
   method: "POST",
   path: "/snapshot",
   parseBody: true,
@@ -8540,7 +9155,7 @@ var locateRoutes = [
 ];
 
 // ../argus-watcher/dist/http/routes/postCodeList.js
-var route21 = defineJsonRoute({
+var route23 = defineJsonRoute({
   method: "POST",
   path: "/code/list",
   parseBody: true,
@@ -8555,7 +9170,7 @@ var route21 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postCodeRead.js
-var route22 = defineJsonRoute({
+var route24 = defineJsonRoute({
   method: "POST",
   path: "/code/read",
   parseBody: true,
@@ -8580,7 +9195,7 @@ var route22 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postCodeGrep.js
-var route23 = defineJsonRoute({
+var route25 = defineJsonRoute({
   method: "POST",
   path: "/code/grep",
   parseBody: true,
@@ -8601,7 +9216,7 @@ var route23 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postCodeEdit.js
-var route24 = defineJsonRoute({
+var route26 = defineJsonRoute({
   method: "POST",
   path: "/code/edit",
   parseBody: true,
@@ -8958,7 +9573,7 @@ var fillResolvedNodes = async (session, handles, value) => {
   return handles.length;
 };
 // ../argus-watcher/dist/http/routes/postDomTree.js
-var route25 = defineJsonRoute({
+var route27 = defineJsonRoute({
   method: "POST",
   path: "/dom/tree",
   parseBody: true,
@@ -8981,7 +9596,7 @@ var route25 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomInfo.js
-var route26 = defineJsonRoute({
+var route28 = defineJsonRoute({
   method: "POST",
   path: "/dom/info",
   parseBody: true,
@@ -9266,7 +9881,7 @@ var defineDomTargetRoute = (input) => defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomHover.js
-var route27 = defineDomTargetRoute({
+var route29 = defineDomTargetRoute({
   path: "/dom/hover",
   endpoint: "dom/hover",
   action: "hover",
@@ -9277,7 +9892,7 @@ var route27 = defineDomTargetRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomClick.js
-var route28 = defineJsonRoute({
+var route30 = defineJsonRoute({
   method: "POST",
   path: "/dom/click",
   bodySchema: domClickRequestSchema,
@@ -9325,7 +9940,7 @@ var route28 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomDrag.js
-var route29 = defineJsonRoute({
+var route31 = defineJsonRoute({
   method: "POST",
   path: "/dom/drag",
   bodySchema: domDragRequestSchema,
@@ -9542,7 +10157,7 @@ var dispatchKeydown = async (session, options) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomKeydown.js
-var route30 = defineJsonRoute({
+var route32 = defineJsonRoute({
   method: "POST",
   path: "/dom/keydown",
   parseBody: true,
@@ -9592,7 +10207,7 @@ var route30 = defineJsonRoute({
 
 // ../argus-watcher/dist/http/routes/postDomAdd.js
 var validPositions = ["beforebegin", "afterbegin", "beforeend", "afterend"];
-var route31 = defineJsonRoute({
+var route33 = defineJsonRoute({
   method: "POST",
   path: "/dom/add",
   parseBody: true,
@@ -9681,7 +10296,7 @@ var selectDomAddNodeIds = (allNodeIds, options) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomRemove.js
-var route32 = defineJsonRoute({
+var route34 = defineJsonRoute({
   method: "POST",
   path: "/dom/remove",
   parseBody: true,
@@ -9703,7 +10318,7 @@ var route32 = defineJsonRoute({
 
 // ../argus-watcher/dist/http/routes/postDomModify.js
 var validTypes = ["attr", "class", "style", "text", "html"];
-var route33 = defineJsonRoute({
+var route35 = defineJsonRoute({
   method: "POST",
   path: "/dom/modify",
   parseBody: true,
@@ -9734,7 +10349,7 @@ var route33 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomSetFile.js
-var route34 = defineJsonRoute({
+var route36 = defineJsonRoute({
   method: "POST",
   path: "/dom/set-file",
   parseBody: true,
@@ -9772,7 +10387,7 @@ var route34 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomFocus.js
-var route35 = defineDomTargetRoute({
+var route37 = defineDomTargetRoute({
   path: "/dom/focus",
   endpoint: "dom/focus",
   action: "focus",
@@ -9783,7 +10398,7 @@ var route35 = defineDomTargetRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomFill.js
-var route36 = defineDomTargetRoute({
+var route38 = defineDomTargetRoute({
   path: "/dom/fill",
   endpoint: "dom/fill",
   action: "fill",
@@ -9804,7 +10419,7 @@ var route36 = defineDomTargetRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDomScroll.js
-var route37 = defineJsonRoute({
+var route39 = defineJsonRoute({
   method: "POST",
   path: "/dom/scroll",
   parseBody: true,
@@ -9863,7 +10478,7 @@ var getViewportSize = async (session) => {
 };
 
 // ../argus-watcher/dist/http/routes/postDomScrollTo.js
-var route38 = defineJsonRoute({
+var route40 = defineJsonRoute({
   method: "POST",
   path: "/dom/scroll-to",
   parseBody: true,
@@ -9910,7 +10525,7 @@ var route38 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getEmulation.js
-var route39 = defineJsonRoute({
+var route41 = defineJsonRoute({
   method: "GET",
   path: "/emulation",
   endpoint: "emulation",
@@ -9919,7 +10534,7 @@ var route39 = defineJsonRoute({
 
 // ../argus-watcher/dist/http/routes/postEmulation.js
 var validActions = ["set", "clear"];
-var route40 = defineJsonRoute({
+var route42 = defineJsonRoute({
   method: "POST",
   path: "/emulation",
   parseBody: true,
@@ -9978,7 +10593,7 @@ function validateEmulationRequest(payload) {
 }
 
 // ../argus-watcher/dist/http/routes/getThrottle.js
-var route41 = defineJsonRoute({
+var route43 = defineJsonRoute({
   method: "GET",
   path: "/throttle",
   endpoint: "throttle",
@@ -9987,7 +10602,7 @@ var route41 = defineJsonRoute({
 
 // ../argus-watcher/dist/http/routes/postThrottle.js
 var validActions2 = ["set", "clear"];
-var route42 = defineJsonRoute({
+var route44 = defineJsonRoute({
   method: "POST",
   path: "/throttle",
   parseBody: true,
@@ -10015,7 +10630,7 @@ var route42 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getDialog.js
-var route43 = defineJsonRoute({
+var route45 = defineJsonRoute({
   method: "GET",
   path: "/dialog",
   endpoint: "dialog/status",
@@ -10023,7 +10638,7 @@ var route43 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDialog.js
-var route44 = defineJsonRoute({
+var route46 = defineJsonRoute({
   method: "POST",
   path: "/dialog",
   parseBody: true,
@@ -10062,7 +10677,7 @@ var route44 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postVisibility.js
-var route45 = defineJsonRoute({
+var route47 = defineJsonRoute({
   method: "POST",
   path: "/visibility",
   parseBody: true,
@@ -10179,7 +10794,7 @@ function validateStoragePayload(payload) {
 }
 
 // ../argus-watcher/dist/http/routes/postReload.js
-var route46 = defineJsonRoute({
+var route48 = defineJsonRoute({
   method: "POST",
   path: "/reload",
   parseBody: true,
@@ -10193,7 +10808,7 @@ var route46 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postShutdown.js
-var route47 = defineJsonRoute({
+var route49 = defineJsonRoute({
   method: "POST",
   path: "/shutdown",
   endpoint: "shutdown",
@@ -10208,7 +10823,7 @@ var route47 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getExtensionTabs.js
-var route48 = defineJsonRoute({
+var route50 = defineJsonRoute({
   method: "GET",
   path: "/tabs",
   extensionOnly: true,
@@ -10229,7 +10844,7 @@ var route48 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getExtensionDiagnostics.js
-var route49 = defineJsonRoute({
+var route51 = defineJsonRoute({
   method: "GET",
   path: "/extension/diagnostics",
   extensionOnly: true,
@@ -10243,7 +10858,7 @@ var route49 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/getTargets.js
-var route50 = defineJsonRoute({
+var route52 = defineJsonRoute({
   method: "GET",
   path: "/targets",
   extensionOnly: true,
@@ -10258,7 +10873,7 @@ var route50 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postAttach.js
-var route51 = defineJsonRoute({
+var route53 = defineJsonRoute({
   method: "POST",
   path: "/attach",
   parseBody: true,
@@ -10281,7 +10896,7 @@ var route51 = defineJsonRoute({
 });
 
 // ../argus-watcher/dist/http/routes/postDetach.js
-var route52 = defineJsonRoute({
+var route54 = defineJsonRoute({
   method: "POST",
   path: "/detach",
   parseBody: true,
@@ -10306,9 +10921,9 @@ var route52 = defineJsonRoute({
 // ../argus-watcher/dist/http/routes/index.js
 var watcherRoutes = [
   route,
-  route2,
   route3,
   route4,
+  route2,
   route5,
   route6,
   route7,
@@ -10317,23 +10932,23 @@ var watcherRoutes = [
   route10,
   route11,
   route12,
-  ...netMockRoutes,
   route13,
+  route14,
+  ...netMockRoutes,
+  route15,
   cookieGetRoute,
   cookieSetRoute,
   cookieDeleteRoute,
   cookieClearRoute,
-  route14,
-  route15,
   route16,
   route17,
   route18,
-  ...recordRoutes,
   route19,
   route20,
-  ...locateRoutes,
+  ...recordRoutes,
   route21,
   route22,
+  ...locateRoutes,
   route23,
   route24,
   route25,
@@ -10357,18 +10972,20 @@ var watcherRoutes = [
   route43,
   route44,
   route45,
-  ...storageRoutes,
   route46,
   route47,
+  ...storageRoutes,
   route48,
   route49,
   route50,
   route51,
-  route52
+  route52,
+  route53,
+  route54
 ];
 
 // ../argus-watcher/dist/http/router.js
-var routes = new Map(watcherRoutes.map((route53) => [`${route53.method} ${route53.path}`, route53]));
+var routes = new Map(watcherRoutes.map((route55) => [`${route55.method} ${route55.path}`, route55]));
 var dispatch = (req, res, url, ctx) => {
   const entry = routes.get(`${req.method} ${url.pathname}`);
   if (!entry || entry.extensionOnly && !ctx.sourceHandle) {
@@ -11032,97 +11649,6 @@ var formatWatcherError = (error) => {
 import os3 from "node:os";
 import path7 from "node:path";
 
-// ../argus-watcher/dist/buffer/LogBuffer.js
-class LogBuffer {
-  maxSize;
-  events = [];
-  nextId = 1;
-  waiters = [];
-  constructor(maxSize) {
-    this.maxSize = maxSize;
-  }
-  add(event) {
-    const entry = {
-      ...event,
-      id: this.nextId++
-    };
-    this.events.push(entry);
-    this.trim();
-    this.flushWaiters();
-    return entry;
-  }
-  listAfter(after, filters, limit) {
-    const filtered = this.events.filter((event) => event.id > after && matchesFilters(event, filters));
-    return filtered.slice(0, limit);
-  }
-  waitForAfter(after, filters, limit, timeoutMs) {
-    const immediate = this.listAfter(after, filters, limit);
-    if (immediate.length > 0) {
-      return Promise.resolve(immediate);
-    }
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        this.waiters = this.waiters.filter((waiter) => waiter.timer !== timer);
-        resolve([]);
-      }, timeoutMs);
-      this.waiters.push({ after, filters, limit, resolve, timer });
-    });
-  }
-  getStats() {
-    if (this.events.length === 0) {
-      return { size: this.maxSize, count: 0, minId: null, maxId: null };
-    }
-    return {
-      size: this.maxSize,
-      count: this.events.length,
-      minId: this.events[0]?.id ?? null,
-      maxId: this.events[this.events.length - 1]?.id ?? null
-    };
-  }
-  trim() {
-    if (this.events.length <= this.maxSize) {
-      return;
-    }
-    this.events = this.events.slice(this.events.length - this.maxSize);
-  }
-  flushWaiters() {
-    if (this.waiters.length === 0) {
-      return;
-    }
-    const remaining = [];
-    for (const waiter of this.waiters) {
-      const events = this.listAfter(waiter.after, waiter.filters, waiter.limit);
-      if (events.length > 0) {
-        clearTimeout(waiter.timer);
-        waiter.resolve(events);
-        continue;
-      }
-      remaining.push(waiter);
-    }
-    this.waiters = remaining;
-  }
-}
-var matchesFilters = (event, filters) => {
-  if (filters.sinceTs && event.ts < filters.sinceTs) {
-    return false;
-  }
-  if (filters.levels && filters.levels.length > 0 && !filters.levels.includes(event.level)) {
-    return false;
-  }
-  if (filters.source && !event.source.toLowerCase().includes(filters.source.toLowerCase())) {
-    return false;
-  }
-  if (filters.match && filters.match.length > 0) {
-    for (const pattern of filters.match) {
-      if (pattern.test(event.text)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return true;
-};
-
 // ../argus-watcher/dist/buffer/NetBuffer.js
 class NetBuffer {
   maxSize;
@@ -15140,8 +15666,8 @@ var startCdpWatcher = (options) => {
         await connectOnce();
         backoffMs = 1000;
       } catch (error) {
-        const reason = `connect_failed: ${formatError3(error)}`;
-        options.onLog(createSystemLog(`CDP connection failed: ${formatError3(error)}`));
+        const reason = `connect_failed: ${formatError4(error)}`;
+        options.onLog(createSystemLog(`CDP connection failed: ${formatError4(error)}`));
         options.onStatus({ attached: false, target: null, reason });
         options.onDetach?.(reason);
         await delay4(backoffMs);
@@ -15218,7 +15744,7 @@ var createSystemLog = (message) => ({
   pageTitle: null,
   source: "system"
 });
-var formatError3 = (error) => {
+var formatError4 = (error) => {
   if (!error) {
     return "Unknown error";
   }
@@ -19712,9 +20238,11 @@ var previewLogEvent = (event) => ({
 
 // dist/watchers/queryParams.js
 var appendAfterLimitParams = (params, options) => {
-  const after = parseNumber(options.after);
-  if (after != null) {
-    params.set("after", String(after));
+  if (options.after?.trim()) {
+    params.set("after", options.after.trim());
+  }
+  if (options.sinceEpoch?.trim()) {
+    params.set("sinceEpoch", options.sinceEpoch.trim());
   }
   const limit = parseNumber(options.limit);
   if (limit != null) {
@@ -19851,6 +20379,14 @@ var appendRepeatedParams = (params, key, values) => {
 };
 
 // dist/commands/logs.js
+var runLogCursor = defineWatcherCommand({
+  build: () => ({ path: "/logs/cursor", timeoutMs: 5000 }),
+  formatHuman: (response, { output }) => output.writeHuman(response.cursor)
+});
+var runLogEpoch = defineWatcherCommand({
+  build: () => ({ path: "/logs/epoch", timeoutMs: 5000 }),
+  formatHuman: (response, { output }) => output.writeHuman(response.epoch)
+});
 var runLogs = defineWatcherCommand({
   isJson: (options) => options.jsonFull === true,
   build: (_args, options, output) => buildLogsPlan(options, output),
@@ -19892,7 +20428,14 @@ var runTail = async (id, options) => {
   if (!resolved)
     return;
   const { watcher } = resolved;
-  let after = parseNumber(options.after) ?? 0;
+  const afterEpoch = options.after?.trim() || undefined;
+  const sinceEpoch = options.sinceEpoch?.trim() || undefined;
+  if (afterEpoch && sinceEpoch) {
+    output.writeWarn("Use either --after or --since-epoch, not both.");
+    process.exitCode = 2;
+    return;
+  }
+  let position = afterEpoch ?? sinceEpoch;
   const timeoutMs = parseNumber(options.timeout) ?? 25000;
   const limit = parseNumber(options.limit);
   let running = true;
@@ -19903,7 +20446,9 @@ var runTail = async (id, options) => {
   process.on("SIGTERM", stop);
   while (running) {
     const params = new URLSearchParams;
-    params.set("after", String(after));
+    if (position) {
+      params.set(sinceEpoch ? "sinceEpoch" : "after", position);
+    }
     params.set("timeoutMs", String(timeoutMs));
     if (limit != null) {
       params.set("limit", String(limit));
@@ -19923,24 +20468,22 @@ var runTail = async (id, options) => {
       process.exitCode = 1;
       return;
     }
-    if (response.events.length > 0) {
-      for (const event of response.events) {
-        if (options.jsonFull) {
-          output.writeJsonLine({ watcher: watcher.id, event });
-          continue;
-        }
-        if (options.json) {
-          const previewEvent = previewLogEvent(event);
-          output.writeJsonLine({ watcher: watcher.id, event: previewEvent });
-          continue;
-        }
-        output.writeHuman(formatLogEvent(event, {
-          includeTimestamps: watcher.includeTimestamps
-        }));
-      }
+    for (const event of response.events) {
+      writeTailEvent(event, watcher, options, output);
     }
-    after = response.nextAfter;
+    position = response.nextCursor;
+  }
+};
+var writeTailEvent = (event, watcher, options, output) => {
+  if (options.jsonFull) {
+    output.writeJsonLine({ watcher: watcher.id, event });
+    return;
+  }
+  if (options.json) {
+    output.writeJsonLine({ watcher: watcher.id, event: previewLogEvent(event) });
+    return;
   }
+  output.writeHuman(formatLogEvent(event, { includeTimestamps: watcher.includeTimestamps }));
 };
 
 // dist/cli/register/logsCommands.js
@@ -19968,7 +20511,8 @@ var logsCommands = [
     options: [
       ...sharedFilterOptions,
       { flags: "--since <duration>", description: "Filter by time window (e.g. 10m, 2h, 30s)" },
-      { flags: "--after <id>", description: "Only return events after this id" },
+      { flags: "--after <cursor>", description: "Only return events after this opaque cursor" },
+      { flags: "--since-epoch <epoch>", description: "Only return events after this opaque epoch" },
       { flags: "--limit <count>", description: "Maximum number of events" },
       { flags: "--json", description: "Output bounded JSON preview for automation" },
       { flags: "--json-full", description: "Output full JSON (can be very large)" }
@@ -19980,13 +20524,34 @@ var logsCommands = [
       await runLogs(id, options);
     },
     subcommands: [
+      {
+        name: "epoch",
+        description: "Return an opaque watcher-session log epoch without downloading events",
+        arguments: [{ flags: "[id]", description: "Watcher id to query" }],
+        options: [{ flags: "--json", description: "Output one JSON document for automation" }],
+        examples: ["argus logs epoch app", "argus logs epoch app --json"],
+        action: async (id, options, command) => {
+          await runLogEpoch(id, command.optsWithGlobals?.() ?? options);
+        }
+      },
+      {
+        name: "cursor",
+        description: "Return the current log cursor without downloading events",
+        arguments: [{ flags: "[id]", description: "Watcher id to query" }],
+        options: [{ flags: "--json", description: "Output one JSON document for automation" }],
+        examples: ["argus logs cursor app", "argus logs cursor app --json"],
+        action: async (id, options, command) => {
+          await runLogCursor(id, command.optsWithGlobals?.() ?? options);
+        }
+      },
       {
         name: "tail",
         description: "Stream logs via long-polling",
         arguments: [{ flags: "[id]", description: "Watcher id to follow" }],
         options: [
           ...sharedFilterOptions,
-          { flags: "--after <id>", description: "Start after this event id" },
+          { flags: "--after <cursor>", description: "Start after this opaque cursor" },
+          { flags: "--since-epoch <epoch>", description: "Start after this opaque epoch" },
           { flags: "--limit <count>", description: "Maximum number of events per poll" },
           { flags: "--timeout <ms>", description: "Long-poll timeout in milliseconds" },
           { flags: "--json", description: "Output bounded newline-delimited JSON events" },
@@ -19998,10 +20563,11 @@ var logsCommands = [
           "argus logs tail app --json",
           "argus logs tail app --json-full"
         ],
-        action: async (id, options) => {
-          if (!validateLogsOptions(options))
+        action: async (id, options, command) => {
+          const resolvedOptions = command.optsWithGlobals?.() ?? options;
+          if (!validateLogsOptions(resolvedOptions))
             return;
-          await runTail(id, options);
+          await runTail(id, resolvedOptions);
         }
       }
     ]
@@ -20030,7 +20596,8 @@ var evalOnce = async (input) => {
     awaitPromise: input.awaitPromise,
     replMode: input.replMode,
     returnByValue: input.returnByValue,
-    timeoutMs: input.timeoutMs
+    timeoutMs: input.timeoutMs,
+    scenario: input.scenario
   };
   const requestTimeoutMs = input.timeoutMs ? input.timeoutMs + 5000 : DEFAULT_EVAL_REQUEST_TIMEOUT_MS;
   let response;
@@ -20088,7 +20655,8 @@ var evalWithRetries = async (input) => {
       replMode: input.replMode,
       returnByValue: input.returnByValue,
       timeoutMs: input.timeoutMs,
-      failOnException: input.failOnException
+      failOnException: input.failOnException,
+      scenario: input.scenario
     });
     if (outcome.ok) {
       return { ...outcome, attempt };
@@ -20309,6 +20877,10 @@ import path13 from "node:path";
 var esbuildModulePromise;
 var loadEsbuild = () => esbuildModulePromise ??= import("esbuild");
 var RESULT_BINDING = "__argusEvalBundleResult";
+var LEGACY_RESULT_BINDING = "__argusEvalLegacyResult";
+var LEGACY_RESULT_EXPORT = "__argusLegacyResult";
+var VIRTUAL_ENTRY = "argus:eval-entry";
+var VIRTUAL_NAMESPACE = "argus-eval-entry";
 var bundleEvalEntry = async (entryPath) => {
   let entryPoint;
   try {
@@ -20320,7 +20892,7 @@ var bundleEvalEntry = async (entryPath) => {
     const esbuild = await loadEsbuild();
     const result = await esbuild.build({
       absWorkingDir: process.cwd(),
-      entryPoints: [entryPoint],
+      entryPoints: [VIRTUAL_ENTRY],
       bundle: true,
       write: false,
       splitting: false,
@@ -20343,6 +20915,12 @@ var bundleEvalEntry = async (entryPath) => {
 var createPageEvalBundlePlugin = (entryPoint) => ({
   name: "argus-eval-bundle",
   setup(build) {
+    build.onResolve({ filter: /^argus:eval-entry$/ }, () => ({ path: VIRTUAL_ENTRY, namespace: VIRTUAL_NAMESPACE }));
+    build.onLoad({ filter: /.*/, namespace: VIRTUAL_NAMESPACE }, () => ({
+      contents: buildVirtualEntrySource(entryPoint),
+      loader: "js",
+      resolveDir: process.cwd()
+    }));
     build.onResolve({ filter: /^node:/ }, (args) => bundleError(`Node built-in import ${JSON.stringify(args.path)} is not allowed in page eval.`));
     build.onLoad({ filter: /.*/ }, async (args) => {
       if (await realpath(args.path) !== entryPoint) {
@@ -20350,7 +20928,7 @@ var createPageEvalBundlePlugin = (entryPoint) => ({
       }
       const source = await readFile3(args.path, "utf8");
       return {
-        contents: captureFinalExpression(source),
+        contents: exposeLegacyResult(source),
         loader: loaderForPath(args.path)
       };
     });
@@ -20362,12 +20940,23 @@ var createPageEvalBundlePlugin = (entryPoint) => ({
       if (outputs.length !== 1) {
         return bundleError(`Bundle produced ${outputs.length} outputs; expected exactly one script.`);
       }
-      if (/\bexport\b/.test(outputs[0]?.text ?? "")) {
-        return bundleError("Bundled script contains top-level export statements, which page eval cannot run. Remove exports from the entry file (helpers may still export symbols for import).");
-      }
     });
   }
 });
+var buildVirtualEntrySource = (entryPoint) => `
+import * as __argusEntry from ${JSON.stringify(entryPoint)};
+const __argusDefault = __argusEntry.default;
+if (__argusDefault !== undefined && typeof __argusDefault !== 'function') {
+  throw new TypeError('The default export of an Argus scenario must be a function');
+}
+${RESULT_BINDING} = typeof __argusDefault === 'function'
+  ? await __argusDefault(__argusScenarioContext)
+  : __argusEntry.${LEGACY_RESULT_EXPORT};
+`;
+var exposeLegacyResult = (source) => `let ${LEGACY_RESULT_BINDING};
+${captureFinalExpression(source)}
+export { ${LEGACY_RESULT_BINDING} as ${LEGACY_RESULT_EXPORT} };
+`;
 var captureFinalExpression = (source) => {
   const lines = source.split(/\r?\n/);
   const index = findFinalCodeLine(lines);
@@ -20380,7 +20969,7 @@ var captureFinalExpression = (source) => {
     return source;
   }
   const indent = line.match(/^\s*/)?.[0] ?? "";
-  lines[index] = `${indent}${RESULT_BINDING} = (${expression});`;
+  lines[index] = `${indent}${LEGACY_RESULT_BINDING} = (${expression});`;
   return lines.join(`
 `);
 };
@@ -20393,7 +20982,7 @@ var findFinalCodeLine = (lines) => {
   }
   return null;
 };
-var isStatementLike = (source) => /^(?:import|export|const|let|var|function|class|if|for|while|switch|try|catch|finally|return|throw|break|continue)\b/.test(source);
+var isStatementLike = (source) => source === "}" || /^(?:[{}]|import|export|const|let|var|function|class|if|for|while|switch|try|catch|finally|return|throw|break|continue)\b/.test(source);
 var loaderForPath = (filePath) => {
   const extension = path13.extname(filePath).toLowerCase();
   if (extension === ".ts")
@@ -20553,14 +21142,15 @@ var prepareEvalExpression = async (inline, options, output) => {
   if (args == null) {
     return null;
   }
-  const resolvedExpression = await resolveExpression(inline, options, output);
-  if (resolvedExpression == null) {
+  const resolved = await resolveExpressionSource(inline, options, output);
+  if (resolved == null) {
     return null;
   }
   if (!options.iframe) {
     return {
-      expression: resolvedExpression,
-      args: hasEvalArgs2(args) ? args : undefined
+      expression: resolved.expression,
+      args: hasEvalArgs2(args) ? args : undefined,
+      scenario: resolved.scenario
     };
   }
   const iframeTimeoutMs = parseDurationFlagMs(options.iframeTimeout, "--iframe-timeout");
@@ -20569,14 +21159,15 @@ var prepareEvalExpression = async (inline, options, output) => {
     return null;
   }
   return {
-    expression: wrapForIframeEval(wrapExpressionWithArgs(resolvedExpression, args), {
+    expression: wrapForIframeEval(wrapExpressionWithArgs(resolved.expression, args), {
       selector: options.iframe,
       namespace: options.iframeNamespace ?? "argus",
       timeoutMs: iframeTimeoutMs.value ?? 5000
-    })
+    }),
+    scenario: resolved.scenario
   };
 };
-var resolveExpression = async (inline, options, output) => {
+var resolveExpressionSource = async (inline, options, output) => {
   const wantsStdin = options.stdin === true || inline === "-";
   const hasInline = inline != null && inline !== "-";
   const filePath = options.file;
@@ -20598,6 +21189,7 @@ var resolveExpression = async (inline, options, output) => {
     return null;
   }
   let expression;
+  let scenario;
   if (hasFile) {
     const fileContent = await readFileContent(filePath, options.file, output);
     if (fileContent == null) {
@@ -20618,6 +21210,7 @@ var resolveExpression = async (inline, options, output) => {
         return null;
       }
       expression = bundled.code;
+      scenario = true;
     } else {
       expression = fileContent;
     }
@@ -20643,7 +21236,8 @@ var resolveExpression = async (inline, options, output) => {
     output.writeWarn("Expression is required. Provide an inline expression, --file, or --stdin (or pass - as expression).");
     return null;
   }
-  return await prependInjectSource(expression, options.inject, output);
+  const injected = await prependInjectSource(expression, options.inject, output);
+  return injected == null ? null : { expression: injected, scenario };
 };
 var resolveBundleDecision = (options, fileContent) => {
   if (options.noBundle) {
@@ -23601,7 +24195,8 @@ var pollEval = async (input) => {
         returnByValue: input.returnByValue,
         timeoutMs: input.timeoutMs,
         failOnException: input.failOnException,
-        retryCount: input.retryCount
+        retryCount: input.retryCount,
+        scenario: input.scenario
       });
       if (!result.ok) {
         return { kind: "eval-error", failure: result };
@@ -23694,7 +24289,8 @@ var runEval = async (id, rawExpression, options) => {
       returnByValue: options.returnByValue ?? true,
       timeoutMs: timeoutMs.value,
       failOnException: options.failOnException ?? true,
-      retryCount: retryCount.value
+      retryCount: retryCount.value,
+      scenario: prepared.scenario
     });
     if (!singleResult.ok) {
       emitter.emitError(singleResult);
@@ -23713,6 +24309,7 @@ var runEval = async (id, rawExpression, options) => {
     timeoutMs: timeoutMs.value,
     failOnException: options.failOnException ?? true,
     retryCount: retryCount.value,
+    scenario: prepared.scenario,
     intervalMs: intervalMs.value,
     count: countValue.value,
     onResult: async (response) => {
@@ -23826,6 +24423,7 @@ var runEvalUntil = async (id, rawExpression, options) => {
     timeoutMs: timeoutMs.value,
     failOnException: options.failOnException ?? true,
     retryCount: retryCount.value,
+    scenario: prepared.scenario,
     intervalMs: pollIntervalMs,
     count: countValue.value,
     totalTimeoutMs: totalTimeoutMs.value,
@@ -23976,6 +24574,7 @@ var evalCommands = [
       'argus eval app "window.store.getState()" --inject ./debug-hooks.js',
       "argus eval app --file ./script.js --arg level=10 --arg mode=fast",
       "argus eval app --file ./script.js --args ./args.json",
+      "argus eval app --file ./scenario.ts --arg level=10 --json",
       'argus eval app "document.title" --json --out ./result.json',
       'argus eval app "Date.now()" --interval 500 --count 10 --out ./poll.ndjson',
       'argus eval app "Date.now()" --interval 500 --count 10 --out ./frames.json --rotate',
@@ -49994,7 +50593,7 @@ var runExtensionTabs = async (options) => {
       returnErrorResponse: true
     });
   } catch (error) {
-    writeCommandError(output, options, `${resolved.watcher.id}: failed to list extension tabs (${formatError4(error)})`, formatError4(error));
+    writeCommandError(output, options, `${resolved.watcher.id}: failed to list extension tabs (${formatError5(error)})`, formatError5(error));
     process.exitCode = 1;
     return;
   }
@@ -50055,7 +50654,7 @@ var writeCommandError = (output, options, humanMessage, jsonPayload) => {
   }
   output.writeWarn(humanMessage);
 };
-var formatError4 = (error) => error instanceof Error ? error.message : String(error);
+var formatError5 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/tabSelection.js
 var parseTabSelector = (options, missingReason) => {
@@ -50100,7 +50699,7 @@ var fetchExtensionTabs = async (watcher, selector) => {
     }
     return { ok: true, tabs: response.tabs };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to list extension tabs (${formatError5(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to list extension tabs (${formatError6(error)})` };
   }
 };
 var hasTabSelector = (options) => Boolean(options.tab != null || options.url || options.title);
@@ -50130,7 +50729,7 @@ var buildTabsQuery2 = (selector) => {
   }
   return query;
 };
-var formatError5 = (error) => error instanceof Error ? error.message : String(error);
+var formatError6 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/tabAttach.js
 var WATCHER_POLL_TIMEOUT_MS = 5000;
@@ -50149,7 +50748,7 @@ var attachTab = async (controlWatcher, tab, options = {}) => {
     }
     return { ok: true, tab: response.tab, watcherId: response.watcherId };
   } catch (error) {
-    return { ok: false, error: `${controlWatcher.id}: failed to attach tab (${formatError6(error)})` };
+    return { ok: false, error: `${controlWatcher.id}: failed to attach tab (${formatError7(error)})` };
   }
 };
 var waitForTabWatcher = async (controlWatcher, selector, tab, watcherId) => {
@@ -50228,7 +50827,7 @@ var targetMatchesTab = (target, tab) => {
   return Boolean(target.title && target.title === tab.title && target.url === tab.url);
 };
 var delay8 = (ms3) => new Promise((resolve2) => setTimeout(resolve2, ms3));
-var formatError6 = (error) => error instanceof Error ? error.message : String(error);
+var formatError7 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/show.js
 var runExtensionShow = async (id, options, config = {}) => {
@@ -50304,7 +50903,7 @@ var showWatcher = async (watcher, tab, output, options) => {
       returnErrorResponse: true
     });
   } catch (error) {
-    writeFailure(output, options, `${watcher.id}: failed to show page (${formatError7(error)})`, 1);
+    writeFailure(output, options, `${watcher.id}: failed to show page (${formatError8(error)})`, 1);
     return;
   }
   if (!response.ok) {
@@ -50353,7 +50952,7 @@ var writeFailure = (output, options, error, exitCode, extra = {}) => {
   }
   process.exitCode = exitCode;
 };
-var formatError7 = (error) => error instanceof Error ? error.message : String(error);
+var formatError8 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/attach.js
 var runExtensionAttach = async (options) => {
@@ -50577,7 +51176,7 @@ var fetchExtensionTargets = async (watcher) => {
     }
     return { ok: true, targets: response.targets };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to list extension targets (${formatError8(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to list extension targets (${formatError9(error)})` };
   }
 };
 var selectExtensionTarget = async (watcher, target) => {
@@ -50594,7 +51193,7 @@ var selectExtensionTarget = async (watcher, target) => {
     }
     return { ok: true, tab: response.tab, watcherId: response.watcherId };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to select target (${formatError8(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to select target (${formatError9(error)})` };
   }
 };
 var waitForSelectedTarget = async (watcher, target, options = {}) => {
@@ -50740,7 +51339,7 @@ var fetchWatcherStatus = async (watcher) => {
   try {
     return { ok: true, status: await fetchWatcherJson(watcher, { path: "/status", timeoutMs: 1000 }) };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to read status (${formatError8(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to read status (${formatError9(error)})` };
   }
 };
 var statusMatchesTarget = (status, target) => {
@@ -50765,7 +51364,7 @@ var originOf = (url) => {
 };
 var shortenId = (id) => id.length > 18 ? `${id.slice(0, 14)}...` : id;
 var delay9 = (ms3) => new Promise((resolve2) => setTimeout(resolve2, ms3));
-var formatError8 = (error) => error instanceof Error ? error.message : String(error);
+var formatError9 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/use.js
 var runExtensionUse = async (options) => {
@@ -50937,7 +51536,7 @@ var inspectNativeHostState = () => {
       issues: configured ? [] : ["Native messaging hosts are not fully configured."]
     };
   } catch (error) {
-    return { configured: false, hosts: [], issues: [formatError9(error)] };
+    return { configured: false, hosts: [], issues: [formatError10(error)] };
   }
 };
 var fetchExtensionDiagnostics = async (watcher) => {
@@ -50952,7 +51551,7 @@ var fetchExtensionDiagnostics = async (watcher) => {
     }
     return { ok: false, error: response.error.message };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to read extension diagnostics (${formatError9(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to read extension diagnostics (${formatError10(error)})` };
   }
 };
 var inspectWatcher = async (id, diagnostics) => {
@@ -50995,10 +51594,10 @@ var fetchWatcherStatus2 = async (watcher) => {
   try {
     return { ok: true, status: await fetchWatcherJson(watcher, { path: "/status", timeoutMs: 1000 }) };
   } catch (error) {
-    return { ok: false, error: `${watcher.id}: failed to read status (${formatError9(error)})` };
+    return { ok: false, error: `${watcher.id}: failed to read status (${formatError10(error)})` };
   }
 };
-var formatError9 = (error) => error instanceof Error ? error.message : String(error);
+var formatError10 = (error) => error instanceof Error ? error.message : String(error);
 
 // dist/commands/extension/targets.js
 var runExtensionTargets = async (id, options) => {
@@ -51462,6 +52061,7 @@ var coreCommandDefinitions = [
 var coreProgramRegistrars = [(program2) => defineCommands(program2, coreCommandDefinitions)];
 
 // dist/bin.js
+configureMachineSafeConsole(process.argv.slice(2));
 var program2 = createProgram();
 for (const registerProgramPart of coreProgramRegistrars) {
   registerProgramPart(program2);