@saptools/cf-inspector 0.6.2 → 0.7.0

package/dist/cli.js

@@ -152,7 +152,7 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process11 from "process";
+import process12 from "process";
 
 // src/cli/program.ts
 import { readFileSync } from "fs";
@@ -334,6 +334,56 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
   }
   return { browser, protocolVersion };
 }
+function startInspectorKeepalive(host, port, options = {}) {
+  const intervalMs = options.intervalMs ?? 1e4;
+  const probeTimeoutMs = options.probeTimeoutMs ?? 2e3;
+  const failureThreshold = options.failureThreshold ?? 3;
+  const probe = options.probe ?? (async () => await fetchInspectorVersion(host, port, probeTimeoutMs));
+  let cancelled = false;
+  let consecutiveFailures = 0;
+  let timer;
+  let rejectFailure;
+  const failure = new Promise((_resolve, reject) => {
+    rejectFailure = reject;
+  });
+  const schedule = () => {
+    if (cancelled) {
+      return;
+    }
+    timer = setTimeout(() => {
+      void runProbe();
+    }, intervalMs);
+  };
+  const runProbe = async () => {
+    try {
+      await probe();
+      consecutiveFailures = 0;
+    } catch (error) {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= failureThreshold) {
+        cancelled = true;
+        const detail = error instanceof Error ? error.message : String(error);
+        rejectFailure?.(new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          `Inspector tunnel ${host}:${port.toString()} failed ${failureThreshold.toString()} consecutive keepalive probes and is no longer round-tripping. Retry the command after restarting or investigating the owning tunnel session.`,
+          detail
+        ));
+        return;
+      }
+    }
+    schedule();
+  };
+  schedule();
+  return {
+    failure,
+    cancel: () => {
+      cancelled = true;
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
 
 // src/cli/output.ts
 import process from "process";
@@ -351,6 +401,7 @@ function writeHumanSnapshot(snapshot) {
   lines.push(
     `Snapshot @ ${snapshot.capturedAt}`,
     `  reason:  ${snapshot.reason}`,
+    `  isolate: ${formatIsolate(snapshot.isolate)}`,
     `  paused:  ${pausedDuration}`
   );
   if (snapshot.exception !== void 0) {
@@ -419,12 +470,13 @@ function writeLogEvent(event, json) {
 `);
     return;
   }
+  const isolateSuffix = event.isolate === void 0 ? "" : ` (${formatIsolate(event.isolate)})`;
   if (event.error !== void 0) {
-    process.stdout.write(`[${event.ts}] ${event.at} !err ${renderTruncated(event.error, event)}
+    process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} !err ${renderTruncated(event.error, event)}
 `);
     return;
   }
-  process.stdout.write(`[${event.ts}] ${event.at} ${renderTruncated(event.value ?? "", event)}
+  process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} ${renderTruncated(event.value ?? "", event)}
 `);
 }
 function writeWatchEvent(event, json) {
@@ -433,8 +485,10 @@ function writeWatchEvent(event, json) {
 `);
     return;
   }
-  process.stdout.write(`[${event.ts}] hit#${event.hit.toString()} ${event.at}
-`);
+  process.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)}
 `);
@@ -445,6 +499,12 @@ function writeWatchEvent(event, json) {
 `);
   }
 }
