@saptools/cf-inspector 0.3.15 → 0.3.17

package/dist/index.js

@@ -29,7 +29,7 @@ var init_types = __esm({
   }
 });
 
-// src/wsTransport.ts
+// src/cdp/wsTransport.ts
 var wsTransport_exports = {};
 __export(wsTransport_exports, {
   wsTransportFactory: () => wsTransportFactory
@@ -37,6 +37,32 @@ __export(wsTransport_exports, {
 import { WebSocket } from "ws";
 async function wsTransportFactory(url) {
   const socket = new WebSocket(url, { perMessageDeflate: false });
+  await waitForOpen(socket, url);
+  const wrappers = /* @__PURE__ */ new WeakMap();
+  return {
+    send(payload) {
+      socket.send(payload);
+    },
+    close() {
+      socket.close();
+    },
+    get readyState() {
+      return socket.readyState;
+    },
+    on(event, listener) {
+      const wrapped = wrapListener(event, listener, wrappers);
+      socket.on(event, wrapped);
+    },
+    off(event, listener) {
+      const wrapped = wrappers.get(listener);
+      if (!wrapped) {
+        return;
+      }
+      socket.off(event, wrapped);
+    }
+  };
+}
+async function waitForOpen(socket, url) {
   await new Promise((resolve, reject) => {
     const onOpen = () => {
       socket.off("error", onError);
@@ -54,64 +80,30 @@ async function wsTransportFactory(url) {
     socket.once("open", onOpen);
     socket.once("error", onError);
   });
-  const wrappers = /* @__PURE__ */ new WeakMap();
-  const wrapMessage = (listener) => {
-    const wrapped = (data) => {
+}
+function wrapListener(event, listener, wrappers) {
+  if (event === "message") {
+    const wrapped2 = (data) => {
       listener(data.toString("utf8"));
     };
-    wrappers.set(listener, wrapped);
-    return wrapped;
-  };
-  const wrapClose = (listener) => {
-    const wrapped = () => {
+    wrappers.set(listener, wrapped2);
+    return wrapped2;
+  }
+  if (event === "close") {
+    const wrapped2 = () => {
       listener();
     };
-    wrappers.set(listener, wrapped);
-    return wrapped;
-  };
-  const wrapError = (listener) => {
-    const wrapped = (err) => {
-      listener(err);
-    };
-    wrappers.set(listener, wrapped);
-    return wrapped;
-  };
-  return {
-    send(payload) {
-      socket.send(payload);
-    },
-    close() {
-      socket.close();
-    },
-    get readyState() {
-      return socket.readyState;
-    },
-    on(event, listener) {
-      if (event === "message") {
-        socket.on("message", wrapMessage(listener));
-      } else if (event === "close") {
-        socket.on("close", wrapClose(listener));
-      } else {
-        socket.on("error", wrapError(listener));
-      }
-    },
-    off(event, listener) {
-      const wrapped = wrappers.get(listener);
-      if (!wrapped) {
-        return;
-      }
-      if (event === "message") {
-        socket.off("message", wrapped);
-      } else if (event === "close") {
-        socket.off("close", wrapped);
-      } else {
-        socket.off("error", wrapped);
-      }
-    }
+    wrappers.set(listener, wrapped2);
+    return wrapped2;
+  }
+  const wrapped = (err) => {
+    listener(err);
   };
+  wrappers.set(listener, wrapped);
+  return wrapped;
 }
 var init_wsTransport = __esm({
-  "src/wsTransport.ts"() {
+  "src/cdp/wsTransport.ts"() {
     "use strict";
     init_types();
   }
@@ -259,252 +251,155 @@ function buildBreakpointUrlRegex(input) {
   }
 }
 
-// src/inspector.ts
-import { request } from "http";
-import { performance } from "perf_hooks";
-
-// src/cdp.ts
+// src/inspector/breakpoints.ts
 init_types();
-import { EventEmitter } from "events";
-var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
-function parseMessage(raw) {
-  try {
-    const value = JSON.parse(raw);
-    if (typeof value !== "object" || value === null) {
-      return void 0;
-    }
-    return value;
-  } catch {
-    return void 0;
-  }
+
+// src/inspector/conversions.ts
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
 }
-async function loadDefaultFactory() {
-  const mod = await Promise.resolve().then(() => (init_wsTransport(), wsTransport_exports));
-  return mod.wsTransportFactory;
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-var CdpClient = class _CdpClient {
-  transport;
-  requestTimeoutMs;
-  pending = /* @__PURE__ */ new Map();
-  emitter = new EventEmitter();
-  nextId = 1;
-  closed = false;
-  closeReason;
-  handleMessage = (raw) => {
-    const parsed = parseMessage(raw);
-    if (!parsed) {
-      return;
+function toResolvedLocations(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
     }
-    if (typeof parsed.id === "number") {
-      const pending = this.pending.get(parsed.id);
-      if (!pending) {
-        return;
-      }
-      this.pending.delete(parsed.id);
-      clearTimeout(pending.timer);
-      if (parsed.error) {
-        pending.reject(
-          new CfInspectorError(
-            "CDP_REQUEST_FAILED",
-            `CDP request ${parsed.id.toString()} failed: ${parsed.error.message}`,
-            JSON.stringify(parsed.error)
-          )
-        );
-        return;
-      }
-      pending.resolve(parsed.result);
-      return;
+    const candidate = entry;
+    const scriptId = asString(candidate.scriptId);
+    if (scriptId.length === 0) {
+      return [];
     }
-    if (typeof parsed.method === "string") {
-      this.emitter.emit(parsed.method, parsed.params);
-      this.emitter.emit("event", { method: parsed.method, params: parsed.params });
+    const url = typeof candidate.url === "string" ? candidate.url : void 0;
+    const lineNumber = asNumber(candidate.lineNumber);
+    const result = url === void 0 ? { scriptId, lineNumber, columnNumber: asNumber(candidate.columnNumber) } : { scriptId, url, lineNumber, columnNumber: asNumber(candidate.columnNumber) };
+    return [result];
+  });
+}
+function toScopeChain(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
     }
+    const candidate = entry;
+    const type = asString(candidate.type);
+    if (type.length === 0) {
+      return [];
+    }
+    const objectId = typeof candidate.object?.objectId === "string" ? candidate.object.objectId : void 0;
+    const name = typeof candidate.name === "string" ? candidate.name : void 0;
+    const base = name === void 0 ? { type } : { type, name };
+    return [objectId === void 0 ? base : { ...base, objectId }];
+  });
+}
+function toCallFrames(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
+    }
+    const candidate = entry;
+    const callFrameId = asString(candidate.callFrameId);
+    if (callFrameId.length === 0) {
+      return [];
+    }
+    const url = typeof candidate.url === "string" ? candidate.url : void 0;
+    const base = {
+      callFrameId,
+      functionName: asString(candidate.functionName),
+      lineNumber: asNumber(candidate.location?.lineNumber),
+      columnNumber: asNumber(candidate.location?.columnNumber),
+      scopeChain: toScopeChain(candidate.scopeChain)
+    };
+    return [url === void 0 ? base : { ...base, url }];
+  });
+}
+function toPauseEvent(params, receivedAtMs) {
+  return {
+    reason: asString(params.reason),
+    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
+    callFrames: toCallFrames(params.callFrames),
+    receivedAtMs
   };
-  handleClose = () => {
-    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Inspector connection closed"));
-  };
-  handleError = (err) => {
-    this.markClosed(
-      err instanceof CfInspectorError ? err : new CfInspectorError("INSPECTOR_CONNECTION_FAILED", err.message)
-    );
+}
+function topFrameLocation(pause) {
+  const top = pause.callFrames[0];
+  if (top === void 0) {
+    return "(no call frame)";
+  }
+  const url = top.url !== void 0 && top.url.length > 0 ? top.url : "(unknown)";
+  return `${url}:${(top.lineNumber + 1).toString()}:${(top.columnNumber + 1).toString()}`;
+}
+function pauseDetail(pause) {
+  return JSON.stringify({
+    reason: pause.reason,
+    hitBreakpoints: pause.hitBreakpoints,
+    topFrame: topFrameLocation(pause)
+  });
+}
+
+// src/inspector/breakpoints.ts
+async function setBreakpoint(session, input) {
+  const remoteRoot = input.remoteRoot ?? { kind: "none" };
+  const urlRegex = buildBreakpointUrlRegex({ file: input.file, remoteRoot });
+  const params = {
+    lineNumber: input.line - 1,
+    urlRegex
   };
-  constructor(transport, requestTimeoutMs) {
-    this.transport = transport;
-    this.requestTimeoutMs = requestTimeoutMs;
-    transport.on("message", this.handleMessage);
-    transport.on("close", this.handleClose);
-    transport.on("error", this.handleError);
+  if (input.condition !== void 0 && input.condition.length > 0) {
+    params["condition"] = input.condition;
   }
-  static async connect(options) {
-    const factory = options.transportFactory ?? await loadDefaultFactory();
-    const transport = await factory(options.url);
-    return new _CdpClient(transport, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
+  const result = await session.client.send(
+    "Debugger.setBreakpointByUrl",
+    params
+  );
+  const breakpointId = asString(result.breakpointId);
+  if (breakpointId.length === 0) {
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      `setBreakpointByUrl did not return a breakpointId for ${input.file}:${input.line.toString()}`
+    );
   }
-  async send(method, params = {}) {
-    if (this.closed) {
-      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
-    }
-    const id = this.nextId++;
-    const payload = JSON.stringify({ id, method, params });
-    return await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(
-          new CfInspectorError(
-            "CDP_REQUEST_FAILED",
-            `CDP method ${method} timed out after ${this.requestTimeoutMs.toString()}ms`
-          )
-        );
-      }, this.requestTimeoutMs);
-      this.pending.set(id, {
-        resolve: (value) => {
-          resolve(value);
-        },
-        reject,
-        timer
-      });
-      try {
-        this.transport.send(payload);
-      } catch (err) {
-        clearTimeout(timer);
-        this.pending.delete(id);
-        const message = err instanceof Error ? err.message : String(err);
-        reject(new CfInspectorError("CDP_REQUEST_FAILED", `Failed to send ${method}: ${message}`));
-      }
-    });
-  }
-  on(method, listener) {
-    this.emitter.on(method, listener);
-    return () => {
-      this.emitter.off(method, listener);
-    };
-  }
-  async waitFor(method, options = {
-    timeoutMs: this.requestTimeoutMs
-  }) {
-    if (this.closed) {
-      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
-    }
-    return await new Promise((resolve, reject) => {
-      let settled = false;
-      const cleanup = () => {
-        clearTimeout(timer);
-        offEvent();
-        offClose();
-      };
-      const offEvent = this.on(method, (raw) => {
-        if (settled) {
-          return;
-        }
-        const params = raw;
-        if (options.predicate && !options.predicate(params)) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        resolve(params);
-      });
-      const offClose = this.onClose((err) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        reject(err);
-      });
-      const timer = setTimeout(() => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        reject(
-          new CfInspectorError(
-            "BREAKPOINT_NOT_HIT",
-            `Timed out waiting for ${method} after ${options.timeoutMs.toString()}ms`
-          )
-        );
-      }, options.timeoutMs);
-    });
-  }
-  onClose(listener) {
-    if (this.closed) {
-      const reason = this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
-      queueMicrotask(() => {
-        listener(reason);
-      });
-      return () => {
-      };
-    }
-    this.emitter.on("__close__", listener);
-    return () => {
-      this.emitter.off("__close__", listener);
-    };
-  }
-  dispose() {
-    if (this.closed) {
-      return;
-    }
-    this.transport.off("message", this.handleMessage);
-    this.transport.off("close", this.handleClose);
-    this.transport.off("error", this.handleError);
-    try {
-      this.transport.close();
-    } catch {
-    }
-    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection disposed"));
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  markClosed(reason) {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.closeReason = reason;
-    for (const [, pending] of this.pending) {
-      clearTimeout(pending.timer);
-      pending.reject(reason);
-    }
-    this.pending.clear();
-    this.emitter.emit("__close__", reason);
-    this.emitter.removeAllListeners();
-  }
-};
-
-// src/inspector.ts
-init_types();
-var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
-var DEFAULT_HOST = "127.0.0.1";
-async function fetchJson(url, timeoutMs) {
-  return await new Promise((resolve, reject) => {
-    const req = request(url, { method: "GET" }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      res.on("end", () => {
-        try {
-          const text = Buffer.concat(chunks).toString("utf8");
-          resolve(JSON.parse(text));
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          reject(
-            new CfInspectorError(
-              "INSPECTOR_DISCOVERY_FAILED",
-              `Failed to parse inspector discovery response from ${url}: ${message}`
-            )
-          );
-        }
-      });
-      res.on("error", (err) => {
-        reject(
-          new CfInspectorError(
-            "INSPECTOR_DISCOVERY_FAILED",
-            `Inspector discovery response error: ${err.message}`
-          )
-        );
+  return {
+    breakpointId,
+    file: input.file,
+    line: input.line,
+    urlRegex,
+    resolvedLocations: toResolvedLocations(result.locations)
+  };
+}
+async function removeBreakpoint(session, breakpointId) {
+  await session.client.send("Debugger.removeBreakpoint", { breakpointId });
+}
+
+// src/inspector/discovery.ts
+init_types();
+import { request } from "http";
+async function fetchJson(url, timeoutMs) {
+  return await new Promise((resolve, reject) => {
+    const req = request(url, { method: "GET" }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        try {
+          resolve(parseJsonResponse(chunks));
+        } catch (err) {
+          reject(parseDiscoveryError(url, err));
+        }
+      });
+      res.on("error", (err) => {
+        reject(newDiscoveryError(`Inspector discovery response error: ${err.message}`));
       });
     });
     req.setTimeout(timeoutMs, () => {
@@ -526,6 +421,17 @@ async function fetchJson(url, timeoutMs) {
     req.end();
   });
 }
+function parseJsonResponse(chunks) {
+  const text = Buffer.concat(chunks).toString("utf8");
+  return JSON.parse(text);
+}
+function parseDiscoveryError(url, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return newDiscoveryError(`Failed to parse inspector discovery response from ${url}: ${message}`);
+}
+function newDiscoveryError(message) {
+  return new CfInspectorError("INSPECTOR_DISCOVERY_FAILED", message);
+}
 function toInspectorTarget(value, source) {
   if (typeof value !== "object" || value === null) {
     throw new CfInspectorError(
@@ -592,240 +498,61 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
   }
   return { browser, protocolVersion };
 }
-async function connectInspector(options) {
-  const host = options.host ?? DEFAULT_HOST;
-  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
-  const targets = await discoverInspectorTargets(host, options.port, connectTimeoutMs);
-  const target = targets[0];
-  if (!target) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `No inspector targets available on ${host}:${options.port.toString()}`
-    );
+
+// src/inspector/pause.ts
+init_types();
+import { performance } from "perf_hooks";
+function pauseMatches(pause, breakpointIds) {
+  if (breakpointIds === void 0 || breakpointIds.length === 0) {
+    return true;
   }
-  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl });
-  const scripts = /* @__PURE__ */ new Map();
-  client.on("Debugger.scriptParsed", (raw) => {
-    const params = raw;
-    const scriptId = asString(params.scriptId);
-    const url = asString(params.url);
-    if (scriptId.length === 0) {
-      return;
-    }
-    scripts.set(scriptId, { scriptId, url });
-  });
-  const PAUSE_BUFFER_LIMIT = 32;
-  const pauseBuffer = [];
-  const pauseWaitGate = { active: false };
-  const debuggerState = {};
-  client.on("Debugger.paused", (raw) => {
-    if (pauseWaitGate.active) {
-      return;
-    }
-    const params = raw;
-    const event = toPauseEvent(params, performance.now());
-    if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
-      pauseBuffer.shift();
-    }
-    pauseBuffer.push(event);
-  });
-  client.on("Debugger.resumed", () => {
-    debuggerState.lastResumedAtMs = performance.now();
-  });
-  await client.send("Runtime.enable");
-  await client.send("Debugger.enable");
-  return {
-    client,
-    target,
-    scripts,
-    pauseBuffer,
-    pauseWaitGate,
-    debuggerState,
-    dispose: async () => {
-      try {
-        await client.send("Debugger.disable");
-      } catch {
-      }
-      client.dispose();
-    }
-  };
+  return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
 }
-function asString(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
+function remainingUntil(deadlineMs) {
+  return Math.max(0, deadlineMs - performance.now());
 }
-function asNumber(value, fallback = 0) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+function hasResumedSincePause(session, pause) {
+  const pauseAt = pause.receivedAtMs;
+  const resumedAt = session.debuggerState.lastResumedAtMs;
+  return pauseAt !== void 0 && resumedAt !== void 0 && resumedAt >= pauseAt;
 }
-function toResolvedLocations(value) {
-  if (!Array.isArray(value)) {
-    return [];
+function throwBreakpointTimeout(timeoutMs) {
+  throw new CfInspectorError(
+    "BREAKPOINT_NOT_HIT",
+    `Timed out waiting for matching Debugger.paused after ${timeoutMs.toString()}ms`
+  );
+}
+function throwUnrelatedPauseTimeout(pause, timeoutMs) {
+  throw new CfInspectorError(
+    "UNRELATED_PAUSE_TIMEOUT",
+    `Target stayed paused by another debugger event before this command's breakpoint could hit within ${timeoutMs.toString()}ms`,
+    pauseDetail(pause)
+  );
+}
+async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeoutMs) {
+  if (hasResumedSincePause(session, pause)) {
+    return;
   }
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const scriptId = asString(candidate.scriptId);
-    if (scriptId.length === 0) {
-      return [];
+  const remainingMs = remainingUntil(deadlineMs);
+  if (remainingMs <= 0) {
+    throwUnrelatedPauseTimeout(pause, timeoutMs);
+  }
+  try {
+    await session.client.waitFor("Debugger.resumed", { timeoutMs: remainingMs });
+    session.debuggerState.lastResumedAtMs = performance.now();
+  } catch (err) {
+    if (err instanceof CfInspectorError && err.code === "BREAKPOINT_NOT_HIT") {
+      throwUnrelatedPauseTimeout(pause, timeoutMs);
     }
-    const url = typeof candidate.url === "string" ? candidate.url : void 0;
-    const lineNumber = asNumber(candidate.lineNumber);
-    const result = url === void 0 ? { scriptId, lineNumber, columnNumber: asNumber(candidate.columnNumber) } : { scriptId, url, lineNumber, columnNumber: asNumber(candidate.columnNumber) };
-    return [result];
-  });
-}
-async function setBreakpoint(session, input) {
-  const remoteRoot = input.remoteRoot ?? { kind: "none" };
-  const urlRegex = buildBreakpointUrlRegex({ file: input.file, remoteRoot });
-  const params = {
-    lineNumber: input.line - 1,
-    urlRegex
-  };
-  if (input.condition !== void 0 && input.condition.length > 0) {
-    params["condition"] = input.condition;
+    throw err;
   }
-  const result = await session.client.send(
-    "Debugger.setBreakpointByUrl",
-    params
-  );
-  const breakpointId = asString(result.breakpointId);
-  if (breakpointId.length === 0) {
+}
+async function handleUnmatchedPause(session, pause, options, deadlineMs) {
+  if (options.unmatchedPausePolicy === "fail") {
     throw new CfInspectorError(
-      "CDP_REQUEST_FAILED",
-      `setBreakpointByUrl did not return a breakpointId for ${input.file}:${input.line.toString()}`
-    );
-  }
-  return {
-    breakpointId,
-    file: input.file,
-    line: input.line,
-    urlRegex,
-    resolvedLocations: toResolvedLocations(result.locations)
-  };
-}
-async function removeBreakpoint(session, breakpointId) {
-  await session.client.send("Debugger.removeBreakpoint", { breakpointId });
-}
-function toScopeChain(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const type = asString(candidate.type);
-    if (type.length === 0) {
-      return [];
-    }
-    const objectId = typeof candidate.object?.objectId === "string" ? candidate.object.objectId : void 0;
-    const name = typeof candidate.name === "string" ? candidate.name : void 0;
-    const base = name === void 0 ? { type } : { type, name };
-    return [objectId === void 0 ? base : { ...base, objectId }];
-  });
-}
-function toCallFrames(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const callFrameId = asString(candidate.callFrameId);
-    if (callFrameId.length === 0) {
-      return [];
-    }
-    const url = typeof candidate.url === "string" ? candidate.url : void 0;
-    const lineNumber = asNumber(candidate.location?.lineNumber);
-    const columnNumber = asNumber(candidate.location?.columnNumber);
-    const base = {
-      callFrameId,
-      functionName: asString(candidate.functionName),
-      lineNumber,
-      columnNumber,
-      scopeChain: toScopeChain(candidate.scopeChain)
-    };
-    return [url === void 0 ? base : { ...base, url }];
-  });
-}
-function pauseMatches(pause, breakpointIds) {
-  if (breakpointIds === void 0 || breakpointIds.length === 0) {
-    return true;
-  }
-  return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
-}
-function toPauseEvent(params, receivedAtMs) {
-  return {
-    reason: asString(params.reason),
-    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
-    callFrames: toCallFrames(params.callFrames),
-    receivedAtMs
-  };
-}
-function remainingUntil(deadlineMs) {
-  return Math.max(0, deadlineMs - performance.now());
-}
-function topFrameLocation(pause) {
-  const top = pause.callFrames[0];
-  if (top === void 0) {
-    return "(no call frame)";
-  }
-  const url = top.url !== void 0 && top.url.length > 0 ? top.url : "(unknown)";
-  return `${url}:${(top.lineNumber + 1).toString()}:${(top.columnNumber + 1).toString()}`;
-}
-function pauseDetail(pause) {
-  return JSON.stringify({
-    reason: pause.reason,
-    hitBreakpoints: pause.hitBreakpoints,
-    topFrame: topFrameLocation(pause)
-  });
-}
-function hasResumedSincePause(session, pause) {
-  const pauseAt = pause.receivedAtMs;
-  const resumedAt = session.debuggerState.lastResumedAtMs;
-  return pauseAt !== void 0 && resumedAt !== void 0 && resumedAt >= pauseAt;
-}
-function throwBreakpointTimeout(timeoutMs) {
-  throw new CfInspectorError(
-    "BREAKPOINT_NOT_HIT",
-    `Timed out waiting for matching Debugger.paused after ${timeoutMs.toString()}ms`
-  );
-}
-function throwUnrelatedPauseTimeout(pause, timeoutMs) {
-  throw new CfInspectorError(
-    "UNRELATED_PAUSE_TIMEOUT",
-    `Target stayed paused by another debugger event before this command's breakpoint could hit within ${timeoutMs.toString()}ms`,
-    pauseDetail(pause)
-  );
-}
-async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeoutMs) {
-  if (hasResumedSincePause(session, pause)) {
-    return;
-  }
-  const remainingMs = remainingUntil(deadlineMs);
-  if (remainingMs <= 0) {
-    throwUnrelatedPauseTimeout(pause, timeoutMs);
-  }
-  try {
-    await session.client.waitFor("Debugger.resumed", { timeoutMs: remainingMs });
-    session.debuggerState.lastResumedAtMs = performance.now();
-  } catch (err) {
-    if (err instanceof CfInspectorError && err.code === "BREAKPOINT_NOT_HIT") {
-      throwUnrelatedPauseTimeout(pause, timeoutMs);
-    }
-    throw err;
-  }
-}
-async function handleUnmatchedPause(session, pause, options, deadlineMs) {
-  if (options.unmatchedPausePolicy === "fail") {
-    throw new CfInspectorError(
-      "UNRELATED_PAUSE",
-      "Target paused before this command's breakpoint was reached",
-      pauseDetail(pause)
+      "UNRELATED_PAUSE",
+      "Target paused before this command's breakpoint was reached",
+      pauseDetail(pause)
     );
   }
   if (hasResumedSincePause(session, pause)) {
@@ -848,25 +575,7 @@ async function waitForPause(session, options) {
       }
       await handleUnmatchedPause(session, buffered, options, deadlineMs);
     }
-    const remainingMs = remainingUntil(deadlineMs);
-    if (remainingMs <= 0) {
-      throwBreakpointTimeout(options.timeoutMs);
-    }
-    session.pauseWaitGate.active = true;
-    let receivedAtMs;
-    let params;
-    try {
-      params = await session.client.waitFor("Debugger.paused", {
-        timeoutMs: remainingMs,
-        predicate: () => {
-          receivedAtMs = performance.now();
-          return true;
-        }
-      });
-    } finally {
-      session.pauseWaitGate.active = false;
-    }
-    const pause = toPauseEvent(params, receivedAtMs ?? performance.now());
+    const pause = await waitForLivePause(session, options, deadlineMs);
     if (pauseMatches(pause, options.breakpointIds)) {
       return pause;
     }
@@ -874,6 +583,30 @@ async function waitForPause(session, options) {
   }
   throwBreakpointTimeout(options.timeoutMs);
 }
+async function waitForLivePause(session, options, deadlineMs) {
+  const remainingMs = remainingUntil(deadlineMs);
+  if (remainingMs <= 0) {
+    throwBreakpointTimeout(options.timeoutMs);
+  }
+  session.pauseWaitGate.active = true;
+  let receivedAtMs;
+  let params;
+  try {
+    params = await session.client.waitFor("Debugger.paused", {
+      timeoutMs: remainingMs,
+      predicate: () => {
+        receivedAtMs = performance.now();
+        return true;
+      }
+    });
+  } finally {
+    session.pauseWaitGate.active = false;
+  }
+  return toPauseEvent(params, receivedAtMs ?? performance.now());
+}
+
+// src/inspector/runtime.ts
+init_types();
 async function resume(session) {
   await session.client.send("Debugger.resume");
 }
@@ -922,194 +655,328 @@ async function getProperties(session, objectId) {
   return result.result;
 }
 
-// src/snapshot.ts
+// src/inspector/session.ts
+import { performance as performance2 } from "perf_hooks";
+
+// src/cdp/client.ts
 init_types();
-var MAX_SCOPES = 3;
-var MAX_SCOPE_VARIABLES = 20;
-var MAX_CHILD_VARIABLES = 8;
-var MAX_VARIABLE_DEPTH = 2;
-var DEFAULT_MAX_VALUE_LENGTH = 4096;
-var PRIORITY_BY_TYPE = {
-  local: 0,
-  arguments: 1,
-  block: 2,
-  closure: 3,
-  catch: 4,
-  with: 5,
-  module: 6,
-  script: 7
-};
-function buildDescribed(value, type, objectId) {
-  const base = { value };
-  if (type !== void 0) {
-    base.type = type;
-  }
-  if (objectId !== void 0) {
-    base.objectId = objectId;
+import { EventEmitter } from "events";
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+function parseMessage(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null) {
+      return void 0;
+    }
+    return value;
+  } catch {
+    return void 0;
   }
-  return base;
 }
-function describeProperty(prop) {
-  const value = prop.value;
-  if (value === void 0) {
-    return { value: "undefined" };
+async function loadDefaultFactory() {
+  const mod = await Promise.resolve().then(() => (init_wsTransport(), wsTransport_exports));
+  return mod.wsTransportFactory;
+}
+var CdpClient = class _CdpClient {
+  transport;
+  requestTimeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  emitter = new EventEmitter();
+  nextId = 1;
+  closed = false;
+  closeReason;
+  handleMessage = (raw) => {
+    const parsed = parseMessage(raw);
+    if (!parsed) {
+      return;
+    }
+    if (typeof parsed.id === "number") {
+      this.handleResponse(parsed);
+      return;
+    }
+    if (typeof parsed.method === "string") {
+      this.emitter.emit(parsed.method, parsed.params);
+      this.emitter.emit("event", { method: parsed.method, params: parsed.params });
+    }
+  };
+  handleClose = () => {
+    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Inspector connection closed"));
+  };
+  handleError = (err) => {
+    this.markClosed(
+      err instanceof CfInspectorError ? err : new CfInspectorError("INSPECTOR_CONNECTION_FAILED", err.message)
+    );
+  };
+  constructor(transport, requestTimeoutMs) {
+    this.transport = transport;
+    this.requestTimeoutMs = requestTimeoutMs;
+    transport.on("message", this.handleMessage);
+    transport.on("close", this.handleClose);
+    transport.on("error", this.handleError);
   }
-  const type = typeof value.type === "string" ? value.type : void 0;
-  const objectId = typeof value.objectId === "string" ? value.objectId : void 0;
-  if (type === "undefined") {
-    return buildDescribed("undefined", type);
+  static async connect(options) {
+    const factory = options.transportFactory ?? await loadDefaultFactory();
+    const transport = await factory(options.url);
+    return new _CdpClient(transport, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
   }
-  if (type === "string" && typeof value.value === "string") {
-    return buildDescribed(JSON.stringify(value.value), type);
+  async send(method, params = {}) {
+    if (this.closed) {
+      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+    }
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, method, params });
+    return await new Promise((resolve, reject) => {
+      const timer = this.createRequestTimer(id, method, reject);
+      this.pending.set(id, {
+        resolve: (value) => {
+          resolve(value);
+        },
+        reject,
+        timer
+      });
+      this.sendPayload(id, method, payload, timer, reject);
+    });
   }
-  if ((type === "number" || type === "boolean" || type === "bigint" || type === "symbol") && isPrimitive(value.value)) {
-    return buildDescribed(formatPrimitive(value.value), type);
+  on(method, listener) {
+    this.emitter.on(method, listener);
+    return () => {
+      this.emitter.off(method, listener);
+    };
   }
-  if (typeof value.description === "string") {
-    return buildDescribed(value.description, type, objectId);
+  async waitFor(method, options = {
+    timeoutMs: this.requestTimeoutMs
+  }) {
+    if (this.closed) {
+      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+    }
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        offEvent();
+        offClose();
+      };
+      const finish = (value) => {
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+      const offEvent = this.on(method, (raw) => {
+        if (settled) {
+          return;
+        }
+        const params = raw;
+        if (options.predicate && !options.predicate(params)) {
+          return;
+        }
+        finish(params);
+      });
+      const offClose = this.onClose((err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(err);
+      });
+      const timer = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(this.createWaitTimeoutError(method, options.timeoutMs));
+      }, options.timeoutMs);
+    });
   }
-  if (isPrimitive(value.value)) {
-    return buildDescribed(formatPrimitive(value.value), type);
+  onClose(listener) {
+    if (this.closed) {
+      const reason = this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+      queueMicrotask(() => {
+        listener(reason);
+      });
+      return () => {
+      };
+    }
+    this.emitter.on("__close__", listener);
+    return () => {
+      this.emitter.off("__close__", listener);
+    };
   }
-  if (objectId === void 0) {
-    return buildDescribed("undefined", type);
+  dispose() {
+    if (this.closed) {
+      return;
+    }
+    this.transport.off("message", this.handleMessage);
+    this.transport.off("close", this.handleClose);
+    this.transport.off("error", this.handleError);
+    try {
+      this.transport.close();
+    } catch {
+    }
+    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection disposed"));
   }
-  return buildDescribed("[object]", type, objectId);
-}
-function isPrimitive(value) {
-  const t = typeof value;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol";
-}
-function formatPrimitive(value) {
-  if (typeof value === "symbol") {
-    return value.toString();
+  get isClosed() {
+    return this.closed;
   }
-  if (typeof value === "bigint") {
-    return `${value.toString()}n`;
+  handleResponse(parsed) {
+    const pending = this.pending.get(parsed.id ?? -1);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(parsed.id ?? -1);
+    clearTimeout(pending.timer);
+    if (parsed.error) {
+      pending.reject(
+        new CfInspectorError(
+          "CDP_REQUEST_FAILED",
+          `CDP request ${(parsed.id ?? -1).toString()} failed: ${parsed.error.message}`,
+          JSON.stringify(parsed.error)
+        )
+      );
+      return;
+    }
+    pending.resolve(parsed.result);
   }
-  return String(value);
-}
-function resolveMaxValueLength(value) {
-  if (value === void 0) {
-    return DEFAULT_MAX_VALUE_LENGTH;
+  createRequestTimer(id, method, reject) {
+    return setTimeout(() => {
+      this.pending.delete(id);
+      reject(
+        new CfInspectorError(
+          "CDP_REQUEST_FAILED",
+          `CDP method ${method} timed out after ${this.requestTimeoutMs.toString()}ms`
+        )
+      );
+    }, this.requestTimeoutMs);
   }
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new CfInspectorError(
-      "INVALID_ARGUMENT",
-      `Invalid maxValueLength: ${value.toString()} \u2014 expected a positive integer`
+  createWaitTimeoutError(method, timeoutMs) {
+    return new CfInspectorError(
+      "BREAKPOINT_NOT_HIT",
+      `Timed out waiting for ${method} after ${timeoutMs.toString()}ms`
     );
   }
-  return value;
-}
-function limitValueLength(raw, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
-  if (raw.length <= maxValueLength) {
-    return raw;
+  sendPayload(id, method, payload, timer, reject) {
+    try {
+      this.transport.send(payload);
+    } catch (err) {
+      clearTimeout(timer);
+      this.pending.delete(id);
+      const message = err instanceof Error ? err.message : String(err);
+      reject(new CfInspectorError("CDP_REQUEST_FAILED", `Failed to send ${method}: ${message}`));
+    }
   }
-  return `${raw.slice(0, maxValueLength)}...`;
-}
-function isExpandable(type) {
-  return type === "object" || type === "function";
-}
-async function captureProperties(session, objectId, limit, depth, maxValueLength) {
-  const properties = await getProperties(session, objectId);
-  const limited = properties.slice(0, limit);
-  const variables = await Promise.all(
-    limited.map(async (prop) => {
-      const name = typeof prop.name === "string" ? prop.name : "?";
-      const described = describeProperty(prop);
-      let children;
-      if (depth > 0 && described.objectId !== void 0 && isExpandable(described.type)) {
-        try {
-          const nested = await captureProperties(
-            session,
-            described.objectId,
-            MAX_CHILD_VARIABLES,
-            depth - 1,
-            maxValueLength
-          );
-          if (nested.length > 0) {
-            children = nested;
-          }
-        } catch {
-        }
-      }
-      const sanitizedValue = limitValueLength(described.value, maxValueLength);
-      const base = { name, value: sanitizedValue };
-      const withType = described.type === void 0 ? base : { ...base, type: described.type };
-      return children === void 0 ? withType : { ...withType, children };
-    })
-  );
-  return variables;
-}
-function selectScopes(scopeChain) {
-  const eligible = scopeChain.filter((scope) => scope.objectId !== void 0 && scope.type !== "global");
-  return [...eligible].sort((a, b) => priorityOf(a.type) - priorityOf(b.type)).slice(0, MAX_SCOPES);
-}
-function priorityOf(type) {
-  return PRIORITY_BY_TYPE[type] ?? Number.MAX_SAFE_INTEGER;
-}
-async function captureScopes(session, frame, maxValueLength) {
-  const scopes = selectScopes(frame.scopeChain);
-  return await Promise.all(
-    scopes.map(async (scope) => {
-      const objectId = scope.objectId;
-      if (objectId === void 0) {
-        return { type: scope.type, variables: [] };
-      }
-      try {
-        const variables = await captureProperties(
-          session,
-          objectId,
-          MAX_SCOPE_VARIABLES,
-          MAX_VARIABLE_DEPTH,
-          maxValueLength
-        );
-        return { type: scope.type, variables };
+  markClosed(reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.closeReason = reason;
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(reason);
+    }
+    this.pending.clear();
+    this.emitter.emit("__close__", reason);
+    this.emitter.removeAllListeners();
+  }
+};
+
+// src/inspector/session.ts
+init_types();
+var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
+var DEFAULT_HOST = "127.0.0.1";
+var PAUSE_BUFFER_LIMIT = 32;
+async function connectInspector(options) {
+  const host = options.host ?? DEFAULT_HOST;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const targets = await discoverInspectorTargets(host, options.port, connectTimeoutMs);
+  const target = targets[0];
+  if (!target) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No inspector targets available on ${host}:${options.port.toString()}`
+    );
+  }
+  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl });
+  const scripts = /* @__PURE__ */ new Map();
+  client.on("Debugger.scriptParsed", (raw) => {
+    const params = raw;
+    const scriptId = asString(params.scriptId);
+    const url = asString(params.url);
+    if (scriptId.length === 0) {
+      return;
+    }
+    scripts.set(scriptId, { scriptId, url });
+  });
+  const pauseBuffer = [];
+  const pauseWaitGate = { active: false };
+  const debuggerState = {};
+  client.on("Debugger.paused", (raw) => {
+    if (pauseWaitGate.active) {
+      return;
+    }
+    const params = raw;
+    const event = toPauseEvent(params, performance2.now());
+    if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
+      pauseBuffer.shift();
+    }
+    pauseBuffer.push(event);
+  });
+  client.on("Debugger.resumed", () => {
+    debuggerState.lastResumedAtMs = performance2.now();
+  });
+  await client.send("Runtime.enable");
+  await client.send("Debugger.enable");
+  return {
+    client,
+    target,
+    scripts,
+    pauseBuffer,
+    pauseWaitGate,
+    debuggerState,
+    dispose: async () => {
+      try {
+        await client.send("Debugger.disable");
       } catch {
-        return { type: scope.type, variables: [] };
       }
-    })
-  );
-}
-function evalResultToCaptured(expression, result, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
-  if (result.exceptionDetails !== void 0) {
-    const text = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "evaluation failed";
-    return { expression, error: limitValueLength(text, maxValueLength) };
-  }
-  const inner = result.result;
-  if (!inner) {
-    return { expression, error: "no result returned" };
-  }
-  const type = typeof inner.type === "string" ? inner.type : void 0;
-  const buildCaptured = (rendered) => {
-    const sanitized = limitValueLength(rendered, maxValueLength);
-    const base = { expression, value: sanitized };
-    return type === void 0 ? base : { ...base, type };
+      client.dispose();
+    }
   };
-  if (type === "string" && typeof inner.value === "string") {
-    return buildCaptured(JSON.stringify(inner.value));
+}
+
+// src/snapshot/values.ts
+init_types();
+var DEFAULT_MAX_VALUE_LENGTH = 4096;
+function isPrimitive(value) {
+  const t = typeof value;
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol";
+}
+function formatPrimitive(value) {
+  if (typeof value === "symbol") {
+    return value.toString();
   }
-  if ((type === "number" || type === "boolean" || type === "bigint") && isPrimitive(inner.value)) {
-    return buildCaptured(formatPrimitive(inner.value));
+  if (typeof value === "bigint") {
+    return `${value.toString()}n`;
   }
-  if (typeof inner.description === "string") {
-    return buildCaptured(inner.description);
+  return String(value);
+}
+function resolveMaxValueLength(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_VALUE_LENGTH;
   }
-  if (isPrimitive(inner.value)) {
-    return buildCaptured(formatPrimitive(inner.value));
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `Invalid maxValueLength: ${value.toString()} \u2014 expected a positive integer`
+    );
   }
-  return buildCaptured("undefined");
+  return value;
 }
-function objectIdFromEvalResult(result) {
-  const inner = result.result;
-  if (inner?.type !== "object") {
-    return void 0;
-  }
-  const objectId = inner.objectId;
-  if (typeof objectId !== "string" || objectId.length === 0) {
-    return void 0;
+function limitValueLength(raw, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
+  if (raw.length <= maxValueLength) {
+    return raw;
   }
-  return objectId;
+  return `${raw.slice(0, maxValueLength)}...`;
 }
 function parseQuotedString(value) {
   try {
@@ -1177,6 +1044,134 @@ function toStructuredValue(variable) {
   }
   return out;
 }
+
+// src/snapshot/evaluation.ts
+function evalResultToCaptured(expression, result, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
+  if (result.exceptionDetails !== void 0) {
+    return { expression, error: readEvalError(result, maxValueLength) };
+  }
+  const inner = result.result;
+  if (!inner) {
+    return { expression, error: "no result returned" };
+  }
+  const type = typeof inner.type === "string" ? inner.type : void 0;
+  const buildCaptured = (rendered) => {
+    const sanitized = limitValueLength(rendered, maxValueLength);
+    const base = { expression, value: sanitized };
+    return type === void 0 ? base : { ...base, type };
+  };
+  if (type === "string" && typeof inner.value === "string") {
+    return buildCaptured(JSON.stringify(inner.value));
+  }
+  if ((type === "number" || type === "boolean" || type === "bigint") && isPrimitive(inner.value)) {
+    return buildCaptured(formatPrimitive(inner.value));
+  }
+  if (typeof inner.description === "string") {
+    return buildCaptured(inner.description);
+  }
+  if (isPrimitive(inner.value)) {
+    return buildCaptured(formatPrimitive(inner.value));
+  }
+  return buildCaptured("undefined");
+}
+function readEvalError(result, maxValueLength) {
+  const text = typeof result.exceptionDetails?.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails?.text === "string" ? result.exceptionDetails.text : "evaluation failed";
+  return limitValueLength(text, maxValueLength);
+}
+
+// src/snapshot/properties.ts
+var MAX_SCOPE_VARIABLES = 20;
+var MAX_CHILD_VARIABLES = 8;
+var MAX_VARIABLE_DEPTH = 2;
+function buildDescribed(value, type, objectId) {
+  const base = { value };
+  if (type !== void 0) {
+    base.type = type;
+  }
+  if (objectId !== void 0) {
+    base.objectId = objectId;
+  }
+  return base;
+}
+function describeProperty(prop) {
+  const value = prop.value;
+  if (value === void 0) {
+    return { value: "undefined" };
+  }
+  const type = typeof value.type === "string" ? value.type : void 0;
+  const objectId = typeof value.objectId === "string" ? value.objectId : void 0;
+  if (type === "undefined") {
+    return buildDescribed("undefined", type);
+  }
+  if (type === "string" && typeof value.value === "string") {
+    return buildDescribed(JSON.stringify(value.value), type);
+  }
+  if ((type === "number" || type === "boolean" || type === "bigint" || type === "symbol") && isPrimitive(value.value)) {
+    return buildDescribed(formatPrimitive(value.value), type);
+  }
+  if (typeof value.description === "string") {
+    return buildDescribed(value.description, type, objectId);
+  }
+  if (isPrimitive(value.value)) {
+    return buildDescribed(formatPrimitive(value.value), type);
+  }
+  if (objectId === void 0) {
+    return buildDescribed("undefined", type);
+  }
+  return buildDescribed("[object]", type, objectId);
+}
+function isExpandable(type) {
+  return type === "object" || type === "function";
+}
+async function captureProperties(session, objectId, limit, depth, maxValueLength) {
+  const properties = await getProperties(session, objectId);
+  const limited = properties.slice(0, limit);
+  const variables = await Promise.all(
+    limited.map(async (prop) => {
+      return await captureProperty(session, prop, depth, maxValueLength);
+    })
+  );
+  return variables;
+}
+async function captureProperty(session, prop, depth, maxValueLength) {
+  const name = typeof prop.name === "string" ? prop.name : "?";
+  const described = describeProperty(prop);
+  const children = await capturePropertyChildren(session, described, depth, maxValueLength);
+  const sanitizedValue = limitValueLength(described.value, maxValueLength);
+  const base = { name, value: sanitizedValue };
+  const withType = described.type === void 0 ? base : { ...base, type: described.type };
+  return children === void 0 ? withType : { ...withType, children };
+}
+async function capturePropertyChildren(session, described, depth, maxValueLength) {
+  if (depth <= 0 || described.objectId === void 0 || !isExpandable(described.type)) {
+    return void 0;
+  }
+  try {
+    const nested = await captureProperties(
+      session,
+      described.objectId,
+      MAX_CHILD_VARIABLES,
+      depth - 1,
+      maxValueLength
+    );
+    return nested.length > 0 ? nested : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/snapshot/objects.ts
+function objectIdFromEvalResult(result) {
+  const inner = result.result;
+  if (inner?.type !== "object") {
+    return void 0;
+  }
+  const objectId = inner.objectId;
+  if (typeof objectId !== "string" || objectId.length === 0) {
+    return void 0;
+  }
+  return objectId;
+}
 async function renderObjectCapture(session, objectId, maxValueLength) {
   try {
     const properties = await captureProperties(
@@ -1223,6 +1218,51 @@ async function withSerializedObjectCapture(session, expression, evalResult, capt
   const value = limitValueLength(normalized, maxValueLength);
   return captured.type === void 0 ? { expression, value } : { expression, value, type: captured.type };
 }
+
+// src/snapshot/scopes.ts
+var MAX_SCOPES = 3;
+var PRIORITY_BY_TYPE = {
+  local: 0,
+  arguments: 1,
+  block: 2,
+  closure: 3,
+  catch: 4,
+  with: 5,
+  module: 6,
+  script: 7
+};
+function selectScopes(scopeChain) {
+  const eligible = scopeChain.filter((scope) => scope.objectId !== void 0 && scope.type !== "global");
+  return [...eligible].sort((a, b) => priorityOf(a.type) - priorityOf(b.type)).slice(0, MAX_SCOPES);
+}
+function priorityOf(type) {
+  return PRIORITY_BY_TYPE[type] ?? Number.MAX_SAFE_INTEGER;
+}
+async function captureScopes(session, frame, maxValueLength) {
+  const scopes = selectScopes(frame.scopeChain);
+  return await Promise.all(
+    scopes.map(async (scope) => {
+      const objectId = scope.objectId;
+      if (objectId === void 0) {
+        return { type: scope.type, variables: [] };
+      }
+      try {
+        const variables = await captureProperties(
+          session,
+          objectId,
+          MAX_SCOPE_VARIABLES,
+          MAX_VARIABLE_DEPTH,
+          maxValueLength
+        );
+        return { type: scope.type, variables };
+      } catch {
+        return { type: scope.type, variables: [] };
+      }
+    })
+  );
+}
+
+// src/snapshot/capture.ts
 async function captureSnapshot(session, pause, options = {}) {
   const maxValueLength = resolveMaxValueLength(options.maxValueLength);
   const top = pause.callFrames[0];
@@ -1239,26 +1279,7 @@ async function captureSnapshot(session, pause, options = {}) {
       const scopes = await captureScopes(session, top, maxValueLength);
       topFrame = { ...topFrame, scopes };
     }
-    if (options.captures !== void 0 && options.captures.length > 0) {
-      captures = await Promise.all(
-        options.captures.map(async (expression) => {
-          try {
-            const result = await evaluateOnFrame(session, top.callFrameId, expression);
-            const captured = evalResultToCaptured(expression, result, maxValueLength);
-            return await withSerializedObjectCapture(
-              session,
-              expression,
-              result,
-              captured,
-              maxValueLength
-            );
-          } catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { expression, error: limitValueLength(message, maxValueLength) };
-          }
-        })
-      );
-    }
+    captures = await captureExpressions(session, top.callFrameId, options.captures, maxValueLength);
   }
   return {
     reason: pause.reason,
@@ -1268,8 +1289,28 @@ async function captureSnapshot(session, pause, options = {}) {
     captures
   };
 }
+async function captureExpressions(session, callFrameId, captures, maxValueLength) {
+  if (captures === void 0 || captures.length === 0) {
+    return [];
+  }
+  return await Promise.all(
+    captures.map(async (expression) => {
+      return await captureExpression(session, callFrameId, expression, maxValueLength);
+    })
+  );
+}
+async function captureExpression(session, callFrameId, expression, maxValueLength) {
+  try {
+    const result = await evaluateOnFrame(session, callFrameId, expression);
+    const captured = evalResultToCaptured(expression, result, maxValueLength);
+    return await withSerializedObjectCapture(session, expression, result, captured, maxValueLength);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { expression, error: limitValueLength(message, maxValueLength) };
+  }
+}
 
-// src/logpoint.ts
+// src/logpoint/condition.ts
 import { randomBytes } from "crypto";
 var SENTINEL_PREFIX = "__CFI_LOG_";
 var SENTINEL_SUFFIX = "__";
@@ -1288,6 +1329,11 @@ function buildLogpointCondition(sentinel, expression) {
     "})()"
   ].join("");
 }
+function generateSentinel() {
+  return `${SENTINEL_PREFIX}${randomBytes(8).toString("hex")}${SENTINEL_SUFFIX}`;
+}
+
+// src/logpoint/events.ts
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -1320,6 +1366,9 @@ function parseLogEvent(rawArgs, sentinel, location, timestamp) {
   if (payload.startsWith("!err:")) {
     return { ts, at, error: payload.slice("!err:".length) };
   }
+  return parsePayload(ts, at, payload);
+}
+function parsePayload(ts, at, payload) {
   try {
     const parsed = JSON.parse(payload);
     if (typeof parsed === "string") {
@@ -1330,20 +1379,14 @@ function parseLogEvent(rawArgs, sentinel, location, timestamp) {
     return { ts, at, value: payload, raw: payload };
   }
 }
-function generateSentinel() {
-  return `${SENTINEL_PREFIX}${randomBytes(8).toString("hex")}${SENTINEL_SUFFIX}`;
-}
+
+// src/logpoint/stream.ts
 async function streamLogpoint(session, options) {
   const sentinel = generateSentinel();
   const condition = buildLogpointCondition(sentinel, options.expression);
   let emitted = 0;
   const offEvent = session.client.on("Runtime.consoleAPICalled", (raw) => {
-    const params = raw;
-    if (asString2(params.type) !== "log") {
-      return;
-    }
-    const ts = typeof params.timestamp === "number" ? params.timestamp : void 0;
-    const event = parseLogEvent(params.args, sentinel, options.location, ts);
+    const event = toLogpointEvent(raw, sentinel, options.location);
     if (event === void 0) {
       return;
     }
@@ -1363,18 +1406,26 @@ async function streamLogpoint(session, options) {
     throw err;
   }
   options.onBreakpointSet?.(handle);
-  const cleanup = async () => {
-    offEvent();
-    try {
-      await removeBreakpoint(session, handle.breakpointId);
-    } catch {
-    }
-  };
   try {
     const reason = await waitForStop(session, options);
     return { handle, sentinel, emitted, stoppedReason: reason };
   } finally {
-    await cleanup();
+    offEvent();
+    await removeBreakpointBestEffort(session, handle.breakpointId);
+  }
+}
+function toLogpointEvent(raw, sentinel, location) {
+  const params = raw;
+  if (asString2(params.type) !== "log") {
+    return void 0;
+  }
+  const ts = typeof params.timestamp === "number" ? params.timestamp : void 0;
+  return parseLogEvent(params.args, sentinel, location, ts);
+}
+async function removeBreakpointBestEffort(session, breakpointId) {
+  try {
+    await removeBreakpoint(session, breakpointId);
+  } catch {
   }
 }
 async function waitForStop(session, options) {
@@ -1411,7 +1462,7 @@ async function waitForStop(session, options) {
   });
 }
 
-// src/tunnel.ts
+// src/cf/tunnel.ts
 import { startDebugger } from "@saptools/cf-debugger";
 async function openCfTunnel(target) {
   const opts = {