@saptools/cf-inspector 0.7.0 → 0.8.0

package/dist/cli.js

@@ -152,16 +152,16 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process12 from "process";
+import process13 from "process";
 
 // src/cli/program.ts
 import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 
 // src/cli/commands/attach.ts
-import process3 from "process";
+import process4 from "process";
 
 // src/inspector/discovery.ts
 init_types();
@@ -386,13 +386,22 @@ function startInspectorKeepalive(host, port, options = {}) {
 }
 
 // src/cli/output.ts
-import process from "process";
+import process2 from "process";
 function writeProgress(message) {
-  process.stderr.write(`[cf-inspector] ${message}
+  process2.stderr.write(`[cf-inspector] ${message}
+`);
+}
+function writeArmedEvent(event) {
+  const payload = {
+    event: "breakpoint-armed",
+    schemaVersion: 1,
+    ...event
+  };
+  process2.stderr.write(`${JSON.stringify(payload)}
 `);
 }
 function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
+  process2.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
 }
 function writeHumanSnapshot(snapshot) {
@@ -423,7 +432,7 @@ function writeHumanSnapshot(snapshot) {
       appendStackFrameLine(lines, frame);
     }
   }
-  process.stdout.write(`${lines.join("\n")}
+  process2.stdout.write(`${lines.join("\n")}
 `);
 }
 function appendFrameLines(lines, frame) {
@@ -466,36 +475,36 @@ function appendExceptionLines(lines, exception) {
 }
 function writeLogEvent(event, json) {
   if (json) {
-    process.stdout.write(`${JSON.stringify(event)}
+    process2.stdout.write(`${JSON.stringify(event)}
 `);
     return;
   }
   const isolateSuffix = event.isolate === void 0 ? "" : ` (${formatIsolate(event.isolate)})`;
   if (event.error !== void 0) {
-    process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} !err ${renderTruncated(event.error, event)}
+    process2.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} !err ${renderTruncated(event.error, event)}
 `);
     return;
   }
-  process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} ${renderTruncated(event.value ?? "", event)}
+  process2.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} ${renderTruncated(event.value ?? "", event)}
 `);
 }
 function writeWatchEvent(event, json) {
   if (json) {
-    process.stdout.write(`${JSON.stringify(event)}
+    process2.stdout.write(`${JSON.stringify(event)}
 `);
     return;
   }
