@saptools/cf-inspector 0.6.2 → 0.7.1

package/dist/cli.js

@@ -152,16 +152,16 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process11 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();
@@ -334,15 +334,65 @@ 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";
+import process2 from "process";
 function writeProgress(message) {
-  process.stderr.write(`[cf-inspector] ${message}
+  process2.stderr.write(`[cf-inspector] ${message}
 `);
 }
 function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
+  process2.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
 }
 function writeHumanSnapshot(snapshot) {
@@ -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) {
@@ -372,7 +423,7 @@ function writeHumanSnapshot(snapshot) {
       appendStackFrameLine(lines, frame);
     }
   }
-  process.stdout.write(`${lines.join("\n")}
+  process2.stdout.write(`${lines.join("\n")}
 `);
 }
 function appendFrameLines(lines, frame) {
@@ -415,36 +466,45 @@ 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} !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} ${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(`[${event.ts}] hit#${event.hit.toString()} ${event.at}
-`);
+  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)}
 `);
   }
 }
+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,
@@ -1453,9 +1776,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) {
@@ -1570,7 +2131,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}
 `
   );
@@ -1585,7 +2146,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.
 `
   );
@@ -1594,7 +2155,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.
 `
   );
@@ -1603,7 +2164,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}
 `
       );
@@ -1614,15 +2175,15 @@ 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(
-      `[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.
+    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.
 `
     );
   }
@@ -1634,8 +2195,8 @@ function warnOnBoundBreakpointWithoutHit(handles) {
   if (boundCount === 0) {
     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.
+  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.
 `
   );
 }
@@ -1644,7 +2205,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...
 `
   );
@@ -1701,12 +2262,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 +2297,9 @@ function resolveTarget(opts, options = {}) {
     app,
     parseTunnelTimeout(opts, options),
     targetIndex,
-    workerIndex
+    workerIndex,
+    workerId,
+    mainOnly
   );
 }
 async function resolveTargetWithCurrentCfTarget(opts, options = {}) {
@@ -1764,13 +2330,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,41 +2347,127 @@ 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;
 }
-async function withSession(target, fn, reportProgress, signal) {
-  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)
-    });
-    warnOnImplicitInspectorSelection(
-      session,
-      target.targetIndex !== void 0,
-      target.workerIndex !== void 0
-    );
-    reportProgress?.("Inspector session is ready.");
-    return await fn(session, tunnel.port);
+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 lock = await acquireDebugSessionLock(target);
+  try {
+    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 === 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();
+    }
   } finally {
-    if (session) {
-      reportProgress?.("Closing the inspector session...");
-      await session.dispose();
-      reportProgress?.("Inspector session closed.");
+    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 {
+      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();
+      }
     }
-    await tunnel.dispose();
+  } finally {
+    await lock.release();
   }
 }
+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 {
@@ -1856,7 +2510,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}
@@ -1867,137 +2521,7 @@ async function handleAttach(opts) {
   }
 }
 
-// src/cli/commands/eval.ts
-import process4 from "process";
-
-// src/inspector/runtime.ts
-init_types();
-async function resume(session) {
-  await session.client.send("Debugger.resume");
-}
-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) {
-      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";
+// src/cli/commands/checkBreakpoint.ts
 import process5 from "process";
 
 // src/pathMapper.ts
@@ -2207,6 +2731,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") {
+    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") {
+    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;
+  }
+  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}`;
+      process5.stdout.write(
+        `  ${isolate}	${script.url}	line ${(location.lineNumber + 1).toString()}:${((location.columnNumber ?? 0) + 1).toString()}
+`
+      );
+    }
+  }
+}
+
+// src/cli/commands/eval.ts
+import process6 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) {
+      process6.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";
+    process6.stderr.write(`${detail}
+`);
+    process6.exitCode = 1;
+    return;
+  }
+  const inner = result.result;
+  if (inner === void 0) {
+    process6.stdout.write("\n");
+    return;
+  }
+  if (typeof inner.value === "string") {
+    process6.stdout.write(`${inner.value}
+`);
+    return;
+  }
+  if (typeof inner.description === "string") {
+    process6.stdout.write(`${inner.description}
+`);
+    return;
+  }
+  process6.stdout.write(`${JSON.stringify(inner.value)}
+`);
+}
+
+// src/cli/commands/exception.ts
+import { performance as performance5 } from "perf_hooks";
+import process8 from "process";
 
 // src/inspector/pause.ts
 init_types();
