@saptools/cf-inspector 0.4.12 → 0.6.0

package/dist/cli.js

@@ -152,7 +152,7 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process12 from "process";
+import process11 from "process";
 
 // src/cli/program.ts
 import { readFileSync } from "fs";
@@ -166,37 +166,65 @@ import process3 from "process";
 // src/inspector/discovery.ts
 init_types();
 import { request } from "http";
+import { performance } from "perf_hooks";
+var InvalidDiscoveryPayloadError = class extends CfInspectorError {
+};
 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}`));
+  const deadline = performance.now() + timeoutMs;
+  let lastError;
+  while (performance.now() < deadline) {
+    try {
+      const remainingMs = deadline - performance.now();
+      if (remainingMs <= 0) {
+        break;
+      }
+      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}`));
+          });
+        });
+        const attemptTimeoutMs = Math.min(2e3, remainingMs);
+        req.setTimeout(attemptTimeoutMs, () => {
+          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 : formatDiscoveryRequestError(url, err));
+        });
+        req.end();
       });
-    });
-    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 : formatDiscoveryRequestError(url, err));
-    });
-    req.end();
-  });
+    } catch (err) {
+      if (err instanceof InvalidDiscoveryPayloadError) {
+        throw err;
+      }
+      lastError = err;
+      const now = performance.now();
+      if (now < deadline) {
+        const sleepMs = Math.min(1e3, deadline - now);
+        await new Promise((r) => setTimeout(r, sleepMs));
+      }
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new CfInspectorError("INSPECTOR_DISCOVERY_FAILED", `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`);
 }
 function isNodeSystemError(err) {
   return err instanceof Error;
@@ -232,7 +260,10 @@ function parseJsonResponse(chunks) {
 }
 function parseDiscoveryError(url, err) {
   const message = err instanceof Error ? err.message : String(err);
-  return newDiscoveryError(`Failed to parse inspector discovery response from ${url}: ${message}`);
+  return new InvalidDiscoveryPayloadError(
+    "INSPECTOR_DISCOVERY_FAILED",
+    `Failed to parse inspector discovery response from ${url}: ${message}`
+  );
 }
 function newDiscoveryError(message) {
   return new CfInspectorError("INSPECTOR_DISCOVERY_FAILED", message);
@@ -332,7 +363,7 @@ function writeHumanSnapshot(snapshot) {
     lines.push("  captures:");
     for (const capture of snapshot.captures) {
       const detail = capture.error ?? capture.value ?? "undefined";
-      lines.push(`    ${capture.expression} = ${detail}`);
+      lines.push(`    ${capture.expression} = ${renderTruncated(detail, capture)}`);
     }
   }
   if (snapshot.stack !== void 0 && snapshot.stack.length > 0) {
@@ -350,13 +381,17 @@ function appendFrameLines(lines, frame) {
   lines.push(
     `  frame:   ${fnName} ${sourceUrl}:${frame.line.toString()}:${frame.column.toString()}`
   );
+  if (frame.truncated === true) {
+    lines.push(`  scopes:  ${truncationLabel(frame)}`);
+  }
   if (frame.scopes === void 0) {
     return;
   }
   for (const scope of frame.scopes) {
-    lines.push(`  scope ${scope.type} (${scope.variables.length.toString()} vars):`);
+    const scopeSuffix = scope.truncated === true ? `; ${truncationLabel(scope)}` : "";
+    lines.push(`  scope ${scope.type} (${scope.variables.length.toString()} vars${scopeSuffix}):`);
     for (const variable of scope.variables) {
-      lines.push(`    ${variable.name} = ${variable.value}`);
+      lines.push(`    ${variable.name} = ${renderTruncated(variable.value, variable)}`);
     }
   }
 }
@@ -367,7 +402,7 @@ function appendStackFrameLine(lines, frame) {
   if (frame.captures !== void 0) {
     for (const capture of frame.captures) {
       const detail = capture.error ?? capture.value ?? "undefined";
-      lines.push(`      ${capture.expression} = ${detail}`);
+      lines.push(`      ${capture.expression} = ${renderTruncated(detail, capture)}`);
     }
   }
 }
@@ -376,8 +411,7 @@ function appendExceptionLines(lines, exception) {
     lines.push(`  exception: !err ${exception.error}`);
     return;
   }
-  const detail = exception.description ?? exception.value ?? "(unknown)";
-  lines.push(`  exception: ${detail}`);
+  lines.push(`  exception: ${renderExceptionDetail(exception)}`);
 }
 function writeLogEvent(event, json) {
   if (json) {
@@ -386,11 +420,11 @@ function writeLogEvent(event, json) {
     return;
   }
   if (event.error !== void 0) {
-    process.stdout.write(`[${event.ts}] ${event.at} !err ${event.error}
+    process.stdout.write(`[${event.ts}] ${event.at} !err ${renderTruncated(event.error, event)}
 `);
     return;
   }
-  process.stdout.write(`[${event.ts}] ${event.at} ${event.value ?? ""}
+  process.stdout.write(`[${event.ts}] ${event.at} ${renderTruncated(event.value ?? "", event)}
 `);
 }
 function writeWatchEvent(event, json) {
@@ -402,90 +436,124 @@ function writeWatchEvent(event, json) {
   process.stdout.write(`[${event.ts}] hit#${event.hit.toString()} ${event.at}
 `);
   if (event.exception !== void 0) {
-    const detail = event.exception.description ?? event.exception.value ?? event.exception.error ?? "(unknown)";
-    process.stdout.write(`  exception: ${detail}
+    process.stdout.write(`  exception: ${renderExceptionDetail(event.exception)}
 `);
   }
   for (const capture of event.captures) {
     const detail = capture.error ?? capture.value ?? "undefined";
-    process.stdout.write(`  ${capture.expression} = ${detail}
+    process.stdout.write(`  ${capture.expression} = ${renderTruncated(detail, capture)}
 `);
   }
 }
+function renderExceptionDetail(exception) {
+  if (exception.description !== void 0) {
+    const originalLength = exception.descriptionOriginalLength;
+    return renderTruncated(
+      exception.description,
+      originalLength === void 0 ? {} : { truncated: true, originalLength }
+    );
+  }
+  if (exception.value !== void 0) {
+    const originalLength = exception.valueOriginalLength ?? exception.originalLength;
+    const summary = {
+      ...originalLength === void 0 ? {} : { truncated: true, originalLength },
+      ...exception.omittedCount === void 0 ? {} : { truncated: true, omittedCount: exception.omittedCount }
+    };
+    return renderTruncated(exception.value, summary);
+  }
+  return exception.error ?? "(unknown)";
+}
+function renderTruncated(value, summary) {
+  if (summary.truncated !== true) {
+    return value;
+  }
+  const visualValue = summary.originalLength === void 0 ? value : `${value}\u2026`;
+  return `${visualValue} [${truncationLabel(summary)}]`;
+}
+function truncationLabel(summary) {
+  const details = [];
+  if (summary.originalLength !== void 0) {
+    details.push(`original ${summary.originalLength.toString()} chars`);
+  }
+  if (summary.omittedCount !== void 0) {
+    details.push(`${summary.omittedCount.toString()} omitted`);
+  }
+  return details.length === 0 ? "truncated" : `truncated: ${details.join(", ")}`;
+}
 
 // src/cli/target.ts
-import process2 from "process";
-import {
-  readCurrentCfTarget,
-  requireCurrentCfRegion
-} from "@saptools/cf-debugger";
+import "@saptools/cf-debugger";
 
 // src/cf/tunnel.ts
 import { startDebugger } from "@saptools/cf-debugger";
-async function openCfTunnel(target) {
-  const opts = {
-    region: target.region,
+function targetOptions(target) {
+  return {
     ...target.apiEndpoint === void 0 ? {} : { apiEndpoint: target.apiEndpoint },
-    org: target.org,
-    space: target.space,
-    app: target.app,
+    ...target.process === void 0 ? {} : { process: target.process },
+    ...target.instance === void 0 ? {} : { instance: target.instance },
+    ...target.nodePid === void 0 ? {} : { nodePid: target.nodePid }
+  };
+}
+function lifecycleOptions(target) {
+  return {
+    ...target.allowSshEnableRestart === void 0 ? {} : { allowSshEnableRestart: target.allowSshEnableRestart },
     ...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 },
     ...target.onStatus === void 0 ? {} : { onStatus: target.onStatus }
   };
-  try {
-    const handle = await startDebugger(opts);
-    return {
-      localPort: handle.session.localPort,
-      handle,
-      dispose: async () => {
-        await handle.dispose();
-      }
-    };
-  } catch (err) {
-    return reuseExistingTunnelOrThrow(err, target.onStatus);
-  }
 }
-function reuseExistingTunnelOrThrow(err, onStatus) {
-  if (!isSessionAlreadyRunningError(err)) {
-    throw err;
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  const port = extractExistingTunnelPort(message);
-  if (port === void 0) {
-    throw err;
-  }
-  const warning = `Reusing existing tunnel on port ${port.toString()}`;
-  onStatus?.("ready", warning);
+function toStartDebuggerOptions(target) {
   return {
-    localPort: port,
-    dispose: () => Promise.resolve()
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    ...targetOptions(target),
+    ...lifecycleOptions(target)
   };
 }
-function isSessionAlreadyRunningError(err) {
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-  const code = err.code;
-  return code === "SESSION_ALREADY_RUNNING";
+async function openOwnedCfTunnel(target) {
+  const opts = toStartDebuggerOptions(target);
+  const handle = await startDebugger(opts);
+  return {
+    localPort: handle.session.localPort,
+    handle,
+    dispose: async () => {
+      await handle.dispose();
+    }
+  };
 }
-function extractExistingTunnelPort(message) {
-  const match = /on port (\d+)/i.exec(message);
-  if (match === null) {
+function isExistingSessionError(error) {
+  return error instanceof Error && "code" in error && error.code === "SESSION_ALREADY_RUNNING";
+}
+function existingTunnelPort(error) {
+  if (!isExistingSessionError(error)) {
     return void 0;
   }
-  const rawPort = match[1];
+  const rawPort = /\bon port (\d+)\b/iu.exec(error.message)?.[1];
   if (rawPort === void 0) {
     return void 0;
   }
   const port = Number.parseInt(rawPort, 10);
-  return Number.isNaN(port) ? void 0 : port;
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : void 0;
+}
+async function openCfTunnel(target) {
+  try {
+    return await openOwnedCfTunnel(target);
+  } catch (error) {
+    const localPort = existingTunnelPort(error);
+    if (localPort === void 0) {
+      throw error;
+    }
+    target.onStatus?.("ready", `Reusing existing tunnel on port ${localPort.toString()}`);
+    return { localPort, dispose: () => Promise.resolve() };
+  }
 }
 
 // src/inspector/session.ts
-import { performance } from "perf_hooks";
+import { performance as performance2 } from "perf_hooks";
 
 // src/cdp/client.ts
 init_types();
@@ -588,54 +656,70 @@ var CdpClient = class _CdpClient {
     if (this.closed) {
       throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
     }
-    return await new Promise((resolve, reject) => {
+    if (options.signal?.aborted === true) {
+      throw this.createWaitAbortError(method);
+    }
+    return await this.createEventWait(method, options);
+  }
+  createEventWait(method, options) {
+    return new Promise((resolve, reject) => {
       let settled = false;
+      let offEvent = () => void 0;
+      let offClose = () => void 0;
       const cleanup = () => {
         clearTimeout(timer);
         offEvent();
         offClose();
+        options.signal?.removeEventListener("abort", onAbort);
       };
-      const finish = (value) => {
+      const resolveOnce = (value) => {
+        if (settled) {
+          return;
+        }
         settled = true;
         cleanup();
         resolve(value);
       };
-      const offEvent = this.on(method, (raw) => {
-        if (settled) {
-          return;
-        }
-        const params = raw;
-        if (options.predicate) {
-          let accepted;
-          try {
-            accepted = options.predicate(params);
-          } catch {
-            return;
-          }
-          if (!accepted) {
-            return;
-          }
-        }
-        finish(params);
-      });
-      const offClose = this.onClose((err) => {
+      const rejectOnce = (error) => {
         if (settled) {
           return;
         }
         settled = true;
         cleanup();
-        reject(err);
-      });
+        reject(error);
+      };
+      const onAbort = () => {
+        rejectOnce(this.createWaitAbortError(method));
+      };
       const timer = setTimeout(() => {
-        if (settled) {
+        rejectOnce(this.createWaitTimeoutError(method, options.timeoutMs));
+      }, options.timeoutMs);
+      offEvent = this.on(method, (raw) => {
+        const params = raw;
+        if (!this.eventMatches(params, options.predicate)) {
           return;
         }
-        settled = true;
-        cleanup();
-        reject(this.createWaitTimeoutError(method, options.timeoutMs));
-      }, options.timeoutMs);
+        resolveOnce(params);
+      });
+      offClose = this.onClose((error) => {
+        rejectOnce(error);
+      });
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (options.signal?.aborted === true) {
+        onAbort();
+      }
     });
   }
+  eventMatches(params, predicate) {
+    if (predicate === void 0) {
+      return true;
+    }
+    try {
+      return predicate(params);
+    } catch {
+      return false;
+    }
+  }
   onClose(listener) {
     if (this.closed) {
       const reason = this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
@@ -702,6 +786,9 @@ var CdpClient = class _CdpClient {
       `Timed out waiting for ${method} after ${timeoutMs.toString()}ms`
     );
   }
+  createWaitAbortError(method) {
+    return new CfInspectorError("ABORTED", `Aborted while waiting for ${method}`);
+  }
   sendPayload(id, method, payload, timer, reject) {
     try {
       this.transport.send(payload);
@@ -727,101 +814,378 @@ var CdpClient = class _CdpClient {
     this.emitter.removeAllListeners();
   }
 };
+var NodeWorkerTransport = class {
+  constructor(parent, sessionId) {
+    this.parent = parent;
+    this.sessionId = sessionId;
+    this.detachParentListeners = [
+      parent.on("NodeWorker.receivedMessageFromWorker", (raw) => {
+        this.forwardWorkerMessage(raw);
+      }),
+      parent.on("NodeWorker.detachedFromWorker", (raw) => {
+        this.handleWorkerDetach(raw);
+      }),
+      parent.onClose((error) => {
+        this.closeWithError(error);
+      })
+    ];
+  }
+  parent;
+  sessionId;
+  emitter = new EventEmitter();
+  detachParentListeners;
+  readyState = 1;
+  send(payload) {
+    if (this.readyState !== 1) {
+      throw new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Worker inspector session is closed");
+    }
+    void this.parent.send("NodeWorker.sendMessageToWorker", {
+      sessionId: this.sessionId,
+      message: payload
+    }).catch((error) => {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      this.closeWithError(normalized);
+    });
+  }
+  close() {
+    this.finishClose();
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  forwardWorkerMessage(raw) {
+    const params = asNodeWorkerEventParams(raw);
+    if (params.sessionId !== this.sessionId || typeof params.message !== "string") {
+      return;
+    }
+    this.emitter.emit("message", params.message);
+  }
+  handleWorkerDetach(raw) {
+    const params = asNodeWorkerEventParams(raw);
+    if (params.sessionId === this.sessionId) {
+      this.finishClose();
+    }
+  }
+  closeWithError(error) {
+    if (this.readyState !== 1) {
+      return;
+    }
+    this.emitter.emit("error", error);
+    this.finishClose();
+  }
+  finishClose() {
+    if (this.readyState !== 1) {
+      return;
+    }
+    this.readyState = 3;
+    for (const detach of this.detachParentListeners) {
+      detach();
+    }
+    this.emitter.emit("close");
+    this.emitter.removeAllListeners();
+  }
+};
+function asNodeWorkerEventParams(raw) {
+  if (!isUnknownRecord(raw)) {
+    return {};
+  }
+  const sessionId = raw["sessionId"];
+  const message = raw["message"];
+  return {
+    ...typeof sessionId === "string" ? { sessionId } : {},
+    ...typeof message === "string" ? { message } : {}
+  };
+}
+function isUnknownRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function createNodeWorkerClient(parent, sessionId, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const transport = new NodeWorkerTransport(parent, sessionId);
+  return await CdpClient.connect({
+    url: `node-worker://${sessionId}`,
+    transportFactory: () => Promise.resolve(transport),
+    requestTimeoutMs
+  });
+}
 
 // src/inspector/session.ts
 init_types();
 
 // src/inspector/conversions.ts
+var INTERNAL_SLOT_SUBTYPES = /* @__PURE__ */ new Set([
+  "regexp",
+  "date",
+  "map",
+  "set",
+  "weakmap",
+  "weakset",
+  "iterator",
+  "generator",
+  "promise",
+  "typedarray",
+  "arraybuffer",
+  "dataview",
+  "webassemblymemory",
+  "wasmvalue",
+  "trustedtype"
+]);
 function asString(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
 function asNumber(value, fallback = 0) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function nonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalCoordinate(value) {
+  const number = optionalNumber(value);
+  return number !== void 0 && Number.isSafeInteger(number) && number >= 0 ? number : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function toScriptLocation(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  const lineNumber = optionalCoordinate(value["lineNumber"]);
+  if (scriptId === void 0 || lineNumber === void 0) {
+    return void 0;
+  }
+  const rawColumnNumber = value["columnNumber"];
+  const columnNumber = optionalCoordinate(rawColumnNumber);
+  if (rawColumnNumber !== void 0 && columnNumber === void 0) {
+    return void 0;
+  }
+  return columnNumber === void 0 ? { scriptId, lineNumber } : { scriptId, lineNumber, columnNumber };
+}
 function toResolvedLocations(value) {
   if (!Array.isArray(value)) {
     return [];
   }
   return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
       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];
+    const url = typeof entry["url"] === "string" ? entry["url"] : void 0;
+    return [url === void 0 ? location : { ...location, url }];
   });
 }
-function toScopeChain(value) {
-  if (!Array.isArray(value)) {
-    return [];
+function remoteCompleteness(subtype) {
+  if (subtype === "proxy") {
+    return "unavailable";
   }
-  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 }];
-  });
+  return subtype !== void 0 && INTERNAL_SLOT_SUBTYPES.has(subtype) ? "truncated" : void 0;
+}
+function optionalOwnField(key, value) {
+  return Object.hasOwn(value, key) ? { [key]: value[key] } : {};
+}
+function toRemoteObject(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const type = nonEmptyString(value["type"]);
+  if (type === void 0) {
+    return void 0;
+  }
+  const subtype = nonEmptyString(value["subtype"]);
+  const completeness = remoteCompleteness(subtype);
+  return {
+    type,
+    ...subtype === void 0 ? {} : { subtype },
+    ...optionalTextField("className", value["className"]),
+    ...completeness === void 0 ? {} : { completeness },
+    ...optionalOwnField("value", value),
+    ...optionalTextField("unserializableValue", value["unserializableValue"]),
+    ...optionalTextField("description", value["description"]),
+    ...optionalOwnField("deepSerializedValue", value),
+    ...optionalTextField("objectId", value["objectId"]),
+    ...optionalOwnField("preview", value),
+    ...optionalOwnField("customPreview", value)
+  };
+}
+function optionalTextField(key, value) {
+  return typeof value === "string" ? { [key]: value } : {};
+}
+function toScope(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const type = nonEmptyString(value["type"]);
+  if (type === void 0) {
+    return void 0;
+  }
+  const object = toRemoteObject(value["object"]);
+  const name = nonEmptyString(value["name"]);
+  const startLocation = toScriptLocation(value["startLocation"]);
+  const endLocation = toScriptLocation(value["endLocation"]);
+  return {
+    type,
+    ...name === void 0 ? {} : { name },
+    ...object === void 0 ? {} : { object },
+    ...object?.objectId === void 0 ? {} : { objectId: object.objectId },
+    ...startLocation === void 0 ? {} : { startLocation },
+    ...endLocation === void 0 ? {} : { endLocation }
+  };
+}
+function toScopeChain(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => {
+    const scope = toScope(entry);
+    return scope === void 0 ? [] : [scope];
+  }) : [];
 }
 function resolveCallFrameUrl(frame, scripts) {
-  const direct = nonEmptyString(frame.url);
+  const direct = nonEmptyString(frame["url"]);
   if (direct !== void 0) {
     return direct;
   }
-  const scriptId = nonEmptyString(frame.location?.scriptId);
-  if (scriptId === void 0) {
+  const scriptId = toScriptLocation(frame["location"])?.scriptId;
+  return scriptId === void 0 ? void 0 : nonEmptyString(scripts?.get(scriptId)?.url);
+}
+function toCallFrameMetadata(candidate, location, scripts) {
+  const functionLocation = toScriptLocation(candidate["functionLocation"]);
+  const thisObject = toRemoteObject(candidate["this"]);
+  const returnValue = toRemoteObject(candidate["returnValue"]);
+  const url = resolveCallFrameUrl(candidate, scripts);
+  return {
+    ...location === void 0 ? {} : { scriptId: location.scriptId },
+    ...functionLocation === void 0 ? {} : { functionLocation },
+    ...url === void 0 ? {} : { url },
+    ...thisObject === void 0 ? {} : { thisObject },
+    ...returnValue === void 0 ? {} : { returnValue }
+  };
+}
+function toCallFrame(value, scripts) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const callFrameId = nonEmptyString(value["callFrameId"]);
+  if (callFrameId === void 0) {
     return void 0;
   }
-  return nonEmptyString(scripts?.get(scriptId)?.url);
+  const location = toScriptLocation(value["location"]);
+  return {
+    callFrameId,
+    functionName: asString(value["functionName"]),
+    ...toCallFrameMetadata(value, location, scripts),
+    lineNumber: location?.lineNumber ?? 0,
+    columnNumber: location?.columnNumber ?? 0,
+    scopeChain: toScopeChain(value["scopeChain"])
+  };
 }
 function toCallFrames(value, scripts) {
-  if (!Array.isArray(value)) {
-    return [];
+  return Array.isArray(value) ? value.flatMap((entry) => {
+    const frame = toCallFrame(entry, scripts);
+    return frame === void 0 ? [] : [frame];
+  }) : [];
+}
+function toStackTraceId(value) {
+  if (!isRecord(value)) {
+    return void 0;
   }
-  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 = resolveCallFrameUrl(candidate, scripts);
-    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 }];
+  const id = nonEmptyString(value["id"]);
+  if (id === void 0) {
+    return void 0;
+  }
+  const debuggerId = nonEmptyString(value["debuggerId"]);
+  return debuggerId === void 0 ? { id } : { id, debuggerId };
+}
+function toStackTraceFrame(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  if (scriptId === void 0) {
+    return void 0;
+  }
+  return {
+    functionName: asString(value["functionName"]),
+    scriptId,
+    url: asString(value["url"]),
+    lineNumber: asNumber(value["lineNumber"]),
+    columnNumber: asNumber(value["columnNumber"])
+  };
+}
+function toStackTrace(value) {
+  if (!isRecord(value) || !Array.isArray(value["callFrames"])) {
+    return void 0;
+  }
+  const callFrames = value["callFrames"].flatMap((entry) => {
+    const frame = toStackTraceFrame(entry);
+    return frame === void 0 ? [] : [frame];
   });
+  const description = nonEmptyString(value["description"]);
+  const parent = toStackTrace(value["parent"]);
+  const parentId = toStackTraceId(value["parentId"]);
+  return {
+    callFrames,
+    ...description === void 0 ? {} : { description },
+    ...parent === void 0 ? {} : { parent },
+    ...parentId === void 0 ? {} : { parentId }
+  };
 }
-function toPauseEvent(params, receivedAtMs, scripts) {
-  const base = {
-    reason: asString(params.reason),
-    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
-    callFrames: toCallFrames(params.callFrames, scripts),
-    receivedAtMs
+function toPauseEvent(value, receivedAtMs, scripts) {
+  const params = isRecord(value) ? value : {};
+  const asyncStackTrace = toStackTrace(params["asyncStackTrace"]);
+  const asyncStackTraceId = toStackTraceId(params["asyncStackTraceId"]);
+  const asyncCallStackTraceId = toStackTraceId(params["asyncCallStackTraceId"]);
+  return {
+    reason: asString(params["reason"]),
+    hitBreakpoints: Array.isArray(params["hitBreakpoints"]) ? params["hitBreakpoints"].filter((id) => typeof id === "string") : [],
+    callFrames: toCallFrames(params["callFrames"], scripts),
+    receivedAtMs,
+    ...params["data"] === void 0 ? {} : { data: params["data"] },
+    ...asyncStackTrace === void 0 ? {} : { asyncStackTrace },
+    ...asyncStackTraceId === void 0 ? {} : { asyncStackTraceId },
+    ...asyncCallStackTraceId === void 0 ? {} : { asyncCallStackTraceId }
+  };
+}
+function toScriptInfo(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  if (scriptId === void 0) {
+    return void 0;
+  }
+  const stackTrace = toStackTrace(value["stackTrace"]);
+  return {
+    scriptId,
+    url: asString(value["url"]),
+    ...optionalNumericField("startLine", value["startLine"]),
+    ...optionalNumericField("startColumn", value["startColumn"]),
+    ...optionalNumericField("endLine", value["endLine"]),
+    ...optionalNumericField("endColumn", value["endColumn"]),
+    ...optionalNumericField("executionContextId", value["executionContextId"]),
+    ...optionalTextField("hash", value["hash"]),
+    ...optionalTextField("buildId", value["buildId"]),
+    ...value["executionContextAuxData"] === void 0 ? {} : { executionContextAuxData: value["executionContextAuxData"] },
+    ...optionalTextField("sourceMapURL", value["sourceMapURL"]),
+    ...optionalBooleanField("hasSourceURL", value["hasSourceURL"]),
+    ...optionalBooleanField("isModule", value["isModule"]),
+    ...optionalNumericField("length", value["length"]),
+    ...stackTrace === void 0 ? {} : { stackTrace }
   };
-  return params.data === void 0 ? base : { ...base, data: params.data };
+}
+function optionalNumericField(key, value) {
+  const number = optionalNumber(value);
+  return number === void 0 ? {} : { [key]: number };
+}
+function optionalBooleanField(key, value) {
+  const boolean = optionalBoolean(value);
+  return boolean === void 0 ? {} : { [key]: boolean };
 }
 function topFrameLocation(pause) {
   const top = pause.callFrames[0];
@@ -843,6 +1207,101 @@ function pauseDetail(pause) {
 var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
 var DEFAULT_HOST = "127.0.0.1";
 var PAUSE_BUFFER_LIMIT = 32;
+var NodeWorkerDiscovery = class {
+  constructor(client) {
+    this.client = client;
+    this.detachListeners = [
+      client.on("NodeWorker.attachedToWorker", (raw) => {
+        const worker = toInspectorWorkerTarget(raw);
+        if (worker !== void 0) {
+          this.workers.set(worker.sessionId, worker);
+        }
+      }),
+      client.on("NodeWorker.detachedFromWorker", (raw) => {
+        const sessionId = readField(raw, "sessionId");
+        if (typeof sessionId === "string") {
+          this.workers.delete(sessionId);
+        }
+      })
+    ];
+  }
+  client;
+  workers = /* @__PURE__ */ new Map();
+  detachListeners;
+  supported = false;
+  disposed = false;
+  async enable() {
+    try {
+      await this.client.send("NodeWorker.enable", { waitForDebuggerOnStart: false });
+      this.supported = true;
+    } catch (error) {
+      if (!isUnsupportedNodeWorkerDomain(error)) {
+        throw error;
+      }
+    }
+  }
+  list() {
+    return [...this.workers.values()].sort(compareWorkers);
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (this.supported && !this.client.isClosed) {
+      try {
+        await this.client.send("NodeWorker.disable");
+      } catch {
+      }
+    }
+    for (const detach of this.detachListeners) {
+      detach();
+    }
+  }
+};
+function isUnsupportedNodeWorkerDomain(error) {
+  if (!(error instanceof CfInspectorError) || error.code !== "CDP_REQUEST_FAILED") {
+    return false;
+  }
+  return error.detail?.includes('"code":-32601') === true;
+}
+function compareWorkers(left, right) {
+  const leftId = Number.parseInt(left.workerId, 10);
+  const rightId = Number.parseInt(right.workerId, 10);
+  if (!Number.isNaN(leftId) && !Number.isNaN(rightId) && leftId !== rightId) {
+    return leftId - rightId;
+  }
+  return left.workerId.localeCompare(right.workerId);
+}
+function toInspectorWorkerTarget(raw) {
+  const sessionId = readField(raw, "sessionId");
+  const info = readField(raw, "workerInfo");
+  if (typeof sessionId !== "string" || !isUnknownRecord2(info)) {
+    return void 0;
+  }
+  const workerId = asString(info["workerId"]);
+  if (workerId.length === 0) {
+    return void 0;
+  }
+  return {
+    sessionId,
+    workerId,
+    type: asString(info["type"]),
+    title: asString(info["title"]),
+    url: asString(info["url"])
+  };
+}
+function readField(value, name) {
+  return isUnknownRecord2(value) ? value[name] : void 0;
+}
+function isUnknownRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+async function startNodeWorkerDiscovery(client) {
+  const discovery = new NodeWorkerDiscovery(client);
+  await discovery.enable();
+  return discovery;
+}
 async function connectInspector(options) {
   const host = options.host ?? DEFAULT_HOST;
   const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
@@ -852,50 +1311,123 @@ async function connectInspector(options) {
   if (!target) {
     throw new CfInspectorError(
       "INSPECTOR_DISCOVERY_FAILED",
-      `No inspector target at index ${targetIndex.toString()} on ${host}:${options.port.toString()} (available: ${targets.length.toString()})`
+      `No inspector target at index ${targetIndex.toString()} on ${host}:${options.port.toString()} (available: ${targets.length.toString()})`
+    );
+  }
+  const client = await CdpClient.connect({
+    url: target.webSocketDebuggerUrl,
+    connectTimeoutMs
+  });
+  let workerDiscovery;
+  try {
+    workerDiscovery = await startNodeWorkerDiscovery(client);
+    if (options.workerIndex === void 0) {
+      const session = await initSession(client, target);
+      return withWorkerMetadata(session, workerDiscovery, targetIndex, targets.length);
+    }
+    return await initWorkerSession(
+      client,
+      workerDiscovery,
+      options.workerIndex,
+      targetIndex,
+      targets.length
+    );
+  } catch (err) {
+    await workerDiscovery?.dispose();
+    client.dispose();
+    throw err;
+  }
+}
+async function initWorkerSession(parent, discovery, workerIndex, targetIndex, targetCount) {
+  const workers = discovery.list();
+  if (!discovery.supported) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      "This runtime does not expose the NodeWorker CDP domain; --worker cannot be used. Run list-targets for available raw targets."
+    );
+  }
+  const worker = workers[workerIndex];
+  if (worker === void 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No NodeWorker sub-session at index ${workerIndex.toString()} (available: ${workers.length.toString()}). Ensure the worker is alive, then rerun list-targets.`
     );
   }
-  const client = await CdpClient.connect({
-    url: target.webSocketDebuggerUrl,
-    connectTimeoutMs
-  });
+  const client = await createNodeWorkerClient(parent, worker.sessionId);
+  const session = await initSession(client, workerToInspectorTarget(worker));
+  return withWorkerMetadata(session, discovery, targetIndex, targetCount, workerIndex, parent);
+}
+function withWorkerMetadata(session, discovery, targetIndex, targetCount, workerIndex, parent) {
+  return {
+    ...session,
+    targetIndex,
+    targetCount,
+    ...workerIndex === void 0 ? {} : { workerIndex },
+    workerTargets: discovery.list(),
+    workerDiscoverySupported: discovery.supported,
+    dispose: async () => {
+      await session.dispose();
+      await discovery.dispose();
+      parent?.dispose();
+    }
+  };
+}
+function workerToInspectorTarget(worker) {
+  return {
+    description: "Node worker sub-session",
+    id: worker.workerId,
+    title: worker.title,
+    type: worker.type,
+    url: worker.url,
+    webSocketDebuggerUrl: `node-worker://${worker.sessionId}`
+  };
+}
+async function discoverNodeWorkerTargets(target, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl, connectTimeoutMs });
+  let discovery;
   try {
-    return await initSession(client, target);
-  } catch (err) {
+    discovery = await startNodeWorkerDiscovery(client);
+    return { supported: discovery.supported, workers: discovery.list() };
+  } finally {
+    await discovery?.dispose();
     client.dispose();
-    throw err;
   }
 }
 async function initSession(client, target) {
   const scripts = /* @__PURE__ */ new Map();
-  client.on("Debugger.scriptParsed", (raw) => {
-    const params = raw;
-    const scriptId = asString(params.scriptId);
-    const url = asString(params.url);
-    if (scriptId.length === 0) {
-      return;
-    }
-    scripts.set(scriptId, { scriptId, url });
-  });
+  registerScriptTracking(client, scripts);
   const pauseBuffer = [];
   const pauseWaitGate = { active: false };
   const debuggerState = {};
+  registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState);
+  await client.send("Runtime.enable");
+  await client.send("Debugger.enable");
+  return createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState);
+}
+function registerScriptTracking(client, scripts) {
+  client.on("Debugger.scriptParsed", (raw) => {
+    const script = toScriptInfo(raw);
+    if (script !== void 0) {
+      scripts.set(script.scriptId, script);
+    }
+  });
+}
+function registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   client.on("Debugger.paused", (raw) => {
     if (pauseWaitGate.active) {
       return;
     }
-    const params = raw;
-    const event = toPauseEvent(params, performance.now(), scripts);
+    const event = toPauseEvent(raw, performance2.now(), scripts);
     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");
+}
+function createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   return {
     client,
     target,
@@ -921,6 +1453,223 @@ var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
 var DEFAULT_CF_TIMEOUT_SEC = 180;
 var DEFAULT_EXCEPTION_TIMEOUT_SEC = 30;
 
+// src/cli/warnings.ts
+init_types();
+import process2 from "process";
+
+// src/cli/captureParser.ts
+function parseCaptureList(raw) {
+  if (raw === void 0 || raw.trim().length === 0) {
+    return [];
+  }
+  return splitCaptureExpressions(raw);
+}
+function isQuoteChar(value) {
+  return value === "'" || value === '"' || value === "`";
+}
+function consumeQuotedChar(state, char) {
+  if (state.quote === void 0) {
+    return false;
+  }
+  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 stripQuotedText(expression) {
+  const state = { quote: void 0, escaped: false };
+  let stripped = "";
+  for (const char of expression) {
+    if (consumeQuotedChar(state, char)) {
+      stripped += " ";
+      continue;
+    }
+    if (isQuoteChar(char)) {
+      state.quote = char;
+      stripped += " ";
+      continue;
+    }
+    stripped += char;
+  }
+  return stripped;
+}
+function looksLikeMutation(expression) {
+  const stripped = stripQuotedText(expression);
+  const hasUpdate = /(?:\+\+|--)/u.test(stripped);
+  const hasAssignment = /(?:\*\*=|&&=|\|\|=|\?\?=|[+\-*/%&|^]=|(?:^|[^=!<>])=(?!=|>))/u.test(stripped);
+  const hasDelete = /\bdelete\b/u.test(stripped);
+  const hasMutatingMethod = /\.\s*(?:push|pop|shift|unshift|splice|sort|reverse|fill|copyWithin|set|add|delete|clear)\s*\(/u.test(stripped);
+  const hasObjectMutation = /\bObject\s*\.\s*(?:assign|defineProperty|defineProperties)\s*\(/u.test(stripped);
+  return hasUpdate || hasAssignment || hasDelete || hasMutatingMethod || hasObjectMutation;
+}
+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 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/warnings.ts
+function warnOnCaptureMutationRisk(expressions, allowMutation) {
+  const riskyCount = expressions.filter(looksLikeMutation).length;
+  if (riskyCount === 0) {
+    return;
+  }
+  const suffix = allowMutation ? "will run without the V8 side-effect guard because --allow-mutation was passed." : "will be checked by the V8 side-effect guard and blocked unless V8 proves them safe; pass --allow-mutation to run them unrestricted.";
+  process2.stderr.write(
+    `[cf-inspector] warning: ${riskyCount.toString()} capture ${riskyCount === 1 ? "expression looks" : "expressions look"} mutation-capable and ${suffix}
+`
+  );
+}
+function enforceNativeConditionMutationPolicy(expression, allowMutation, context) {
+  if (!looksLikeMutation(expression)) {
+    return;
+  }
+  if (!allowMutation) {
+    throw new CfInspectorError(
+      "MUTATION_NOT_ALLOWED",
+      `${context} looks mutation-capable. Native breakpoint conditions cannot be protected by V8's side-effect guard; pass --allow-mutation to arm it explicitly.`
+    );
+  }
+  process2.stderr.write(
+    `[cf-inspector] warning: ${context} looks mutation-capable and will run as a native breakpoint condition; native conditions cannot be side-effect-gated.
+`
+  );
+}
+function warnOnMutationRisk(expression, context) {
+  if (!looksLikeMutation(expression)) {
+    return;
+  }
+  process2.stderr.write(
+    `[cf-inspector] warning: ${context} looks mutation-capable and will execute against the live inspectee without a side-effect guard.
+`
+  );
+}
+function warnOnUnboundBreakpoints(handles) {
+  for (const handle of handles) {
+    if (handle.resolvedLocations.length === 0) {
+      const tsHint = handle.file.endsWith(".ts") ? " Hint: Source TS breakpoints may not bind. Try inspecting loaded scripts with list-scripts and target the compiled .js file instead." : "";
+      process2.stderr.write(
+        `[cf-inspector] warning: breakpoint ${handle.file}:${handle.line.toString()} did not bind to any loaded script. Check the path or pass --remote-root. Use 'list-scripts' to inspect what V8 currently has loaded.${tsHint}
+`
+      );
+    }
+  }
+}
+function warnOnImplicitInspectorSelection(session, targetWasExplicit, workerWasExplicit) {
+  const targetCount = session.targetCount ?? 1;
+  const targetIndex = session.targetIndex ?? 0;
+  if (!targetWasExplicit && targetCount > 1) {
+    process2.stderr.write(
+      `[cf-inspector] notice: attached to inspector target ${targetIndex.toString()} of ${targetCount.toString()}; pass --target <index> to pick another.
+`
+    );
+  }
+  const workerCount = session.workerTargets?.length ?? 0;
+  if (!workerWasExplicit && workerCount > 0) {
+    process2.stderr.write(
+      `[cf-inspector] notice: attached to the main isolate; ${workerCount.toString()} Node ${workerCount === 1 ? "worker is" : "workers are"} available. Run list-targets and pass --worker <index> to inspect one.
+`
+    );
+  }
+}
+function warnOnBoundBreakpointWithoutHit(handles) {
+  const boundCount = handles.reduce((count, handle) => {
+    return count + handle.resolvedLocations.length;
+  }, 0);
+  if (boundCount === 0) {
+    return;
+  }
+  process2.stderr.write(
+    `[cf-inspector] warning: ${boundCount.toString()} breakpoint ${boundCount === 1 ? "location bound" : "locations bound"}, but no hit was observed. The code may be running in another worker isolate. Run list-targets and retry with --worker <index> for a NodeWorker sub-session or --target <index> for a raw target.
+`
+  );
+}
+function roundDurationMs(durationMs) {
+  return Math.round(durationMs * 1e3) / 1e3;
+}
+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 withPausedDuration(snapshot, pausedDurationMs) {
+  const base = {
+    reason: snapshot.reason,
+    hitBreakpoints: snapshot.hitBreakpoints,
+    capturedAt: snapshot.capturedAt,
+    pausedDurationMs,
+    captures: snapshot.captures
+  };
+  const withFrame = snapshot.topFrame === void 0 ? base : { ...base, topFrame: snapshot.topFrame };
+  const withStack = snapshot.stack === void 0 ? withFrame : { ...withFrame, stack: snapshot.stack };
+  return snapshot.exception === void 0 ? withStack : { ...withStack, exception: snapshot.exception };
+}
+function formatPauseLocation(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()}`;
+}
+
 // src/cli/target.ts
 var CF_TUNNEL_STATUS_MESSAGES = {
   starting: "Preparing the Cloud Foundry debugger...",
@@ -948,41 +1697,48 @@ function parsePositiveInt(raw, label) {
   }
   return value;
 }
-async function resolveTargetWithCurrentCfTarget(opts, options = {}) {
+function resolveTarget(opts, options = {}) {
   const port = parsePositiveInt(opts.port, "--port");
   const targetIndex = parseTargetIndex(opts.target);
+  const workerIndex = parseSelectionIndex(opts.worker, "--worker");
   if (port !== void 0) {
-    return { kind: "port", port, host: opts.host ?? "127.0.0.1", ...targetIndexOption(targetIndex) };
-  }
-  const app = optionalText(opts.app);
-  if (app === void 0) {
-    throw missingTargetError();
+    return {
+      kind: "port",
+      port,
+      host: opts.host ?? "127.0.0.1",
+      ...selectionOptions(targetIndex, workerIndex)
+    };
   }
-  const tunnelTimeoutSec = parseTunnelTimeout(opts, options);
   const region = optionalText(opts.region);
-  const apiEndpoint = optionalText(opts.apiEndpoint);
   const org = optionalText(opts.org);
   const space = optionalText(opts.space);
-  if (region !== void 0 && org !== void 0 && space !== void 0) {
-    return buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, targetIndex);
-  }
-  const current = await readCurrentTarget();
-  if (current === void 0) {
+  const app = optionalText(opts.app);
+  const missingFlags = [
+    ...region === void 0 ? ["--region"] : [],
+    ...org === void 0 ? ["--org"] : [],
+    ...space === void 0 ? ["--space"] : [],
+    ...app === void 0 ? ["--app"] : []
+  ];
+  if (region === void 0 || org === void 0 || space === void 0 || app === void 0) {
     throw new CfInspectorError(
       "MISSING_TARGET",
-      "No current CF target found. Run `cf target -o <org> -s <space>` or pass --region/--org/--space."
+      `Cloud Foundry targeting requires explicit selectors. Missing: ${missingFlags.join(", ")}. cf-inspector does not consult ambient \`cf target\` because it can silently change between runs.`
     );
   }
   return buildCfTarget(
-    region ?? currentRegion(current),
-    apiEndpoint ?? current.apiEndpoint,
-    org ?? current.org,
-    space ?? current.space,
+    region,
+    optionalText(opts.apiEndpoint),
+    org,
+    space,
     app,
-    tunnelTimeoutSec,
-    targetIndex
+    parseTunnelTimeout(opts, options),
+    targetIndex,
+    workerIndex
   );
 }
+async function resolveTargetWithCurrentCfTarget(opts, options = {}) {
+  return await Promise.resolve(resolveTarget(opts, options));
+}
 function parseTunnelTimeout(opts, options) {
   if (options.useTimeoutForTunnel === false) {
     return DEFAULT_CF_TIMEOUT_SEC;
@@ -990,19 +1746,31 @@ function parseTunnelTimeout(opts, options) {
   return parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_CF_TIMEOUT_SEC;
 }
 function parseTargetIndex(raw) {
+  return parseSelectionIndex(raw, "--target");
+}
+function parseSelectionIndex(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 --target: "${raw}" \u2014 expected a non-negative integer`);
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `Invalid ${label}: "${raw}" \u2014 expected a non-negative integer`
+    );
   }
   return value;
 }
 function targetIndexOption(targetIndex) {
   return targetIndex === void 0 ? {} : { targetIndex };
 }
-function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, targetIndex) {
+function selectionOptions(targetIndex, workerIndex) {
+  return {
+    ...targetIndexOption(targetIndex),
+    ...workerIndex === void 0 ? {} : { workerIndex }
+  };
+}
+function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, targetIndex, workerIndex) {
   return {
     kind: "cf",
     region,
@@ -1011,44 +1779,15 @@ function buildCfTarget(region, apiEndpoint, org, space, app, tunnelTimeoutSec, t
     space,
     app,
     tunnelTimeoutMs: tunnelTimeoutSec * 1e3,
-    ...targetIndexOption(targetIndex)
+    ...selectionOptions(targetIndex, workerIndex)
   };
 }
 function optionalText(value) {
   const trimmed = value?.trim();
   return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
 }
-function currentCfOptions() {
-  const command = process2.env["CF_DEBUGGER_CF_BIN"];
-  return command === void 0 ? void 0 : { command };
-}
-async function readCurrentTarget() {
-  try {
-    return await readCurrentCfTarget(currentCfOptions());
-  } catch (error) {
-    throw new CfInspectorError(
-      "MISSING_TARGET",
-      "No current CF target found. Run `cf target -o <org> -s <space>` or pass --region/--org/--space.",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-function currentRegion(current) {
-  try {
-    return requireCurrentCfRegion(current, "Pass --region explicitly.");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new CfInspectorError("MISSING_TARGET", message);
-  }
-}
-function missingTargetError() {
-  return new CfInspectorError(
-    "MISSING_TARGET",
-    "Provide either --port (and optionally --host), an --app with current cf target, or all of --region, --org, --space, --app."
-  );
-}
-async function withSession(target, fn, reportProgress) {
-  const tunnel = await openTarget(target, reportProgress);
+async function withSession(target, fn, reportProgress, signal) {
+  const tunnel = await openTarget(target, reportProgress, signal);
   let session;
   try {
     reportProgress?.(
@@ -1057,8 +1796,13 @@ async function withSession(target, fn, reportProgress) {
     session = await connectInspector({
       port: tunnel.port,
       host: tunnel.host,
-      ...targetIndexOption(target.targetIndex)
+      ...selectionOptions(target.targetIndex, target.workerIndex)
     });
+    warnOnImplicitInspectorSelection(
+      session,
+      target.targetIndex !== void 0,
+      target.workerIndex !== void 0
+    );
     reportProgress?.("Inspector session is ready.");
     return await fn(session, tunnel.port);
   } finally {
@@ -1070,7 +1814,7 @@ async function withSession(target, fn, reportProgress) {
     await tunnel.dispose();
   }
 }
-async function openTarget(target, reportProgress) {
+async function openTarget(target, reportProgress, signal) {
   if (target.kind === "port") {
     return {
       port: target.port,
@@ -1086,6 +1830,7 @@ async function openTarget(target, reportProgress) {
     space: target.space,
     app: target.app,
     tunnelReadyTimeoutMs: target.tunnelTimeoutMs,
+    ...signal === void 0 ? {} : { signal },
     ...reportProgress === void 0 ? {} : {
       onStatus: (status, message) => {
         reportProgress(message ?? formatCfTunnelStatus(status));
@@ -1133,15 +1878,31 @@ async function resume(session) {
 async function setPauseOnExceptions(session, state) {
   await session.client.send("Debugger.setPauseOnExceptions", { state });
 }
-async function evaluateOnFrame(session, callFrameId, expression) {
+async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
   return await session.client.send("Debugger.evaluateOnCallFrame", {
     callFrameId,
     expression,
     returnByValue: false,
     generatePreview: true,
-    silent: true
+    silent: true,
+    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect },
+    ...options.objectGroup === void 0 ? {} : { objectGroup: options.objectGroup }
   });
 }
+function isSideEffectRefusal(result) {
+  const classNames = [
+    result.result?.className,
+    result.exceptionDetails?.exception?.className
+  ];
+  const descriptions = [
+    result.result?.description,
+    result.exceptionDetails?.exception?.description
+  ];
+  const isEvalError = classNames.includes("EvalError");
+  return isEvalError && descriptions.some(
+    (description) => typeof description === "string" && description.toLowerCase().includes("possible side-effect in debug-evaluate")
+  );
+}
 async function evaluateGlobal(session, expression) {
   return await session.client.send("Runtime.evaluate", {
     expression,
@@ -1194,6 +1955,7 @@ async function getProperties(session, objectId) {
 
 // src/cli/commands/eval.ts
 async function handleEval(opts) {
+  warnOnMutationRisk(opts.expr, "eval --expr");
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const result = await withSession(target, async (session) => {
     return await evaluateGlobal(session, opts.expr);
@@ -1235,8 +1997,8 @@ function writeHumanEvalResult(result) {
 }
 
 // src/cli/commands/exception.ts
-import { performance as performance3 } from "perf_hooks";
-import process6 from "process";
+import { performance as performance4 } from "perf_hooks";
+import process5 from "process";
 
 // src/pathMapper.ts
 init_types();
@@ -1448,7 +2210,7 @@ async function removeBreakpoint(session, breakpointId) {
 
 // src/inspector/pause.ts
 init_types();
-import { performance as performance2 } from "perf_hooks";
+import { performance as performance3 } from "perf_hooks";
 function pauseMatches(pause, breakpointIds, pauseReasons) {
   if (pauseReasons !== void 0 && pauseReasons.length > 0) {
     return pauseReasons.includes(pause.reason);
@@ -1459,7 +2221,12 @@ function pauseMatches(pause, breakpointIds, pauseReasons) {
   return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
 }
 function remainingUntil(deadlineMs) {
-  return Math.max(0, deadlineMs - performance2.now());
+  return Math.max(0, deadlineMs - performance3.now());
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted === true) {
+    throw new CfInspectorError("ABORTED", "Aborted while waiting for Debugger.paused");
+  }
 }
 function hasResumedSincePause(session, pause) {
   const pauseAt = pause.receivedAtMs;
@@ -1479,20 +2246,23 @@ function throwUnrelatedPauseTimeout(pause, timeoutMs) {
     pauseDetail(pause)
   );
 }
-async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeoutMs) {
+async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, options) {
   if (hasResumedSincePause(session, pause)) {
     return;
   }
   const remainingMs = remainingUntil(deadlineMs);
   if (remainingMs <= 0) {
-    throwUnrelatedPauseTimeout(pause, timeoutMs);
+    throwUnrelatedPauseTimeout(pause, options.timeoutMs);
   }
   try {
-    await session.client.waitFor("Debugger.resumed", { timeoutMs: remainingMs });
-    session.debuggerState.lastResumedAtMs = performance2.now();
+    await session.client.waitFor("Debugger.resumed", {
+      timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    });
+    session.debuggerState.lastResumedAtMs = performance3.now();
   } catch (err) {
     if (err instanceof CfInspectorError && err.code === "BREAKPOINT_NOT_HIT") {
-      throwUnrelatedPauseTimeout(pause, timeoutMs);
+      throwUnrelatedPauseTimeout(pause, options.timeoutMs);
     }
     throw err;
   }
@@ -1509,13 +2279,16 @@ async function handleUnmatchedPause(session, pause, options, deadlineMs) {
     return;
   }
   options.onUnmatchedPause?.(pause);
-  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options.timeoutMs);
+  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options);
 }
 async function waitForPause(session, options) {
-  const deadlineMs = performance2.now() + options.timeoutMs;
+  throwIfAborted(options.signal);
+  const deadlineMs = performance3.now() + options.timeoutMs;
   const buffer = session.pauseBuffer;
   while (buffer.length > 0 || remainingUntil(deadlineMs) > 0) {
+    throwIfAborted(options.signal);
     while (buffer.length > 0) {
+      throwIfAborted(options.signal);
       const buffered = buffer.shift();
       if (buffered === void 0) {
         continue;
@@ -1544,20 +2317,25 @@ async function waitForLivePause(session, options, deadlineMs) {
   try {
     params = await session.client.waitFor("Debugger.paused", {
       timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal },
       predicate: () => {
-        receivedAtMs = performance2.now();
+        receivedAtMs = performance3.now();
         return true;
       }
     });
   } finally {
     session.pauseWaitGate.active = false;
   }
-  return toPauseEvent(params, receivedAtMs ?? performance2.now(), session.scripts);
+  return toPauseEvent(params, receivedAtMs ?? performance3.now(), session.scripts);
 }
 
+// src/snapshot/evaluation.ts
+init_types();
+
 // src/snapshot/values.ts
 init_types();
-var DEFAULT_MAX_VALUE_LENGTH = 4096;
+var DEFAULT_MAX_VALUE_LENGTH = 131072;
+var DEFAULT_STREAM_MAX_VALUE_LENGTH = 4096;
 function isPrimitive(value) {
   const t = typeof value;
   return t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol";
@@ -1585,9 +2363,16 @@ function resolveMaxValueLength(value) {
 }
 function limitValueLength(raw, maxValueLength = DEFAULT_MAX_VALUE_LENGTH) {
   if (raw.length <= maxValueLength) {
-    return raw;
+    return { text: raw, truncated: false };
   }
-  return `${raw.slice(0, maxValueLength)}...`;
+  return {
+    text: raw.slice(0, maxValueLength),
+    truncated: true,
+    originalLength: raw.length
+  };
+}
+function textTruncationFields(limited) {
+  return limited.truncated ? { truncated: true, originalLength: limited.originalLength } : {};
 }
 function parseQuotedString(value) {
   try {
@@ -1672,7 +2457,12 @@ function toStructuredValue(variable) {
 // 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 limited = readEvalError(result, maxValueLength);
+    return {
+      expression,
+      error: limited.text,
+      ...textTruncationFields(limited)
+    };
   }
   const inner = result.result;
   if (!inner) {
@@ -1680,8 +2470,12 @@ function evalResultToCaptured(expression, result, maxValueLength = DEFAULT_MAX_V
   }
   const type = typeof inner.type === "string" ? inner.type : void 0;
   const buildCaptured = (rendered) => {
-    const sanitized = limitValueLength(rendered, maxValueLength);
-    const base = { expression, value: sanitized };
+    const limited = limitValueLength(rendered, maxValueLength);
+    const base = {
+      expression,
+      value: limited.text,
+      ...textTruncationFields(limited)
+    };
     return type === void 0 ? base : { ...base, type };
   };
   if (type === "string" && typeof inner.value === "string") {
@@ -1698,6 +2492,18 @@ function evalResultToCaptured(expression, result, maxValueLength = DEFAULT_MAX_V
   }
   return buildCaptured("undefined");
 }
+function sideEffectRefusalToCaptured(expression) {
+  const error = new CfInspectorError(
+    "MUTATION_NOT_ALLOWED",
+    `V8 blocked the capture expression "${expression}" because it may have side effects. Pass --allow-mutation to run it explicitly.`
+  );
+  return {
+    expression,
+    error: `${error.code}: ${error.message}`,
+    mutationRisk: true,
+    blocked: true
+  };
+}
 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);
@@ -1755,56 +2561,88 @@ async function captureProperties(session, objectId, limit, depth, maxValueLength
       return await captureProperty(session, prop, depth, maxValueLength);
     })
   );
-  return variables;
+  const omittedCount = Math.max(properties.length - limited.length, 0);
+  return omittedCount === 0 ? { variables } : { variables, omittedCount };
 }
 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 capturedChildren = await capturePropertyChildren(
+    session,
+    described,
+    depth,
+    maxValueLength
+  );
+  const limited = limitValueLength(described.value, maxValueLength);
+  const base = {
+    name,
+    value: limited.text,
+    ...textTruncationFields(limited)
+  };
   const withType = described.type === void 0 ? base : { ...base, type: described.type };
-  return children === void 0 ? withType : { ...withType, children };
+  const children = capturedChildren?.variables;
+  const withChildren = children === void 0 || children.length === 0 ? withType : { ...withType, children };
+  const omittedCount = capturedChildren?.omittedCount ?? 0;
+  return omittedCount === 0 ? withChildren : { ...withChildren, truncated: true, omittedCount };
 }
 async function capturePropertyChildren(session, described, depth, maxValueLength) {
-  if (depth <= 0 || described.objectId === void 0 || !isExpandable(described.type)) {
+  if (described.objectId === void 0 || !isExpandable(described.type)) {
     return void 0;
   }
+  if (depth <= 0) {
+    return await countDepthOmissions(session, described.objectId);
+  }
   try {
-    const nested = await captureProperties(
+    return await captureProperties(
       session,
       described.objectId,
       MAX_CHILD_VARIABLES,
       depth - 1,
       maxValueLength
     );
-    return nested.length > 0 ? nested : void 0;
   } catch {
     return void 0;
   }
 }
+async function countDepthOmissions(session, objectId) {
+  try {
+    const properties = await getProperties(session, objectId);
+    return properties.length === 0 ? void 0 : { variables: [], omittedCount: properties.length };
+  } catch {
+    return void 0;
+  }
+}
+function countPropertyOmissions(captured) {
+  return (captured.omittedCount ?? 0) + captured.variables.reduce((total, variable) => {
+    const childOmissions = variable.children === void 0 ? 0 : countPropertyOmissions({ variables: variable.children });
+    return total + (variable.omittedCount ?? 0) + childOmissions;
+  }, 0);
+}
 
 // src/snapshot/exception.ts
 function asString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-async function materializeObject(session, objectId, maxValueLength) {
+async function materializeObject(session, objectId) {
   try {
-    const properties = await captureProperties(
+    const captured = await captureProperties(
       session,
       objectId,
       MAX_SCOPE_VARIABLES,
       MAX_VARIABLE_DEPTH,
-      maxValueLength
+      Number.MAX_SAFE_INTEGER
     );
-    if (properties.length === 0) {
+    if (captured.variables.length === 0) {
       return void 0;
     }
     const structured = {};
-    for (const variable of properties) {
+    for (const variable of captured.variables) {
       structured[variable.name] = toStructuredValue(variable);
     }
-    return JSON.stringify(structured);
+    return {
+      value: JSON.stringify(structured),
+      omittedCount: countPropertyOmissions(captured)
+    };
   } catch {
     return void 0;
   }
@@ -1857,18 +2695,44 @@ async function captureException(session, pause, maxValueLength) {
     return { error: "exception data has no objectId or value" };
   }
   const message = await readPropertyDescription(session, objectId, "message");
-  const rendered = await materializeObject(session, objectId, maxValueLength);
+  const rendered = await materializeObject(session, objectId);
   if (rendered !== void 0) {
-    const result = buildResult(type, description, rendered, maxValueLength);
-    return message === void 0 ? result : { ...result, description: limitValueLength(message, maxValueLength) };
+    return buildResult(
+      type,
+      message ?? description,
+      rendered.value,
+      maxValueLength,
+      rendered.omittedCount
+    );
   }
   return buildResult(type, description, description ?? "[exception]", maxValueLength);
 }
-function buildResult(type, description, value, maxValueLength) {
-  const safeValue = limitValueLength(value, maxValueLength);
-  const base = { value: safeValue };
+function buildResult(type, description, value, maxValueLength, omittedCount = 0) {
+  const limitedValue = limitValueLength(value, maxValueLength);
+  const limitedDescription = description === void 0 ? void 0 : limitValueLength(description, maxValueLength);
+  const base = {
+    value: limitedValue.text,
+    ...exceptionTruncationFields(limitedValue, limitedDescription)
+  };
   const withType = type === void 0 ? base : { ...base, type };
-  return description === void 0 ? withType : { ...withType, description: limitValueLength(description, maxValueLength) };
+  const withDescription = limitedDescription === void 0 ? withType : { ...withType, description: limitedDescription.text };
+  return omittedCount === 0 ? withDescription : { ...withDescription, truncated: true, omittedCount };
+}
+function exceptionTruncationFields(value, description) {
+  const valueLength = value.truncated ? value.originalLength : void 0;
+  const descriptionLength = description?.truncated === true ? description.originalLength : void 0;
+  const lengths = [valueLength, descriptionLength].filter(
+    (length) => length !== void 0
+  );
+  if (lengths.length === 0) {
+    return {};
+  }
+  return {
+    truncated: true,
+    originalLength: Math.max(...lengths),
+    ...valueLength === void 0 ? {} : { valueOriginalLength: valueLength },
+    ...descriptionLength === void 0 ? {} : { descriptionOriginalLength: descriptionLength }
+  };
 }
 
 // src/snapshot/objects.ts
@@ -1883,20 +2747,23 @@ function objectIdFromEvalResult(result) {
   }
   return objectId;
 }
-async function renderObjectCapture(session, objectId, maxValueLength) {
+async function renderObjectCapture(session, objectId) {
   try {
-    const properties = await captureProperties(
+    const captured = await captureProperties(
       session,
       objectId,
       MAX_SCOPE_VARIABLES,
       MAX_VARIABLE_DEPTH,
-      maxValueLength
+      Number.MAX_SAFE_INTEGER
     );
     const structured = {};
-    for (const variable of properties) {
+    for (const variable of captured.variables) {
       structured[variable.name] = toStructuredValue(variable);
     }
-    return JSON.stringify(structured);
+    return {
+      value: JSON.stringify(structured),
+      omittedCount: countPropertyOmissions(captured)
+    };
   } catch {
     return void 0;
   }
@@ -1918,16 +2785,22 @@ async function withSerializedObjectCapture(session, expression, evalResult, capt
   if (objectId === void 0) {
     return captured;
   }
-  const rendered = await renderObjectCapture(session, objectId, maxValueLength);
+  const rendered = await renderObjectCapture(session, objectId);
   if (rendered === void 0) {
     return captured;
   }
-  const normalized = normalizeRenderedObjectCapture(rendered, captured.value);
+  const normalized = normalizeRenderedObjectCapture(rendered.value, captured.value);
   if (normalized === void 0) {
     return captured;
   }
-  const value = limitValueLength(normalized, maxValueLength);
-  return captured.type === void 0 ? { expression, value } : { expression, value, type: captured.type };
+  const limited = limitValueLength(normalized, maxValueLength);
+  const base = {
+    expression,
+    value: limited.text,
+    ...textTruncationFields(limited),
+    ...captured.type === void 0 ? {} : { type: captured.type }
+  };
+  return rendered.omittedCount === 0 ? base : { ...base, truncated: true, omittedCount: rendered.omittedCount };
 }
 
 // src/snapshot/scopes.ts
@@ -1942,35 +2815,39 @@ var PRIORITY_BY_TYPE = {
   module: 6,
   script: 7
 };
-function selectScopes(scopeChain) {
+function rankedScopes(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);
+  return [...eligible].sort((a, b) => priorityOf(a.type) - priorityOf(b.type));
 }
 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(
+  const ranked = rankedScopes(frame.scopeChain);
+  const scopes = ranked.slice(0, MAX_SCOPES);
+  const capturedScopes = 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(
+        const captured = await captureProperties(
           session,
           objectId,
           MAX_SCOPE_VARIABLES,
           MAX_VARIABLE_DEPTH,
           maxValueLength
         );
-        return { type: scope.type, variables };
+        const base = { type: scope.type, variables: captured.variables };
+        return captured.omittedCount === void 0 ? base : { ...base, truncated: true, omittedCount: captured.omittedCount };
       } catch {
         return { type: scope.type, variables: [] };
       }
     })
   );
+  const omittedCount = Math.max(ranked.length - capturedScopes.length, 0);
+  return omittedCount === 0 ? { scopes: capturedScopes } : { scopes: capturedScopes, omittedCount };
 }
 
 // src/snapshot/stack.ts
@@ -1990,23 +2867,48 @@ function buildBaseFrame(frame) {
   };
   return frame.url === void 0 ? base : { ...base, url: frame.url };
 }
-async function captureFrameExpression(session, callFrameId, expression, maxValueLength) {
+async function captureFrameExpression(session, callFrameId, expression, maxValueLength, throwOnSideEffect) {
+  const mutationRisk = throwOnSideEffect === false && looksLikeMutation(expression);
   try {
-    const result = await evaluateOnFrame(session, callFrameId, expression);
+    const result = await evaluateOnFrame(session, callFrameId, expression, {
+      ...throwOnSideEffect === void 0 ? {} : { throwOnSideEffect }
+    });
+    if (isSideEffectRefusal(result)) {
+      return sideEffectRefusalToCaptured(expression);
+    }
     const captured = evalResultToCaptured(expression, result, maxValueLength);
-    return await withSerializedObjectCapture(session, expression, result, captured, maxValueLength);
+    const serialized = await withSerializedObjectCapture(
+      session,
+      expression,
+      result,
+      captured,
+      maxValueLength
+    );
+    return mutationRisk ? { ...serialized, mutationRisk: true } : serialized;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { expression, error: limitValueLength(message, maxValueLength) };
+    const limited = limitValueLength(message, maxValueLength);
+    const captured = {
+      expression,
+      error: limited.text,
+      ...textTruncationFields(limited)
+    };
+    return mutationRisk ? { ...captured, mutationRisk: true } : captured;
   }
 }
-async function captureFrameExpressions(session, frame, expressions, maxValueLength) {
+async function captureFrameExpressions(session, frame, expressions, maxValueLength, throwOnSideEffect) {
   if (expressions.length === 0) {
     return [];
   }
   return await Promise.all(
     expressions.map(
-      (expression) => captureFrameExpression(session, frame.callFrameId, expression, maxValueLength)
+      (expression) => captureFrameExpression(
+        session,
+        frame.callFrameId,
+        expression,
+        maxValueLength,
+        throwOnSideEffect
+      )
     )
   );
 }
@@ -2026,7 +2928,8 @@ async function walkStack(session, callFrames, options) {
         session,
         frame,
         options.stackCaptures,
-        options.maxValueLength
+        options.maxValueLength,
+        options.throwOnSideEffect
       );
       return { ...base, captures };
     })
@@ -2048,14 +2951,25 @@ async function captureSnapshot(session, pause, options = {}) {
       column: top.columnNumber + 1
     };
     if (options.includeScopes === true) {
-      const scopes = await captureScopes(session, top, maxValueLength);
-      topFrame = { ...topFrame, scopes };
+      const capturedScopes = await captureScopes(session, top, maxValueLength);
+      topFrame = {
+        ...topFrame,
+        scopes: capturedScopes.scopes,
+        ...capturedScopes.omittedCount === void 0 ? {} : { truncated: true, omittedCount: capturedScopes.omittedCount }
+      };
     }
-    captures = await captureExpressions(session, top.callFrameId, options.captures, maxValueLength);
+    captures = await captureExpressions(
+      session,
+      top.callFrameId,
+      options.captures,
+      maxValueLength,
+      options.throwOnSideEffect
+    );
     stack = await walkStack(session, pause.callFrames, {
       stackDepth: options.stackDepth ?? DEFAULT_STACK_DEPTH,
       stackCaptures: options.stackCaptures ?? [],
-      maxValueLength
+      maxValueLength,
+      ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect }
     });
   }
   const exception = await captureException(session, pause, maxValueLength);
@@ -2078,159 +2992,62 @@ function buildResult2(input) {
   const withStack = input.stack.length > 0 ? { ...withFrame, stack: input.stack } : withFrame;
   return input.exception === void 0 ? withStack : { ...withStack, exception: input.exception };
 }
-async function captureExpressions(session, callFrameId, captures, maxValueLength) {
+async function captureExpressions(session, callFrameId, captures, maxValueLength, throwOnSideEffect) {
   if (captures === void 0 || captures.length === 0) {
     return [];
   }
   return await Promise.all(
     captures.map(async (expression) => {
-      return await captureExpression(session, callFrameId, expression, maxValueLength);
+      return await captureExpression(
+        session,
+        callFrameId,
+        expression,
+        maxValueLength,
+        throwOnSideEffect
+      );
     })
   );
 }
-async function captureExpression(session, callFrameId, expression, maxValueLength) {
+async function captureExpression(session, callFrameId, expression, maxValueLength, throwOnSideEffect) {
+  const mutationRisk = throwOnSideEffect === false && looksLikeMutation(expression);
   try {
-    const result = await evaluateOnFrame(session, callFrameId, expression);
+    const result = await evaluateOnFrame(session, callFrameId, expression, {
+      ...throwOnSideEffect === void 0 ? {} : { throwOnSideEffect }
+    });
+    if (isSideEffectRefusal(result)) {
+      return sideEffectRefusalToCaptured(expression);
+    }
     const captured = evalResultToCaptured(expression, result, maxValueLength);
-    return await withSerializedObjectCapture(session, expression, result, captured, maxValueLength);
+    const serialized = await withSerializedObjectCapture(
+      session,
+      expression,
+      result,
+      captured,
+      maxValueLength
+    );
+    return mutationRisk ? { ...serialized, mutationRisk: true } : serialized;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { expression, error: limitValueLength(message, maxValueLength) };
+    const limited = limitValueLength(message, maxValueLength);
+    const captured = {
+      expression,
+      error: limited.text,
+      ...textTruncationFields(limited)
+    };
+    return mutationRisk ? { ...captured, mutationRisk: true } : captured;
   }
 }
 
 // src/cli/commands/exception.ts
 init_types();
-
-// src/cli/captureParser.ts
-function parseCaptureList(raw) {
-  if (raw === void 0 || raw.trim().length === 0) {
-    return [];
-  }
-  return splitCaptureExpressions(raw);
-}
-function isQuoteChar(value) {
-  return value === "'" || value === '"' || value === "`";
-}
-function consumeQuotedChar(state, char) {
-  if (state.quote === void 0) {
-    return false;
-  }
-  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 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 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/warnings.ts
-import process5 from "process";
-function warnOnUnboundBreakpoints(handles) {
-  for (const handle of handles) {
-    if (handle.resolvedLocations.length === 0) {
-      const tsHint = handle.file.endsWith(".ts") ? " Hint: Source TS breakpoints may not bind. Try inspecting loaded scripts with list-scripts and target the compiled .js file instead." : "";
-      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.${tsHint}
-`
-      );
-    }
-  }
-}
-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) {
-  const base = {
-    reason: snapshot.reason,
-    hitBreakpoints: snapshot.hitBreakpoints,
-    capturedAt: snapshot.capturedAt,
-    pausedDurationMs,
-    captures: snapshot.captures
-  };
-  const withFrame = snapshot.topFrame === void 0 ? base : { ...base, topFrame: snapshot.topFrame };
-  const withStack = snapshot.stack === void 0 ? withFrame : { ...withFrame, stack: snapshot.stack };
-  return snapshot.exception === void 0 ? withStack : { ...withStack, exception: snapshot.exception };
-}
-function formatPauseLocation(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()}`;
-}
-
-// src/cli/commands/exception.ts
 var VALID_PAUSE_TYPES = ["uncaught", "caught", "all"];
 async function handleException(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
   const prepared = prepareExceptionCommand(opts, target);
+  warnOnCaptureMutationRisk(
+    [...prepared.captures, ...prepared.stackCaptures],
+    opts.allowMutation === true
+  );
   const result = await runExceptionCommand(prepared, opts);
   if (opts.json) {
     writeJson(result);
@@ -2247,7 +3064,7 @@ function prepareExceptionCommand(opts, target) {
     );
   }
   const timeoutSec = parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_EXCEPTION_TIMEOUT_SEC;
-  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length");
+  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length") ?? DEFAULT_MAX_VALUE_LENGTH;
   const stackDepth = parsePositiveInt(opts.stackDepth, "--stack-depth");
   return {
     target,
@@ -2255,9 +3072,10 @@ function prepareExceptionCommand(opts, target) {
     captures: parseCaptureList(opts.capture),
     remoteRoot: parseRemoteRoot(opts.remoteRoot),
     timeoutMs: timeoutSec * 1e3,
-    ...maxValueLength === void 0 ? {} : { maxValueLength },
+    maxValueLength,
     ...stackDepth === void 0 ? {} : { stackDepth },
-    stackCaptures: parseCaptureList(opts.stackCaptures)
+    stackCaptures: parseCaptureList(opts.stackCaptures),
+    throwOnSideEffect: opts.allowMutation !== true
   };
 }
 async function runExceptionCommand(command, opts) {
@@ -2269,13 +3087,14 @@ async function runExceptionCommand(command, opts) {
         pauseReasons: ["exception", "promiseRejection"],
         unmatchedPausePolicy: "wait-for-resume"
       });
-      const pausedStartedAt = pause.receivedAtMs ?? performance3.now();
+      const pausedStartedAt = pause.receivedAtMs ?? performance4.now();
       const snapshot = await captureSnapshot(session, pause, {
         captures: command.captures,
         includeScopes: opts.includeScopes === true,
-        ...command.maxValueLength === void 0 ? {} : { maxValueLength: command.maxValueLength },
+        maxValueLength: command.maxValueLength,
         ...command.stackDepth === void 0 ? {} : { stackDepth: command.stackDepth },
-        stackCaptures: command.stackCaptures
+        stackCaptures: command.stackCaptures,
+        throwOnSideEffect: command.throwOnSideEffect
       });
       if (opts.keepPaused === true) {
         return withPausedDuration(snapshot, null);
@@ -2289,9 +3108,9 @@ async function runExceptionCommand(command, opts) {
 async function resumeAfterException(session, snapshot, pausedStartedAt) {
   try {
     await resume(session);
-    return withPausedDuration(snapshot, roundDurationMs(performance3.now() - pausedStartedAt));
+    return withPausedDuration(snapshot, roundDurationMs(performance4.now() - pausedStartedAt));
   } catch {
-    process6.stderr.write(
+    process5.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after exception capture; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -2305,7 +3124,7 @@ async function disablePauseOnExceptionsBestEffort(session) {
 }
 
 // src/cli/commands/listScripts.ts
-import process7 from "process";
+import process6 from "process";
 async function handleListScripts(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const filter = compileScriptUrlFilter(opts.filter);
@@ -2315,7 +3134,7 @@ async function handleListScripts(opts) {
     return;
   }
   for (const script of scripts) {
-    process7.stdout.write(`${script.scriptId}	${script.url}
+    process6.stdout.write(`${script.scriptId}	${script.url}
 `);
   }
 }
@@ -2324,19 +3143,86 @@ async function handleListTargets(opts) {
   const tunnel = await openTarget(target);
   try {
     const targets = await discoverInspectorTargets(tunnel.host, tunnel.port, 5e3);
-    const indexedTargets = targets.map((entry, index) => ({ index, ...entry }));
+    const indexedTargets = await buildListedTargets(targets);
+    const workerCount = indexedTargets.reduce((count, targetEntry) => {
+      return count + targetEntry.workers.length;
+    }, 0);
+    writeTargetCountSummary(indexedTargets.length, workerCount);
+    warnOnMissingWorkers(indexedTargets.length, workerCount, indexedTargets);
     if (opts.json) {
       writeJson(indexedTargets);
       return;
     }
-    for (const entry of indexedTargets) {
-      process7.stdout.write(`${entry.index.toString()}	${entry.type}	${entry.title}	${entry.url}
-`);
-    }
+    writeHumanTargets(indexedTargets);
   } finally {
     await tunnel.dispose();
   }
 }
+async function buildListedTargets(targets) {
+  return await Promise.all(targets.map(async (target, index) => {
+    try {
+      const workerResult = await discoverNodeWorkerTargets(target);
+      return buildListedTarget(target, index, workerResult.supported, workerResult.workers);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process6.stderr.write(
+        `[cf-inspector] warning: worker discovery failed for raw target ${index.toString()}: ${message}
+`
+      );
+      return buildListedTarget(target, index, false, []);
+    }
+  }));
+}
+function buildListedTarget(target, index, workerDiscoverySupported, workers) {
+  return {
+    index,
+    ...target,
+    likelyWorker: looksLikeWorkerTarget(target),
+    workerDiscoverySupported,
+    workers: workers.map((worker, workerIndex) => ({
+      index: workerIndex,
+      workerId: worker.workerId,
+      type: worker.type,
+      title: worker.title,
+      url: worker.url
+    }))
+  };
+}
+function looksLikeWorkerTarget(target) {
+  return `${target.type} ${target.title} ${target.url}`.toLowerCase().includes("worker");
+}
+function writeTargetCountSummary(targetCount, workerCount) {
+  process6.stderr.write(
+    `[cf-inspector] ${targetCount.toString()} raw inspector ${targetCount === 1 ? "target" : "targets"}; ${workerCount.toString()} ${workerCount === 1 ? "worker" : "workers"}.
+`
+  );
+}
+function warnOnMissingWorkers(targetCount, workerCount, targets) {
+  if (targetCount !== 1 || workerCount !== 0) {
+    return;
+  }
+  const supported = targets[0]?.workerDiscoverySupported === true;
+  const supportHint = supported ? "NodeWorker discovery is available, but no live worker attached." : "This runtime did not expose NodeWorker discovery.";
+  process6.stderr.write(
+    `[cf-inspector] warning: only the main inspector target is reachable. ${supportHint} If worker code is expected, ensure the worker is alive and rerun list-targets. A worker on a separate inspector port is not carried by a single Cloud Foundry tunnel.
+`
+  );
+}
+function writeHumanTargets(targets) {
+  for (const target of targets) {
+    const workerLabel = target.likelyWorker ? "	likely-worker" : "";
+    process6.stdout.write(
+      `${target.index.toString()}	target	${target.type}	${target.title}	${target.url}${workerLabel}
+`
+    );
+    for (const worker of target.workers) {
+      process6.stdout.write(
+        `  ${worker.index.toString()}	worker	${worker.type}	${worker.title}	${worker.url}
+`
+      );
+    }
+  }
+}
 function compileScriptUrlFilter(pattern) {
   if (pattern === void 0 || pattern.length === 0) {
     return void 0;
@@ -2407,7 +3293,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process9 from "process";
+import process8 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -2493,7 +3379,7 @@ function readArg(arg, index) {
   }
   return index === 0 ? void 0 : "";
 }
-function parseLogEvent(rawArgs, sentinel, location, timestamp) {
+function parseLogEvent(rawArgs, sentinel, location, timestamp, maxValueLength = DEFAULT_STREAM_MAX_VALUE_LENGTH) {
   if (!Array.isArray(rawArgs) || rawArgs.length < 2) {
     return void 0;
   }
@@ -2505,21 +3391,37 @@ function parseLogEvent(rawArgs, sentinel, location, timestamp) {
   const ts = new Date(typeof timestamp === "number" ? timestamp : Date.now()).toISOString();
   const at = `${location.file}:${location.line.toString()}`;
   if (payload.startsWith("!err:")) {
-    return { ts, at, error: payload.slice("!err:".length) };
+    const limited = limitValueLength(payload.slice("!err:".length), maxValueLength);
+    return {
+      ts,
+      at,
+      error: limited.text,
+      ...textTruncationFields(limited)
+    };
   }
-  return parsePayload(ts, at, payload);
+  return parsePayload(ts, at, payload, maxValueLength);
 }
-function parsePayload(ts, at, payload) {
+function parsePayload(ts, at, payload, maxValueLength) {
   try {
     const parsed = JSON.parse(payload);
     if (typeof parsed === "string") {
-      return { ts, at, value: parsed };
+      return buildValueEvent(ts, at, parsed, maxValueLength);
     }
-    return { ts, at, value: JSON.stringify(parsed) };
+    return buildValueEvent(ts, at, JSON.stringify(parsed), maxValueLength);
   } catch {
-    return { ts, at, value: payload, raw: payload };
+    return buildValueEvent(ts, at, payload, maxValueLength, true);
   }
 }
+function buildValueEvent(ts, at, value, maxValueLength, includeRaw = false) {
+  const limited = limitValueLength(value, maxValueLength);
+  return {
+    ts,
+    at,
+    value: limited.text,
+    ...includeRaw ? { raw: limited.text } : {},
+    ...textTruncationFields(limited)
+  };
+}
 
 // src/logpoint/stream.ts
 function validateMaxEvents(maxEvents) {
@@ -2549,6 +3451,9 @@ function validateHitCount2(hitCount) {
 async function streamLogpoint(session, options) {
   const maxEvents = validateMaxEvents(options.maxEvents);
   const hitCount = validateHitCount2(options.hitCount);
+  const maxValueLength = resolveMaxValueLength(
+    options.maxValueLength ?? DEFAULT_STREAM_MAX_VALUE_LENGTH
+  );
   const sentinel = generateSentinel();
   const condition = buildLogpointCondition(sentinel, options.expression, {
     ...options.condition === void 0 ? {} : { predicate: options.condition },
@@ -2561,7 +3466,7 @@ async function streamLogpoint(session, options) {
     if (maxEventsReached) {
       return;
     }
-    const event = toLogpointEvent(raw, sentinel, options.location);
+    const event = toLogpointEvent(raw, sentinel, options.location, maxValueLength);
     if (event === void 0) {
       return;
     }
@@ -2601,13 +3506,13 @@ async function streamLogpoint(session, options) {
     await removeBreakpointBestEffort(session, handle.breakpointId);
   }
 }
-function toLogpointEvent(raw, sentinel, location) {
+function toLogpointEvent(raw, sentinel, location, maxValueLength) {
   const params = raw;
   if (asString3(params.type) !== "log") {
     return void 0;
   }
   const ts = typeof params.timestamp === "number" ? params.timestamp : void 0;
-  return parseLogEvent(params.args, sentinel, location, ts);
+  return parseLogEvent(params.args, sentinel, location, ts, maxValueLength);
 }
 async function removeBreakpointBestEffort(session, breakpointId) {
   try {
@@ -2656,19 +3561,19 @@ async function waitForStop(session, options, registerMaxEventsSignal) {
 init_types();
 
 // src/cli/signals.ts
-import process8 from "process";
+import process7 from "process";
 async function withTerminationSignal(fn) {
   const abort = new AbortController();
   const onSignal = () => {
     abort.abort();
   };
-  process8.once("SIGINT", onSignal);
-  process8.once("SIGTERM", onSignal);
+  process7.once("SIGINT", onSignal);
+  process7.once("SIGTERM", onSignal);
   try {
     return await fn(abort.signal);
   } finally {
-    process8.off("SIGINT", onSignal);
-    process8.off("SIGTERM", onSignal);
+    process7.off("SIGINT", onSignal);
+    process7.off("SIGTERM", onSignal);
   }
 }
 
@@ -2680,11 +3585,16 @@ async function handleLog(opts) {
   const durationSec = parsePositiveInt(opts.duration, "--duration");
   const maxEvents = parsePositiveInt(opts.maxEvents, "--max-events");
   const hitCount = parsePositiveInt(opts.hitCount, "--hit-count");
+  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length") ?? DEFAULT_STREAM_MAX_VALUE_LENGTH;
   const expression = opts.expr.trim();
   if (expression.length === 0) {
     throw new CfInspectorError("INVALID_EXPRESSION", "--expr must not be empty");
   }
   const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
+  warnOnMutationRisk(expression, "log --expr");
+  if (condition !== void 0) {
+    warnOnMutationRisk(condition, "log --condition");
+  }
   await withTerminationSignal(async (signal) => {
     await withSession(target, async (session) => {
       await validateExpression(session, expression);
@@ -2699,6 +3609,7 @@ async function handleLog(opts) {
         ...maxEvents === void 0 ? {} : { maxEvents },
         ...hitCount === void 0 ? {} : { hitCount },
         ...condition === void 0 ? {} : { condition },
+        maxValueLength,
         signal,
         onEvent: (event) => {
           writeLogEvent(event, opts.json);
@@ -2707,29 +3618,39 @@ async function handleLog(opts) {
           warnOnUnboundBreakpoints([handle]);
         }
       });
+      if (result.emitted === 0 && (result.stoppedReason === "duration" || result.stoppedReason === "signal")) {
+        warnOnBoundBreakpointWithoutHit([result.handle]);
+      }
       writeLogSummary(result.stoppedReason, result.emitted, opts.json);
-    });
+    }, void 0, signal);
   });
 }
 function writeLogSummary(stoppedReason, emitted, json) {
   if (json) {
-    process9.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+    process8.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process9.stderr.write(
+  process8.stderr.write(
     `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
 `
   );
 }
 
 // src/cli/commands/snapshot.ts
-import { performance as performance4 } from "perf_hooks";
-import process10 from "process";
+import { performance as performance5 } from "perf_hooks";
+import process9 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
   const prepared = prepareSnapshotCommand(opts, target);
+  warnOnCaptureMutationRisk(
+    [...prepared.captures, ...prepared.stackCaptures],
+    opts.allowMutation === true
+  );
+  for (const expression of prepared.setupEvals) {
+    warnOnMutationRisk(expression, "snapshot --setup-eval");
+  }
   const reportProgress = opts.quiet === true ? void 0 : writeProgress;
   const result = await runSnapshotCommand(prepared, opts, reportProgress);
   if (opts.json) {
@@ -2747,11 +3668,16 @@ function prepareSnapshotCommand(opts, target) {
     );
   }
   const timeoutSec = parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_BREAKPOINT_TIMEOUT_SEC;
-  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length");
+  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length") ?? DEFAULT_MAX_VALUE_LENGTH;
   const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
   const hitCount = parsePositiveInt(opts.hitCount, "--hit-count");
   const stackDepth = parsePositiveInt(opts.stackDepth, "--stack-depth");
   const setupEvals = parseSetupEvals(opts.setupEval);
+  enforceNativeConditionMutationPolicy(
+    condition ?? "",
+    opts.allowMutation === true,
+    "snapshot --condition"
+  );
   return {
     target,
     setupEvals,
@@ -2760,10 +3686,11 @@ function prepareSnapshotCommand(opts, target) {
     remoteRoot: parseRemoteRoot(opts.remoteRoot),
     timeoutMs: timeoutSec * 1e3,
     ...condition === void 0 ? {} : { condition },
-    ...maxValueLength === void 0 ? {} : { maxValueLength },
+    maxValueLength,
     ...hitCount === void 0 ? {} : { hitCount },
     ...stackDepth === void 0 ? {} : { stackDepth },
-    stackCaptures: parseCaptureList(opts.stackCaptures)
+    stackCaptures: parseCaptureList(opts.stackCaptures),
+    throwOnSideEffect: opts.allowMutation !== true
   };
 }
 async function runSnapshotCommand(command, opts, reportProgress) {
@@ -2804,13 +3731,14 @@ async function runSnapshotOnSession(session, command, opts, reportProgress) {
   reportProgress?.(
     `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
   );
-  const pausedStartedAt = pause.receivedAtMs ?? performance4.now();
+  const pausedStartedAt = pause.receivedAtMs ?? performance5.now();
   const snapshot = await captureSnapshot(session, pause, {
     captures: command.captures,
     includeScopes: opts.includeScopes === true,
-    ...command.maxValueLength === void 0 ? {} : { maxValueLength: command.maxValueLength },
+    maxValueLength: command.maxValueLength,
     ...command.stackDepth === void 0 ? {} : { stackDepth: command.stackDepth },
-    stackCaptures: command.stackCaptures
+    stackCaptures: command.stackCaptures,
+    throwOnSideEffect: command.throwOnSideEffect
   });
   if (opts.keepPaused === true) {
     reportProgress?.("Snapshot captured; leaving the target paused as requested.");
@@ -2834,26 +3762,33 @@ async function setCommandBreakpoints(session, command) {
 }
 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;
+  try {
+    return await waitForPause(session, {
+      timeoutMs,
+      breakpointIds: handles.map((h) => h.breakpointId),
+      unmatchedPausePolicy: opts.failOnUnmatchedPause === true ? "fail" : "wait-for-resume",
+      onUnmatchedPause: (unmatchedPause) => {
+        if (warnedUnmatchedPause || opts.failOnUnmatchedPause === true) {
+          return;
+        }
+        warnedUnmatchedPause = true;
+        warnOnUnmatchedPause(unmatchedPause);
       }
-      warnedUnmatchedPause = true;
-      warnOnUnmatchedPause(unmatchedPause);
+    });
+  } catch (error) {
+    if (error instanceof CfInspectorError && (error.code === "BREAKPOINT_NOT_HIT" || error.code === "UNRELATED_PAUSE_TIMEOUT")) {
+      warnOnBoundBreakpointWithoutHit(handles);
     }
-  });
+    throw error;
+  }
 }
 async function resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress) {
   try {
     await resume(session);
     reportProgress?.("Target resumed.");
-    return withPausedDuration(snapshot, roundDurationMs(performance4.now() - pausedStartedAt));
+    return withPausedDuration(snapshot, roundDurationMs(performance5.now() - pausedStartedAt));
   } catch {
-    process10.stderr.write(
+    process9.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -2865,12 +3800,19 @@ function parseSetupEvals(raw) {
 }
 
 // src/cli/commands/watch.ts
-import { performance as performance5 } from "perf_hooks";
-import process11 from "process";
+import { performance as performance6 } from "perf_hooks";
+import process10 from "process";
 init_types();
 async function handleWatch(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
   const prepared = prepareWatchCommand(opts, target);
+  warnOnCaptureMutationRisk(
+    [...prepared.captures, ...prepared.stackCaptures],
+    opts.allowMutation === true
+  );
+  for (const expression of prepared.setupEvals) {
+    warnOnMutationRisk(expression, "watch --setup-eval");
+  }
   let stoppedReason = "signal";
   let emitted = 0;
   await withTerminationSignal(async (signal) => {
@@ -2878,7 +3820,7 @@ async function handleWatch(opts) {
       const result = await runWatchLoop(session, prepared, opts, signal);
       stoppedReason = result.stoppedReason;
       emitted = result.emitted;
-    });
+    }, void 0, signal);
   });
   writeWatchSummary(stoppedReason, emitted, opts.json);
 }
@@ -2892,11 +3834,16 @@ function prepareWatchCommand(opts, target) {
   const perHitTimeoutSec = parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_BREAKPOINT_TIMEOUT_SEC;
   const durationSec = parsePositiveInt(opts.duration, "--duration");
   const maxEvents = parsePositiveInt(opts.maxEvents, "--max-events");
-  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length");
+  const maxValueLength = parsePositiveInt(opts.maxValueLength, "--max-value-length") ?? DEFAULT_STREAM_MAX_VALUE_LENGTH;
   const hitCount = parsePositiveInt(opts.hitCount, "--hit-count");
   const stackDepth = parsePositiveInt(opts.stackDepth, "--stack-depth");
   const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
   const setupEvals = parseSetupEvals2(opts.setupEval);
+  enforceNativeConditionMutationPolicy(
+    condition ?? "",
+    opts.allowMutation === true,
+    "watch --condition"
+  );
   return {
     target,
     setupEvals,
@@ -2906,11 +3853,12 @@ function prepareWatchCommand(opts, target) {
     perHitTimeoutMs: perHitTimeoutSec * 1e3,
     ...durationSec === void 0 ? {} : { durationMs: durationSec * 1e3 },
     ...maxEvents === void 0 ? {} : { maxEvents },
-    ...maxValueLength === void 0 ? {} : { maxValueLength },
+    maxValueLength,
     ...condition === void 0 ? {} : { condition },
     ...hitCount === void 0 ? {} : { hitCount },
     ...stackDepth === void 0 ? {} : { stackDepth },
-    stackCaptures: parseCaptureList(opts.stackCaptures)
+    stackCaptures: parseCaptureList(opts.stackCaptures),
+    throwOnSideEffect: opts.allowMutation !== true
   };
 }
 async function runWatchLoop(session, command, opts, signal) {
@@ -2964,7 +3912,7 @@ async function runWatchLoop(session, command, opts, signal) {
         break;
       }
       if (pause === "timeout") {
-        if (deadline !== void 0 && performance5.now() >= deadline) {
+        if (deadline !== void 0 && performance6.now() >= deadline) {
           setStop("duration");
           break;
         }
@@ -2976,7 +3924,7 @@ async function runWatchLoop(session, command, opts, signal) {
       try {
         await resume(session);
       } catch {
-        process11.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
+        process10.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
         setStop("transport-closed");
         break;
       }
@@ -2988,19 +3936,22 @@ async function runWatchLoop(session, command, opts, signal) {
   } finally {
     transportClosed.cancel();
   }
+  if (emitted === 0 && (state.reason === "duration" || state.reason === "signal")) {
+    warnOnBoundBreakpointWithoutHit(handles);
+  }
   return { emitted, stoppedReason: state.reason };
 }
 function computeDeadline(durationMs) {
   if (durationMs === void 0) {
     return void 0;
   }
-  return performance5.now() + durationMs;
+  return performance6.now() + durationMs;
 }
 function remainingForLoop(deadline, perHitTimeoutMs) {
   if (deadline === void 0) {
     return perHitTimeoutMs;
   }
-  const remaining = deadline - performance5.now();
+  const remaining = deadline - performance6.now();
   if (remaining <= 0) {
     return 0;
   }
@@ -3034,10 +3985,14 @@ async function waitForNextWatchPause(session, handles, timeoutMs, signal) {
     return await waitForPause(session, {
       timeoutMs,
       breakpointIds: handles.map((h) => h.breakpointId),
-      unmatchedPausePolicy: "wait-for-resume"
+      unmatchedPausePolicy: "wait-for-resume",
+      signal
     });
   } catch (err) {
     if (err instanceof CfInspectorError) {
+      if (err.code === "ABORTED") {
+        return "signal";
+      }
       if (err.code === "BREAKPOINT_NOT_HIT") {
         return "timeout";
       }
@@ -3052,9 +4007,10 @@ async function captureWatchEvent(session, command, pause, hit, opts) {
   const snapshot = await captureSnapshot(session, pause, {
     captures: command.captures,
     includeScopes: opts.includeScopes === true,
-    ...command.maxValueLength === void 0 ? {} : { maxValueLength: command.maxValueLength },
+    maxValueLength: command.maxValueLength,
     ...command.stackDepth === void 0 ? {} : { stackDepth: command.stackDepth },
-    stackCaptures: command.stackCaptures
+    stackCaptures: command.stackCaptures,
+    throwOnSideEffect: command.throwOnSideEffect
   });
   const at = formatLocation(command, snapshot.topFrame);
   const base = {
@@ -3081,11 +4037,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process11.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process10.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process11.stderr.write(
+  process10.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -3097,8 +4053,16 @@ function parseSetupEvals2(raw) {
 
 // src/cli/program.ts
 function applyTargetOptions(cmd, options = {}) {
-  const withBaseOptions = 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 (default: current cf target)").option("--api-endpoint <url>", "CF API endpoint override for --region").option("--org <name>", "CF org name (default: current cf target)").option("--space <name>", "CF space name (default: current cf target)").option("--app <name>", "CF app name when not using --port").option("--target <index>", "Inspector target index from /json/list (default: 0)");
-  return options.includeTimeout === false ? withBaseOptions : withBaseOptions.option("--timeout <seconds>", "Timeout for CF tunnel readiness in seconds (default: 180)");
+  const withEndpointOptions = 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 (required with --app)").option("--api-endpoint <url>", "CF API endpoint override for --region").option("--org <name>", "CF org name (required with --app)").option("--space <name>", "CF space name (required with --app)").option(
+    "--app <name>",
+    "CF app name; requires explicit --region/--org/--space (ambient cf target is ignored)"
+  );
+  const withTargetOption = options.includeTarget === false ? withEndpointOptions : withEndpointOptions.option(
+    "--target <index>",
+    "Inspector target index from /json/list (default: 0)"
+  );
+  const withWorkerOption = options.includeWorker === false ? withTargetOption : withTargetOption.option("--worker <index>", "NodeWorker sub-session index listed by list-targets");
+  return options.includeTimeout === false ? withWorkerOption : withWorkerOption.option("--timeout <seconds>", "Timeout for CF tunnel readiness in seconds (default: 180)");
 }
 var collectStrings = (value, prev = []) => [
   ...prev,
@@ -3139,14 +4103,14 @@ function registerSnapshot(program) {
   applyTargetOptions(
     program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture expressions, and resume"),
     { includeTimeout: false }
-  ).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("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).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("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--quiet", "Suppress progress messages on stderr").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("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).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: 131072)").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("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--quiet", "Suppress progress messages on stderr").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("--max-events <n>", "Stop streaming after emitting N log events").option("--hit-count <n>", "Start logging once the line has been hit N or more times").option("--condition <expr>", "Only log when this JS expression evaluates truthy on the inspectee").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
+  ).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("--max-events <n>", "Stop streaming after emitting N log events").option("--hit-count <n>", "Start logging once the line has been hit N or more times").option("--condition <expr>", "Only log when this JS expression evaluates truthy on the inspectee").option("--max-value-length <chars>", "Maximum characters per log value before truncation (default: 4096)").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
     await handleLog(opts);
   });
 }
@@ -3154,7 +4118,7 @@ function registerWatch(program) {
   applyTargetOptions(
     program.command("watch").description("Stream a snapshot per breakpoint hit (multi-shot watch); resume between hits"),
     { includeTimeout: false }
-  ).option("--bp <file:line>", "Breakpoint location (repeatable), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate per hit").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--condition <expr>", "Only emit hits where this JS expression evaluates truthy").option("--hit-count <n>", "Start emitting after the line has been hit N or more times").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("--max-events <n>", "Stop streaming after emitting N watch events").option("--timeout <seconds>", "How long to wait for the next hit before giving up (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--stack-depth <n>", "Walk this many call frames per hit (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame").option("--include-scopes", "Include expanded paused-frame scopes per hit").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
+  ).option("--bp <file:line>", "Breakpoint location (repeatable), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate per hit").option("--setup-eval <expr>", "Evaluate a global setup expression before breakpoint setup (repeatable)", collectStrings, []).option("--condition <expr>", "Only emit hits where this JS expression evaluates truthy").option("--hit-count <n>", "Start emitting after the line has been hit N or more times").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("--max-events <n>", "Stop streaming after emitting N watch events").option("--timeout <seconds>", "How long to wait for the next hit before giving up (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--stack-depth <n>", "Walk this many call frames per hit (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame").option("--allow-mutation", "Allow mutation-capable captures and native breakpoint conditions to run").option("--include-scopes", "Include expanded paused-frame scopes per hit").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
     await handleWatch(opts);
   });
 }
@@ -3162,7 +4126,7 @@ function registerException(program) {
   applyTargetOptions(
     program.command("exception").description("Pause on a thrown exception, capture the value and frame, then resume"),
     { includeTimeout: false }
-  ).option("--type <state>", "Pause type: uncaught (default), caught, or all").option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--timeout <seconds>", "How long to wait for an exception (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--no-json", "Print a human-readable summary instead of JSON").action(async (opts) => {
+  ).option("--type <state>", "Pause type: uncaught (default), caught, or all").option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--timeout <seconds>", "How long to wait for an exception (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 131072)").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--allow-mutation", "Allow mutation-capable capture expressions to run").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--no-json", "Print a human-readable summary instead of JSON").action(async (opts) => {
     await handleException(opts);
   });
 }
@@ -3182,14 +4146,21 @@ function registerListScripts(program) {
 }
 function registerListTargets(program) {
   applyTargetOptions(
-    program.command("list-targets").description("Print inspector targets from /json/list for selecting workers with --target")
-  ).option("--no-json", "Print index<TAB>type<TAB>title<TAB>url instead of JSON").action(async (opts) => {
+    program.command("list-targets").description(
+      "List raw /json/list targets and nested workers; use --target or --worker on other commands"
+    ),
+    { includeTarget: false, includeWorker: false }
+  ).option(
+    "--no-json",
+    "Print tab-separated target/worker rows: index, kind, type, title, and URL"
+  ).action(async (opts) => {
     await handleListTargets(opts);
   });
 }
 function registerAttach(program) {
   applyTargetOptions(
-    program.command("attach").description("Connect, fetch the inspector version, and disconnect (smoke-test)")
+    program.command("attach").description("Connect, fetch the inspector version, and disconnect (smoke-test)"),
+    { includeTarget: false, includeWorker: false }
   ).option("--no-json", "Print a multi-line summary instead of JSON").action(async (opts) => {
     await handleAttach(opts);
   });
@@ -3198,20 +4169,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process12.argv);
+  await main(process11.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process12.stderr.write(`Error [${err.code}]: ${err.message}
+    process11.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process12.stderr.write(`  detail: ${err.detail}
+      process11.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process12.exit(1);
+    process11.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process12.stderr.write(`Error: ${message}
+  process11.stderr.write(`Error: ${message}
 `);
-  process12.exit(1);
+  process11.exit(1);
 }
 //# sourceMappingURL=cli.js.map