-  process.stdout.write(
+  process2.stdout.write(
     `[${event.ts}] hit#${event.hit.toString()} ${event.at} (${formatIsolate(event.isolate)})
 `
   );
   if (event.exception !== void 0) {
-    process.stdout.write(`  exception: ${renderExceptionDetail(event.exception)}
+    process2.stdout.write(`  exception: ${renderExceptionDetail(event.exception)}
 `);
   }
   for (const capture of event.captures) {
     const detail = capture.error ?? capture.value ?? "undefined";
-    process.stdout.write(`  ${capture.expression} = ${renderTruncated(detail, capture)}
+    process2.stdout.write(`  ${capture.expression} = ${renderTruncated(detail, capture)}
 `);
   }
 }
@@ -1776,9 +1785,247 @@ var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
 var DEFAULT_CF_TIMEOUT_SEC = 180;
 var DEFAULT_EXCEPTION_TIMEOUT_SEC = 30;
 
+// src/cli/sessionLock.ts
+init_types();
+import { execFileSync } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import { mkdir, open, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var ELECTION_WINDOW_MS = 25;
+var LOCK_FILE_SUFFIX = ".lock";
+async function acquireDebugSessionLock(target, options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const pid = options.pid ?? process.pid;
+  const getProcessStart = options.getProcessStart ?? processStart;
+  const ownerProcessStart = getProcessStart(pid);
+  const token = options.token?.() ?? randomUUID();
+  const targetIdentity = debugTargetIdentity(target);
+  const key = createHash("sha256").update(targetIdentity).digest("hex");
+  const lockRoot = options.stateRoot ?? defaultStateRoot();
+  const lockDirectory = join(lockRoot, "cf-inspector", "locks");
+  const ownPath = join(lockDirectory, `${key}.${pid.toString()}.${token}${LOCK_FILE_SUFFIX}`);
+  const metadata = {
+    pid,
+    ...ownerProcessStart === void 0 ? {} : { processStart: ownerProcessStart },
+    state: "pending",
+    startedAt: now().toISOString(),
+    token,
+    target: targetIdentity
+  };
+  await mkdir(lockDirectory, { recursive: true, mode: 448 });
+  const handle = await open(ownPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+  try {
+    await handle.writeFile(`${JSON.stringify(metadata)}
+`, "utf8");
+  } finally {
+    await handle.close();
+  }
+  try {
+    await new Promise((resolve) => {
+      setTimeout(resolve, ELECTION_WINDOW_MS);
+    });
+    const contenders = await findLiveContenders(
+      lockDirectory,
+      key,
+      ownPath,
+      options.isProcessAlive ?? processIsAlive,
+      getProcessStart
+    );
+    const owner = contenders.find((candidate) => candidate.state === "owned") ?? contenders.filter((candidate) => candidate.state === "pending" && candidate.token < token).sort((left, right) => left.token.localeCompare(right.token))[0];
+    if (owner !== void 0) {
+      throw alreadyDebuggedError(owner);
+    }
+    await writeLockMetadata(ownPath, { ...metadata, state: "owned" });
+  } catch (error) {
+    await unlink(ownPath).catch(() => {
+    });
+    throw error;
+  }
+  let released = false;
+  return {
+    path: ownPath,
+    release: async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      const current = await readLockMetadata(ownPath);
+      if (current?.token !== token || current.pid !== pid) {
+        return;
+      }
+      await unlink(ownPath).catch((error) => {
+        if (!isNodeError(error, "ENOENT")) {
+          throw error;
+        }
+      });
+    }
+  };
+}
+function debugTargetIdentity(target) {
+  const targetIndex = target.targetIndex ?? 0;
+  if (target.kind === "port") {
+    return JSON.stringify({
+      kind: "port",
+      host: normalizeHost(target.host),
+      port: target.port,
+      targetIndex
+    });
+  }
+  return JSON.stringify({
+    kind: "cf",
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    targetIndex
+  });
+}
+function defaultStateRoot() {
+  const configured = process.env["CF_INSPECTOR_STATE_DIR"]?.trim();
+  return configured === void 0 || configured.length === 0 ? join(homedir(), ".saptools") : configured;
+}
+async function findLiveContenders(lockDirectory, key, ownPath, isProcessAlive, getProcessStart) {
+  const prefix = `${key}.`;
+  const names = await readdir(lockDirectory);
+  const contenders = [];
+  for (const name of names) {
+    if (!name.startsWith(prefix) || !name.endsWith(LOCK_FILE_SUFFIX)) {
+      continue;
+    }
+    const path = join(lockDirectory, name);
+    if (path === ownPath) {
+      continue;
+    }
+    const info = await stat(path).catch(() => {
+    });
+    const metadata = await readLockMetadata(path) ?? (info === void 0 ? void 0 : metadataFromFilename(name, key, info.mtimeMs));
+    if (metadata !== void 0) {
+      if (ownerIsAlive(metadata, isProcessAlive, getProcessStart)) {
+        contenders.push(metadata);
+      } else {
+        await unlink(path).catch(() => {
+        });
+      }
+      continue;
+    }
+    if (info !== void 0) {
+      contenders.push({
+        pid: 0,
+        state: "owned",
+        startedAt: new Date(info.mtimeMs).toISOString(),
+        token: "unknown",
+        target: "unknown"
+      });
+    }
+  }
+  return contenders;
+}
+async function readLockMetadata(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (!isRecord2(parsed)) {
+      return void 0;
+    }
+    const pid = parsed["pid"];
+    const processStart2 = parsed["processStart"];
+    const state = parsed["state"];
+    const startedAt = parsed["startedAt"];
+    const token = parsed["token"];
+    const target = parsed["target"];
+    if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0 || processStart2 !== void 0 && typeof processStart2 !== "string" || state !== "pending" && state !== "owned" || typeof startedAt !== "string" || Number.isNaN(Date.parse(startedAt)) || typeof token !== "string" || token.length === 0 || typeof target !== "string" || target.length === 0) {
+      return void 0;
+    }
+    return {
+      pid,
+      ...typeof processStart2 === "string" ? { processStart: processStart2 } : {},
+      state,
+      startedAt,
+      token,
+      target
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeLockMetadata(path, metadata) {
+  await writeFile(path, `${JSON.stringify(metadata)}
+`, { encoding: "utf8", mode: 384 });
+}
+function metadataFromFilename(name, key, mtimeMs) {
+  const match = new RegExp(`^${key}\\.(\\d+)\\.(.+)\\${LOCK_FILE_SUFFIX}$`, "u").exec(name);
+  const rawPid = match?.[1];
+  const token = match?.[2];
+  if (rawPid === void 0 || token === void 0 || token.length === 0) {
+    return void 0;
+  }
+  const pid = Number.parseInt(rawPid, 10);
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return void 0;
+  }
+  return {
+    pid,
+    state: "owned",
+    startedAt: new Date(mtimeMs).toISOString(),
+    token,
+    target: "unknown"
+  };
+}
+function ownerIsAlive(metadata, isProcessAlive, getProcessStart) {
+  if (!isProcessAlive(metadata.pid)) {
+    return false;
+  }
+  const currentStart = getProcessStart(metadata.pid);
+  return metadata.processStart === void 0 || currentStart === void 0 || metadata.processStart === currentStart;
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    const status = processStatus(pid);
+    return !status?.startsWith("Z");
+  } catch (error) {
+    return isNodeError(error, "EPERM");
+  }
+}
+function processStatus(pid) {
+  return runPs(pid, "stat=");
+}
+function processStart(pid) {
+  return runPs(pid, "lstart=");
+}
+function runPs(pid, field) {
+  try {
+    const value = execFileSync("ps", ["-o", field, "-p", pid.toString()], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value.length === 0 ? void 0 : value;
+  } catch {
+    return void 0;
+  }
+}
+function alreadyDebuggedError(owner) {
+  const ownerLabel = owner.pid > 0 ? `PID ${owner.pid.toString()}` : "an unknown process";
+  return new CfInspectorError(
+    "TARGET_ALREADY_DEBUGGED",
+    `Another cf-inspector session (${ownerLabel}, started ${owner.startedAt}) is already actively debugging this target. Concurrent debugging sessions on the same isolate(s) can corrupt each other and disrupt real application traffic, so this attempt was refused rather than queued. Wait for the other session to finish, or confirm that it is gone before retrying; locks from dead processes are reclaimed automatically.`
+  );
+}
+function normalizeHost(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized === "localhost" || normalized === "::1" ? "127.0.0.1" : normalized;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
 // src/cli/warnings.ts
 init_types();
-import process2 from "process";
+import process3 from "process";
 
 // src/cli/captureParser.ts
 function parseCaptureList(raw) {
@@ -1893,7 +2140,7 @@ function warnOnCaptureMutationRisk(expressions, allowMutation) {
     return;
   }
   const suffix = allowMutation ? "will run without the V8 side-effect guard because --allow-mutation was passed." : "will be checked by the V8 side-effect guard and blocked unless V8 proves them safe; pass --allow-mutation to run them unrestricted.";
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${riskyCount.toString()} capture ${riskyCount === 1 ? "expression looks" : "expressions look"} mutation-capable and ${suffix}
 `
   );
@@ -1908,7 +2155,7 @@ function enforceNativeConditionMutationPolicy(expression, allowMutation, context
       `${context} looks mutation-capable. Native breakpoint conditions cannot be protected by V8's side-effect guard; pass --allow-mutation to arm it explicitly.`
     );
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${context} looks mutation-capable and will run as a native breakpoint condition; native conditions cannot be side-effect-gated.
 `
   );
@@ -1917,7 +2164,7 @@ function warnOnMutationRisk(expression, context) {
   if (!looksLikeMutation(expression)) {
     return;
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${context} looks mutation-capable and will execute against the live inspectee without a side-effect guard.
 `
   );
@@ -1926,7 +2173,7 @@ function warnOnUnboundBreakpoints(handles) {
   for (const handle of handles) {
     if (handle.resolvedLocations.length === 0) {
       const tsHint = handle.file.endsWith(".ts") ? " Hint: Source TS breakpoints may not bind. Try inspecting loaded scripts with list-scripts and target the compiled .js file instead." : "";
-      process2.stderr.write(
+      process3.stderr.write(
         `[cf-inspector] warning: breakpoint ${handle.file}:${handle.line.toString()} did not bind to any loaded script. Check the path or pass --remote-root. Use 'list-scripts' to inspect what V8 currently has loaded.${tsHint}
 `
       );
@@ -1937,14 +2184,14 @@ function warnOnImplicitInspectorSelection(session, targetWasExplicit, workerWasE
   const targetCount = session.targetCount ?? 1;
   const targetIndex = session.targetIndex ?? 0;
   if (!targetWasExplicit && targetCount > 1) {
-    process2.stderr.write(
+    process3.stderr.write(
       `[cf-inspector] notice: attached to inspector target ${targetIndex.toString()} of ${targetCount.toString()}; pass --target <index> to pick another.
 `
     );
   }
   const workerCount = session.workerTargets?.length ?? 0;
   if (!workerWasExplicit && workerCount > 0) {
-    process2.stderr.write(
+    process3.stderr.write(
       `[cf-inspector] notice: attached to the main isolate; ${workerCount.toString()} Node ${workerCount === 1 ? "worker is" : "workers are"} available. This command is single-isolate by nature; use --worker-id <id> to inspect one worker explicitly.
 `
     );
@@ -1957,7 +2204,7 @@ function warnOnBoundBreakpointWithoutHit(handles) {
   if (boundCount === 0) {
     return;
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${boundCount.toString()} breakpoint ${boundCount === 1 ? "location bound" : "locations bound"}, but no hit was observed. No selected isolate executed the location before the command stopped. Check conditions, hit counts, request traffic, and use check-breakpoint to verify the exact line.
 `
   );
@@ -1967,7 +2214,7 @@ function roundDurationMs(durationMs) {
 }
 function warnOnUnmatchedPause(pause) {
   const reason = pause.reason.length > 0 ? pause.reason : "unknown";
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: target is paused by another debugger event (${reason} at ${formatPauseLocation(pause)}); waiting for it to resume...
 `
   );
@@ -2142,65 +2389,75 @@ function parseWorkerId(value) {
   return trimmed;
 }
 async function withSession(target, fn, reportProgress, signal) {
-  const tunnel = await openTarget(target, reportProgress, signal);
-  let session;
+  const lock = await acquireDebugSessionLock(target);
   try {
-    reportProgress?.(
-      `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
-    );
-    session = await connectInspector({
-      port: tunnel.port,
-      host: tunnel.host,
-      ...selectionOptions(target.targetIndex, target.workerIndex),
-      ...target.workerId === void 0 ? {} : { workerId: target.workerId }
-    });
-    warnOnImplicitInspectorSelection(
-      session,
-      target.targetIndex !== void 0,
-      target.workerIndex !== void 0 || target.workerId !== void 0
-    );
-    reportProgress?.("Inspector session is ready.");
-    return await fn(session, tunnel.port);
-  } finally {
-    if (session) {
-      reportProgress?.("Closing the inspector session...");
-      await session.dispose();
-      reportProgress?.("Inspector session closed.");
-    }
-    await tunnel.dispose();
-  }
-}
-async function withSessions(target, fn, reportProgress, signal) {
-  const tunnel = await openTarget(target, reportProgress, signal);
-  let group;
-  try {
-    reportProgress?.(
-      `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
-    );
-    const autoAttach = target.targetIndex === void 0 && target.workerIndex === void 0 && target.workerId === void 0 && target.mainOnly !== true;
-    if (autoAttach) {
-      group = await connectInspectorGroup({ port: tunnel.port, host: tunnel.host });
-    } else {
-      const session = await connectInspector({
+    const tunnel = await openTarget(target, reportProgress, signal);
+    let session;
+    try {
+      reportProgress?.(
+        `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
+      );
+      session = await connectInspector({
         port: tunnel.port,
         host: tunnel.host,
-        ...selectionOptions(target.targetIndex, target.workerIndex, target.workerId)
+        ...selectionOptions(target.targetIndex, target.workerIndex),
+        ...target.workerId === void 0 ? {} : { workerId: target.workerId }
       });
-      group = singleSessionGroup(session);
+      warnOnImplicitInspectorSelection(
+        session,
+        target.targetIndex !== void 0,
+        target.workerIndex !== void 0 || target.workerId !== void 0
+      );
+      reportProgress?.("Inspector session is ready.");
+      return await fn(session, tunnel.port);
+    } finally {
+      if (session) {
+        reportProgress?.("Closing the inspector session...");
+        await session.dispose();
+        reportProgress?.("Inspector session closed.");
+      }
+      await tunnel.dispose();
     }
-    reportProgress?.("Inspector session is ready.");
-    return await fn(group, tunnel.port);
   } finally {
+    await lock.release();
+  }
+}
+async function withSessions(target, fn, reportProgress, signal) {
+  const lock = await acquireDebugSessionLock(target);
+  try {
+    const tunnel = await openTarget(target, reportProgress, signal);
+    let group;
     try {
-      if (group !== void 0) {
-        const sessionCount = group.list().length;
-        reportProgress?.(sessionCount === 1 ? "Closing the inspector session..." : `Closing ${sessionCount.toString()} inspector sessions...`);
-        await group.dispose();
-        reportProgress?.(sessionCount === 1 ? "Inspector session closed." : "Inspector sessions closed.");
+      reportProgress?.(
+        `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
+      );
+      const autoAttach = target.targetIndex === void 0 && target.workerIndex === void 0 && target.workerId === void 0 && target.mainOnly !== true;
+      if (autoAttach) {
+        group = await connectInspectorGroup({ port: tunnel.port, host: tunnel.host });
+      } else {
+        const session = await connectInspector({
+          port: tunnel.port,
+          host: tunnel.host,
+          ...selectionOptions(target.targetIndex, target.workerIndex, target.workerId)
+        });
+        group = singleSessionGroup(session);
       }
+      reportProgress?.("Inspector session is ready.");
+      return await fn(group, tunnel.port);
     } finally {
-      await tunnel.dispose();
+      try {
+        if (group !== void 0) {
+          const sessionCount = group.list().length;
+          reportProgress?.(sessionCount === 1 ? "Closing the inspector session..." : `Closing ${sessionCount.toString()} inspector sessions...`);
+          await group.dispose();
+          reportProgress?.(sessionCount === 1 ? "Inspector session closed." : "Inspector sessions closed.");
+        }
+      } finally {
+        await tunnel.dispose();
+      }
     }
+  } finally {
+    await lock.release();
   }
 }
 function singleSessionGroup(session) {
@@ -2262,7 +2519,7 @@ async function handleAttach(opts) {
       writeJson({ host: tunnel.host, port: tunnel.port, ...version });
       return;
     }
-    process3.stdout.write(
+    process4.stdout.write(
       `Connected to ${tunnel.host}:${tunnel.port.toString()}
   Browser: ${version.browser}
   Protocol: ${version.protocolVersion}
@@ -2274,7 +2531,7 @@ async function handleAttach(opts) {
 }
 
 // src/cli/commands/checkBreakpoint.ts
-import process4 from "process";
+import process5 from "process";
 
 // src/pathMapper.ts
 init_types();
@@ -2561,25 +2818,25 @@ async function checkSession(session, matcher, requestedLine) {
 }
 function writeHumanCheck(result) {
   if (result.status === "script-not-loaded") {
-    process4.stdout.write(
+    process5.stdout.write(
       `${result.file}:${result.line.toString()} does not match any loaded script. Run list-scripts and check --remote-root/path mapping, or trigger lazy module loading first.
 `
     );
     return;
   }
   if (result.status === "unbreakable") {
-    process4.stdout.write(
+    process5.stdout.write(
       `${result.file}:${result.line.toString()} matches a loaded script, but this exact line has no breakable location. Try a neighboring executable line.
 `
     );
     return;
   }
-  process4.stdout.write(`${result.file}:${result.line.toString()} is breakable:
+  process5.stdout.write(`${result.file}:${result.line.toString()} is breakable:
 `);
   for (const script of result.scripts) {
     for (const location of script.locations) {
       const isolate = script.isolate.kind === "main" ? "main" : `worker ${script.isolate.workerId}`;
-      process4.stdout.write(
+      process5.stdout.write(
         `  ${isolate}	${script.url}	line ${(location.lineNumber + 1).toString()}:${((location.columnNumber ?? 0) + 1).toString()}
 `
       );
@@ -2588,7 +2845,7 @@ function writeHumanCheck(result) {
 }
 
 // src/cli/commands/eval.ts
-import process5 from "process";
+import process6 from "process";
 
 // src/inspector/runtime.ts
 init_types();
@@ -2685,7 +2942,7 @@ async function handleEval(opts) {
   if (opts.json) {
     writeJson(result);
     if (result.exceptionDetails !== void 0) {
-      process5.exitCode = 1;
+      process6.exitCode = 1;
     }
     return;
   }
@@ -2694,33 +2951,33 @@ async function handleEval(opts) {
 function writeHumanEvalResult(result) {
   if (result.exceptionDetails !== void 0) {
     const detail = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "evaluation failed";
-    process5.stderr.write(`${detail}
+    process6.stderr.write(`${detail}
 `);
-    process5.exitCode = 1;
+    process6.exitCode = 1;
     return;
   }
   const inner = result.result;
   if (inner === void 0) {
-    process5.stdout.write("\n");
+    process6.stdout.write("\n");
     return;
   }
   if (typeof inner.value === "string") {
-    process5.stdout.write(`${inner.value}
+    process6.stdout.write(`${inner.value}
 `);
     return;
   }
   if (typeof inner.description === "string") {
-    process5.stdout.write(`${inner.description}
+    process6.stdout.write(`${inner.description}
 `);
     return;
   }
-  process5.stdout.write(`${JSON.stringify(inner.value)}
+  process6.stdout.write(`${JSON.stringify(inner.value)}
 `);
 }
 
 // src/cli/commands/exception.ts
 import { performance as performance5 } from "perf_hooks";
-import process7 from "process";
+import process8 from "process";
 
 // src/inspector/pause.ts
 init_types();
@@ -2855,6 +3112,8 @@ var BreakpointFanout = class {
   detachError;
   activeRace;
   pauseReasons = [];
+  pendingSetupError;
+  preserveReadinessErrors = false;
   constructor(group, setupSession, pauseReasons = []) {
     this.pauseReasons = pauseReasons;
     this.detach = group.onSession((session) => {
@@ -2880,13 +3139,51 @@ var BreakpointFanout = class {
       this.activeRace?.remove(session);
     });
     this.detachError = group.onError((error) => {
+      if (this.setupErrors.length === 0 && this.pendingSetupError === void 0) {
+        this.pendingSetupError = error;
+      }
       for (const reject of this.setupErrors) {
         reject(error);
       }
     });
   }
-  async ready() {
-    await Promise.all([...this.records.values()].map((record) => record.setup));
+  async ready(options = {}) {
+    if (options.includeNewSessions !== true) {
+      const records = [...this.records.values()];
+      await Promise.all(records.map((record) => record.setup));
+      options.onReady?.(this.outcomesFor(records));
+      return;
+    }
+    this.preserveReadinessErrors = true;
+    const pendingError = this.takePendingSetupError();
+    if (pendingError !== void 0) {
+      throw pendingError;
+    }
+    let rejectGroupError = () => void 0;
+    const groupError = new Promise((_resolve, reject) => {
+      rejectGroupError = reject;
+    });
+    this.setupErrors.push(rejectGroupError);
+    try {
+      let stableRecords;
+      while (stableRecords === void 0) {
+        const records = [...this.records.values()];
+        await Promise.race([
+          Promise.all(records.map((record) => record.setup)),
+          groupError
+        ]);
+        const stable = records.length === this.records.size && records.every((record) => this.records.get(record.session) === record);
+        if (stable) {
+          stableRecords = records;
+        }
+      }
+      options.onReady?.(this.outcomesFor(stableRecords));
+    } finally {
+      const index = this.setupErrors.indexOf(rejectGroupError);
+      if (index >= 0) {
+        this.setupErrors.splice(index, 1);
+      }
+    }
   }
   trackHandle(session, handle) {
     const record = this.records.get(session);
@@ -2895,11 +3192,19 @@ var BreakpointFanout = class {
     }
   }
   availableOutcomes() {
-    return [...this.records.values()].map((record) => ({
+    return this.outcomesFor([...this.records.values()]);
+  }
+  outcomesFor(records) {
+    return records.map((record) => ({
       session: record.session,
       setup: { handles: record.handles }
     }));
   }
+  takePendingSetupError() {
+    const error = this.pendingSetupError;
+    this.pendingSetupError = void 0;
+    return error;
+  }
   async waitForFirst(timeoutMs, options = {}, signal) {
     if (this.activeRace !== void 0) {
       throw new CfInspectorError("INVALID_ARGUMENT", "A fan-out pause race is already active");
@@ -2908,6 +3213,12 @@ var BreakpointFanout = class {
     this.pauseReasons = options.pauseReasons ?? [];
     this.activeRace = race;
     this.setupErrors.push(race.reject);
+    if (this.preserveReadinessErrors) {
+      const pendingError = this.takePendingSetupError();
+      if (pendingError !== void 0) {
+        race.reject(pendingError);
+      }
+    }
     for (const record of this.records.values()) {
       race.add(record);
     }
@@ -3814,19 +4125,19 @@ async function captureExpression(session, callFrameId, expression, maxValueLengt
 init_types();
 
 // src/cli/signals.ts
-import process6 from "process";
+import process7 from "process";
 async function withTerminationSignal(fn) {
   const abort = new AbortController();
   const onSignal = () => {
     abort.abort();
   };
-  process6.once("SIGINT", onSignal);
-  process6.once("SIGTERM", onSignal);
+  process7.once("SIGINT", onSignal);
+  process7.once("SIGTERM", onSignal);
   try {
     return await fn(abort.signal);
   } finally {
-    process6.off("SIGINT", onSignal);
-    process6.off("SIGTERM", onSignal);
+    process7.off("SIGINT", onSignal);
+    process7.off("SIGTERM", onSignal);
   }
 }
 
@@ -3878,7 +4189,20 @@ async function runExceptionCommand(command, opts, signal) {
     let winner;
     let preserveWinner = false;
     try {
-      await fanout.ready();
+      await fanout.ready(opts.readyEvent === true ? {
+        includeNewSessions: true,
+        onReady: (outcomes) => {
+          if (signal?.aborted === true) {
+            return;
+          }
+          writeArmedEvent({
+            command: "exception",
+            sessions: outcomes.length,
+            resolvedLocations: null,
+            timeoutMs: command.timeoutMs
+          });
+        }
+      } : {});
       const hit = await fanout.waitForFirst(command.timeoutMs, {
         pauseReasons: ["exception", "promiseRejection"],
         unmatchedPausePolicy: "wait-for-resume"
@@ -3913,7 +4237,7 @@ async function resumeAfterException(session, snapshot, pausedStartedAt) {
     await resume(session);
     return withPausedDuration(snapshot, roundDurationMs(performance5.now() - pausedStartedAt));
   } catch {
-    process7.stderr.write(
+    process8.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after exception capture; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3927,20 +4251,48 @@ async function disablePauseOnExceptionsBestEffort(session) {
 }
 
 // src/cli/commands/listScripts.ts
-import process8 from "process";
+import process9 from "process";
 async function handleListScripts(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const filter = compileScriptUrlFilter(opts.filter);
-  const scripts = (await withSession(target, (session) => Promise.resolve(listScripts(session)))).filter((script) => filter === void 0 || filter(script.url));
+  const scripts = (await withSessions(target, (group) => {
+    const sessions = group.list();
+    warnOnListScriptsSelection(target, {
+      targetCount: group.targetCount,
+      targetIndex: group.targetIndex,
+      ...sessions[0]?.workerTargets === void 0 ? {} : { workerTargets: sessions[0].workerTargets }
+    });
+    return Promise.resolve(collectListedScripts(sessions));
+  })).filter((script) => filter === void 0 || filter(script.url));
   if (opts.json) {
     writeJson(scripts);
     return;
   }
   for (const script of scripts) {
-    process8.stdout.write(`${script.scriptId}	${script.url}
-`);
+    process9.stdout.write(
+      `${script.scriptId}	${script.url}	${formatIsolate2(script.isolate)}
+`
+    );
   }
 }
+function warnOnListScriptsSelection(target, selection) {
+  const autoAttach = target.targetIndex === void 0 && target.workerIndex === void 0 && target.workerId === void 0 && target.mainOnly !== true;
+  const isolateWasExplicit = autoAttach || target.workerIndex !== void 0 || target.workerId !== void 0 || target.mainOnly === true;
+  warnOnImplicitInspectorSelection(
+    selection,
+    target.targetIndex !== void 0,
+    isolateWasExplicit
+  );
+}
+function collectListedScripts(sessions) {
+  return sessions.flatMap((session) => listScripts(session).map((script) => ({
+    ...script,
+    isolate: session.isolate ?? { kind: "main" }
+  })));
+}
+function formatIsolate2(isolate) {
+  return isolate.kind === "worker" ? `worker:${isolate.workerId}` : "main";
+}
 async function handleListTargets(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const tunnel = await openTarget(target);
@@ -3968,7 +4320,7 @@ async function buildListedTargets(targets) {
       return buildListedTarget(target, index, workerResult.supported, workerResult.workers);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      process8.stderr.write(
+      process9.stderr.write(
         `[cf-inspector] warning: worker discovery failed for raw target ${index.toString()}: ${message}
 `
       );
@@ -3995,7 +4347,7 @@ function looksLikeWorkerTarget(target) {
   return `${target.type} ${target.title} ${target.url}`.toLowerCase().includes("worker");
 }
 function writeTargetCountSummary(targetCount, workerCount) {
-  process8.stderr.write(
+  process9.stderr.write(
     `[cf-inspector] ${targetCount.toString()} raw inspector ${targetCount === 1 ? "target" : "targets"}; ${workerCount.toString()} ${workerCount === 1 ? "worker" : "workers"}.
 `
   );
@@ -4006,7 +4358,7 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
   }
   const supported = targets[0]?.workerDiscoverySupported === true;
   const supportHint = supported ? "NodeWorker discovery is available, but no live worker attached." : "This runtime did not expose NodeWorker discovery.";
-  process8.stderr.write(
+  process9.stderr.write(
     `[cf-inspector] warning: only the main inspector target is reachable. ${supportHint} If worker code is expected, ensure the worker is alive and rerun list-targets. A worker on a separate inspector port is not carried by a single Cloud Foundry tunnel.
 `
   );
@@ -4014,12 +4366,12 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
 function writeHumanTargets(targets) {
   for (const target of targets) {
     const workerLabel = target.likelyWorker ? "	likely-worker" : "";
-    process8.stdout.write(
+    process9.stdout.write(
       `${target.index.toString()}	target	${target.type}	${target.title}	${target.url}${workerLabel}
 `
     );
     for (const worker of target.workers) {
-      process8.stdout.write(
+      process9.stdout.write(
         `  ${worker.index.toString()}	worker	${worker.type}	${worker.title}	${worker.url}
 `
       );
@@ -4096,7 +4448,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process9 from "process";
+import process10 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -4273,6 +4625,9 @@ async function streamLogpoint(session, options) {
     if (event === void 0) {
       return;
     }
+    if (options.eventGate?.() === false) {
+      return;
+    }
     emitted += 1;
     try {
       options.onEvent(event);
@@ -4391,6 +4746,7 @@ async function handleLog(opts) {
         ...condition === void 0 ? {} : { condition },
         maxValueLength,
         json: opts.json,
+        emitReadyEvent: opts.readyEvent === true,
         signal
       });
       writeLogSummary(result.stoppedReason, result.emitted, opts.json);
@@ -4402,9 +4758,13 @@ async function runLogGroup(group, options) {
   const tasks = /* @__PURE__ */ new Set();
   const removedSessions = /* @__PURE__ */ new Set();
   const results = [];
+  const pendingArming = /* @__PURE__ */ new Set();
+  const resolvedLocations = /* @__PURE__ */ new Map();
   let fatalError;
   let emitted = 0;
   let reason = "signal";
+  let sessionRegistrationComplete = false;
+  let readyEventEmitted = !options.emitReadyEvent;
   let resolveStop;
   const stopped = new Promise((resolve) => {
     resolveStop = resolve;
@@ -4427,10 +4787,35 @@ async function runLogGroup(group, options) {
   const timer = options.durationMs === void 0 ? void 0 : setTimeout(() => {
     finish("duration");
   }, options.durationMs);
+  const detachError = options.emitReadyEvent ? group.onError((error) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    fatalError = error;
+    finish("transport-closed");
+  }) : () => void 0;
+  const emitReadyEventIfArmed = () => {
+    if (readyEventEmitted || !sessionRegistrationComplete || pendingArming.size > 0 || resolvedLocations.size === 0 || controller.signal.aborted) {
+      return;
+    }
+    writeArmedEvent({
+      command: "log",
+      sessions: resolvedLocations.size,
+      resolvedLocations: [...resolvedLocations.values()].reduce(
+        (total, count) => total + count,
+        0
+      ),
+      timeoutMs: null
+    });
+    readyEventEmitted = true;
+  };
   const startSession = (session) => {
     if (controller.signal.aborted) {
       return;
     }
+    if (!readyEventEmitted) {
+      pendingArming.add(session);
+    }
     const task = (async () => {
       await validateExpression(session, options.expression);
       if (options.condition !== void 0) {
@@ -4444,6 +4829,7 @@ async function runLogGroup(group, options) {
         ...options.condition === void 0 ? {} : { condition: options.condition },
         maxValueLength: options.maxValueLength,
         signal: controller.signal,
+        ...options.emitReadyEvent ? { eventGate: () => readyEventEmitted } : {},
         onEvent: (event) => {
           if (controller.signal.aborted) {
             return;
@@ -4456,6 +4842,11 @@ async function runLogGroup(group, options) {
         },
         onBreakpointSet: (handle) => {
           warnOnUnboundBreakpoints([handle]);
+          if (!readyEventEmitted) {
+            resolvedLocations.set(session, handle.resolvedLocations.length);
+            pendingArming.delete(session);
+            emitReadyEventIfArmed();
+          }
         }
       });
     })();
@@ -4468,6 +4859,9 @@ async function runLogGroup(group, options) {
         }
       },
       (error) => {
+        if (options.emitReadyEvent && (removedSessions.has(session) || fatalError !== void 0)) {
+          return;
+        }
         fatalError = error;
         finish("transport-closed");
       }
@@ -4476,8 +4870,27 @@ async function runLogGroup(group, options) {
     });
   };
   const detach = group.onSession(startSession);
+  sessionRegistrationComplete = true;
+  emitReadyEventIfArmed();
   const detachRemoved = group.onSessionRemoved((session) => {
     removedSessions.add(session);
+    if (!readyEventEmitted) {
+      if (controller.signal.aborted) {
+        pendingArming.delete(session);
+        resolvedLocations.delete(session);
+        return;
+      }
+      if (pendingArming.has(session)) {
+        fatalError = new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          "A worker detached before logpoint arming completed; no readiness event was emitted."
+        );
+        finish("transport-closed");
+        return;
+      }
+      resolvedLocations.delete(session);
+      emitReadyEventIfArmed();
+    }
   });
   try {
     await stopped;
@@ -4485,6 +4898,7 @@ async function runLogGroup(group, options) {
   } finally {
     detach();
     detachRemoved();
+    detachError();
     if (timer !== void 0) {
       clearTimeout(timer);
     }
@@ -4503,11 +4917,11 @@ function isZeroHitStop(reason) {
 }
 function writeLogSummary(stoppedReason, emitted, json) {
   if (json) {
-    process9.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+    process10.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process9.stderr.write(
+  process10.stderr.write(
     `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
 `
   );
@@ -4515,7 +4929,7 @@ function writeLogSummary(stoppedReason, emitted, json) {
 
 // src/cli/commands/snapshot.ts
 import { performance as performance6 } from "perf_hooks";
-import process10 from "process";
+import process11 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -4591,18 +5005,38 @@ async function runSnapshotCommand(command, opts, reportProgress, signal) {
     let winner;
     let preserveWinner = false;
     try {
-      await fanout.ready();
-      if (command.setupEvals.length > 0) {
-        reportProgress?.("Setup evaluation complete.");
-      }
-      if (command.condition !== void 0) {
-        reportProgress?.("Breakpoint condition is valid.");
+      const reportArmedSetup = (outcomes) => {
+        if (opts.readyEvent === true && signal?.aborted === true) {
+          return;
+        }
+        if (command.setupEvals.length > 0) {
+          reportProgress?.("Setup evaluation complete.");
+        }
+        if (command.condition !== void 0) {
+          reportProgress?.("Breakpoint condition is valid.");
+        }
+        const setup = reportBreakpointOutcomes(outcomes, reportProgress);
+        reportProgress?.(
+          `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
+        );
+        if (opts.readyEvent === true && signal?.aborted !== true) {
+          writeArmedEvent({
+            command: "snapshot",
+            sessions: setup.sessions,
+            resolvedLocations: setup.resolvedLocations,
+            timeoutMs: command.timeoutMs
+          });
+        }
+      };
+      if (opts.readyEvent === true) {
+        await fanout.ready({
+          includeNewSessions: true,
+          onReady: reportArmedSetup
+        });
+      } else {
+        await fanout.ready();
+        reportArmedSetup(fanout.availableOutcomes());
       }
-      const outcomes = fanout.availableOutcomes();
-      reportBreakpointOutcomes(outcomes, reportProgress);
-      reportProgress?.(
-        `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
-      );
       const hit = await fanout.waitForFirst(command.timeoutMs, {
         unmatchedPausePolicy: opts.failOnUnmatchedPause === true ? "fail" : "wait-for-resume",
         ...opts.failOnUnmatchedPause === true ? {} : { onUnmatchedPause: warnOnUnmatchedPause }
@@ -4650,11 +5084,12 @@ function reportBreakpointOutcomes(outcomes, reportProgress) {
     reportProgress?.(
       `Breakpoint setup complete: ${locations.toString()} resolved ${locations === 1 ? "location" : "locations"}.`
     );
-    return;
+    return { sessions: outcomes.length, resolvedLocations: locations };
   }
   reportProgress?.(
     `Breakpoint setup complete: sessions=${outcomes.length.toString()} boundSessions=${boundSessions.toString()} resolvedLocations=${locations.toString()}.`
   );
+  return { sessions: outcomes.length, resolvedLocations: locations };
 }
 async function captureSnapshotResult(session, pause, command, opts, reportProgress) {
   const pausedStartedAt = pause.receivedAtMs ?? performance6.now();
@@ -4694,7 +5129,7 @@ async function resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportPro
     reportProgress?.("Target resumed.");
     return withPausedDuration(snapshot, roundDurationMs(performance6.now() - pausedStartedAt));
   } catch {
-    process10.stderr.write(
+    process11.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -4707,7 +5142,7 @@ function parseSetupEvals(raw) {
 
 // src/cli/commands/watch.ts
 import { performance as performance7 } from "perf_hooks";
-import process11 from "process";
+import process12 from "process";
 init_types();
 async function handleWatch(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -4775,7 +5210,26 @@ async function runWatchGroup(group, command, opts, signal) {
   let stoppedReason = "signal";
   const deadline = computeDeadline(command.durationMs);
   try {
-    await fanout.ready();
+    await fanout.ready(opts.readyEvent === true ? {
+      includeNewSessions: true,
+      onReady: (outcomes) => {
+        if (signal.aborted || remainingForLoop(deadline, command.perHitTimeoutMs) <= 0) {
+          return;
+        }
+        writeArmedEvent({
+          command: "watch",
+          sessions: outcomes.length,
+          resolvedLocations: outcomes.reduce(
+            (total, outcome) => total + outcome.setup.handles.reduce(
+              (sessionTotal, handle) => sessionTotal + handle.resolvedLocations.length,
+              0
+            ),
+            0
+          ),
+          timeoutMs: command.perHitTimeoutMs
+        });
+      }
+    } : {});
     while (!signal.aborted) {
       const remainingMs = remainingForLoop(deadline, command.perHitTimeoutMs);
       if (remainingMs <= 0) {
@@ -4806,7 +5260,7 @@ async function runWatchGroup(group, command, opts, signal) {
         await resume(hit.session);
         hit.session.debuggerState.paused = false;
       } catch {
-        process11.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
+        process12.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
         stoppedReason = "transport-closed";
         break;
       }
@@ -4820,7 +5274,7 @@ async function runWatchGroup(group, command, opts, signal) {
     }
   } finally {
     const cleanup = await fanout.cleanup();
-    process11.stderr.write(
+    process12.stderr.write(
       `[cf-inspector] breakpoint cleanup: cleared ${cleanup.cleared.toString()} of ${cleanup.attempted.toString()}; resumed ${cleanup.resumed.toString()} paused isolates.
 `
     );
@@ -4918,11 +5372,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process11.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process12.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process11.stderr.write(
+  process12.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -4949,10 +5403,11 @@ var collectStrings = (value, prev = []) => [
   ...prev,
   value
 ];
+var READY_EVENT_DESCRIPTION = "Emit a versioned breakpoint-armed JSON event on stderr after every current isolate is armed";
 function readPackageVersion() {
   let current = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 4; depth += 1) {
-    const candidate = join(current, "package.json");
+    const candidate = join2(current, "package.json");
     try {
       const parsed = JSON.parse(readFileSync(candidate, "utf8"));
       if (typeof parsed === "object" && parsed !== null) {
@@ -4994,14 +5449,14 @@ function registerSnapshot(program) {
   applyTargetOptions(
     program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture expressions, and resume"),
     { includeTimeout: false }
-  ).option("--bp <file:line>", "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 131072)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--condition <expr>", "Only pause when this JS expression evaluates truthy in the paused frame").option("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--quiet", "Suppress progress messages on stderr").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
+  ).option("--bp <file:line>", "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 131072)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--condition <expr>", "Only pause when this JS expression evaluates truthy in the paused frame").option("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--quiet", "Suppress progress messages on stderr").option("--ready-event", READY_EVENT_DESCRIPTION).option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
     await handleSnapshot(opts);
   });
 }
 function registerLog(program) {
   applyTargetOptions(
     program.command("log").description("Stream a non-pausing logpoint: log an expression each time a line executes")
-  ).requiredOption("--at <file:line>", "Logpoint location, e.g. src/handler.ts:42").requiredOption("--expr <expression>", "JavaScript expression to log on each hit").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--max-events <n>", "Stop streaming after emitting N log events").option("--hit-count <n>", "Start logging once the line has been hit N or more times").option("--condition <expr>", "Only log when this JS expression evaluates truthy on the inspectee").option("--max-value-length <chars>", "Maximum characters per log value before truncation (default: 4096)").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
+  ).requiredOption("--at <file:line>", "Logpoint location, e.g. src/handler.ts:42").requiredOption("--expr <expression>", "JavaScript expression to log on each hit").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--max-events <n>", "Stop streaming after emitting N log events").option("--hit-count <n>", "Start logging once the line has been hit N or more times").option("--condition <expr>", "Only log when this JS expression evaluates truthy on the inspectee").option("--max-value-length <chars>", "Maximum characters per log value before truncation (default: 4096)").option("--no-json", "Print human-readable lines instead of JSON Lines").option("--ready-event", READY_EVENT_DESCRIPTION).action(async (opts) => {
     await handleLog(opts);
   });
 }
@@ -5009,7 +5464,7 @@ function registerWatch(program) {
   applyTargetOptions(
     program.command("watch").description("Stream a snapshot per breakpoint hit (multi-shot watch); resume between hits"),
     { includeTimeout: false }
-  ).option("--bp <file:line>", "Breakpoint location (repeatable), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate per hit").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--condition <expr>", "Only emit hits where this JS expression evaluates truthy").option("--hit-count <n>", "Start emitting after the line has been hit N or more times").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--max-events <n>", "Stop streaming after emitting N watch events").option("--timeout <seconds>", "How long to wait for the next hit before giving up (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--stack-depth <n>", "Walk this many call frames per hit (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes per hit").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
+  ).option("--bp <file:line>", "Breakpoint location (repeatable), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate per hit").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--condition <expr>", "Only emit hits where this JS expression evaluates truthy").option("--hit-count <n>", "Start emitting after the line has been hit N or more times").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--max-events <n>", "Stop streaming after emitting N watch events").option("--timeout <seconds>", "How long to wait for the next hit before giving up (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--stack-depth <n>", "Walk this many call frames per hit (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes per hit").option("--no-json", "Print human-readable lines instead of JSON Lines").option("--ready-event", READY_EVENT_DESCRIPTION).action(async (opts) => {
     await handleWatch(opts);
   });
 }
@@ -5017,7 +5472,7 @@ function registerException(program) {
   applyTargetOptions(
     program.command("exception").description("Pause on a thrown exception, capture the value and frame, then resume"),
     { includeTimeout: false }
-  ).option("--type <state>", "Pause type: uncaught (default), caught, or all").option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--timeout <seconds>", "How long to wait for an exception (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 131072)").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable capture expressions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--no-json", "Print a human-readable summary instead of JSON").action(async (opts) => {
+  ).option("--type <state>", "Pause type: uncaught (default), caught, or all").option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--timeout <seconds>", "How long to wait for an exception (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 131072)").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable capture expressions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--no-json", "Print a human-readable summary instead of JSON").option("--ready-event", READY_EVENT_DESCRIPTION).action(async (opts) => {
     await handleException(opts);
   });
 }
@@ -5030,8 +5485,10 @@ function registerEval(program) {
 }
 function registerListScripts(program) {
   applyTargetOptions(
-    program.command("list-scripts").description("Print the scripts the V8 instance currently knows about")
-  ).option("--filter <pattern>", "Only include script URLs matching this pattern").option("--no-json", "Print scriptId<TAB>url instead of JSON").action(async (opts) => {
+    program.command("list-scripts").description(
+      "Print scripts from the main isolate and every worker, tagged by isolate"
+    )
+  ).option("--filter <pattern>", "Only include script URLs matching this pattern").option("--no-json", "Print scriptId<TAB>url<TAB>isolate instead of JSON").action(async (opts) => {
     await handleListScripts(opts);
   });
 }
@@ -5060,20 +5517,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process12.argv);
+  await main(process13.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process12.stderr.write(`Error [${err.code}]: ${err.message}
+    process13.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process12.stderr.write(`  detail: ${err.detail}
+      process13.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process12.exit(1);
+    process13.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process12.stderr.write(`Error: ${message}
+  process13.stderr.write(`Error: ${message}
 `);
-  process12.exit(1);
+  process13.exit(1);
 }
 //# sourceMappingURL=cli.js.map