@saptools/cf-inspector 0.3.15 → 0.3.17

package/dist/cli.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,214 +80,591 @@ 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();
   }
 });
 
 // src/cli.ts
-import { performance as performance2 } from "perf_hooks";
-import process2 from "process";
+import process8 from "process";
+
+// src/cli/program.ts
 import { Command } from "commander";
 
-// src/captureParser.ts
-function parseCaptureList(raw) {
-  if (raw === void 0 || raw.trim().length === 0) {
-    return [];
+// src/cli/commands/attach.ts
+import process2 from "process";
+
+// src/pathMapper.ts
+init_types();
+var REGEX_PREFIX = "regex:";
+var REGEX_FLAGS_PATTERN = /^[dgimsuvy]*$/;
+var TS_JS_EXT_PATTERN = /\.(?:ts|js|mts|mjs|cts|cjs)$/i;
+function parseBreakpointSpec(input) {
+  const idx = input.lastIndexOf(":");
+  if (idx <= 0 || idx === input.length - 1) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint must be in 'file:line' form, received: "${input}"`
+    );
   }
-  return splitCaptureExpressions(raw);
+  const file = input.slice(0, idx).trim();
+  const lineRaw = input.slice(idx + 1).trim();
+  const line = Number.parseInt(lineRaw, 10);
+  if (!Number.isInteger(line) || line <= 0 || line.toString() !== lineRaw) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint line must be a positive integer, received: "${lineRaw}"`
+    );
+  }
+  if (file.length === 0) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint file path is empty in "${input}"`
+    );
+  }
+  return { file, line };
 }
-function isQuoteChar(value) {
-  return value === "'" || value === '"' || value === "`";
+function parseRemoteRoot(value) {
+  const trimmed = value?.trim();
+  if (trimmed === void 0 || trimmed.length === 0) {
+    return { kind: "none" };
+  }
+  if (trimmed.startsWith(REGEX_PREFIX)) {
+    return toRegex(trimmed.slice(REGEX_PREFIX.length), "");
+  }
+  const slashRegex = parseSlashDelimited(trimmed);
+  if (slashRegex !== void 0) {
+    return toRegex(slashRegex.pattern, slashRegex.flags);
+  }
+  return { kind: "literal", value: stripTrailingSlash(trimmed) };
 }
-function consumeQuotedChar(state, char) {
-  if (state.quote === void 0) {
-    return false;
+function toRegex(pattern, flags) {
+  try {
+    const regex = new RegExp(pattern, flags);
+    return { kind: "regex", pattern, flags, regex };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new CfInspectorError(
+      "INVALID_REMOTE_ROOT",
+      `Failed to compile remote-root regex "${pattern}" with flags "${flags}": ${message}`
+    );
   }
-  if (state.escaped) {
-    state.escaped = false;
-    return true;
+}
+function parseSlashDelimited(value) {
+  if (!value.startsWith("/")) {
+    return void 0;
   }
-  if (char === "\\") {
-    state.escaped = true;
-    return true;
+  const closing = findLastUnescapedSlash(value);
+  if (closing <= 0) {
+    return void 0;
   }
-  if (char === state.quote) {
-    state.quote = void 0;
+  const flags = value.slice(closing + 1);
+  if (flags.length === 0 || !REGEX_FLAGS_PATTERN.test(flags)) {
+    return void 0;
   }
-  return true;
+  return { pattern: value.slice(1, closing), flags };
 }
-function updateCaptureDepth(state, char) {
-  if (char === "(") {
-    state.parenDepth += 1;
-  } else if (char === ")") {
-    state.parenDepth = Math.max(0, state.parenDepth - 1);
-  } else if (char === "[") {
-    state.bracketDepth += 1;
-  } else if (char === "]") {
-    state.bracketDepth = Math.max(0, state.bracketDepth - 1);
-  } else if (char === "{") {
-    state.braceDepth += 1;
-  } else if (char === "}") {
-    state.braceDepth = Math.max(0, state.braceDepth - 1);
+function findLastUnescapedSlash(value) {
+  for (let i = value.length - 1; i > 0; i--) {
+    if (value[i] === "/" && !isEscaped(value, i)) {
+      return i;
+    }
   }
+  return -1;
 }
-function isTopLevel(state) {
-  return state.parenDepth === 0 && state.bracketDepth === 0 && state.braceDepth === 0;
+function isEscaped(value, idx) {
+  let backslashes = 0;
+  for (let i = idx - 1; i >= 0; i--) {
+    if (value[i] === "\\") {
+      backslashes++;
+    } else {
+      break;
+    }
+  }
+  return backslashes % 2 === 1;
 }
-function appendCapturePiece(raw, state, end) {
-  const piece = raw.slice(state.start, end).trim();
-  if (piece.length > 0) {
-    state.pieces.push(piece);
+function stripTrailingSlash(value) {
+  if (value.length > 1 && value.endsWith("/")) {
+    return value.slice(0, -1);
   }
+  return value;
 }
-function splitCaptureExpressions(raw) {
-  const state = {
-    escaped: false,
-    parenDepth: 0,
-    bracketDepth: 0,
-    braceDepth: 0,
-    quote: void 0,
-    start: 0,
-    pieces: []
-  };
-  for (let idx = 0; idx < raw.length; idx += 1) {
-    const char = raw.charAt(idx);
-    if (consumeQuotedChar(state, char)) {
-      continue;
+function normalizeRegexRootPattern(pattern) {
+  const withoutStartAnchor = pattern.startsWith("^") ? pattern.slice(1) : pattern;
+  const withoutEndAnchor = withoutStartAnchor.endsWith("$") && !isEscaped(withoutStartAnchor, withoutStartAnchor.length - 1) ? withoutStartAnchor.slice(0, -1) : withoutStartAnchor;
+  return stripTrailingSlash(withoutEndAnchor);
+}
+function buildFileUrlRegex(rootPattern, tail) {
+  const separator = rootPattern.endsWith("/") ? "" : "/";
+  return `^file://${rootPattern}${separator}${tail}$`;
+}
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function normalizeRelative(file) {
+  return file.replaceAll(/^[./\\]+/g, "").replaceAll("\\", "/");
+}
+function dropExtension(file) {
+  const match = TS_JS_EXT_PATTERN.exec(file);
+  if (!match) {
+    return { stem: file, matchedExt: false };
+  }
+  return { stem: file.slice(0, match.index), matchedExt: true };
+}
+var EXT_GROUP = String.raw`\.(?:ts|js|mts|mjs|cts|cjs)`;
+var OPTIONAL_EXT_GROUP = String.raw`(?:\.(?:ts|js|mts|mjs|cts|cjs))?`;
+function buildBreakpointUrlRegex(input) {
+  const normalized = normalizeRelative(input.file);
+  const { stem, matchedExt } = dropExtension(normalized);
+  const escapedStem = escapeRegExp(stem);
+  const tail = matchedExt ? `${escapedStem}${EXT_GROUP}` : `${escapedStem}${OPTIONAL_EXT_GROUP}`;
+  switch (input.remoteRoot.kind) {
+    case "none": {
+      return `(?:^|/)${tail}$`;
     }
-    if (isQuoteChar(char)) {
-      state.quote = char;
-      continue;
+    case "literal": {
+      const escapedRoot = escapeRegExp(input.remoteRoot.value);
+      return buildFileUrlRegex(escapedRoot, tail);
     }
-    updateCaptureDepth(state, char);
-    if (char === "," && isTopLevel(state)) {
-      appendCapturePiece(raw, state, idx);
-      state.start = idx + 1;
+    case "regex": {
+      const rootPattern = normalizeRegexRootPattern(input.remoteRoot.pattern);
+      return buildFileUrlRegex(rootPattern, tail);
     }
   }
-  appendCapturePiece(raw, state, raw.length);
-  return state.pieces;
 }
 
-// src/cliOutput.ts
-import process from "process";
-function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
-`);
+// src/inspector/breakpoints.ts
+init_types();
+
+// src/inspector/conversions.ts
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
 }
-function writeHumanSnapshot(snapshot) {
-  const pausedDuration = snapshot.pausedDurationMs === null ? "unknown" : `${snapshot.pausedDurationMs.toFixed(1)}ms`;
-  const lines = [];
-  lines.push(
-    `Snapshot @ ${snapshot.capturedAt}`,
-    `  reason:  ${snapshot.reason}`,
-    `  paused:  ${pausedDuration}`
-  );
-  if (snapshot.topFrame) {
-    const frame = snapshot.topFrame;
-    const fnName = frame.functionName.length === 0 ? "(anonymous)" : frame.functionName;
-    const sourceUrl = frame.url !== void 0 && frame.url.length > 0 ? frame.url : "(unknown)";
-    lines.push(
-      `  frame:   ${fnName} ${sourceUrl}:${frame.line.toString()}:${frame.column.toString()}`
-    );
-    if (frame.scopes !== void 0) {
-      for (const scope of frame.scopes) {
-        lines.push(`  scope ${scope.type} (${scope.variables.length.toString()} vars):`);
-        for (const variable of scope.variables) {
-          lines.push(`    ${variable.name} = ${variable.value}`);
-        }
-      }
-    }
-  }
-  if (snapshot.captures.length > 0) {
-    lines.push("  captures:");
-    for (const capture of snapshot.captures) {
-      const detail = capture.error ?? capture.value ?? "undefined";
-      lines.push(`    ${capture.expression} = ${detail}`);
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toResolvedLocations(value) {
+  if (!Array.isArray(value)) {
+    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 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
+  };
+}
+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
+  };
+  if (input.condition !== void 0 && input.condition.length > 0) {
+    params["condition"] = input.condition;
+  }
+  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()}`
+    );
+  }
+  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, () => {
+      req.destroy(
+        new CfInspectorError(
+          "INSPECTOR_DISCOVERY_FAILED",
+          `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`
+        )
+      );
+    });
+    req.on("error", (err) => {
+      reject(
+        err instanceof CfInspectorError ? err : new CfInspectorError(
+          "INSPECTOR_DISCOVERY_FAILED",
+          `Inspector discovery at ${url} failed: ${err.message}`
+        )
+      );
+    });
+    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(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Inspector target is not an object in ${source}`
+    );
+  }
+  const candidate = value;
+  const webSocketDebuggerUrl = candidate["webSocketDebuggerUrl"];
+  if (typeof webSocketDebuggerUrl !== "string" || webSocketDebuggerUrl.length === 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Inspector target is missing webSocketDebuggerUrl in ${source}`
+    );
+  }
+  return {
+    description: typeof candidate["description"] === "string" ? candidate["description"] : "",
+    id: typeof candidate["id"] === "string" ? candidate["id"] : "",
+    title: typeof candidate["title"] === "string" ? candidate["title"] : "",
+    type: typeof candidate["type"] === "string" ? candidate["type"] : "",
+    url: typeof candidate["url"] === "string" ? candidate["url"] : "",
+    webSocketDebuggerUrl,
+    ...typeof candidate["devtoolsFrontendUrl"] === "string" ? { devtoolsFrontendUrl: candidate["devtoolsFrontendUrl"] } : {},
+    ...typeof candidate["faviconUrl"] === "string" ? { faviconUrl: candidate["faviconUrl"] } : {}
+  };
+}
+async function discoverInspectorTargets(host, port, timeoutMs) {
+  const url = `http://${host}:${port.toString()}/json/list`;
+  const raw = await fetchJson(url, timeoutMs);
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No inspector targets returned from ${url}`
+    );
+  }
+  return raw.map((entry, idx) => toInspectorTarget(entry, `${url}[${idx.toString()}]`));
+}
+function readVersionField(value, ...keys) {
+  for (const key of keys) {
+    const entry = value[key];
+    if (typeof entry === "string" && entry.length > 0) {
+      return entry;
     }
   }
-  process.stdout.write(`${lines.join("\n")}
-`);
+  return void 0;
+}
+async function fetchInspectorVersion(host, port, timeoutMs) {
+  const url = `http://${host}:${port.toString()}/json/version`;
+  const raw = await fetchJson(url, timeoutMs);
+  if (typeof raw !== "object" || raw === null) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Unexpected /json/version response from ${url}`
+    );
+  }
+  const value = raw;
+  const browser = readVersionField(value, "Browser", "browser");
+  const protocolVersion = readVersionField(value, "Protocol-Version", "protocolVersion");
+  if (browser === void 0 || protocolVersion === void 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Unexpected /json/version response from ${url}`
+    );
+  }
+  return { browser, protocolVersion };
+}
+
+// src/inspector/pause.ts
+init_types();
+import { performance } from "perf_hooks";
+function pauseMatches(pause, breakpointIds) {
+  if (breakpointIds === void 0 || breakpointIds.length === 0) {
+    return true;
+  }
+  return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
+}
+function remainingUntil(deadlineMs) {
+  return Math.max(0, deadlineMs - performance.now());
+}
+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)
+    );
+  }
+  if (hasResumedSincePause(session, pause)) {
+    return;
+  }
+  options.onUnmatchedPause?.(pause);
+  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options.timeoutMs);
+}
+async function waitForPause(session, options) {
+  const deadlineMs = performance.now() + options.timeoutMs;
+  const buffer = session.pauseBuffer;
+  while (buffer.length > 0 || remainingUntil(deadlineMs) > 0) {
+    while (buffer.length > 0) {
+      const buffered = buffer.shift();
+      if (buffered === void 0) {
+        continue;
+      }
+      if (pauseMatches(buffered, options.breakpointIds)) {
+        return buffered;
+      }
+      await handleUnmatchedPause(session, buffered, options, deadlineMs);
+    }
+    const pause = await waitForLivePause(session, options, deadlineMs);
+    if (pauseMatches(pause, options.breakpointIds)) {
+      return pause;
+    }
+    await handleUnmatchedPause(session, pause, options, deadlineMs);
+  }
+  throwBreakpointTimeout(options.timeoutMs);
 }
-function writeLogEvent(event, json) {
-  if (json) {
-    process.stdout.write(`${JSON.stringify(event)}
-`);
-    return;
+async function waitForLivePause(session, options, deadlineMs) {
+  const remainingMs = remainingUntil(deadlineMs);
+  if (remainingMs <= 0) {
+    throwBreakpointTimeout(options.timeoutMs);
   }
-  if (event.error !== void 0) {
-    process.stdout.write(`[${event.ts}] ${event.at} !err ${event.error}
-`);
+  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");
+}
+async function evaluateOnFrame(session, callFrameId, expression) {
+  return await session.client.send("Debugger.evaluateOnCallFrame", {
+    callFrameId,
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true
+  });
+}
+async function evaluateGlobal(session, expression) {
+  return await session.client.send("Runtime.evaluate", {
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true
+  });
+}
+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;
   }
-  process.stdout.write(`[${event.ts}] ${event.at} ${event.value ?? ""}
-`);
+  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/inspector.ts
-import { request } from "http";
-import { performance } from "perf_hooks";
+// src/inspector/session.ts
+import { performance as performance2 } from "perf_hooks";
 
-// src/cdp.ts
+// src/cdp/client.ts
 init_types();
 import { EventEmitter } from "events";
 var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
@@ -294,23 +697,7 @@ var CdpClient = class _CdpClient {
       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);
+      this.handleResponse(parsed);
       return;
     }
     if (typeof parsed.method === "string") {
@@ -345,15 +732,7 @@ var CdpClient = class _CdpClient {
     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);
+      const timer = this.createRequestTimer(id, method, reject);
       this.pending.set(id, {
         resolve: (value) => {
           resolve(value);
@@ -361,14 +740,7 @@ var CdpClient = class _CdpClient {
         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}`));
-      }
+      this.sendPayload(id, method, payload, timer, reject);
     });
   }
   on(method, listener) {
@@ -390,6 +762,11 @@ var CdpClient = class _CdpClient {
         offEvent();
         offClose();
       };
+      const finish = (value) => {
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
       const offEvent = this.on(method, (raw) => {
         if (settled) {
           return;
@@ -398,9 +775,7 @@ var CdpClient = class _CdpClient {
         if (options.predicate && !options.predicate(params)) {
           return;
         }
-        settled = true;
-        cleanup();
-        resolve(params);
+        finish(params);
       });
       const offClose = this.onClose((err) => {
         if (settled) {
@@ -416,12 +791,7 @@ var CdpClient = class _CdpClient {
         }
         settled = true;
         cleanup();
-        reject(
-          new CfInspectorError(
-            "BREAKPOINT_NOT_HIT",
-            `Timed out waiting for ${method} after ${options.timeoutMs.toString()}ms`
-          )
-        );
+        reject(this.createWaitTimeoutError(method, options.timeoutMs));
       }, options.timeoutMs);
     });
   }
@@ -434,301 +804,94 @@ var CdpClient = class _CdpClient {
       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/pathMapper.ts
-init_types();
-var REGEX_PREFIX = "regex:";
-var REGEX_FLAGS_PATTERN = /^[dgimsuvy]*$/;
-var TS_JS_EXT_PATTERN = /\.(?:ts|js|mts|mjs|cts|cjs)$/i;
-function parseBreakpointSpec(input) {
-  const idx = input.lastIndexOf(":");
-  if (idx <= 0 || idx === input.length - 1) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint must be in 'file:line' form, received: "${input}"`
-    );
-  }
-  const file = input.slice(0, idx).trim();
-  const lineRaw = input.slice(idx + 1).trim();
-  const line = Number.parseInt(lineRaw, 10);
-  if (!Number.isInteger(line) || line <= 0 || line.toString() !== lineRaw) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint line must be a positive integer, received: "${lineRaw}"`
-    );
-  }
-  if (file.length === 0) {
-    throw new CfInspectorError(
-      "INVALID_BREAKPOINT",
-      `Breakpoint file path is empty in "${input}"`
-    );
-  }
-  return { file, line };
-}
-function parseRemoteRoot(value) {
-  const trimmed = value?.trim();
-  if (trimmed === void 0 || trimmed.length === 0) {
-    return { kind: "none" };
-  }
-  if (trimmed.startsWith(REGEX_PREFIX)) {
-    return toRegex(trimmed.slice(REGEX_PREFIX.length), "");
-  }
-  const slashRegex = parseSlashDelimited(trimmed);
-  if (slashRegex !== void 0) {
-    return toRegex(slashRegex.pattern, slashRegex.flags);
-  }
-  return { kind: "literal", value: stripTrailingSlash(trimmed) };
-}
-function toRegex(pattern, flags) {
-  try {
-    const regex = new RegExp(pattern, flags);
-    return { kind: "regex", pattern, flags, regex };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new CfInspectorError(
-      "INVALID_REMOTE_ROOT",
-      `Failed to compile remote-root regex "${pattern}" with flags "${flags}": ${message}`
-    );
-  }
-}
-function parseSlashDelimited(value) {
-  if (!value.startsWith("/")) {
-    return void 0;
-  }
-  const closing = findLastUnescapedSlash(value);
-  if (closing <= 0) {
-    return void 0;
-  }
-  const flags = value.slice(closing + 1);
-  if (flags.length === 0 || !REGEX_FLAGS_PATTERN.test(flags)) {
-    return void 0;
-  }
-  return { pattern: value.slice(1, closing), flags };
-}
-function findLastUnescapedSlash(value) {
-  for (let i = value.length - 1; i > 0; i--) {
-    if (value[i] === "/" && !isEscaped(value, i)) {
-      return i;
-    }
-  }
-  return -1;
-}
-function isEscaped(value, idx) {
-  let backslashes = 0;
-  for (let i = idx - 1; i >= 0; i--) {
-    if (value[i] === "\\") {
-      backslashes++;
-    } else {
-      break;
-    }
-  }
-  return backslashes % 2 === 1;
-}
-function stripTrailingSlash(value) {
-  if (value.length > 1 && value.endsWith("/")) {
-    return value.slice(0, -1);
-  }
-  return value;
-}
-function normalizeRegexRootPattern(pattern) {
-  const withoutStartAnchor = pattern.startsWith("^") ? pattern.slice(1) : pattern;
-  const withoutEndAnchor = withoutStartAnchor.endsWith("$") && !isEscaped(withoutStartAnchor, withoutStartAnchor.length - 1) ? withoutStartAnchor.slice(0, -1) : withoutStartAnchor;
-  return stripTrailingSlash(withoutEndAnchor);
-}
-function buildFileUrlRegex(rootPattern, tail) {
-  const separator = rootPattern.endsWith("/") ? "" : "/";
-  return `^file://${rootPattern}${separator}${tail}$`;
-}
-function escapeRegExp(value) {
-  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-}
-function normalizeRelative(file) {
-  return file.replaceAll(/^[./\\]+/g, "").replaceAll("\\", "/");
-}
-function dropExtension(file) {
-  const match = TS_JS_EXT_PATTERN.exec(file);
-  if (!match) {
-    return { stem: file, matchedExt: false };
-  }
-  return { stem: file.slice(0, match.index), matchedExt: true };
-}
-var EXT_GROUP = String.raw`\.(?:ts|js|mts|mjs|cts|cjs)`;
-var OPTIONAL_EXT_GROUP = String.raw`(?:\.(?:ts|js|mts|mjs|cts|cjs))?`;
-function buildBreakpointUrlRegex(input) {
-  const normalized = normalizeRelative(input.file);
-  const { stem, matchedExt } = dropExtension(normalized);
-  const escapedStem = escapeRegExp(stem);
-  const tail = matchedExt ? `${escapedStem}${EXT_GROUP}` : `${escapedStem}${OPTIONAL_EXT_GROUP}`;
-  switch (input.remoteRoot.kind) {
-    case "none": {
-      return `(?:^|/)${tail}$`;
-    }
-    case "literal": {
-      const escapedRoot = escapeRegExp(input.remoteRoot.value);
-      return buildFileUrlRegex(escapedRoot, tail);
-    }
-    case "regex": {
-      const rootPattern = normalizeRegexRootPattern(input.remoteRoot.pattern);
-      return buildFileUrlRegex(rootPattern, tail);
+    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"));
   }
-}
-
-// 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}`
-          )
-        );
-      });
-    });
-    req.setTimeout(timeoutMs, () => {
-      req.destroy(
+  get isClosed() {
+    return this.closed;
+  }
+  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(
-          "INSPECTOR_DISCOVERY_FAILED",
-          `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`
+          "CDP_REQUEST_FAILED",
+          `CDP request ${(parsed.id ?? -1).toString()} failed: ${parsed.error.message}`,
+          JSON.stringify(parsed.error)
         )
       );
-    });
-    req.on("error", (err) => {
+      return;
+    }
+    pending.resolve(parsed.result);
+  }
+  createRequestTimer(id, method, reject) {
+    return setTimeout(() => {
+      this.pending.delete(id);
       reject(
-        err instanceof CfInspectorError ? err : new CfInspectorError(
-          "INSPECTOR_DISCOVERY_FAILED",
-          `Inspector discovery at ${url} failed: ${err.message}`
+        new CfInspectorError(
+          "CDP_REQUEST_FAILED",
+          `CDP method ${method} timed out after ${this.requestTimeoutMs.toString()}ms`
         )
       );
-    });
-    req.end();
-  });
-}
-function toInspectorTarget(value, source) {
-  if (typeof value !== "object" || value === null) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `Inspector target is not an object in ${source}`
-    );
-  }
-  const candidate = value;
-  const webSocketDebuggerUrl = candidate["webSocketDebuggerUrl"];
-  if (typeof webSocketDebuggerUrl !== "string" || webSocketDebuggerUrl.length === 0) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `Inspector target is missing webSocketDebuggerUrl in ${source}`
-    );
+    }, this.requestTimeoutMs);
   }