+function formatIsolate(isolate) {
+  if (isolate?.kind === "worker") {
+    return `worker ${isolate.workerId}`;
+  }
+  return "main";
+}
 function renderExceptionDetail(exception) {
   if (exception.description !== void 0) {
     const originalLength = exception.descriptionOriginalLength;
@@ -486,6 +546,8 @@ import "@saptools/cf-debugger";
 
 // src/cf/tunnel.ts
 import { startDebugger } from "@saptools/cf-debugger";
+init_types();
+var REUSED_TUNNEL_GRACE_MS = 5e3;
 function targetOptions(target) {
   return {
     ...target.apiEndpoint === void 0 ? {} : { apiEndpoint: target.apiEndpoint },
@@ -547,6 +609,16 @@ async function openCfTunnel(target) {
     if (localPort === void 0) {
       throw error;
     }
+    try {
+      await fetchInspectorVersion("127.0.0.1", localPort, REUSED_TUNNEL_GRACE_MS);
+    } catch (livenessError) {
+      const detail = livenessError instanceof Error ? livenessError.message : String(livenessError);
+      throw new CfInspectorError(
+        "INSPECTOR_DISCOVERY_FAILED",
+        `Another debugger session claims tunnel port ${localPort.toString()}, but its Node inspector did not respond within ${REUSED_TUNNEL_GRACE_MS.toString()}ms. The tunnel may be stale or still finishing setup; retry shortly, or inspect and stop the owning cf-debugger session before opening a fresh tunnel.`,
+        detail
+      );
+    }
     target.onStatus?.("ready", `Reusing existing tunnel on port ${localPort.toString()}`);
     return { localPort, dispose: () => Promise.resolve() };
   }
@@ -983,6 +1055,19 @@ function toResolvedLocations(value) {
     return [url === void 0 ? location : { ...location, url }];
   });
 }
+function toBreakLocations(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
+      return [];
+    }
+    const type = nonEmptyString(entry["type"]);
+    return [type === void 0 ? location : { ...location, type }];
+  });
+}
 function remoteCompleteness(subtype) {
   if (subtype === "proxy") {
     return "unavailable";
@@ -1207,6 +1292,7 @@ function pauseDetail(pause) {
 var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
 var DEFAULT_HOST = "127.0.0.1";
 var PAUSE_BUFFER_LIMIT = 32;
+var WORKER_DISCOVERY_SETTLE_MS = 500;
 var NodeWorkerDiscovery = class {
   constructor(client) {
     this.client = client;
@@ -1215,12 +1301,18 @@ var NodeWorkerDiscovery = class {
         const worker = toInspectorWorkerTarget(raw);
         if (worker !== void 0) {
           this.workers.set(worker.sessionId, worker);
+          for (const listener of this.attachedListeners) {
+            listener(worker);
+          }
         }
       }),
       client.on("NodeWorker.detachedFromWorker", (raw) => {
         const sessionId = readField(raw, "sessionId");
         if (typeof sessionId === "string") {
           this.workers.delete(sessionId);
+          for (const listener of this.detachedListeners) {
+            listener(sessionId);
+          }
         }
       })
     ];
@@ -1230,6 +1322,8 @@ var NodeWorkerDiscovery = class {
   detachListeners;
   supported = false;
   disposed = false;
+  attachedListeners = /* @__PURE__ */ new Set();
+  detachedListeners = /* @__PURE__ */ new Set();
   async enable() {
     try {
       await this.client.send("NodeWorker.enable", { waitForDebuggerOnStart: false });
@@ -1243,6 +1337,45 @@ var NodeWorkerDiscovery = class {
   list() {
     return [...this.workers.values()].sort(compareWorkers);
   }
+  onAttached(listener) {
+    this.attachedListeners.add(listener);
+    return () => {
+      this.attachedListeners.delete(listener);
+    };
+  }
+  onDetached(listener) {
+    this.detachedListeners.add(listener);
+    return () => {
+      this.detachedListeners.delete(listener);
+    };
+  }
+  async waitFor(predicate, timeoutMs = WORKER_DISCOVERY_SETTLE_MS) {
+    const existing = predicate(this.list());
+    if (existing !== void 0) {
+      return existing;
+    }
+    return await new Promise((resolve) => {
+      let settled = false;
+      const finish = (worker) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        detach();
+        resolve(worker);
+      };
+      const detach = this.onAttached(() => {
+        const worker = predicate(this.list());
+        if (worker !== void 0) {
+          finish(worker);
+        }
+      });
+      const timer = setTimeout(() => {
+        finish();
+      }, timeoutMs);
+    });
+  }
   async dispose() {
     if (this.disposed) {
       return;
@@ -1257,6 +1390,8 @@ var NodeWorkerDiscovery = class {
     for (const detach of this.detachListeners) {
       detach();
     }
+    this.attachedListeners.clear();
+    this.detachedListeners.clear();
   }
 };
 function isUnsupportedNodeWorkerDomain(error) {
@@ -1321,14 +1456,15 @@ async function connectInspector(options) {
   let workerDiscovery;
   try {
     workerDiscovery = await startNodeWorkerDiscovery(client);
-    if (options.workerIndex === void 0) {
-      const session = await initSession(client, target);
+    if (options.workerIndex === void 0 && options.workerId === void 0) {
+      const session = await initSession(client, target, { kind: "main" });
       return withWorkerMetadata(session, workerDiscovery, targetIndex, targets.length);
     }
     return await initWorkerSession(
       client,
       workerDiscovery,
       options.workerIndex,
+      options.workerId,
       targetIndex,
       targets.length
     );
@@ -1338,25 +1474,207 @@ async function connectInspector(options) {
     throw err;
   }
 }
-async function initWorkerSession(parent, discovery, workerIndex, targetIndex, targetCount) {
-  const workers = discovery.list();
+async function initWorkerSession(parent, discovery, workerIndex, workerId, targetIndex, targetCount) {
   if (!discovery.supported) {
     throw new CfInspectorError(
       "INSPECTOR_DISCOVERY_FAILED",
       "This runtime does not expose the NodeWorker CDP domain; --worker cannot be used. Run list-targets for available raw targets."
     );
   }
-  const worker = workers[workerIndex];
+  const worker = await discovery.waitFor((workers) => workerId === void 0 ? workerIndex === void 0 ? void 0 : workers[workerIndex] : workers.find((candidate) => candidate.workerId === workerId));
   if (worker === void 0) {
+    const workers = discovery.list();
+    const selector = workerId === void 0 ? `index ${(workerIndex ?? 0).toString()}` : `workerId ${JSON.stringify(workerId)}`;
     throw new CfInspectorError(
       "INSPECTOR_DISCOVERY_FAILED",
-      `No NodeWorker sub-session at index ${workerIndex.toString()} (available: ${workers.length.toString()}). Ensure the worker is alive, then rerun list-targets.`
+      `No NodeWorker sub-session with ${selector} is currently attached (available: ${workers.length.toString()}). Ensure the worker is alive, then rerun list-targets.`
     );
   }
   const client = await createNodeWorkerClient(parent, worker.sessionId);
-  const session = await initSession(client, workerToInspectorTarget(worker));
+  const session = await initSession(client, workerToInspectorTarget(worker), {
+    kind: "worker",
+    workerId: worker.workerId
+  });
   return withWorkerMetadata(session, discovery, targetIndex, targetCount, workerIndex, parent);
 }
+async function connectInspectorGroup(options) {
+  const host = options.host ?? DEFAULT_HOST;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const targets = await discoverInspectorTargets(host, options.port, connectTimeoutMs);
+  const targetIndex = options.targetIndex ?? 0;
+  const target = targets[targetIndex];
+  if (target === void 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No inspector target at index ${targetIndex.toString()} on ${host}:${options.port.toString()} (available: ${targets.length.toString()})`
+    );
+  }
+  const parent = await CdpClient.connect({ url: target.webSocketDebuggerUrl, connectTimeoutMs });
+  let discovery;
+  try {
+    discovery = await startNodeWorkerDiscovery(parent);
+    const main2 = await initSession(parent, target, { kind: "main" });
+    const group = new DynamicInspectorSessionGroup(
+      parent,
+      discovery,
+      main2,
+      targetIndex,
+      targets.length
+    );
+    await group.initialize();
+    return group;
+  } catch (error) {
+    await discovery?.dispose();
+    parent.dispose();
+    throw error;
+  }
+}
+var DynamicInspectorSessionGroup = class {
+  constructor(parent, discovery, main2, targetIndex, targetCount) {
+    this.parent = parent;
+    this.discovery = discovery;
+    this.targetIndex = targetIndex;
+    this.targetCount = targetCount;
+    this.workerDiscoverySupported = discovery.supported;
+    this.sessions.set("main", main2);
+    this.detachDiscoveryListeners = [
+      discovery.onAttached((worker) => {
+        this.queueWorker(worker);
+      }),
+      discovery.onDetached((sessionId) => {
+        void this.detachWorker(sessionId);
+      })
+    ];
+  }
+  parent;
+  discovery;
+  targetIndex;
+  targetCount;
+  sessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  removedListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Set();
+  detachedSessionIds = /* @__PURE__ */ new Set();
+  detachDiscoveryListeners;
+  initializationError;
+  initializing = true;
+  disposed = false;
+  workerDiscoverySupported;
+  async initialize() {
+    for (const worker of this.discovery.list()) {
+      this.queueWorker(worker);
+    }
+    await this.waitForPending();
+    this.initializing = false;
+    if (this.initializationError !== void 0) {
+      throw this.initializationError;
+    }
+  }
+  list() {
+    return [...this.sessions.values()];
+  }
+  onSession(listener) {
+    this.listeners.add(listener);
+    for (const session of this.sessions.values()) {
+      listener(session);
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  onSessionRemoved(listener) {
+    this.removedListeners.add(listener);
+    return () => {
+      this.removedListeners.delete(listener);
+    };
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => {
+      this.errorListeners.delete(listener);
+    };
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    for (const detach of this.detachDiscoveryListeners) {
+      detach();
+    }
+    await Promise.allSettled([...this.pending]);
+    const sessions = [...this.list()].reverse();
+    for (const session of sessions) {
+      try {
+        await session.dispose();
+      } catch {
+      }
+    }
+    this.sessions.clear();
+    this.listeners.clear();
+    this.removedListeners.clear();
+    this.errorListeners.clear();
+    await this.discovery.dispose();
+    this.parent.dispose();
+  }
+  queueWorker(worker) {
+    if (this.disposed || this.sessions.has(worker.sessionId)) {
+      return;
+    }
+    const pending = this.attachWorker(worker).catch((error) => {
+      const normalized = error instanceof Error ? error : new Error("Worker inspector attachment failed");
+      if (this.initializing && this.initializationError === void 0) {
+        this.initializationError = normalized;
+      }
+      for (const listener of this.errorListeners) {
+        listener(normalized);
+      }
+    }).finally(() => {
+      this.pending.delete(pending);
+    });
+    this.pending.add(pending);
+  }
+  async attachWorker(worker) {
+    const client = await createNodeWorkerClient(this.parent, worker.sessionId);
+    try {
+      const session = await initSession(client, workerToInspectorTarget(worker), {
+        kind: "worker",
+        workerId: worker.workerId
+      });
+      if (this.disposed || this.detachedSessionIds.delete(worker.sessionId)) {
+        await session.dispose();
+        return;
+      }
+      this.sessions.set(worker.sessionId, session);
+      for (const listener of this.listeners) {
+        listener(session);
+      }
+    } catch (error) {
+      client.dispose();
+      if (!this.disposed) {
+        throw error;
+      }
+    }
+  }
+  async detachWorker(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session === void 0) {
+      this.detachedSessionIds.add(sessionId);
+      return;
+    }
+    this.sessions.delete(sessionId);
+    for (const listener of this.removedListeners) {
+      listener(session);
+    }
+    await session.dispose();
+  }
+  async waitForPending() {
+    while (this.pending.size > 0) {
+      await Promise.all([...this.pending]);
+    }
+  }
+};
 function withWorkerMetadata(session, discovery, targetIndex, targetCount, workerIndex, parent) {
   return {
     ...session,
@@ -1393,16 +1711,16 @@ async function discoverNodeWorkerTargets(target, connectTimeoutMs = DEFAULT_CONN
     client.dispose();
   }
 }
-async function initSession(client, target) {
+async function initSession(client, target, isolate) {
   const scripts = /* @__PURE__ */ new Map();
   registerScriptTracking(client, scripts);
   const pauseBuffer = [];
   const pauseWaitGate = { active: false };
-  const debuggerState = {};
+  const debuggerState = { paused: false };
   registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState);
   await client.send("Runtime.enable");
   await client.send("Debugger.enable");
-  return createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState);
+  return createSession(client, target, isolate, scripts, pauseBuffer, pauseWaitGate, debuggerState);
 }
 function registerScriptTracking(client, scripts) {
   client.on("Debugger.scriptParsed", (raw) => {
@@ -1414,23 +1732,28 @@ function registerScriptTracking(client, scripts) {
 }
 function registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   client.on("Debugger.paused", (raw) => {
+    const event = toPauseEvent(raw, performance2.now(), scripts);
+    debuggerState.paused = true;
+    debuggerState.currentPause = event;
     if (pauseWaitGate.active) {
       return;
     }
-    const event = toPauseEvent(raw, performance2.now(), scripts);
     if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
       pauseBuffer.shift();
     }
     pauseBuffer.push(event);
   });
   client.on("Debugger.resumed", () => {
+    debuggerState.paused = false;
+    delete debuggerState.currentPause;
     debuggerState.lastResumedAtMs = performance2.now();
   });
 }
-function createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
+function createSession(client, target, isolate, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   return {
     client,
     target,
+    isolate,
     scripts,
     pauseBuffer,
     pauseWaitGate,
@@ -1622,7 +1945,7 @@ function warnOnImplicitInspectorSelection(session, targetWasExplicit, workerWasE
   const workerCount = session.workerTargets?.length ?? 0;
   if (!workerWasExplicit && workerCount > 0) {
     process2.stderr.write(
-      `[cf-inspector] notice: attached to the main isolate; ${workerCount.toString()} Node ${workerCount === 1 ? "worker is" : "workers are"} available. Run list-targets and pass --worker <index> to inspect one.
+      `[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.
 `
     );
   }
@@ -1635,7 +1958,7 @@ function warnOnBoundBreakpointWithoutHit(handles) {
     return;
   }
   process2.stderr.write(
-    `[cf-inspector] warning: ${boundCount.toString()} breakpoint ${boundCount === 1 ? "location bound" : "locations bound"}, but no hit was observed. The code may be running in another worker isolate. Run list-targets and retry with --worker <index> for a NodeWorker sub-session or --target <index> for a raw target.
+    `[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.
 `
   );
 }
@@ -1701,12 +2024,15 @@ function resolveTarget(opts, options = {}) {
   const port = parsePositiveInt(opts.port, "--port");
   const targetIndex = parseTargetIndex(opts.target);
   const workerIndex = parseSelectionIndex(opts.worker, "--worker");
+  const workerId = parseWorkerId(opts.workerId);
+  const mainOnly = opts.mainOnly === true;
+  validateIsolateSelectors(targetIndex, workerIndex, workerId, mainOnly);
   if (port !== void 0) {
     return {
       kind: "port",
       port,
       host: opts.host ?? "127.0.0.1",
-      ...selectionOptions(targetIndex, workerIndex)
+      ...selectionOptions(targetIndex, workerIndex, workerId, mainOnly)
     };
   }
   const region = optionalText(opts.region);
@@ -1733,7 +2059,9 @@ function resolveTarget(opts, options = {}) {
     app,
     parseTunnelTimeout(opts, options),
     targetIndex,
-    workerIndex
+    workerIndex,
+    workerId,
+    mainOnly
   );
 }
 async function resolveTargetWithCurrentCfTarget(opts, options = {}) {
@@ -1764,13 +2092,15 @@ function parseSelectionIndex(raw, label) {
 function targetIndexOption(targetIndex) {
   return targetIndex === void 0 ? {} : { targetIndex };
 }
-function selectionOptions(targetIndex, workerIndex) {
+function selectionOptions(targetIndex, workerIndex, workerId, mainOnly) {
   return {
     ...targetIndexOption(targetIndex),
-    ...workerIndex === void 0 ? {} : { workerIndex }
+    ...workerIndex === void 0 ? {} : { workerIndex },
+    ...workerId === void 0 ? {} : { workerId },
+    ...mainOnly === true ? { mainOnly: true } : {}
   };
 }
-function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, targetIndex, workerIndex) {
+function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, targetIndex, workerIndex, workerId, mainOnly) {
   return {
     kind: "cf",
     region,
@@ -1779,13 +2109,38 @@ function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, t
     space,
     app,
     tunnelTimeoutMs: tunnelTimeoutSec * 1e3,
-    ...selectionOptions(targetIndex, workerIndex)
+    ...selectionOptions(targetIndex, workerIndex, workerId, mainOnly)
   };
 }
+function validateIsolateSelectors(targetIndex, workerIndex, workerId, mainOnly) {
+  const workerSelectors = Number(workerIndex !== void 0) + Number(workerId !== void 0);
+  if (workerSelectors > 1 || mainOnly && workerSelectors > 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      "Use only one of --worker, --worker-id, or --main-only."
+    );
+  }
+  if (targetIndex !== void 0 && workerSelectors === 0 && !mainOnly) {
+    return;
+  }
+}
 function optionalText(value) {
   const trimmed = value?.trim();
   return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
 }
+function parseWorkerId(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      "Invalid --worker-id: expected a non-empty workerId from list-targets"
+    );
+  }
+  return trimmed;
+}
 async function withSession(target, fn, reportProgress, signal) {
   const tunnel = await openTarget(target, reportProgress, signal);
   let session;
@@ -1796,12 +2151,13 @@ async function withSession(target, fn, reportProgress, signal) {
     session = await connectInspector({
       port: tunnel.port,
       host: tunnel.host,
-      ...selectionOptions(target.targetIndex, target.workerIndex)
+      ...selectionOptions(target.targetIndex, target.workerIndex),
+      ...target.workerId === void 0 ? {} : { workerId: target.workerId }
     });
     warnOnImplicitInspectorSelection(
       session,
       target.targetIndex !== void 0,
-      target.workerIndex !== void 0
+      target.workerIndex !== void 0 || target.workerId !== void 0
     );
     reportProgress?.("Inspector session is ready.");
     return await fn(session, tunnel.port);
@@ -1814,6 +2170,56 @@ async function withSession(target, fn, reportProgress, signal) {
     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({
+        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 {
+    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();
+    }
+  }
+}
+function singleSessionGroup(session) {
+  return {
+    targetIndex: session.targetIndex ?? 0,
+    targetCount: session.targetCount ?? 1,
+    workerDiscoverySupported: session.workerDiscoverySupported ?? false,
+    list: () => [session],
+    onSession: (listener) => {
+      listener(session);
+      return () => void 0;
+    },
+    onSessionRemoved: () => () => void 0,
+    onError: () => () => void 0,
+    dispose: async () => {
+      await session.dispose();
+    }
+  };
+}
 async function openTarget(target, reportProgress, signal) {
   if (target.kind === "port") {
     return {
@@ -1867,185 +2273,55 @@ async function handleAttach(opts) {
   }
 }
 
-// src/cli/commands/eval.ts
+// src/cli/commands/checkBreakpoint.ts
 import process4 from "process";
 
-// src/inspector/runtime.ts
+// src/pathMapper.ts
 init_types();
-async function resume(session) {
-  await session.client.send("Debugger.resume");
+var REGEX_PREFIX = "regex:";
+var REGEX_FLAGS_PATTERN = /^[dgimsuvy]*$/;
+var TS_JS_EXT_PATTERN = /\.(?:ts|js|mts|mjs|cts|cjs)$/i;
+function parseBreakpointSpec(input) {
+  const idx = input.lastIndexOf(":");
+  if (idx <= 0 || idx === input.length - 1) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint must be in 'file:line' form, received: "${input}"`
+    );
+  }
+  const file = input.slice(0, idx).trim();
+  const lineRaw = input.slice(idx + 1).trim();
+  const line = Number.parseInt(lineRaw, 10);
+  if (!Number.isInteger(line) || line <= 0 || line.toString() !== lineRaw) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint line must be a positive integer, received: "${lineRaw}"`
+    );
+  }
+  if (file.length === 0) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint file path is empty in "${input}"`
+    );
+  }
+  return { file, line };
 }
-async function setPauseOnExceptions(session, state) {
-  await session.client.send("Debugger.setPauseOnExceptions", { state });
+function parseRemoteRoot(value) {
+  const trimmed = value?.trim();
+  if (trimmed === void 0 || trimmed.length === 0) {
+    return { kind: "none" };
+  }
+  if (trimmed.startsWith(REGEX_PREFIX)) {
+    return toRegex(trimmed.slice(REGEX_PREFIX.length), "");
+  }
+  const slashRegex = parseSlashDelimited(trimmed);
+  if (slashRegex !== void 0) {
+    return toRegex(slashRegex.pattern, slashRegex.flags);
+  }
+  return { kind: "literal", value: stripTrailingSlash(trimmed) };
 }
-async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
-  return await session.client.send("Debugger.evaluateOnCallFrame", {
-    callFrameId,
-    expression,
-    returnByValue: false,
-    generatePreview: true,
-    silent: true,
-    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect },
-    ...options.objectGroup === void 0 ? {} : { objectGroup: options.objectGroup }
-  });
-}
-function isSideEffectRefusal(result) {
-  const classNames = [
-    result.result?.className,
-    result.exceptionDetails?.exception?.className
-  ];
-  const descriptions = [
-    result.result?.description,
-    result.exceptionDetails?.exception?.description
-  ];
-  const isEvalError = classNames.includes("EvalError");
-  return isEvalError && descriptions.some(
-    (description) => typeof description === "string" && description.toLowerCase().includes("possible side-effect in debug-evaluate")
-  );
-}
-async function evaluateGlobal(session, expression) {
-  return await session.client.send("Runtime.evaluate", {
-    expression,
-    returnByValue: false,
-    generatePreview: true,
-    silent: true
-  });
-}
-async function runSetupEvals(session, expressions) {
-  for (const expression of expressions) {
-    const result = await evaluateGlobal(session, expression);
-    if (result.exceptionDetails !== void 0) {
-      throw new CfInspectorError(
-        "SETUP_EVAL_FAILED",
-        exceptionDetailsMessage(result, "setup evaluation failed")
-      );
-    }
-  }
-}
-function exceptionDetailsMessage(result, fallback) {
-  return typeof result.exceptionDetails?.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails?.text === "string" ? result.exceptionDetails.text : fallback;
-}
-function listScripts(session) {
-  return [...session.scripts.values()];
-}
-async function validateExpression(session, expression) {
-  const result = await session.client.send("Runtime.compileScript", {
-    expression,
-    sourceURL: "<cf-inspector-validate>",
-    persistScript: false
-  });
-  if (result.exceptionDetails === void 0) {
-    return;
-  }
-  const description = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "expression failed to compile";
-  throw new CfInspectorError("INVALID_EXPRESSION", description);
-}
-async function getProperties(session, objectId) {
-  const result = await session.client.send("Runtime.getProperties", {
-    objectId,
-    ownProperties: true,
-    accessorPropertiesOnly: false,
-    generatePreview: true
-  });
-  if (!Array.isArray(result.result)) {
-    return [];
-  }
-  return result.result;
-}
-
-// src/cli/commands/eval.ts
-async function handleEval(opts) {
-  warnOnMutationRisk(opts.expr, "eval --expr");
-  const target = await resolveTargetWithCurrentCfTarget(opts);
-  const result = await withSession(target, async (session) => {
-    return await evaluateGlobal(session, opts.expr);
-  });
-  if (opts.json) {
-    writeJson(result);
-    if (result.exceptionDetails !== void 0) {
-      process4.exitCode = 1;
-    }
-    return;
-  }
-  writeHumanEvalResult(result);
-}
-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";
-    process4.stderr.write(`${detail}
-`);
-    process4.exitCode = 1;
-    return;
-  }
-  const inner = result.result;
-  if (inner === void 0) {
-    process4.stdout.write("\n");
-    return;
-  }
-  if (typeof inner.value === "string") {
-    process4.stdout.write(`${inner.value}
-`);
-    return;
-  }
-  if (typeof inner.description === "string") {
-    process4.stdout.write(`${inner.description}
-`);
-    return;
-  }
-  process4.stdout.write(`${JSON.stringify(inner.value)}
-`);
-}
-
-// src/cli/commands/exception.ts
-import { performance as performance4 } from "perf_hooks";
-import process5 from "process";
-
-// src/pathMapper.ts
-init_types();
-var REGEX_PREFIX = "regex:";
-var REGEX_FLAGS_PATTERN = /^[dgimsuvy]*$/;
-var TS_JS_EXT_PATTERN = /\.(?:ts|js|mts|mjs|cts|cjs)$/i;
-function parseBreakpointSpec(input) {
-  const idx = input.lastIndexOf(":");
-  if (idx <= 0 || idx === input.length - 1) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint must be in 'file:line' form, received: "${input}"`
-    );
-  }
-  const file = input.slice(0, idx).trim();
-  const lineRaw = input.slice(idx + 1).trim();
-  const line = Number.parseInt(lineRaw, 10);
-  if (!Number.isInteger(line) || line <= 0 || line.toString() !== lineRaw) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint line must be a positive integer, received: "${lineRaw}"`
-    );
-  }
-  if (file.length === 0) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint file path is empty in "${input}"`
-    );
-  }
-  return { file, line };
-}
-function parseRemoteRoot(value) {
-  const trimmed = value?.trim();
-  if (trimmed === void 0 || trimmed.length === 0) {
-    return { kind: "none" };
-  }
-  if (trimmed.startsWith(REGEX_PREFIX)) {
-    return toRegex(trimmed.slice(REGEX_PREFIX.length), "");
-  }
-  const slashRegex = parseSlashDelimited(trimmed);
-  if (slashRegex !== void 0) {
-    return toRegex(slashRegex.pattern, slashRegex.flags);
-  }
-  return { kind: "literal", value: stripTrailingSlash(trimmed) };
-}
-function toRegex(pattern, flags) {
-  return { kind: "regex", pattern, flags };
+function toRegex(pattern, flags) {
+  return { kind: "regex", pattern, flags };
 }
 function parseSlashDelimited(value) {
   if (!value.startsWith("/")) {
@@ -2207,6 +2483,244 @@ async function setBreakpoint(session, input) {
 async function removeBreakpoint(session, breakpointId) {
   await session.client.send("Debugger.removeBreakpoint", { breakpointId });
 }
+function validateCoordinate(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `${label} must be a non-negative integer, received: ${value.toString()}`
+    );
+  }
+}
+function validateScriptLocation(location, label) {
+  if (location.scriptId.trim().length === 0) {
+    throw new CfInspectorError("INVALID_ARGUMENT", `${label}.scriptId must not be empty`);
+  }
+  validateCoordinate(location.lineNumber, `${label}.lineNumber`);
+  if (location.columnNumber !== void 0) {
+    validateCoordinate(location.columnNumber, `${label}.columnNumber`);
+  }
+}
+async function getPossibleBreakpoints(session, options) {
+  validateScriptLocation(options.start, "start");
+  if (options.end !== void 0) {
+    validateScriptLocation(options.end, "end");
+    if (options.end.scriptId !== options.start.scriptId) {
+      throw new CfInspectorError("INVALID_ARGUMENT", "start and end must refer to the same scriptId");
+    }
+  }
+  const result = await session.client.send(
+    "Debugger.getPossibleBreakpoints",
+    {
+      start: options.start,
+      ...options.end === void 0 ? {} : { end: options.end },
+      ...options.restrictToFunction === void 0 ? {} : { restrictToFunction: options.restrictToFunction }
+    }
+  );
+  if (!Array.isArray(result.locations)) {
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      "Debugger.getPossibleBreakpoints did not return a locations array"
+    );
+  }
+  return toBreakLocations(result.locations);
+}
+
+// src/cli/commands/checkBreakpoint.ts
+async function handleCheckBreakpoint(opts) {
+  const target = await resolveTargetWithCurrentCfTarget(opts);
+  const location = parseBreakpointSpec(opts.bp);
+  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
+  const urlRegex = buildBreakpointUrlRegex({ file: location.file, remoteRoot });
+  const matcher = new RegExp(urlRegex, "u");
+  const result = await withSessions(target, async (group) => {
+    const checks = (await Promise.all(group.list().map(async (session) => await checkSession(session, matcher, location.line)))).flat();
+    const status = checks.length === 0 ? "script-not-loaded" : checks.some((check) => check.locations.length > 0) ? "breakable" : "unbreakable";
+    return { file: location.file, line: location.line, status, scripts: checks };
+  });
+  if (opts.json) {
+    writeJson(result);
+    return;
+  }
+  writeHumanCheck(result);
+}
+async function checkSession(session, matcher, requestedLine) {
+  const zeroBasedLine = requestedLine - 1;
+  const scripts = [...session.scripts.values()].filter((script) => matcher.test(script.url));
+  return await Promise.all(scripts.map(async (script) => {
+    const locations = await getPossibleBreakpoints(session, {
+      start: { scriptId: script.scriptId, lineNumber: zeroBasedLine, columnNumber: 0 },
+      end: { scriptId: script.scriptId, lineNumber: zeroBasedLine + 1, columnNumber: 0 }
+    });
+    return {
+      isolate: session.isolate ?? { kind: "main" },
+      scriptId: script.scriptId,
+      url: script.url,
+      locations: locations.filter((candidate) => candidate.lineNumber === zeroBasedLine)
+    };
+  }));
+}
+function writeHumanCheck(result) {
+  if (result.status === "script-not-loaded") {
+    process4.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(
+      `${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:
+`);
+  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(
+        `  ${isolate}	${script.url}	line ${(location.lineNumber + 1).toString()}:${((location.columnNumber ?? 0) + 1).toString()}
+`
+      );
+    }
+  }
+}
+
+// src/cli/commands/eval.ts
+import process5 from "process";
+
+// src/inspector/runtime.ts
+init_types();
+async function resume(session) {
+  await session.client.send("Debugger.resume");
+  session.debuggerState.paused = false;
+  delete session.debuggerState.currentPause;
+}
+async function setPauseOnExceptions(session, state) {
+  await session.client.send("Debugger.setPauseOnExceptions", { state });
+}
+async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
+  return await session.client.send("Debugger.evaluateOnCallFrame", {
+    callFrameId,
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true,
+    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect },
+    ...options.objectGroup === void 0 ? {} : { objectGroup: options.objectGroup }
+  });
+}
+function isSideEffectRefusal(result) {
+  const classNames = [
+    result.result?.className,
+    result.exceptionDetails?.exception?.className
+  ];
+  const descriptions = [
+    result.result?.description,
+    result.exceptionDetails?.exception?.description
+  ];
+  const isEvalError = classNames.includes("EvalError");
+  return isEvalError && descriptions.some(
+    (description) => typeof description === "string" && description.toLowerCase().includes("possible side-effect in debug-evaluate")
+  );
+}
+async function evaluateGlobal(session, expression) {
+  return await session.client.send("Runtime.evaluate", {
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true
+  });
+}
+async function runSetupEvals(session, expressions) {
+  for (const expression of expressions) {
+    const result = await evaluateGlobal(session, expression);
+    if (result.exceptionDetails !== void 0) {
+      throw new CfInspectorError(
+        "SETUP_EVAL_FAILED",
+        exceptionDetailsMessage(result, "setup evaluation failed")
+      );
+    }
+  }
+}
+function exceptionDetailsMessage(result, fallback) {
+  return typeof result.exceptionDetails?.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails?.text === "string" ? result.exceptionDetails.text : fallback;
+}
+function listScripts(session) {
+  return [...session.scripts.values()];
+}
+async function validateExpression(session, expression) {
+  const result = await session.client.send("Runtime.compileScript", {
+    expression,
+    sourceURL: "<cf-inspector-validate>",
+    persistScript: false
+  });
+  if (result.exceptionDetails === void 0) {
+    return;
+  }
+  const description = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "expression failed to compile";
+  throw new CfInspectorError("INVALID_EXPRESSION", description);
+}
+async function getProperties(session, objectId) {
+  const result = await session.client.send("Runtime.getProperties", {
+    objectId,
+    ownProperties: true,
+    accessorPropertiesOnly: false,
+    generatePreview: true
+  });
+  if (!Array.isArray(result.result)) {
+    return [];
+  }
+  return result.result;
+}
+
+// src/cli/commands/eval.ts
+async function handleEval(opts) {
+  warnOnMutationRisk(opts.expr, "eval --expr");
+  const target = await resolveTargetWithCurrentCfTarget(opts);
+  const result = await withSession(target, async (session) => {
+    return await evaluateGlobal(session, opts.expr);
+  });
+  if (opts.json) {
+    writeJson(result);
+    if (result.exceptionDetails !== void 0) {
+      process5.exitCode = 1;
+    }
+    return;
+  }
+  writeHumanEvalResult(result);
+}
+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}
+`);
+    process5.exitCode = 1;
+    return;
+  }
+  const inner = result.result;
+  if (inner === void 0) {
+    process5.stdout.write("\n");
+    return;
+  }
+  if (typeof inner.value === "string") {
+    process5.stdout.write(`${inner.value}
+`);
+    return;
+  }
+  if (typeof inner.description === "string") {
+    process5.stdout.write(`${inner.description}
+`);
+    return;
+  }
+  process5.stdout.write(`${JSON.stringify(inner.value)}
+`);
+}
+
+// src/cli/commands/exception.ts
+import { performance as performance5 } from "perf_hooks";
+import process7 from "process";
 
 // src/inspector/pause.ts
 init_types();
@@ -2302,31 +2816,289 @@ async function waitForPause(session, options) {
     if (pauseMatches(pause, options.breakpointIds, options.pauseReasons)) {
       return pause;
     }
-    await handleUnmatchedPause(session, pause, options, deadlineMs);
+    await handleUnmatchedPause(session, pause, options, deadlineMs);
+  }
+  throwBreakpointTimeout(options.timeoutMs);
+}
+async function waitForLivePause(session, options, deadlineMs) {
+  const remainingMs = remainingUntil(deadlineMs);
+  if (remainingMs <= 0) {
+    throwBreakpointTimeout(options.timeoutMs);
+  }
+  session.pauseWaitGate.active = true;
+  let receivedAtMs;
+  let params;
+  try {
+    params = await session.client.waitFor("Debugger.paused", {
+      timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal },
+      predicate: () => {
+        receivedAtMs = performance3.now();
+        return true;
+      }
+    });
+  } finally {
+    session.pauseWaitGate.active = false;
+  }
+  return toPauseEvent(params, receivedAtMs ?? performance3.now(), session.scripts);
+}
+
+// src/inspector/fanout.ts
+init_types();
+import { performance as performance4 } from "perf_hooks";
+var DEFAULT_CLEANUP_TIMEOUT_MS = 2e3;
+var BreakpointFanout = class {
+  records = /* @__PURE__ */ new Map();
+  setupErrors = [];
+  detach;
+  detachRemoved;
+  detachError;
+  activeRace;
+  pauseReasons = [];
+  constructor(group, setupSession, pauseReasons = []) {
+    this.pauseReasons = pauseReasons;
+    this.detach = group.onSession((session) => {
+      const record = { session, handles: [], setup: Promise.resolve() };
+      this.records.set(session, record);
+      record.setup = setupSession(session, (handle) => {
+        this.trackHandle(session, handle);
+      }).then((result) => {
+        for (const handle of result.handles) {
+          this.trackHandle(session, handle);
+        }
+      });
+      const setup = record.setup;
+      setup.catch((error) => {
+        for (const reject of this.setupErrors) {
+          reject(error);
+        }
+      });
+      this.activeRace?.add(record);
+    });
+    this.detachRemoved = group.onSessionRemoved((session) => {
+      this.records.delete(session);
+      this.activeRace?.remove(session);
+    });
+    this.detachError = group.onError((error) => {
+      for (const reject of this.setupErrors) {
+        reject(error);
+      }
+    });
+  }
+  async ready() {
+    await Promise.all([...this.records.values()].map((record) => record.setup));
+  }
+  trackHandle(session, handle) {
+    const record = this.records.get(session);
+    if (record !== void 0 && !record.handles.some((candidate) => candidate.breakpointId === handle.breakpointId)) {
+      record.handles.push(handle);
+    }
+  }
+  availableOutcomes() {
+    return [...this.records.values()].map((record) => ({
+      session: record.session,
+      setup: { handles: record.handles }
+    }));
+  }
+  async waitForFirst(timeoutMs, options = {}, signal) {
+    if (this.activeRace !== void 0) {
+      throw new CfInspectorError("INVALID_ARGUMENT", "A fan-out pause race is already active");
+    }
+    const race = new ActivePauseRace(timeoutMs, options, signal);
+    this.pauseReasons = options.pauseReasons ?? [];
+    this.activeRace = race;
+    this.setupErrors.push(race.reject);
+    for (const record of this.records.values()) {
+      race.add(record);
+    }
+    try {
+      const winner = await race.result;
+      await race.stopAndSettle();
+      await this.resumePausedLosers(winner.session);
+      return winner;
+    } finally {
+      this.activeRace = void 0;
+      const index = this.setupErrors.indexOf(race.reject);
+      if (index >= 0) {
+        this.setupErrors.splice(index, 1);
+      }
+      await race.stopAndSettle();
+    }
+  }
+  async resumePaused(except) {
+    return await this.resumePausedLosers(except, DEFAULT_CLEANUP_TIMEOUT_MS);
+  }
+  async cleanup(timeoutMs = DEFAULT_CLEANUP_TIMEOUT_MS, preservePaused) {
+    this.detach();
+    this.detachRemoved();
+    this.detachError();
+    const deadline = performance4.now() + timeoutMs;
+    await settleWithin(Promise.allSettled([...this.records.values()].map(async (record) => {
+      await record.setup;
+    })), remaining(deadline));
+    const breakpointEntries = [...this.records.values()].flatMap((record) => record.handles.map((handle) => ({
+      session: record.session,
+      breakpointId: handle.breakpointId
+    })));
+    let cleared = 0;
+    const clearWork = Promise.allSettled(breakpointEntries.map(async (entry) => {
+      await removeBreakpoint(entry.session, entry.breakpointId);
+      cleared += 1;
+    }));
+    await settleWithin(clearWork, remaining(deadline));
+    const resumed = await this.resumePausedLosers(preservePaused, remaining(deadline));
+    return { attempted: breakpointEntries.length, cleared, resumed };
+  }
+  async resumePausedLosers(except, timeoutMs = DEFAULT_CLEANUP_TIMEOUT_MS) {
+    let resumed = 0;
+    await settleWithin(Promise.allSettled([...this.records.keys()].map(async (session) => {
+      if (session === except || session.debuggerState.paused !== true || session.client.isClosed || !this.ownsCurrentPause(session)) {
+        return;
+      }
+      await resume(session);
+      session.debuggerState.paused = false;
+      resumed += 1;
+    })), timeoutMs);
+    return resumed;
+  }
+  ownsCurrentPause(session) {
+    const pause = session.debuggerState.currentPause;
+    if (pause === void 0) {
+      return false;
+    }
+    if (this.pauseReasons.includes(pause.reason)) {
+      return true;
+    }
+    const record = this.records.get(session);
+    const breakpointIds = new Set(record?.handles.map((handle) => handle.breakpointId) ?? []);
+    return pause.hitBreakpoints.some((breakpointId) => breakpointIds.has(breakpointId));
+  }
+};
+var ActivePauseRace = class {
+  constructor(timeoutMs, options, signal) {
+    this.options = options;
+    this.externalSignal = signal;
+    this.deadline = performance4.now() + timeoutMs;
+    let resolveResult;
+    let rejectResult;
+    this.result = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    this.resolveResult = (winner) => {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      resolveResult?.(winner);
+    };
+    this.reject = (error) => {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      rejectResult?.(error);
+    };
+    this.timeout = setTimeout(() => {
+      this.reject(this.terminalTimeoutError ?? new CfInspectorError(
+        "BREAKPOINT_NOT_HIT",
+        `Timed out waiting for a matching pause in any isolate after ${timeoutMs.toString()}ms`
+      ));
+      this.controller.abort();
+    }, timeoutMs + 25);
+    if (signal !== void 0) {
+      if (signal.aborted) {
+        this.reject(new CfInspectorError("ABORTED", "Aborted while waiting for an isolate pause"));
+      } else {
+        signal.addEventListener("abort", this.onExternalAbort, { once: true });
+      }
+    }
+  }
+  options;
+  controller = new AbortController();
+  waits = /* @__PURE__ */ new Set();
+  settled = false;
+  deadline;
+  timeout;
+  externalSignal;
+  onExternalAbort = () => {
+    this.reject(new CfInspectorError("ABORTED", "Aborted while waiting for an isolate pause"));
+    this.controller.abort();
+  };
+  resolveResult;
+  terminalTimeoutError;
+  removedSessions = /* @__PURE__ */ new Set();
+  reject;
+  result;
+  add(record) {
+    if (this.settled) {
+      return;
+    }
+    const wait = this.wait(record).finally(() => {
+      this.waits.delete(wait);
+    });
+    this.waits.add(wait);
+  }
+  remove(session) {
+    this.removedSessions.add(session);
+  }
+  async stopAndSettle() {
+    clearTimeout(this.timeout);
+    this.externalSignal?.removeEventListener("abort", this.onExternalAbort);
+    this.controller.abort();
+    await Promise.allSettled([...this.waits]);
+  }
+  async wait(record) {
+    try {
+      await record.setup;
+      const remainingMs = Math.max(1, this.deadline - performance4.now());
+      const pause = await waitForPause(record.session, {
+        ...this.options,
+        timeoutMs: remainingMs,
+        breakpointIds: record.handles.map((handle) => handle.breakpointId),
+        signal: this.controller.signal
+      });
+      record.session.debuggerState.paused = true;
+      this.resolveResult({ session: record.session, pause });
+      this.controller.abort();
+    } catch (error) {
+      if (this.removedSessions.has(record.session)) {
+        return;
+      }
+      if (error instanceof CfInspectorError && error.code === "UNRELATED_PAUSE_TIMEOUT") {
+        this.terminalTimeoutError = error;
+        return;
+      }
+      if (isExpectedRaceStop(error)) {
+        return;
+      }
+      this.reject(error);
+      this.controller.abort();
+    }
   }
-  throwBreakpointTimeout(options.timeoutMs);
+};
+function isExpectedRaceStop(error) {
+  return error instanceof CfInspectorError && (error.code === "ABORTED" || error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT");
 }
-async function waitForLivePause(session, options, deadlineMs) {
-  const remainingMs = remainingUntil(deadlineMs);
-  if (remainingMs <= 0) {
-    throwBreakpointTimeout(options.timeoutMs);
-  }
-  session.pauseWaitGate.active = true;
-  let receivedAtMs;
-  let params;
+function remaining(deadline) {
+  return Math.max(0, deadline - performance4.now());
+}
+async function settleWithin(work, timeoutMs) {
+  let timer;
   try {
-    params = await session.client.waitFor("Debugger.paused", {
-      timeoutMs: remainingMs,
-      ...options.signal === void 0 ? {} : { signal: options.signal },
-      predicate: () => {
-        receivedAtMs = performance3.now();
-        return true;
-      }
-    });
+    return await Promise.race([
+      work,
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          resolve(null);
+        }, timeoutMs);
+      })
+    ]);
   } finally {
-    session.pauseWaitGate.active = false;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
   }
