@saptools/cf-inspector 0.4.11 → 0.5.0

package/dist/cli.js

@@ -152,9 +152,12 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process12 from "process";
+import process11 from "process";
 
 // src/cli/program.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { Command } from "commander";
 
 // src/cli/commands/attach.ts
@@ -163,42 +166,93 @@ 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 : new CfInspectorError(
-          "INSPECTOR_DISCOVERY_FAILED",
-          `Inspector discovery at ${url} failed: ${err.message}`
-        )
-      );
-    });
-    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;
+}
+function isConnectionRefusedOrUnreachable(code) {
+  return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ETIMEDOUT" || code === "EHOSTUNREACH" || code === "ENETUNREACH";
+}
+function formatEndpoint(url, err) {
+  if (typeof err.address === "string" && typeof err.port === "number") {
+    return `${err.address}:${err.port.toString()}`;
+  }
+  const parsed = new URL(url);
+  return parsed.host;
+}
+function formatDiscoveryRequestError(url, err) {
+  const detail = err instanceof Error ? err.message : String(err);
+  if (!isNodeSystemError(err) || !isConnectionRefusedOrUnreachable(err.code)) {
+    return new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Inspector discovery at ${url} failed: ${detail}`
+    );
+  }
+  const endpoint = formatEndpoint(url, err);
+  return new CfInspectorError(
+    "INSPECTOR_DISCOVERY_FAILED",
+    `Cannot reach Node inspector discovery at ${url}. Nothing is listening on ${endpoint}, or the inspector tunnel is stale/closed. Restart the local inspector or tunnel and retry. If this port came from cf-debugger, stop the stale session and start a fresh tunnel, or run cf-inspector with --app/--region/--org/--space so it can open a tunnel.`,
+    detail
+  );
 }
 function parseJsonResponse(chunks) {
   const text = Buffer.concat(chunks).toString("utf8");
@@ -206,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);
@@ -306,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) {
@@ -324,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)}`);
     }
   }
 }
@@ -341,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)}`);
     }
   }
 }
@@ -350,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) {
@@ -360,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) {
@@ -376,23 +436,53 @@ 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";
@@ -459,7 +549,7 @@ function extractExistingTunnelPort(message) {
 }
 
 // src/inspector/session.ts
-import { performance } from "perf_hooks";
+import { performance as performance2 } from "perf_hooks";
 
 // src/cdp/client.ts
 init_types();
@@ -701,6 +791,102 @@ 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();
@@ -817,6 +1003,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;
@@ -833,13 +1114,81 @@ async function connectInspector(options) {
     url: target.webSocketDebuggerUrl,
     connectTimeoutMs
   });
+  let workerDiscovery;
   try {
-    return await initSession(client, target);
+    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 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 {
+    discovery = await startNodeWorkerDiscovery(client);
+    return { supported: discovery.supported, workers: discovery.list() };
+  } finally {
+    await discovery?.dispose();
+    client.dispose();
+  }
+}
 async function initSession(client, target) {
   const scripts = /* @__PURE__ */ new Map();
   client.on("Debugger.scriptParsed", (raw) => {
@@ -859,14 +1208,14 @@ async function initSession(client, target) {
       return;
     }
     const params = raw;
-    const event = toPauseEvent(params, performance.now(), scripts);
+    const event = toPauseEvent(params, 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");
@@ -895,6 +1244,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...",
@@ -922,41 +1488,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;
@@ -964,19 +1537,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,
@@ -985,42 +1570,13 @@ 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);
   let session;
@@ -1031,8 +1587,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 {
@@ -1107,15 +1668,30 @@ 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 }
   });
 }
+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,
@@ -1168,6 +1744,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);
@@ -1209,8 +1786,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();
@@ -1422,7 +1999,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);
@@ -1433,7 +2010,7 @@ 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 hasResumedSincePause(session, pause) {
   const pauseAt = pause.receivedAtMs;
@@ -1463,7 +2040,7 @@ async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeout
   }
   try {
     await session.client.waitFor("Debugger.resumed", { timeoutMs: remainingMs });
-    session.debuggerState.lastResumedAtMs = performance2.now();
+    session.debuggerState.lastResumedAtMs = performance3.now();
   } catch (err) {
     if (err instanceof CfInspectorError && err.code === "BREAKPOINT_NOT_HIT") {
       throwUnrelatedPauseTimeout(pause, timeoutMs);
@@ -1486,7 +2063,7 @@ async function handleUnmatchedPause(session, pause, options, deadlineMs) {
   await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options.timeoutMs);
 }
 async function waitForPause(session, options) {
-  const deadlineMs = performance2.now() + options.timeoutMs;
+  const deadlineMs = performance3.now() + options.timeoutMs;
   const buffer = session.pauseBuffer;
   while (buffer.length > 0 || remainingUntil(deadlineMs) > 0) {
     while (buffer.length > 0) {
@@ -1519,19 +2096,23 @@ async function waitForLivePause(session, options, deadlineMs) {
     params = await session.client.waitFor("Debugger.paused", {
       timeoutMs: remainingMs,
       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";
@@ -1559,9 +2140,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 {
@@ -1646,7 +2234,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) {
@@ -1654,8 +2247,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") {
@@ -1672,6 +2269,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);
@@ -1729,56 +2338,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;
   }
@@ -1831,18 +2472,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
@@ -1857,20 +2524,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;
   }
@@ -1892,16 +2562,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
@@ -1916,35 +2592,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
@@ -1964,23 +2644,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
+      )
     )
   );
 }
@@ -2000,7 +2705,8 @@ async function walkStack(session, callFrames, options) {
         session,
         frame,
         options.stackCaptures,
-        options.maxValueLength
+        options.maxValueLength,
+        options.throwOnSideEffect
       );
       return { ...base, captures };
     })
@@ -2022,14 +2728,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);
@@ -2052,159 +2769,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);
@@ -2221,7 +2841,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,
@@ -2229,9 +2849,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) {
@@ -2243,13 +2864,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);
@@ -2263,9 +2885,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);
@@ -2279,7 +2901,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);
@@ -2289,7 +2911,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}
 `);
   }
 }