-  return {
-    description: typeof candidate["description"] === "string" ? candidate["description"] : "",
-    id: typeof candidate["id"] === "string" ? candidate["id"] : "",
-    title: typeof candidate["title"] === "string" ? candidate["title"] : "",
-    type: typeof candidate["type"] === "string" ? candidate["type"] : "",
-    url: typeof candidate["url"] === "string" ? candidate["url"] : "",
-    webSocketDebuggerUrl,
-    ...typeof candidate["devtoolsFrontendUrl"] === "string" ? { devtoolsFrontendUrl: candidate["devtoolsFrontendUrl"] } : {},
-    ...typeof candidate["faviconUrl"] === "string" ? { faviconUrl: candidate["faviconUrl"] } : {}
-  };
-}
-async function discoverInspectorTargets(host, port, timeoutMs) {
-  const url = `http://${host}:${port.toString()}/json/list`;
-  const raw = await fetchJson(url, timeoutMs);
-  if (!Array.isArray(raw) || raw.length === 0) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `No inspector targets returned from ${url}`
+  createWaitTimeoutError(method, timeoutMs) {
+    return new CfInspectorError(
+      "BREAKPOINT_NOT_HIT",
+      `Timed out waiting for ${method} after ${timeoutMs.toString()}ms`
     );
   }
-  return raw.map((entry, idx) => toInspectorTarget(entry, `${url}[${idx.toString()}]`));
-}
-function readVersionField(value, ...keys) {
-  for (const key of keys) {
-    const entry = value[key];
-    if (typeof entry === "string" && entry.length > 0) {
-      return entry;
+  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 void 0;
-}
-async function fetchInspectorVersion(host, port, timeoutMs) {
-  const url = `http://${host}:${port.toString()}/json/version`;
-  const raw = await fetchJson(url, timeoutMs);
-  if (typeof raw !== "object" || raw === null) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `Unexpected /json/version response from ${url}`
-    );
-  }
-  const value = raw;
-  const browser = readVersionField(value, "Browser", "browser");
-  const protocolVersion = readVersionField(value, "Protocol-Version", "protocolVersion");
-  if (browser === void 0 || protocolVersion === void 0) {
-    throw new CfInspectorError(
-      "INSPECTOR_DISCOVERY_FAILED",
-      `Unexpected /json/version response from ${url}`
-    );
+  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();
   }
-  return { browser, protocolVersion };
-}
+};
+
+// 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;
@@ -751,7 +914,6 @@ async function connectInspector(options) {
     }
     scripts.set(scriptId, { scriptId, url });
   });