-  return toPauseEvent(params, receivedAtMs ?? performance3.now(), session.scripts);
 }
 
 // src/snapshot/evaluation.ts
@@ -3040,6 +3812,25 @@ async function captureExpression(session, callFrameId, expression, maxValueLengt
 
 // src/cli/commands/exception.ts
 init_types();
+
+// src/cli/signals.ts
+import process6 from "process";
+async function withTerminationSignal(fn) {
+  const abort = new AbortController();
+  const onSignal = () => {
+    abort.abort();
+  };
+  process6.once("SIGINT", onSignal);
+  process6.once("SIGTERM", onSignal);
+  try {
+    return await fn(abort.signal);
+  } finally {
+    process6.off("SIGINT", onSignal);
+    process6.off("SIGTERM", onSignal);
+  }
+}
+
+// src/cli/commands/exception.ts
 var VALID_PAUSE_TYPES = ["uncaught", "caught", "all"];
 async function handleException(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3048,7 +3839,7 @@ async function handleException(opts) {
     [...prepared.captures, ...prepared.stackCaptures],
     opts.allowMutation === true
   );
-  const result = await runExceptionCommand(prepared, opts);
+  const result = await withTerminationSignal(async (signal) => await runExceptionCommand(prepared, opts, signal));
   if (opts.json) {
     writeJson(result);
   } else {
@@ -3078,17 +3869,24 @@ function prepareExceptionCommand(opts, target) {
     throwOnSideEffect: opts.allowMutation !== true
   };
 }
-async function runExceptionCommand(command, opts) {
-  return await withSession(command.target, async (session) => {
-    await setPauseOnExceptions(session, command.state);
+async function runExceptionCommand(command, opts, signal) {
+  return await withSessions(command.target, async (group) => {
+    const fanout = new BreakpointFanout(group, async (session) => {
+      await setPauseOnExceptions(session, command.state);
+      return { handles: [] };
+    }, ["exception", "promiseRejection"]);
+    let winner;
+    let preserveWinner = false;
     try {
-      const pause = await waitForPause(session, {
-        timeoutMs: command.timeoutMs,
+      await fanout.ready();
+      const hit = await fanout.waitForFirst(command.timeoutMs, {
         pauseReasons: ["exception", "promiseRejection"],
         unmatchedPausePolicy: "wait-for-resume"
-      });
-      const pausedStartedAt = pause.receivedAtMs ?? performance4.now();
-      const snapshot = await captureSnapshot(session, pause, {
+      }, signal);
+      winner = hit.session;
+      const pause = hit.pause;
+      const pausedStartedAt = pause.receivedAtMs ?? performance5.now();
+      const snapshot = await captureSnapshot(hit.session, pause, {
         captures: command.captures,
         includeScopes: opts.includeScopes === true,
         maxValueLength: command.maxValueLength,
@@ -3097,20 +3895,25 @@ async function runExceptionCommand(command, opts) {
         throwOnSideEffect: command.throwOnSideEffect
       });
       if (opts.keepPaused === true) {
-        return withPausedDuration(snapshot, null);
+        preserveWinner = true;
+        return { ...withPausedDuration(snapshot, null), isolate: hit.session.isolate ?? { kind: "main" } };
       }
-      return await resumeAfterException(session, snapshot, pausedStartedAt);
+      const result = await resumeAfterException(hit.session, snapshot, pausedStartedAt);
+      return { ...result, isolate: hit.session.isolate ?? { kind: "main" } };
     } finally {
-      await disablePauseOnExceptionsBestEffort(session);
+      await Promise.allSettled(group.list().map(async (session) => {
+        await disablePauseOnExceptionsBestEffort(session);
+      }));
+      await fanout.cleanup(2e3, preserveWinner ? winner : void 0);
     }
-  });
+  }, void 0, signal);
 }
 async function resumeAfterException(session, snapshot, pausedStartedAt) {
   try {
     await resume(session);
-    return withPausedDuration(snapshot, roundDurationMs(performance4.now() - pausedStartedAt));
+    return withPausedDuration(snapshot, roundDurationMs(performance5.now() - pausedStartedAt));
   } catch {
-    process5.stderr.write(
+    process7.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after exception capture; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3124,7 +3927,7 @@ async function disablePauseOnExceptionsBestEffort(session) {
 }
 
 // src/cli/commands/listScripts.ts
-import process6 from "process";
+import process8 from "process";
 async function handleListScripts(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const filter = compileScriptUrlFilter(opts.filter);
@@ -3134,7 +3937,7 @@ async function handleListScripts(opts) {
     return;
   }
   for (const script of scripts) {
-    process6.stdout.write(`${script.scriptId}	${script.url}
+    process8.stdout.write(`${script.scriptId}	${script.url}
 `);
   }
 }
@@ -3165,7 +3968,7 @@ async function buildListedTargets(targets) {
       return buildListedTarget(target, index, workerResult.supported, workerResult.workers);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      process6.stderr.write(
+      process8.stderr.write(
         `[cf-inspector] warning: worker discovery failed for raw target ${index.toString()}: ${message}
 `
       );
@@ -3192,7 +3995,7 @@ function looksLikeWorkerTarget(target) {
   return `${target.type} ${target.title} ${target.url}`.toLowerCase().includes("worker");
 }
 function writeTargetCountSummary(targetCount, workerCount) {
-  process6.stderr.write(
+  process8.stderr.write(
     `[cf-inspector] ${targetCount.toString()} raw inspector ${targetCount === 1 ? "target" : "targets"}; ${workerCount.toString()} ${workerCount === 1 ? "worker" : "workers"}.
 `
   );
@@ -3203,7 +4006,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.";
-  process6.stderr.write(
+  process8.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.
 `
   );
@@ -3211,12 +4014,12 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
 function writeHumanTargets(targets) {
   for (const target of targets) {
     const workerLabel = target.likelyWorker ? "	likely-worker" : "";
-    process6.stdout.write(
+    process8.stdout.write(
       `${target.index.toString()}	target	${target.type}	${target.title}	${target.url}${workerLabel}
 `
     );
     for (const worker of target.workers) {
-      process6.stdout.write(
+      process8.stdout.write(
         `  ${worker.index.toString()}	worker	${worker.type}	${worker.title}	${worker.url}
 `
       );
@@ -3293,7 +4096,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process8 from "process";
+import process9 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -3559,25 +4362,6 @@ async function waitForStop(session, options, registerMaxEventsSignal) {
 
 // src/cli/commands/log.ts
 init_types();
-
-// src/cli/signals.ts
-import process7 from "process";
-async function withTerminationSignal(fn) {
-  const abort = new AbortController();
-  const onSignal = () => {
-    abort.abort();
-  };
-  process7.once("SIGINT", onSignal);
-  process7.once("SIGTERM", onSignal);
-  try {
-    return await fn(abort.signal);
-  } finally {
-    process7.off("SIGINT", onSignal);
-    process7.off("SIGTERM", onSignal);
-  }
-}
-
-// src/cli/commands/log.ts
 async function handleLog(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const location = parseBreakpointSpec(opts.at);
@@ -3596,12 +4380,8 @@ async function handleLog(opts) {
     warnOnMutationRisk(condition, "log --condition");
   }
   await withTerminationSignal(async (signal) => {
-    await withSession(target, async (session) => {
-      await validateExpression(session, expression);
-      if (condition !== void 0) {
-        await validateExpression(session, condition);
-      }
-      const result = await streamLogpoint(session, {
+    await withSessions(target, async (group) => {
+      const result = await runLogGroup(group, {
         location,
         expression,
         remoteRoot,
@@ -3610,36 +4390,132 @@ async function handleLog(opts) {
         ...hitCount === void 0 ? {} : { hitCount },
         ...condition === void 0 ? {} : { condition },
         maxValueLength,
-        signal,
+        json: opts.json,
+        signal
+      });
+      writeLogSummary(result.stoppedReason, result.emitted, opts.json);
+    }, void 0, signal);
+  });
+}
+async function runLogGroup(group, options) {
+  const controller = new AbortController();
+  const tasks = /* @__PURE__ */ new Set();
+  const removedSessions = /* @__PURE__ */ new Set();
+  const results = [];
+  let fatalError;
+  let emitted = 0;
+  let reason = "signal";
+  let resolveStop;
+  const stopped = new Promise((resolve) => {
+    resolveStop = resolve;
+  });
+  const finish = (nextReason) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    reason = nextReason;
+    controller.abort();
+    resolveStop?.();
+  };
+  const onSignal = () => {
+    finish("signal");
+  };
+  options.signal.addEventListener("abort", onSignal, { once: true });
+  if (options.signal.aborted) {
+    finish("signal");
+  }
+  const timer = options.durationMs === void 0 ? void 0 : setTimeout(() => {
+    finish("duration");
+  }, options.durationMs);
+  const startSession = (session) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    const task = (async () => {
+      await validateExpression(session, options.expression);
+      if (options.condition !== void 0) {
+        await validateExpression(session, options.condition);
+      }
+      return await streamLogpoint(session, {
+        location: options.location,
+        expression: options.expression,
+        remoteRoot: options.remoteRoot,
+        ...options.hitCount === void 0 ? {} : { hitCount: options.hitCount },
+        ...options.condition === void 0 ? {} : { condition: options.condition },
+        maxValueLength: options.maxValueLength,
+        signal: controller.signal,
         onEvent: (event) => {
-          writeLogEvent(event, opts.json);
+          if (controller.signal.aborted) {
+            return;
+          }
+          emitted += 1;
+          writeLogEvent({ ...event, isolate: session.isolate ?? { kind: "main" } }, options.json);
+          if (options.maxEvents !== void 0 && emitted >= options.maxEvents) {
+            finish("max-events");
+          }
         },
         onBreakpointSet: (handle) => {
           warnOnUnboundBreakpoints([handle]);
         }
       });
-      if (result.emitted === 0 && (result.stoppedReason === "duration" || result.stoppedReason === "signal")) {
-        warnOnBoundBreakpointWithoutHit([result.handle]);
+    })();
+    tasks.add(task);
+    void task.then(
+      (result) => {
+        results.push(result);
+        if (result.stoppedReason === "transport-closed" && !removedSessions.has(session)) {
+          finish("transport-closed");
+        }
+      },
+      (error) => {
+        fatalError = error;
+        finish("transport-closed");
       }
-      writeLogSummary(result.stoppedReason, result.emitted, opts.json);
-    }, void 0, signal);
+    ).finally(() => {
+      tasks.delete(task);
+    });
+  };
+  const detach = group.onSession(startSession);
+  const detachRemoved = group.onSessionRemoved((session) => {
+    removedSessions.add(session);
   });
+  try {
+    await stopped;
+    await Promise.allSettled([...tasks]);
+  } finally {
+    detach();
+    detachRemoved();
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+    options.signal.removeEventListener("abort", onSignal);
+  }
+  if (emitted === 0 && isZeroHitStop(reason)) {
+    warnOnBoundBreakpointWithoutHit(results.map((result) => result.handle));
+  }
+  if (fatalError !== void 0) {
+    throw fatalError instanceof Error ? fatalError : new Error("Unknown logpoint fan-out failure");
+  }
+  return { emitted, stoppedReason: reason };
+}
+function isZeroHitStop(reason) {
+  return reason === "duration" || reason === "signal";
 }
 function writeLogSummary(stoppedReason, emitted, json) {
   if (json) {
-    process8.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+    process9.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process8.stderr.write(
+  process9.stderr.write(
     `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
 `
   );
 }
 
 // src/cli/commands/snapshot.ts
-import { performance as performance5 } from "perf_hooks";
-import process9 from "process";
+import { performance as performance6 } from "perf_hooks";
+import process10 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3652,7 +4528,7 @@ async function handleSnapshot(opts) {
     warnOnMutationRisk(expression, "snapshot --setup-eval");
   }
   const reportProgress = opts.quiet === true ? void 0 : writeProgress;
-  const result = await runSnapshotCommand(prepared, opts, reportProgress);
+  const result = await withTerminationSignal(async (signal) => await runSnapshotCommand(prepared, opts, reportProgress, signal));
   if (opts.json) {
     writeJson(result);
   } else {
@@ -3693,45 +4569,95 @@ function prepareSnapshotCommand(opts, target) {
     throwOnSideEffect: opts.allowMutation !== true
   };
 }
-async function runSnapshotCommand(command, opts, reportProgress) {
-  return await withSession(command.target, async (session) => {
-    return await runSnapshotOnSession(session, command, opts, reportProgress);
-  }, reportProgress);
+async function runSnapshotCommand(command, opts, reportProgress, signal) {
+  return await withSessions(command.target, async (group) => {
+    if (command.setupEvals.length > 0) {
+      const setupCount = command.setupEvals.length;
+      reportProgress?.(
+        `Running ${setupCount.toString()} setup ${setupCount === 1 ? "evaluation" : "evaluations"}...`
+      );
+    }
+    if (command.condition !== void 0) {
+      reportProgress?.("Validating the breakpoint condition...");
+    }
+    const breakpointCount = command.breakpoints.length;
+    reportProgress?.(
+      `Setting ${breakpointCount.toString()} ${breakpointCount === 1 ? "breakpoint" : "breakpoints"}...`
+    );
+    const fanout = new BreakpointFanout(group, async (session, trackHandle) => {
+      await prepareSnapshotSession(session, command);
+      return { handles: await setCommandBreakpoints(session, command, trackHandle) };
+    });
+    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 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 }
+      }, signal);
+      winner = hit.session;
+      const captureCount = command.captures.length;
+      reportProgress?.(
+        `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
+      );
+      const result = await captureSnapshotResult(hit.session, hit.pause, command, opts, reportProgress);
+      preserveWinner = opts.keepPaused === true;
+      return { ...result, isolate: hit.session.isolate ?? { kind: "main" } };
+    } catch (error) {
+      if (error instanceof CfInspectorError && (error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT")) {
+        const outcomes = fanout.availableOutcomes();
+        warnOnBoundBreakpointWithoutHit(outcomes.flatMap((outcome) => outcome.setup.handles));
+      }
+      throw error;
+    } finally {
+      const cleanup = await fanout.cleanup(2e3, preserveWinner ? winner : void 0);
+      reportProgress?.(
+        `Breakpoint cleanup: cleared ${cleanup.cleared.toString()} of ${cleanup.attempted.toString()}; resumed ${cleanup.resumed.toString()} paused losing isolates.`
+      );
+    }
+  }, reportProgress, signal);
 }
-async function runSnapshotOnSession(session, command, opts, reportProgress) {
+async function prepareSnapshotSession(session, command) {
   if (command.setupEvals.length > 0) {
-    const setupCount = command.setupEvals.length;
-    reportProgress?.(`Running ${setupCount.toString()} setup ${setupCount === 1 ? "evaluation" : "evaluations"}...`);
     await runSetupEvals(session, command.setupEvals);
-    reportProgress?.("Setup evaluation complete.");
   }
   if (command.condition !== void 0) {
-    reportProgress?.("Validating the breakpoint condition...");
     await validateExpression(session, command.condition);
-    reportProgress?.("Breakpoint condition is valid.");
   }
-  const breakpointCount = command.breakpoints.length;
-  reportProgress?.(
-    `Setting ${breakpointCount.toString()} ${breakpointCount === 1 ? "breakpoint" : "breakpoints"}...`
-  );
-  const handles = await setCommandBreakpoints(session, command);
-  const resolvedCount = handles.reduce(
-    (total, handle) => total + handle.resolvedLocations.length,
+}
+function reportBreakpointOutcomes(outcomes, reportProgress) {
+  for (const outcome of outcomes) {
+    warnOnUnboundBreakpoints(outcome.setup.handles);
+  }
+  const boundSessions = outcomes.filter((outcome) => outcome.setup.handles.some((handle) => handle.resolvedLocations.length > 0)).length;
+  const locations = outcomes.reduce((total, outcome) => total + outcome.setup.handles.reduce(
+    (sessionTotal, handle) => sessionTotal + handle.resolvedLocations.length,
     0
-  );
-  reportProgress?.(
-    `Breakpoint setup complete: ${resolvedCount.toString()} resolved ${resolvedCount === 1 ? "location" : "locations"}.`
-  );
-  warnOnUnboundBreakpoints(handles);
-  reportProgress?.(
-    `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
-  );
-  const pause = await waitForCommandPause(session, opts, handles, command.timeoutMs);
-  const captureCount = command.captures.length;
+  ), 0);
+  if (outcomes.length === 1) {
+    reportProgress?.(
+      `Breakpoint setup complete: ${locations.toString()} resolved ${locations === 1 ? "location" : "locations"}.`
+    );
+    return;
+  }
   reportProgress?.(
-    `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
+    `Breakpoint setup complete: sessions=${outcomes.length.toString()} boundSessions=${boundSessions.toString()} resolvedLocations=${locations.toString()}.`
   );
-  const pausedStartedAt = pause.receivedAtMs ?? performance5.now();
+}
+async function captureSnapshotResult(session, pause, command, opts, reportProgress) {
+  const pausedStartedAt = pause.receivedAtMs ?? performance6.now();
   const snapshot = await captureSnapshot(session, pause, {
     captures: command.captures,
     includeScopes: opts.includeScopes === true,
@@ -3741,13 +4667,12 @@ async function runSnapshotOnSession(session, command, opts, reportProgress) {
     throwOnSideEffect: command.throwOnSideEffect
   });
   if (opts.keepPaused === true) {
-    reportProgress?.("Snapshot captured; leaving the target paused as requested.");
     return withPausedDuration(snapshot, null);
   }
   reportProgress?.("Snapshot captured; resuming the target...");
   return await resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress);
 }
-async function setCommandBreakpoints(session, command) {
+async function setCommandBreakpoints(session, command, onSet) {
   return await Promise.all(
     command.breakpoints.map(
       (bp) => setBreakpoint(session, {
@@ -3756,39 +4681,20 @@ async function setCommandBreakpoints(session, command) {
         remoteRoot: command.remoteRoot,
         ...command.condition === void 0 ? {} : { condition: command.condition },
         ...command.hitCount === void 0 ? {} : { hitCount: command.hitCount }
+      }).then((handle) => {
+        onSet?.(handle);
+        return handle;
       })
     )
   );
 }
-async function waitForCommandPause(session, opts, handles, timeoutMs) {
-  let warnedUnmatchedPause = false;
-  try {
-    return await waitForPause(session, {
-      timeoutMs,
-      breakpointIds: handles.map((h) => h.breakpointId),
-      unmatchedPausePolicy: opts.failOnUnmatchedPause === true ? "fail" : "wait-for-resume",
-      onUnmatchedPause: (unmatchedPause) => {
-        if (warnedUnmatchedPause || opts.failOnUnmatchedPause === true) {
-          return;
-        }
-        warnedUnmatchedPause = true;
-        warnOnUnmatchedPause(unmatchedPause);
-      }
-    });
-  } catch (error) {
-    if (error instanceof CfInspectorError && (error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT")) {
-      warnOnBoundBreakpointWithoutHit(handles);
-    }
-    throw error;
-  }
-}
 async function resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress) {
   try {
     await resume(session);
     reportProgress?.("Target resumed.");
-    return withPausedDuration(snapshot, roundDurationMs(performance5.now() - pausedStartedAt));
+    return withPausedDuration(snapshot, roundDurationMs(performance6.now() - pausedStartedAt));
   } catch {
-    process9.stderr.write(
+    process10.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3800,8 +4706,8 @@ function parseSetupEvals(raw) {
 }
 
 // src/cli/commands/watch.ts
-import { performance as performance6 } from "perf_hooks";
-import process10 from "process";
+import { performance as performance7 } from "perf_hooks";
+import process11 from "process";
 init_types();
 async function handleWatch(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3816,14 +4722,115 @@ async function handleWatch(opts) {
   let stoppedReason = "signal";
   let emitted = 0;
   await withTerminationSignal(async (signal) => {
-    await withSession(prepared.target, async (session) => {
-      const result = await runWatchLoop(session, prepared, opts, signal);
-      stoppedReason = result.stoppedReason;
-      emitted = result.emitted;
+    await withSessions(prepared.target, async (group, port) => {
+      const host = prepared.target.kind === "port" ? prepared.target.host : "127.0.0.1";
+      const keepalive = startInspectorKeepalive(host, port);
+      const commandAbort = new AbortController();
+      const onSignal = () => {
+        commandAbort.abort();
+      };
+      signal.addEventListener("abort", onSignal, { once: true });
+      let keepaliveError;
+      void keepalive.failure.catch((error) => {
+        keepaliveError = error;
+        commandAbort.abort();
+      });
+      try {
+        const result = await runWatchGroup(group, prepared, opts, commandAbort.signal);
+        stoppedReason = result.stoppedReason;
+        emitted = result.emitted;
+        if (keepaliveError !== void 0) {
+          throw keepaliveError instanceof Error ? keepaliveError : new Error("Unknown inspector keepalive failure");
+        }
+      } finally {
+        keepalive.cancel();
+        signal.removeEventListener("abort", onSignal);
+      }
     }, void 0, signal);
   });
   writeWatchSummary(stoppedReason, emitted, opts.json);
 }
+async function runWatchGroup(group, command, opts, signal) {
+  const fanout = new BreakpointFanout(group, async (session, trackHandle) => {
+    if (command.setupEvals.length > 0) {
+      await runSetupEvals(session, command.setupEvals);
+    }
+    if (command.condition !== void 0) {
+      await validateExpression(session, command.condition);
+    }
+    const handles = await Promise.all(command.breakpoints.map((bp) => setBreakpoint(session, {
+      file: bp.file,
+      line: bp.line,
+      remoteRoot: command.remoteRoot,
+      ...command.condition === void 0 ? {} : { condition: command.condition },
+      ...command.hitCount === void 0 ? {} : { hitCount: command.hitCount }
+    }).then((handle) => {
+      trackHandle(handle);
+      return handle;
+    })));
+    warnOnUnboundBreakpoints(handles);
+    return { handles };
+  });
+  let emitted = 0;
+  let stoppedReason = "signal";
+  const deadline = computeDeadline(command.durationMs);
+  try {
+    await fanout.ready();
+    while (!signal.aborted) {
+      const remainingMs = remainingForLoop(deadline, command.perHitTimeoutMs);
+      if (remainingMs <= 0) {
+        stoppedReason = "duration";
+        break;
+      }
+      let hit;
+      try {
+        hit = await fanout.waitForFirst(remainingMs, { unmatchedPausePolicy: "wait-for-resume" }, signal);
+      } catch (error) {
+        if (error instanceof CfInspectorError && error.code === "ABORTED") {
+          stoppedReason = "signal";
+          break;
+        }
+        if (error instanceof CfInspectorError && (error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT")) {
+          if (deadline !== void 0 && performance7.now() >= deadline) {
+            stoppedReason = "duration";
+            break;
+          }
+          continue;
+        }
+        throw error;
+      }
+      const event = await captureWatchEvent(hit.session, command, hit.pause, emitted + 1, opts);
+      emitted += 1;
+      writeWatchEvent({ ...event, isolate: hit.session.isolate ?? { kind: "main" } }, opts.json);
+      try {
+        await resume(hit.session);
+        hit.session.debuggerState.paused = false;
+      } catch {
+        process11.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
+        stoppedReason = "transport-closed";
+        break;
+      }
+      if (command.maxEvents !== void 0 && emitted >= command.maxEvents) {
+        stoppedReason = "max-events";
+        break;
+      }
+    }
+    if (signal.aborted) {
+      stoppedReason = "signal";
+    }
+  } finally {
+    const cleanup = await fanout.cleanup();
+    process11.stderr.write(
+      `[cf-inspector] breakpoint cleanup: cleared ${cleanup.cleared.toString()} of ${cleanup.attempted.toString()}; resumed ${cleanup.resumed.toString()} paused isolates.
+`
+    );
+  }
+  if (emitted === 0 && (stoppedReason === "duration" || stoppedReason === "signal")) {
+    const outcomes = fanout.availableOutcomes();
+    warnOnBoundBreakpointWithoutHit(outcomes.flatMap((outcome) => outcome.setup.handles));
+  }
+  return { emitted, stoppedReason };
+}
 function prepareWatchCommand(opts, target) {
   if (opts.bp.length === 0) {
     throw new CfInspectorError(
@@ -3861,147 +4868,21 @@ function prepareWatchCommand(opts, target) {
     throwOnSideEffect: opts.allowMutation !== true
   };
 }
-async function runWatchLoop(session, command, opts, signal) {
-  if (command.setupEvals.length > 0) {
-    await runSetupEvals(session, command.setupEvals);
-  }
-  if (command.condition !== void 0) {
-    await validateExpression(session, command.condition);
-  }
-  const handles = await Promise.all(
-    command.breakpoints.map(
-      (bp) => setBreakpoint(session, {
-        file: bp.file,
-        line: bp.line,
-        remoteRoot: command.remoteRoot,
-        ...command.condition === void 0 ? {} : { condition: command.condition },
-        ...command.hitCount === void 0 ? {} : { hitCount: command.hitCount }
-      })
-    )
-  );
-  warnOnUnboundBreakpoints(handles);
-  const deadline = computeDeadline(command.durationMs);
-  let emitted = 0;
-  const state = { stopped: false, reason: "signal" };
-  const setStop = (reason) => {
-    if (state.stopped) {
-      return;
-    }
-    state.reason = reason;
-    state.stopped = true;
-  };
-  const transportClosed = waitForTransportClose(session);
-  transportClosed.promise.then(() => {
-    setStop("transport-closed");
-  }).catch(() => {
-  });
-  try {
-    while (!state.stopped) {
-      if (signal.aborted) {
-        setStop("signal");
-        break;
-      }
-      const remainingMs = remainingForLoop(deadline, command.perHitTimeoutMs);
-      if (remainingMs <= 0) {
-        setStop("duration");
-        break;
-      }
-      const pause = await waitForNextWatchPause(session, handles, remainingMs, signal);
-      if (pause === "signal") {
-        setStop("signal");
-        break;
-      }
-      if (pause === "timeout") {
-        if (deadline !== void 0 && performance6.now() >= deadline) {
-          setStop("duration");
-          break;
-        }
-        continue;
-      }
-      const event = await captureWatchEvent(session, command, pause, emitted + 1, opts);
-      emitted += 1;
-      writeWatchEvent(event, opts.json);
-      try {
-        await resume(session);
-      } catch {
-        process10.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
-        setStop("transport-closed");
-        break;
-      }
-      if (command.maxEvents !== void 0 && emitted >= command.maxEvents) {
-        setStop("max-events");
-        break;
-      }
-    }
-  } finally {
-    transportClosed.cancel();
-  }
-  if (emitted === 0 && (state.reason === "duration" || state.reason === "signal")) {
-    warnOnBoundBreakpointWithoutHit(handles);
-  }
-  return { emitted, stoppedReason: state.reason };
-}
 function computeDeadline(durationMs) {
   if (durationMs === void 0) {
     return void 0;
   }
-  return performance6.now() + durationMs;
+  return performance7.now() + durationMs;
 }
 function remainingForLoop(deadline, perHitTimeoutMs) {
   if (deadline === void 0) {
     return perHitTimeoutMs;
   }
-  const remaining = deadline - performance6.now();
-  if (remaining <= 0) {
+  const remaining2 = deadline - performance7.now();
+  if (remaining2 <= 0) {
     return 0;
   }
-  return Math.min(remaining, perHitTimeoutMs);
-}
-function waitForTransportClose(session) {
-  let cancelled = false;
-  let resolve;
-  const promise = new Promise((res) => {
-    resolve = res;
-  });
-  const off = session.client.onClose(() => {
-    if (!cancelled) {
-      resolve?.();
-    }
-  });
-  return {
-    promise,
-    cancel: () => {
-      cancelled = true;
-      off();
-      resolve?.();
-    }
-  };
-}
-async function waitForNextWatchPause(session, handles, timeoutMs, signal) {
-  if (signal.aborted) {
-    return "signal";
-  }
-  try {
-    return await waitForPause(session, {
-      timeoutMs,
-      breakpointIds: handles.map((h) => h.breakpointId),
-      unmatchedPausePolicy: "wait-for-resume",
-      signal
-    });
-  } catch (err) {
-    if (err instanceof CfInspectorError) {
-      if (err.code === "ABORTED") {
-        return "signal";
-      }
-      if (err.code === "BREAKPOINT_NOT_HIT") {
-        return "timeout";
-      }
-      if (err.code === "UNRELATED_PAUSE_TIMEOUT") {
-        return "timeout";
-      }
-    }
-    throw err;
-  }
+  return Math.min(remaining2, perHitTimeoutMs);
 }
 async function captureWatchEvent(session, command, pause, hit, opts) {
   const snapshot = await captureSnapshot(session, pause, {
@@ -4037,11 +4918,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process10.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process11.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process10.stderr.write(
+  process11.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -4061,7 +4942,7 @@ function applyTargetOptions(cmd, options = {}) {
     "--target <index>",
     "Inspector target index from /json/list (default: 0)"
   );
-  const withWorkerOption = options.includeWorker === false ? withTargetOption : withTargetOption.option("--worker <index>", "NodeWorker sub-session index listed by list-targets");
+  const withWorkerOption = options.includeWorker === false ? withTargetOption : withTargetOption.option("--worker <index>", "NodeWorker sub-session index listed by list-targets").option("--worker-id <id>", "Stable NodeWorker workerId listed by list-targets").option("--main-only", "Attach only to the main isolate and ignore workers");
   return options.includeTimeout === false ? withWorkerOption : withWorkerOption.option("--timeout <seconds>", "Timeout for CF tunnel readiness in seconds (default: 180)");
 }
 var collectStrings = (value, prev = []) => [
@@ -4093,12 +4974,22 @@ async function main(argv) {
   registerLog(program);
   registerWatch(program);
   registerException(program);
+  registerCheckBreakpoint(program);
   registerEval(program);
   registerListScripts(program);
   registerListTargets(program);
   registerAttach(program);
   await program.parseAsync([...argv]);
 }
+function registerCheckBreakpoint(program) {
+  applyTargetOptions(
+    program.command("check-breakpoint").description(
+      "Report whether a loaded script can break at a file:line location"
+    )
+  ).requiredOption("--bp <file:line>", "Source location to check").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--no-json", "Print a human-readable result instead of JSON").action(async (opts) => {
+    await handleCheckBreakpoint(opts);
+  });
+}
 function registerSnapshot(program) {
   applyTargetOptions(
     program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture expressions, and resume"),
@@ -4169,20 +5060,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process11.argv);
+  await main(process12.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process11.stderr.write(`Error [${err.code}]: ${err.message}
+    process12.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process11.stderr.write(`  detail: ${err.detail}
+      process12.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process11.exit(1);
+    process12.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process11.stderr.write(`Error: ${message}
+  process12.stderr.write(`Error: ${message}
 `);
-  process11.exit(1);
+  process12.exit(1);
 }
 //# sourceMappingURL=cli.js.map