@saptools/cf-inspector 0.6.2 → 0.7.0

package/dist/index.js

@@ -913,6 +913,56 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
   }
   return { browser, protocolVersion };
 }
+function startInspectorKeepalive(host, port, options = {}) {
+  const intervalMs = options.intervalMs ?? 1e4;
+  const probeTimeoutMs = options.probeTimeoutMs ?? 2e3;
+  const failureThreshold = options.failureThreshold ?? 3;
+  const probe = options.probe ?? (async () => await fetchInspectorVersion(host, port, probeTimeoutMs));
+  let cancelled = false;
+  let consecutiveFailures = 0;
+  let timer;
+  let rejectFailure;
+  const failure = new Promise((_resolve, reject) => {
+    rejectFailure = reject;
+  });
+  const schedule = () => {
+    if (cancelled) {
+      return;
+    }
+    timer = setTimeout(() => {
+      void runProbe();
+    }, intervalMs);
+  };
+  const runProbe = async () => {
+    try {
+      await probe();
+      consecutiveFailures = 0;
+    } catch (error) {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= failureThreshold) {
+        cancelled = true;
+        const detail = error instanceof Error ? error.message : String(error);
+        rejectFailure?.(new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          `Inspector tunnel ${host}:${port.toString()} failed ${failureThreshold.toString()} consecutive keepalive probes and is no longer round-tripping. Retry the command after restarting or investigating the owning tunnel session.`,
+          detail
+        ));
+        return;
+      }
+    }
+    schedule();
+  };
+  schedule();
+  return {
+    failure,
+    cancel: () => {
+      cancelled = true;
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
 
 // src/inspector/pause.ts
 init_types();
@@ -1035,10 +1085,16 @@ async function waitForLivePause(session, options, deadlineMs) {
   return toPauseEvent(params, receivedAtMs ?? performance2.now(), session.scripts);
 }
 
+// src/inspector/fanout.ts
+init_types();
+import { performance as performance3 } from "perf_hooks";
+
 // 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 });
@@ -1154,8 +1210,264 @@ async function releaseObjectGroup(session, objectGroup) {
   await session.client.send("Runtime.releaseObjectGroup", { objectGroup });
 }
 
+// src/inspector/fanout.ts
+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 = performance3.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 = performance3.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 - performance3.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 - performance3.now());
+}
+async function settleWithin(work, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          resolve(null);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  }
+}
+
 // src/inspector/session.ts
-import { performance as performance3 } from "perf_hooks";
+import { performance as performance4 } from "perf_hooks";
 
 // src/cdp/client.ts
 init_types();
@@ -1518,6 +1830,7 @@ init_types();
 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;
@@ -1526,12 +1839,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);
+          }
         }
       })
     ];
@@ -1541,6 +1860,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 });
@@ -1554,6 +1875,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;
@@ -1568,6 +1928,8 @@ var NodeWorkerDiscovery = class {
     for (const detach of this.detachListeners) {
       detach();
     }
+    this.attachedListeners.clear();
+    this.detachedListeners.clear();
   }
 };
 function isUnsupportedNodeWorkerDomain(error) {
@@ -1632,14 +1994,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
     );
@@ -1649,25 +2012,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 main = await initSession(parent, target, { kind: "main" });
+    const group = new DynamicInspectorSessionGroup(
+      parent,
+      discovery,
+      main,
+      targetIndex,
+      targets.length
+    );
+    await group.initialize();
+    return group;
+  } catch (error) {
+    await discovery?.dispose();
+    parent.dispose();
+    throw error;
+  }
+}
+var DynamicInspectorSessionGroup = class {
+  constructor(parent, discovery, main, targetIndex, targetCount) {
+    this.parent = parent;
+    this.discovery = discovery;
+    this.targetIndex = targetIndex;
+    this.targetCount = targetCount;
+    this.workerDiscoverySupported = discovery.supported;
+    this.sessions.set("main", main);
+    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,
@@ -1693,16 +2238,16 @@ function workerToInspectorTarget(worker) {
     webSocketDebuggerUrl: `node-worker://${worker.sessionId}`
   };
 }
-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) => {
@@ -1714,23 +2259,28 @@ function registerScriptTracking(client, scripts) {
 }
 function registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   client.on("Debugger.paused", (raw) => {
+    const event = toPauseEvent(raw, performance4.now(), scripts);
+    debuggerState.paused = true;
+    debuggerState.currentPause = event;
     if (pauseWaitGate.active) {
       return;
     }
-    const event = toPauseEvent(raw, performance3.now(), scripts);
     if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
       pauseBuffer.shift();
     }
     pauseBuffer.push(event);
   });
   client.on("Debugger.resumed", () => {
-    debuggerState.lastResumedAtMs = performance3.now();
+    debuggerState.paused = false;
+    delete debuggerState.currentPause;
+    debuggerState.lastResumedAtMs = performance4.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,
@@ -2766,6 +3316,8 @@ async function waitForStop(session, options, registerMaxEventsSignal) {
 
 // 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 },
@@ -2827,11 +3379,22 @@ 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() };
   }
 }
 export {
+  BreakpointFanout,
   CfInspectorError,
   buildBreakpointUrlRegex,
   buildHitCountedCondition,
@@ -2839,6 +3402,7 @@ export {
   captureException,
   captureSnapshot,
   connectInspector,
+  connectInspectorGroup,
   discoverInspectorTargets,
   evaluateGlobal,
   evaluateOnFrame,
@@ -2860,6 +3424,7 @@ export {
   setBreakpoint,
   setBreakpointAtLocation,
   setPauseOnExceptions,
+  startInspectorKeepalive,
   stepInto,
   stepOut,
   stepOver,