-  const PAUSE_BUFFER_LIMIT = 32;
   const pauseBuffer = [];
   const pauseWaitGate = { active: false };
   const debuggerState = {};
@@ -760,14 +922,14 @@ async function connectInspector(options) {
       return;
     }
     const params = raw;
-    const event = toPauseEvent(params, performance.now());
+    const event = toPauseEvent(params, performance2.now());
     if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
       pauseBuffer.shift();
     }
     pauseBuffer.push(event);
   });
   client.on("Debugger.resumed", () => {
-    debuggerState.lastResumedAtMs = performance.now();
+    debuggerState.lastResumedAtMs = performance2.now();
   });
   await client.send("Runtime.enable");
   await client.send("Debugger.enable");
@@ -787,279 +949,254 @@ async function connectInspector(options) {
     }
   };
 }
-function asString(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
-}
-function asNumber(value, fallback = 0) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+
+// src/cli/output.ts
+import process from "process";
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
 }
-function toResolvedLocations(value) {
-  if (!Array.isArray(value)) {
-    return [];
+function writeHumanSnapshot(snapshot) {
+  const pausedDuration = snapshot.pausedDurationMs === null ? "unknown" : `${snapshot.pausedDurationMs.toFixed(1)}ms`;
+  const lines = [];
+  lines.push(
+    `Snapshot @ ${snapshot.capturedAt}`,
+    `  reason:  ${snapshot.reason}`,
+    `  paused:  ${pausedDuration}`
+  );
+  if (snapshot.topFrame) {
+    appendFrameLines(lines, snapshot);
   }
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const scriptId = asString(candidate.scriptId);
-    if (scriptId.length === 0) {
-      return [];
+  if (snapshot.captures.length > 0) {
+    lines.push("  captures:");
+    for (const capture of snapshot.captures) {
+      const detail = capture.error ?? capture.value ?? "undefined";
+      lines.push(`    ${capture.expression} = ${detail}`);
     }
-    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;
-  }
-  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()}`
-    );
   }
-  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 });
+  process.stdout.write(`${lines.join("\n")}
+`);
 }
-function toScopeChain(value) {
-  if (!Array.isArray(value)) {
-    return [];
+function appendFrameLines(lines, snapshot) {
+  const frame = snapshot.topFrame;
+  if (frame === void 0) {
+    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 [];
+  const fnName = frame.functionName.length === 0 ? "(anonymous)" : frame.functionName;
+  const sourceUrl = frame.url !== void 0 && frame.url.length > 0 ? frame.url : "(unknown)";
+  lines.push(
+    `  frame:   ${fnName} ${sourceUrl}:${frame.line.toString()}:${frame.column.toString()}`
+  );
+  if (frame.scopes === void 0) {
+    return;
+  }
+  for (const scope of frame.scopes) {
+    lines.push(`  scope ${scope.type} (${scope.variables.length.toString()} vars):`);
+    for (const variable of scope.variables) {
+      lines.push(`    ${variable.name} = ${variable.value}`);
+    }
   }
-  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;
+function writeLogEvent(event, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(event)}
+`);
+    return;
   }
-  return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
+  if (event.error !== void 0) {
+    process.stdout.write(`[${event.ts}] ${event.at} !err ${event.error}
+`);
+    return;
+  }
+  process.stdout.write(`[${event.ts}] ${event.at} ${event.value ?? ""}
+`);
 }