@@ -2311,22 +3073,280 @@ async function waitForLivePause(session, options, deadlineMs) {
   if (remainingMs <= 0) {
     throwBreakpointTimeout(options.timeoutMs);
   }
-  session.pauseWaitGate.active = true;
-  let receivedAtMs;
-  let params;
+  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();
+    }
+  }
+};
+function isExpectedRaceStop(error) {
+  return error instanceof CfInspectorError && (error.code === "ABORTED" || error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT");
+}
+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 +4060,25 @@ async function captureExpression(session, callFrameId, expression, maxValueLengt
 
 // src/cli/commands/exception.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/exception.ts
 var VALID_PAUSE_TYPES = ["uncaught", "caught", "all"];
 async function handleException(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3048,7 +4087,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 +4117,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 +4143,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(
+    process8.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after exception capture; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3124,7 +4175,7 @@ async function disablePauseOnExceptionsBestEffort(session) {
 }
 
 // src/cli/commands/listScripts.ts
-import process6 from "process";
+import process9 from "process";
 async function handleListScripts(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const filter = compileScriptUrlFilter(opts.filter);
@@ -3134,7 +4185,7 @@ async function handleListScripts(opts) {
     return;
   }
   for (const script of scripts) {
-    process6.stdout.write(`${script.scriptId}	${script.url}
+    process9.stdout.write(`${script.scriptId}	${script.url}
 `);
   }
 }
@@ -3165,7 +4216,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(
+      process9.stderr.write(
         `[cf-inspector] warning: worker discovery failed for raw target ${index.toString()}: ${message}
 `
       );
@@ -3192,7 +4243,7 @@ function looksLikeWorkerTarget(target) {
   return `${target.type} ${target.title} ${target.url}`.toLowerCase().includes("worker");
 }
 function writeTargetCountSummary(targetCount, workerCount) {
-  process6.stderr.write(
+  process9.stderr.write(
     `[cf-inspector] ${targetCount.toString()} raw inspector ${targetCount === 1 ? "target" : "targets"}; ${workerCount.toString()} ${workerCount === 1 ? "worker" : "workers"}.
 `
   );
@@ -3203,7 +4254,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(
+  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.
 `
   );
@@ -3211,12 +4262,12 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
 function writeHumanTargets(targets) {
   for (const target of targets) {
     const workerLabel = target.likelyWorker ? "	likely-worker" : "";
-    process6.stdout.write(
+    process9.stdout.write(
       `${target.index.toString()}	target	${target.type}	${target.title}	${target.url}${workerLabel}
 `
     );
     for (const worker of target.workers) {
-      process6.stdout.write(
+      process9.stdout.write(
         `  ${worker.index.toString()}	worker	${worker.type}	${worker.title}	${worker.url}
 `
       );
@@ -3293,7 +4344,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process8 from "process";
+import process10 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -3559,25 +4610,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 +4628,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 +4638,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 })}
+    process10.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process8.stderr.write(
+  process10.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 process11 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3652,7 +4776,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 +4817,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 +4915,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 +4929,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(
+    process11.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3800,8 +4954,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 process12 from "process";
 init_types();
 async function handleWatch(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -3816,14 +4970,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 {
+        process12.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();
+    process12.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 +5116,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 +5166,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process10.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process12.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process10.stderr.write(
+  process12.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -4061,7 +5190,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 = []) => [
@@ -4071,7 +5200,7 @@ var collectStrings = (value, prev = []) => [
 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) {
@@ -4093,12 +5222,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 +5308,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process11.argv);
+  await main(process13.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process11.stderr.write(`Error [${err.code}]: ${err.message}
+    process13.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process11.stderr.write(`  detail: ${err.detail}
+      process13.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process11.exit(1);
+    process13.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process11.stderr.write(`Error: ${message}
+  process13.stderr.write(`Error: ${message}
 `);
-  process11.exit(1);
+  process13.exit(1);
 }
 //# sourceMappingURL=cli.js.map