@@ -2298,19 +2920,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;
@@ -2381,7 +3070,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process9 from "process";
+import process8 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -2467,7 +3156,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;
   }
@@ -2479,21 +3168,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) {
@@ -2523,6 +3228,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 },
@@ -2535,7 +3243,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;
     }
@@ -2575,13 +3283,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 {
@@ -2630,19 +3338,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);
   }
 }
 
@@ -2654,11 +3362,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);
@@ -2673,6 +3386,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);
@@ -2681,29 +3395,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);
     });
   });
 }
 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) {
@@ -2721,11 +3445,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,
@@ -2734,62 +3463,67 @@ 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) {
   return await withSession(command.target, async (session) => {
-    if (command.setupEvals.length > 0) {
-      const setupCount = command.setupEvals.length;
-      reportProgress?.(`Running ${setupCount.toString()} setup ${setupCount === 1 ? "evaluation" : "evaluations"}...`);
-      await runSetupEvals(session, command.setupEvals);
-      reportProgress?.("Setup evaluation complete.");
-    }
-    if (command.condition !== void 0) {
-      reportProgress?.("Validating the breakpoint condition...");
-      await validateExpression(session, command.condition);
-      reportProgress?.("Breakpoint condition is valid.");
-    }
-    const breakpointCount = command.breakpoints.length;
-    reportProgress?.(
-      `Setting ${breakpointCount.toString()} ${breakpointCount === 1 ? "breakpoint" : "breakpoints"}...`
-    );
-    const handles = await setCommandBreakpoints(session, command);
-    const resolvedCount = handles.reduce(
-      (total, handle) => total + handle.resolvedLocations.length,
-      0
-    );
-    reportProgress?.(
-      `Breakpoint setup complete: ${resolvedCount.toString()} resolved ${resolvedCount === 1 ? "location" : "locations"}.`
-    );
-    warnOnUnboundBreakpoints(handles);
-    reportProgress?.(
-      `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
-    );
-    const pause = await waitForCommandPause(session, opts, handles, command.timeoutMs);
-    const captureCount = command.captures.length;
-    reportProgress?.(
-      `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
-    );
-    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 },
-      ...command.stackDepth === void 0 ? {} : { stackDepth: command.stackDepth },
-      stackCaptures: command.stackCaptures
-    });
-    if (opts.keepPaused === true) {
-      reportProgress?.("Snapshot captured; leaving the target paused as requested.");
-      return withPausedDuration(snapshot, null);
-    }
-    reportProgress?.("Snapshot captured; resuming the target...");
-    return await resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress);
+    return await runSnapshotOnSession(session, command, opts, reportProgress);
   }, reportProgress);
 }