-function toPauseEvent(params, receivedAtMs) {
+
+// src/cf/tunnel.ts
+import { startDebugger } from "@saptools/cf-debugger";
+async function openCfTunnel(target) {
+  const opts = {
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    ...target.tunnelReadyTimeoutMs === void 0 ? {} : { tunnelReadyTimeoutMs: target.tunnelReadyTimeoutMs },
+    ...target.preferredPort === void 0 ? {} : { preferredPort: target.preferredPort },
+    ...target.verbose === void 0 ? {} : { verbose: target.verbose },
+    ...target.signal === void 0 ? {} : { signal: target.signal }
+  };
+  const handle = await startDebugger(opts);
   return {
-    reason: asString(params.reason),
-    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
-    callFrames: toCallFrames(params.callFrames),
-    receivedAtMs
+    localPort: handle.session.localPort,
+    handle,
+    dispose: async () => {
+      await handle.dispose();
+    }
   };
 }
-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)";
+
+// src/cli/target.ts
+init_types();
+
+// src/cli/commandTypes.ts
+var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
+var DEFAULT_CF_TIMEOUT_SEC = 60;
+
+// src/cli/target.ts
+function parsePositiveInt(raw, label) {
+  if (raw === void 0) {
+    return void 0;
   }
-  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;
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value <= 0 || value.toString() !== raw.trim()) {
+    throw new CfInspectorError("INVALID_ARGUMENT", `Invalid ${label}: "${raw}" \u2014 expected a positive integer`);
+  }
+  return value;
 }
-function throwBreakpointTimeout(timeoutMs) {
+function resolveTarget(opts) {
+  const port = parsePositiveInt(opts.port, "--port");
+  if (port !== void 0) {
+    return { kind: "port", port, host: opts.host ?? "127.0.0.1" };
+  }
+  if (hasCfTarget(opts)) {
+    const cfTimeoutSec = parsePositiveInt(opts.cfTimeout, "--cf-timeout") ?? DEFAULT_CF_TIMEOUT_SEC;
+    return {
+      kind: "cf",
+      region: opts.region,
+      org: opts.org,
+      space: opts.space,
+      app: opts.app,
+      cfTimeoutMs: cfTimeoutSec * 1e3
+    };
+  }
   throw new CfInspectorError(
-    "BREAKPOINT_NOT_HIT",
-    `Timed out waiting for matching Debugger.paused after ${timeoutMs.toString()}ms`
+    "MISSING_TARGET",
+    "Provide either --port (and optionally --host) or all of --region, --org, --space, --app."
   );
 }
-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)
-  );
+function hasCfTarget(opts) {
+  return opts.region !== void 0 && opts.org !== void 0 && opts.space !== void 0 && opts.app !== void 0;
 }
-async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeoutMs) {
-  if (hasResumedSincePause(session, pause)) {
-    return;
-  }
-  const remainingMs = remainingUntil(deadlineMs);
-  if (remainingMs <= 0) {
-    throwUnrelatedPauseTimeout(pause, timeoutMs);
-  }
+async function withSession(target, fn) {
+  const tunnel = await openTarget(target);
+  let session;
   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);
+    session = await connectInspector({ port: tunnel.port, host: tunnel.host });
+    return await fn(session, tunnel.port);
+  } finally {
+    if (session) {
+      await session.dispose();
     }
-    throw err;
+    await tunnel.dispose();
   }
 }
-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)
-    );
-  }
-  if (hasResumedSincePause(session, pause)) {
-    return;
+async function openTarget(target) {
+  if (target.kind === "port") {
+    return {
+      port: target.port,
+      host: target.host,
+      dispose: () => Promise.resolve()
+    };
   }
-  options.onUnmatchedPause?.(pause);
-  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options.timeoutMs);
-}
-async function waitForPause(session, options) {
-  const deadlineMs = performance.now() + options.timeoutMs;
-  const buffer = session.pauseBuffer;
-  while (buffer.length > 0 || remainingUntil(deadlineMs) > 0) {
-    while (buffer.length > 0) {
-      const buffered = buffer.shift();
-      if (buffered === void 0) {
-        continue;
-      }
-      if (pauseMatches(buffered, options.breakpointIds)) {
-        return buffered;
-      }
-      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 tunnel = await openCfTunnel({
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    tunnelReadyTimeoutMs: target.cfTimeoutMs
+  });
+  return {
+    port: tunnel.localPort,
+    host: "127.0.0.1",
+    dispose: async () => {
+      await tunnel.dispose();
     }
-    const pause = toPauseEvent(params, receivedAtMs ?? performance.now());
-    if (pauseMatches(pause, options.breakpointIds)) {
-      return pause;
+  };
+}
+
+// src/cli/commands/attach.ts
+async function handleAttach(opts) {
+  const target = resolveTarget(opts);
+  const tunnel = await openTarget(target);
+  try {
+    const version = await fetchInspectorVersion(tunnel.host, tunnel.port, 5e3);
+    if (opts.json) {
+      writeJson({ host: tunnel.host, port: tunnel.port, ...version });
+      return;
     }
-    await handleUnmatchedPause(session, pause, options, deadlineMs);
+    process2.stdout.write(
+      `Connected to ${tunnel.host}:${tunnel.port.toString()}
+  Browser: ${version.browser}
+  Protocol: ${version.protocolVersion}
+`
+    );
+  } finally {
+    await tunnel.dispose();
   }
-  throwBreakpointTimeout(options.timeoutMs);
-}
-async function resume(session) {
-  await session.client.send("Debugger.resume");
-}
-async function evaluateOnFrame(session, callFrameId, expression) {
-  return await session.client.send("Debugger.evaluateOnCallFrame", {
-    callFrameId,
-    expression,
-    returnByValue: false,
-    generatePreview: true,
-    silent: true
-  });
 }
-async function evaluateGlobal(session, expression) {
-  return await session.client.send("Runtime.evaluate", {
-    expression,
-    returnByValue: false,
-    generatePreview: true,
-    silent: true
+
+// src/cli/commands/eval.ts
+import process3 from "process";
+async function handleEval(opts) {
+  const target = resolveTarget(opts);
+  const result = await withSession(target, async (session) => {
+    return await evaluateGlobal(session, opts.expr);
   });
+  if (opts.json) {
+    writeJson(result);
+    if (result.exceptionDetails !== void 0) {
+      process3.exitCode = 1;
+    }
+    return;
+  }
+  writeHumanEvalResult(result);
 }
-function listScripts(session) {
-  return [...session.scripts.values()];
+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";
+    process3.stderr.write(`${detail}
+`);
+    process3.exitCode = 1;
+    return;
+  }
+  const inner = result.result;
+  if (inner === void 0) {
+    process3.stdout.write("\n");
+    return;
+  }
+  if (typeof inner.value === "string") {
+    process3.stdout.write(`${inner.value}
+`);
+    return;
+  }
+  if (typeof inner.description === "string") {
+    process3.stdout.write(`${inner.description}
+`);
+    return;
+  }
+  process3.stdout.write(`${JSON.stringify(inner.value)}
+`);
 }
-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) {
+
+// src/cli/commands/listScripts.ts
+import process4 from "process";
+async function handleListScripts(opts) {
+  const target = resolveTarget(opts);
+  const scripts = await withSession(target, (session) => Promise.resolve(listScripts(session)));
+  if (opts.json) {
+    writeJson(scripts);
     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 [];
+  for (const script of scripts) {
+    process4.stdout.write(`${script.scriptId}	${script.url}
+`);
   }
-  return result.result;
 }
 
-// src/logpoint.ts
+// src/cli/commands/log.ts
+import process6 from "process";
+
+// src/logpoint/condition.ts
 import { randomBytes } from "crypto";
 var SENTINEL_PREFIX = "__CFI_LOG_";
 var SENTINEL_SUFFIX = "__";
@@ -1078,6 +1215,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;
 }
@@ -1110,6 +1252,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") {
@@ -1120,20 +1265,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;
     }
@@ -1153,18 +1292,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) {
@@ -1201,60 +1348,108 @@ async function waitForStop(session, options) {
   });
 }
 
-// src/snapshot.ts
+// src/cli/commands/log.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;
+
+// src/cli/warnings.ts
+import process5 from "process";
+function warnOnUnboundBreakpoints(handles) {
+  for (const handle of handles) {
+    if (handle.resolvedLocations.length === 0) {
+      process5.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.
+`
+      );
+    }
   }
-  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);
+function roundDurationMs(durationMs) {
+  return Math.round(durationMs * 1e3) / 1e3;
+}
+function warnOnUnmatchedPause(pause) {
+  const reason = pause.reason.length > 0 ? pause.reason : "unknown";
+  process5.stderr.write(
+    `[cf-inspector] warning: target is paused by another debugger event (${reason} at ${formatPauseLocation(pause)}); waiting for it to resume...
+`
+  );
+}
+function withPausedDuration(snapshot, pausedDurationMs) {
+  return {
+    reason: snapshot.reason,
+    hitBreakpoints: snapshot.hitBreakpoints,
+    capturedAt: snapshot.capturedAt,
+    pausedDurationMs,
+    ...snapshot.topFrame === void 0 ? {} : { topFrame: snapshot.topFrame },
+    captures: snapshot.captures
+  };
+}
+function formatPauseLocation(pause) {
+  const top = pause.callFrames[0];
+  if (top === void 0) {
+    return "(no call frame)";
   }
-  if (typeof value.description === "string") {
-    return buildDescribed(value.description, type, objectId);
+  const url = top.url !== void 0 && top.url.length > 0 ? top.url : "(unknown)";
+  return `${url}:${(top.lineNumber + 1).toString()}:${(top.columnNumber + 1).toString()}`;
+}
+
+// src/cli/commands/log.ts
+async function handleLog(opts) {
+  const target = resolveTarget(opts);
+  const location = parseBreakpointSpec(opts.at);
+  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
+  const durationSec = parsePositiveInt(opts.duration, "--duration");
+  const expression = opts.expr.trim();
+  if (expression.length === 0) {
+    throw new CfInspectorError("INVALID_BREAKPOINT", "--expr must not be empty");
   }
-  if (isPrimitive(value.value)) {
-    return buildDescribed(formatPrimitive(value.value), type);
+  const abort = new AbortController();
+  const onSig = () => {
+    abort.abort();
+  };
+  process6.once("SIGINT", onSig);
+  process6.once("SIGTERM", onSig);
+  try {
+    await withSession(target, async (session) => {
+      await validateExpression(session, expression);
+      const result = await streamLogpoint(session, {
+        location,
+        expression,
+        remoteRoot,
+        ...durationSec === void 0 ? {} : { durationMs: durationSec * 1e3 },
+        signal: abort.signal,
+        onEvent: (event) => {
+          writeLogEvent(event, opts.json);
+        },
+        onBreakpointSet: (handle) => {
+          warnOnUnboundBreakpoints([handle]);
+        }
+      });
+      writeLogSummary(result.stoppedReason, result.emitted, opts.json);
+    });
+  } finally {
+    process6.off("SIGINT", onSig);
+    process6.off("SIGTERM", onSig);
   }
-  if (objectId === void 0) {
-    return buildDescribed("undefined", type);
+}
+function writeLogSummary(stoppedReason, emitted, json) {
+  if (json) {
+    process6.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+`);
+    return;
   }
-  return buildDescribed("[object]", type, objectId);
+  process6.stderr.write(
+    `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
+`
+  );
 }
+
+// src/cli/commands/snapshot.ts
+import { performance as performance3 } from "perf_hooks";
+import process7 from "process";
+
+// 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";
@@ -1266,129 +1461,25 @@ function formatPrimitive(value) {
   if (typeof value === "bigint") {
     return `${value.toString()}n`;
   }
-  return String(value);
-}
-function resolveMaxValueLength(value) {
-  if (value === void 0) {
-    return DEFAULT_MAX_VALUE_LENGTH;
-  }
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new CfInspectorError(
-      "INVALID_ARGUMENT",
-      `Invalid maxValueLength: ${value.toString()} \u2014 expected a positive integer`
-    );
-  }
-  return value;
-}
-function limitValueLength(raw, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
-  if (raw.length <= maxValueLength) {
-    return raw;
-  }
-  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 };
-      } 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 };
-  };
-  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");
+  return String(value);
 }