+async function runSnapshotOnSession(session, command, opts, reportProgress) {
+  if (command.setupEvals.length > 0) {
+    const setupCount = command.setupEvals.length;
+    reportProgress?.(`Running ${setupCount.toString()} setup ${setupCount === 1 ? "evaluation" : "evaluations"}...`);
+    await runSetupEvals(session, command.setupEvals);
+    reportProgress?.("Setup evaluation complete.");
+  }
+  if (command.condition !== void 0) {
+    reportProgress?.("Validating the breakpoint condition...");
+    await validateExpression(session, command.condition);
+    reportProgress?.("Breakpoint condition is valid.");
+  }
+  const breakpointCount = command.breakpoints.length;
+  reportProgress?.(
+    `Setting ${breakpointCount.toString()} ${breakpointCount === 1 ? "breakpoint" : "breakpoints"}...`
+  );
+  const handles = await setCommandBreakpoints(session, command);
+  const resolvedCount = handles.reduce(
+    (total, handle) => total + handle.resolvedLocations.length,
+    0
+  );
+  reportProgress?.(
+    `Breakpoint setup complete: ${resolvedCount.toString()} resolved ${resolvedCount === 1 ? "location" : "locations"}.`
+  );
+  warnOnUnboundBreakpoints(handles);
+  reportProgress?.(
+    `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
+  );
+  const pause = await waitForCommandPause(session, opts, handles, command.timeoutMs);
+  const captureCount = command.captures.length;
+  reportProgress?.(
+    `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
+  );
+  const pausedStartedAt = pause.receivedAtMs ?? performance5.now();
+  const snapshot = await captureSnapshot(session, pause, {
+    captures: command.captures,
+    includeScopes: opts.includeScopes === true,
+    maxValueLength: command.maxValueLength,
+    ...command.stackDepth === void 0 ? {} : { stackDepth: command.stackDepth },
+    stackCaptures: command.stackCaptures,
+    throwOnSideEffect: command.throwOnSideEffect
+  });
+  if (opts.keepPaused === true) {
+    reportProgress?.("Snapshot captured; leaving the target paused as requested.");
+    return withPausedDuration(snapshot, null);
+  }
+  reportProgress?.("Snapshot captured; resuming the target...");
+  return await resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress);
+}
 async function setCommandBreakpoints(session, command) {
   return await Promise.all(
     command.breakpoints.map(
@@ -2805,26 +3539,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);
@@ -2836,12 +3577,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) => {
@@ -2863,11 +3611,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,
@@ -2877,11 +3630,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) {
@@ -2935,7 +3689,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;
         }
@@ -2947,7 +3701,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;
       }
@@ -2959,19 +3713,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;
   }
@@ -3023,9 +3780,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 = {
@@ -3052,11 +3810,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"}.
 `
   );
@@ -3068,16 +3826,42 @@ 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,
   value
 ];
+function readPackageVersion() {
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 4; depth += 1) {
+    const candidate = join(current, "package.json");
+    try {
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (typeof parsed === "object" && parsed !== null) {
+        const record = parsed;
+        if (record["name"] === "@saptools/cf-inspector" && typeof record["version"] === "string") {
+          return record["version"];
+        }
+      }
+    } catch {
+    }
+    current = dirname(current);
+  }
+  throw new Error("Unable to read @saptools/cf-inspector package version");
+}
 async function main(argv) {
   const program = new Command();
-  program.name("cf-inspector").description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
+  program.name("cf-inspector").version(readPackageVersion()).description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
   registerSnapshot(program);
   registerLog(program);
   registerWatch(program);
@@ -3092,14 +3876,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);
   });
 }
@@ -3107,7 +3891,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);
   });
 }
@@ -3115,7 +3899,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);
   });
 }
@@ -3135,14 +3919,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);
   });
@@ -3151,20 +3942,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