-function objectIdFromEvalResult(result) {
-  const inner = result.result;
-  if (inner?.type !== "object") {
-    return void 0;
+function resolveMaxValueLength(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_VALUE_LENGTH;
   }
-  const objectId = inner.objectId;
-  if (typeof objectId !== "string" || objectId.length === 0) {
-    return void 0;
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `Invalid maxValueLength: ${value.toString()} \u2014 expected a positive integer`
+    );
   }
-  return objectId;
+  return value;
+}
+function limitValueLength(raw, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
+  if (raw.length <= maxValueLength) {
+    return raw;
+  }
+  return `${raw.slice(0, maxValueLength)}...`;
 }
 function parseQuotedString(value) {
   try {
@@ -1456,6 +1547,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(
@@ -1502,6 +1721,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];
@@ -1518,169 +1782,131 @@ 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,
     hitBreakpoints: pause.hitBreakpoints,
     capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...topFrame === void 0 ? {} : { topFrame },
-    captures
-  };
-}
-
-// src/tunnel.ts
-import { startDebugger } from "@saptools/cf-debugger";
-async function openCfTunnel(target) {
-  const opts = {
-    region: target.region,
-    org: target.org,
-    space: target.space,
-    app: target.app,
-    ...target.tunnelReadyTimeoutMs === void 0 ? {} : { tunnelReadyTimeoutMs: target.tunnelReadyTimeoutMs },
-    ...target.preferredPort === void 0 ? {} : { preferredPort: target.preferredPort },
-    ...target.verbose === void 0 ? {} : { verbose: target.verbose },
-    ...target.signal === void 0 ? {} : { signal: target.signal }
-  };
-  const handle = await startDebugger(opts);
-  return {
-    localPort: handle.session.localPort,
-    handle,
-    dispose: async () => {
-      await handle.dispose();
-    }
-  };
-}
-
-// src/cli.ts
-init_types();
-var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
-var DEFAULT_CF_TIMEOUT_SEC = 60;
-function parsePositiveInt(raw, label) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  const value = Number.parseInt(raw, 10);
-  if (Number.isNaN(value) || value <= 0 || value.toString() !== raw.trim()) {
-    throw new CfInspectorError("INVALID_ARGUMENT", `Invalid ${label}: "${raw}" \u2014 expected a positive integer`);
-  }
-  return value;
-}
-function resolveTarget(opts) {
-  const port = parsePositiveInt(opts.port, "--port");
-  if (port !== void 0) {
-    return { kind: "port", port, host: opts.host ?? "127.0.0.1" };
-  }
-  if (opts.region !== void 0 && opts.org !== void 0 && opts.space !== void 0 && opts.app !== void 0) {
-    const cfTimeoutSec = parsePositiveInt(opts.cfTimeout, "--cf-timeout") ?? DEFAULT_CF_TIMEOUT_SEC;
-    return {
-      kind: "cf",
-      region: opts.region,
-      org: opts.org,
-      space: opts.space,
-      app: opts.app,
-      cfTimeoutMs: cfTimeoutSec * 1e3
-    };
-  }
-  throw new CfInspectorError(
-    "MISSING_TARGET",
-    "Provide either --port (and optionally --host) or all of --region, --org, --space, --app."
-  );
-}
-async function openTarget(target) {
-  if (target.kind === "port") {
-    return {
-      port: target.port,
-      host: target.host,
-      dispose: () => Promise.resolve()
-    };
-  }
-  const tunnel = await openCfTunnel({
-    region: target.region,
-    org: target.org,
-    space: target.space,
-    app: target.app,
-    tunnelReadyTimeoutMs: target.cfTimeoutMs
-  });
-  return {
-    port: tunnel.localPort,
-    host: "127.0.0.1",
-    dispose: async () => {
-      await tunnel.dispose();
-    }
+    captures
   };
 }
-async function withSession(target, fn) {
-  const tunnel = await openTarget(target);
-  let session;
+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 {
-    session = await connectInspector({ port: tunnel.port, host: tunnel.host });
-    return await fn(session, tunnel.port);
-  } finally {
-    if (session) {
-      await session.dispose();
-    }
-    await tunnel.dispose();
+    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) };
   }
 }
-function warnOnUnboundBreakpoints(handles) {
-  for (const handle of handles) {
-    if (handle.resolvedLocations.length === 0) {
-      process2.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.
-`
-      );
-    }
+
+// src/cli/commands/snapshot.ts
+init_types();
+
+// src/cli/captureParser.ts
+function parseCaptureList(raw) {
+  if (raw === void 0 || raw.trim().length === 0) {
+    return [];
   }
+  return splitCaptureExpressions(raw);
 }
-function roundDurationMs(durationMs) {
-  return Math.round(durationMs * 1e3) / 1e3;
+function isQuoteChar(value) {
+  return value === "'" || value === '"' || value === "`";
 }
-function formatPauseLocation(pause) {
-  const top = pause.callFrames[0];
-  if (top === void 0) {
-    return "(no call frame)";
+function consumeQuotedChar(state, char) {
+  if (state.quote === void 0) {
+    return false;
   }
-  const url = top.url !== void 0 && top.url.length > 0 ? top.url : "(unknown)";
-  return `${url}:${(top.lineNumber + 1).toString()}:${(top.columnNumber + 1).toString()}`;
+  if (state.escaped) {
+    state.escaped = false;
+    return true;
+  }
+  if (char === "\\") {
+    state.escaped = true;
+    return true;
+  }
+  if (char === state.quote) {
+    state.quote = void 0;
+  }
+  return true;
 }
-function warnOnUnmatchedPause(pause) {
-  const reason = pause.reason.length > 0 ? pause.reason : "unknown";
-  process2.stderr.write(
-    `[cf-inspector] warning: target is paused by another debugger event (${reason} at ${formatPauseLocation(pause)}); waiting for it to resume...
-`
-  );
+function updateCaptureDepth(state, char) {
+  if (char === "(") {
+    state.parenDepth += 1;
+  } else if (char === ")") {
+    state.parenDepth = Math.max(0, state.parenDepth - 1);
+  } else if (char === "[") {
+    state.bracketDepth += 1;
+  } else if (char === "]") {
+    state.bracketDepth = Math.max(0, state.bracketDepth - 1);
+  } else if (char === "{") {
+    state.braceDepth += 1;
+  } else if (char === "}") {
+    state.braceDepth = Math.max(0, state.braceDepth - 1);
+  }
 }
-function withPausedDuration(snapshot, pausedDurationMs) {
-  return {
-    reason: snapshot.reason,
-    hitBreakpoints: snapshot.hitBreakpoints,
-    capturedAt: snapshot.capturedAt,
-    pausedDurationMs,
-    ...snapshot.topFrame === void 0 ? {} : { topFrame: snapshot.topFrame },
-    captures: snapshot.captures
+function isTopLevel(state) {
+  return state.parenDepth === 0 && state.bracketDepth === 0 && state.braceDepth === 0;
+}
+function appendCapturePiece(raw, state, end) {
+  const piece = raw.slice(state.start, end).trim();
+  if (piece.length > 0) {
+    state.pieces.push(piece);
+  }
+}
+function splitCaptureExpressions(raw) {
+  const state = {
+    escaped: false,
+    parenDepth: 0,
+    bracketDepth: 0,
+    braceDepth: 0,
+    quote: void 0,
+    start: 0,
+    pieces: []
   };
+  for (let idx = 0; idx < raw.length; idx += 1) {
+    const char = raw.charAt(idx);
+    if (consumeQuotedChar(state, char)) {
+      continue;
+    }
+    if (isQuoteChar(char)) {
+      state.quote = char;
+      continue;
+    }
+    updateCaptureDepth(state, char);
+    if (char === "," && isTopLevel(state)) {
+      appendCapturePiece(raw, state, idx);
+      state.start = idx + 1;
+    }
+  }
+  appendCapturePiece(raw, state, raw.length);
+  return state.pieces;
 }
+
+// src/cli/commands/snapshot.ts
 async function handleSnapshot(opts) {
+  const prepared = prepareSnapshotCommand(opts);
+  const result = await runSnapshotCommand(prepared, opts);
+  if (opts.json) {
+    writeJson(result);
+  } else {
+    writeHumanSnapshot(result);
+  }
+}
+function prepareSnapshotCommand(opts) {
   const target = resolveTarget(opts);
   if (opts.bp.length === 0) {
     throw new CfInspectorError(
@@ -1688,249 +1914,146 @@ async function handleSnapshot(opts) {
       "At least one --bp <file:line> is required."
     );
   }
-  const breakpoints = opts.bp.map((spec) => parseBreakpointSpec(spec));
-  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
-  const captures = parseCaptureList(opts.capture);
   const timeoutSec = parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_BREAKPOINT_TIMEOUT_SEC;
   const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length");
-  const timeoutMs = timeoutSec * 1e3;
   const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
-  const result = await withSession(target, async (session) => {
-    if (condition !== void 0) {
-      await validateExpression(session, condition);
+  return {
+    target,
+    breakpoints: opts.bp.map((spec) => parseBreakpointSpec(spec)),
+    captures: parseCaptureList(opts.capture),
+    remoteRoot: parseRemoteRoot(opts.remoteRoot),
+    timeoutMs: timeoutSec * 1e3,
+    ...condition === void 0 ? {} : { condition },
+    ...maxValueLength === void 0 ? {} : { maxValueLength }
+  };
+}
+async function runSnapshotCommand(command, opts) {
+  return await withSession(command.target, async (session) => {
+    if (command.condition !== void 0) {
+      await validateExpression(session, command.condition);
     }
     const handles = await Promise.all(
-      breakpoints.map(
+      command.breakpoints.map(
         (bp) => setBreakpoint(session, {
           file: bp.file,
           line: bp.line,
-          remoteRoot,
-          ...condition === void 0 ? {} : { condition }
+          remoteRoot: command.remoteRoot,
+          ...command.condition === void 0 ? {} : { condition: command.condition }
         })
       )
     );
     warnOnUnboundBreakpoints(handles);
-    const breakpointIds = handles.map((h) => h.breakpointId);
-    let warnedUnmatchedPause = false;
-    const pause = await waitForPause(session, {
-      timeoutMs,
-      breakpointIds,
-      unmatchedPausePolicy: opts.failOnUnmatchedPause === true ? "fail" : "wait-for-resume",
-      onUnmatchedPause: (unmatchedPause) => {
-        if (warnedUnmatchedPause || opts.failOnUnmatchedPause === true) {
-          return;
-        }
-        warnedUnmatchedPause = true;
-        warnOnUnmatchedPause(unmatchedPause);
-      }
-    });
-    const pausedStartedAt = pause.receivedAtMs ?? performance2.now();
+    const pause = await waitForCommandPause(session, opts, handles, command.timeoutMs);
+    const pausedStartedAt = pause.receivedAtMs ?? performance3.now();
     const snapshot = await captureSnapshot(session, pause, {
-      captures,
+      captures: command.captures,
       includeScopes: opts.includeScopes === true,
-      ...maxValueLength === void 0 ? {} : { maxValueLength }
+      ...command.maxValueLength === void 0 ? {} : { maxValueLength: command.maxValueLength }
     });
     if (opts.keepPaused === true) {
       return withPausedDuration(snapshot, null);
     }
-    try {
-      await resume(session);
-      return withPausedDuration(
-        snapshot,
-        roundDurationMs(performance2.now() - pausedStartedAt)
-      );
-    } catch {
-      process2.stderr.write(
-        "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
-      );
-      return withPausedDuration(snapshot, null);
-    }
-  });
-  if (opts.json) {
-    writeJson(result);
-  } else {
-    writeHumanSnapshot(result);
-  }
-}
-async function handleEval(opts) {
-  const target = resolveTarget(opts);
-  const result = await withSession(target, async (session) => {
-    return await evaluateGlobal(session, opts.expr);
+    return await resumeAfterSnapshot(session, snapshot, pausedStartedAt);
   });
-  if (opts.json) {
-    writeJson(result);
-    if (result.exceptionDetails !== void 0) {
-      process2.exitCode = 1;
-    }
-    return;
-  }
-  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";
-    process2.stderr.write(`${detail}
-`);
-    process2.exitCode = 1;
-    return;
-  }
-  const inner = result.result;
-  if (inner === void 0) {
-    process2.stdout.write("\n");
-    return;
-  }
-  if (typeof inner.value === "string") {
-    process2.stdout.write(`${inner.value}
-`);
-    return;
-  }
-  if (typeof inner.description === "string") {
-    process2.stdout.write(`${inner.description}
-`);
-    return;
-  }
-  process2.stdout.write(`${JSON.stringify(inner.value)}
-`);
 }
-async function handleLog(opts) {
-  const target = resolveTarget(opts);
-  const location = parseBreakpointSpec(opts.at);
-  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
-  const durationSec = parsePositiveInt(opts.duration, "--duration");
-  const expression = opts.expr.trim();
-  if (expression.length === 0) {
-    throw new CfInspectorError("INVALID_BREAKPOINT", "--expr must not be empty");
-  }
-  const abort = new AbortController();
-  const onSig = () => {
-    abort.abort();
-  };
-  process2.once("SIGINT", onSig);
-  process2.once("SIGTERM", onSig);
-  try {
-    await withSession(target, async (session) => {
-      await validateExpression(session, expression);
-      const result = await streamLogpoint(session, {
-        location,
-        expression,
-        remoteRoot,
-        ...durationSec === void 0 ? {} : { durationMs: durationSec * 1e3 },
-        signal: abort.signal,
-        onEvent: (event) => {
-          writeLogEvent(event, opts.json);
-        },
-        onBreakpointSet: (handle) => {
-          warnOnUnboundBreakpoints([handle]);
-        }
-      });
-      if (opts.json) {
-        process2.stderr.write(
-          `${JSON.stringify({ stopped: result.stoppedReason, emitted: result.emitted })}
-`
-        );
-      } else {
-        process2.stderr.write(
-          `Stopped (${result.stoppedReason}); emitted ${result.emitted.toString()} log ${result.emitted === 1 ? "entry" : "entries"}.
-`
-        );
+async function waitForCommandPause(session, opts, handles, timeoutMs) {
+  let warnedUnmatchedPause = false;
+  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;
       }
-    });
-  } finally {
-    process2.off("SIGINT", onSig);
-    process2.off("SIGTERM", onSig);
-  }
-}
-async function handleListScripts(opts) {
-  const target = resolveTarget(opts);
-  const scripts = await withSession(target, (session) => Promise.resolve(listScripts(session)));
-  if (opts.json) {
-    writeJson(scripts);
-    return;
-  }
-  for (const script of scripts) {
-    process2.stdout.write(`${script.scriptId}	${script.url}
-`);
-  }
+      warnedUnmatchedPause = true;
+      warnOnUnmatchedPause(unmatchedPause);
+    }
+  });
 }
-async function handleAttach(opts) {
-  const target = resolveTarget(opts);
-  const tunnel = await openTarget(target);
+async function resumeAfterSnapshot(session, snapshot, pausedStartedAt) {
   try {
-    const version = await fetchInspectorVersion(tunnel.host, tunnel.port, 5e3);
-    if (opts.json) {
-      writeJson({ host: tunnel.host, port: tunnel.port, ...version });
-      return;
-    }
-    process2.stdout.write(
-      `Connected to ${tunnel.host}:${tunnel.port.toString()}
-  Browser: ${version.browser}
-  Protocol: ${version.protocolVersion}
-`
+    await resume(session);
+    return withPausedDuration(snapshot, roundDurationMs(performance3.now() - pausedStartedAt));
+  } catch {
+    process7.stderr.write(
+      "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
-  } finally {
-    await tunnel.dispose();
+    return withPausedDuration(snapshot, null);
   }
 }
+
+// src/cli/program.ts
 function applyTargetOptions(cmd) {
   return cmd.option("--port <number>", "Local port the inspector or tunnel listens on").option("--host <host>", "Hostname (default: 127.0.0.1)", "127.0.0.1").option("--region <key>", "CF region key (e.g. eu10)").option("--org <name>", "CF org name").option("--space <name>", "CF space name").option("--app <name>", "CF app name").option("--cf-timeout <seconds>", "Timeout for CF tunnel readiness in seconds");
 }
 async function main(argv) {
   const program = new Command();
   program.name("cf-inspector").description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
+  registerSnapshot(program);
+  registerLog(program);
+  registerEval(program);
+  registerListScripts(program);
+  registerAttach(program);
+  await program.parseAsync([...argv]);
+}
+function registerSnapshot(program) {
   const collectStrings = (value, prev = []) => [
     ...prev,
     value
   ];
   applyTargetOptions(
     program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture expressions, and resume")
-  ).option(
-    "--bp <file:line>",
-    "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42",
-    collectStrings,
-    []
-  ).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option(
-    "--condition <expr>",
-    "Only pause when this JS expression evaluates truthy in the paused frame"
-  ).option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
+  ).option("--bp <file:line>", "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--condition <expr>", "Only pause when this JS expression evaluates truthy in the paused frame").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
     await handleSnapshot(opts);
   });
+}
+function registerLog(program) {
   applyTargetOptions(
     program.command("log").description("Stream a non-pausing logpoint: log an expression each time a line executes")
   ).requiredOption("--at <file:line>", "Logpoint location, e.g. src/handler.ts:42").requiredOption("--expr <expression>", "JavaScript expression to log on each hit").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
     await handleLog(opts);
   });
+}
+function registerEval(program) {
   applyTargetOptions(
     program.command("eval").description("Evaluate an expression against the global Runtime")
   ).requiredOption("--expr <expression>", "JavaScript expression to evaluate").option("--no-json", "Print only the resulting value, not the full CDP envelope").action(async (opts) => {
     await handleEval(opts);
   });
+}
+function registerListScripts(program) {
   applyTargetOptions(
     program.command("list-scripts").description("Print the scripts the V8 instance currently knows about")
   ).option("--no-json", "Print scriptId<TAB>url instead of JSON").action(async (opts) => {
     await handleListScripts(opts);
   });
+}
+function registerAttach(program) {
   applyTargetOptions(
     program.command("attach").description("Connect, fetch the inspector version, and disconnect (smoke-test)")
   ).option("--no-json", "Print a multi-line summary instead of JSON").action(async (opts) => {
     await handleAttach(opts);
   });
-  await program.parseAsync([...argv]);
 }
+
+// src/cli.ts
+init_types();
 try {
-  await main(process2.argv);
+  await main(process8.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process2.stderr.write(`Error [${err.code}]: ${err.message}
+    process8.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process2.stderr.write(`  detail: ${err.detail}
+      process8.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process2.exit(1);
+    process8.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process2.stderr.write(`Error: ${message}
+  process8.stderr.write(`Error: ${message}
 `);
-  process2.exit(1);
+  process8.exit(1);
 }
-export {
-  main
-};
 //# sourceMappingURL=cli.js.map