@saptools/cf-inspector 0.4.12 → 0.6.0

package/dist/index.js

@@ -289,96 +289,290 @@ function buildBreakpointUrlRegex(input) {
 init_types();
 
 // src/inspector/conversions.ts
+var INTERNAL_SLOT_SUBTYPES = /* @__PURE__ */ new Set([
+  "regexp",
+  "date",
+  "map",
+  "set",
+  "weakmap",
+  "weakset",
+  "iterator",
+  "generator",
+  "promise",
+  "typedarray",
+  "arraybuffer",
+  "dataview",
+  "webassemblymemory",
+  "wasmvalue",
+  "trustedtype"
+]);
 function asString(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
 function asNumber(value, fallback = 0) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function nonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalCoordinate(value) {
+  const number = optionalNumber(value);
+  return number !== void 0 && Number.isSafeInteger(number) && number >= 0 ? number : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function toScriptLocation(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  const lineNumber = optionalCoordinate(value["lineNumber"]);
+  if (scriptId === void 0 || lineNumber === void 0) {
+    return void 0;
+  }
+  const rawColumnNumber = value["columnNumber"];
+  const columnNumber = optionalCoordinate(rawColumnNumber);
+  if (rawColumnNumber !== void 0 && columnNumber === void 0) {
+    return void 0;
+  }
+  return columnNumber === void 0 ? { scriptId, lineNumber } : { scriptId, lineNumber, columnNumber };
+}
 function toResolvedLocations(value) {
   if (!Array.isArray(value)) {
     return [];
   }
   return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const scriptId = asString(candidate.scriptId);
-    if (scriptId.length === 0) {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
       return [];
     }
-    const url = typeof candidate.url === "string" ? candidate.url : void 0;
-    const lineNumber = asNumber(candidate.lineNumber);
-    const result = url === void 0 ? { scriptId, lineNumber, columnNumber: asNumber(candidate.columnNumber) } : { scriptId, url, lineNumber, columnNumber: asNumber(candidate.columnNumber) };
-    return [result];
+    const url = typeof entry["url"] === "string" ? entry["url"] : void 0;
+    return [url === void 0 ? location : { ...location, url }];
   });
 }
-function toScopeChain(value) {
+function toBreakLocations(value) {
   if (!Array.isArray(value)) {
     return [];
   }
   return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const type = asString(candidate.type);
-    if (type.length === 0) {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
       return [];
     }
-    const objectId = typeof candidate.object?.objectId === "string" ? candidate.object.objectId : void 0;
-    const name = typeof candidate.name === "string" ? candidate.name : void 0;
-    const base = name === void 0 ? { type } : { type, name };
-    return [objectId === void 0 ? base : { ...base, objectId }];
+    const type = nonEmptyString(entry["type"]);
+    return [type === void 0 ? location : { ...location, type }];
   });
 }
+function remoteCompleteness(subtype) {
+  if (subtype === "proxy") {
+    return "unavailable";
+  }
+  return subtype !== void 0 && INTERNAL_SLOT_SUBTYPES.has(subtype) ? "truncated" : void 0;
+}
+function optionalOwnField(key, value) {
+  return Object.hasOwn(value, key) ? { [key]: value[key] } : {};
+}
+function toRemoteObject(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const type = nonEmptyString(value["type"]);
+  if (type === void 0) {
+    return void 0;
+  }
+  const subtype = nonEmptyString(value["subtype"]);
+  const completeness = remoteCompleteness(subtype);
+  return {
+    type,
+    ...subtype === void 0 ? {} : { subtype },
+    ...optionalTextField("className", value["className"]),
+    ...completeness === void 0 ? {} : { completeness },
+    ...optionalOwnField("value", value),
+    ...optionalTextField("unserializableValue", value["unserializableValue"]),
+    ...optionalTextField("description", value["description"]),
+    ...optionalOwnField("deepSerializedValue", value),
+    ...optionalTextField("objectId", value["objectId"]),
+    ...optionalOwnField("preview", value),
+    ...optionalOwnField("customPreview", value)
+  };
+}
+function optionalTextField(key, value) {
+  return typeof value === "string" ? { [key]: value } : {};
+}
+function toScope(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const type = nonEmptyString(value["type"]);
+  if (type === void 0) {
+    return void 0;
+  }
+  const object = toRemoteObject(value["object"]);
+  const name = nonEmptyString(value["name"]);
+  const startLocation = toScriptLocation(value["startLocation"]);
+  const endLocation = toScriptLocation(value["endLocation"]);
+  return {
+    type,
+    ...name === void 0 ? {} : { name },
+    ...object === void 0 ? {} : { object },
+    ...object?.objectId === void 0 ? {} : { objectId: object.objectId },
+    ...startLocation === void 0 ? {} : { startLocation },
+    ...endLocation === void 0 ? {} : { endLocation }
+  };
+}
+function toScopeChain(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => {
+    const scope = toScope(entry);
+    return scope === void 0 ? [] : [scope];
+  }) : [];
+}
 function resolveCallFrameUrl(frame, scripts) {
-  const direct = nonEmptyString(frame.url);
+  const direct = nonEmptyString(frame["url"]);
   if (direct !== void 0) {
     return direct;
   }
-  const scriptId = nonEmptyString(frame.location?.scriptId);
-  if (scriptId === void 0) {
+  const scriptId = toScriptLocation(frame["location"])?.scriptId;
+  return scriptId === void 0 ? void 0 : nonEmptyString(scripts?.get(scriptId)?.url);
+}
+function toCallFrameMetadata(candidate, location, scripts) {
+  const functionLocation = toScriptLocation(candidate["functionLocation"]);
+  const thisObject = toRemoteObject(candidate["this"]);
+  const returnValue = toRemoteObject(candidate["returnValue"]);
+  const url = resolveCallFrameUrl(candidate, scripts);
+  return {
+    ...location === void 0 ? {} : { scriptId: location.scriptId },
+    ...functionLocation === void 0 ? {} : { functionLocation },
+    ...url === void 0 ? {} : { url },
+    ...thisObject === void 0 ? {} : { thisObject },
+    ...returnValue === void 0 ? {} : { returnValue }
+  };
+}
+function toCallFrame(value, scripts) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const callFrameId = nonEmptyString(value["callFrameId"]);
+  if (callFrameId === void 0) {
     return void 0;
   }
-  return nonEmptyString(scripts?.get(scriptId)?.url);
+  const location = toScriptLocation(value["location"]);
+  return {
+    callFrameId,
+    functionName: asString(value["functionName"]),
+    ...toCallFrameMetadata(value, location, scripts),
+    lineNumber: location?.lineNumber ?? 0,
+    columnNumber: location?.columnNumber ?? 0,
+    scopeChain: toScopeChain(value["scopeChain"])
+  };
 }
 function toCallFrames(value, scripts) {
-  if (!Array.isArray(value)) {
-    return [];
+  return Array.isArray(value) ? value.flatMap((entry) => {
+    const frame = toCallFrame(entry, scripts);
+    return frame === void 0 ? [] : [frame];
+  }) : [];
+}
+function toStackTraceId(value) {
+  if (!isRecord(value)) {
+    return void 0;
   }
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
-      return [];
-    }
-    const candidate = entry;
-    const callFrameId = asString(candidate.callFrameId);
-    if (callFrameId.length === 0) {
-      return [];
-    }
-    const url = resolveCallFrameUrl(candidate, scripts);
-    const base = {
-      callFrameId,
-      functionName: asString(candidate.functionName),
-      lineNumber: asNumber(candidate.location?.lineNumber),
-      columnNumber: asNumber(candidate.location?.columnNumber),
-      scopeChain: toScopeChain(candidate.scopeChain)
-    };
-    return [url === void 0 ? base : { ...base, url }];
+  const id = nonEmptyString(value["id"]);
+  if (id === void 0) {
+    return void 0;
+  }
+  const debuggerId = nonEmptyString(value["debuggerId"]);
+  return debuggerId === void 0 ? { id } : { id, debuggerId };
+}
+function toStackTraceFrame(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  if (scriptId === void 0) {
+    return void 0;
+  }
+  return {
+    functionName: asString(value["functionName"]),
+    scriptId,
+    url: asString(value["url"]),
+    lineNumber: asNumber(value["lineNumber"]),
+    columnNumber: asNumber(value["columnNumber"])
+  };
+}
+function toStackTrace(value) {
+  if (!isRecord(value) || !Array.isArray(value["callFrames"])) {
+    return void 0;
+  }
+  const callFrames = value["callFrames"].flatMap((entry) => {
+    const frame = toStackTraceFrame(entry);
+    return frame === void 0 ? [] : [frame];
   });
+  const description = nonEmptyString(value["description"]);
+  const parent = toStackTrace(value["parent"]);
+  const parentId = toStackTraceId(value["parentId"]);
+  return {
+    callFrames,
+    ...description === void 0 ? {} : { description },
+    ...parent === void 0 ? {} : { parent },
+    ...parentId === void 0 ? {} : { parentId }
+  };
 }
-function toPauseEvent(params, receivedAtMs, scripts) {
-  const base = {
-    reason: asString(params.reason),
-    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
-    callFrames: toCallFrames(params.callFrames, scripts),
-    receivedAtMs
+function toPauseEvent(value, receivedAtMs, scripts) {
+  const params = isRecord(value) ? value : {};
+  const asyncStackTrace = toStackTrace(params["asyncStackTrace"]);
+  const asyncStackTraceId = toStackTraceId(params["asyncStackTraceId"]);
+  const asyncCallStackTraceId = toStackTraceId(params["asyncCallStackTraceId"]);
+  return {
+    reason: asString(params["reason"]),
+    hitBreakpoints: Array.isArray(params["hitBreakpoints"]) ? params["hitBreakpoints"].filter((id) => typeof id === "string") : [],
+    callFrames: toCallFrames(params["callFrames"], scripts),
+    receivedAtMs,
+    ...params["data"] === void 0 ? {} : { data: params["data"] },
+    ...asyncStackTrace === void 0 ? {} : { asyncStackTrace },
+    ...asyncStackTraceId === void 0 ? {} : { asyncStackTraceId },
+    ...asyncCallStackTraceId === void 0 ? {} : { asyncCallStackTraceId }
+  };
+}
+function toScriptInfo(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const scriptId = nonEmptyString(value["scriptId"]);
+  if (scriptId === void 0) {
+    return void 0;
+  }
+  const stackTrace = toStackTrace(value["stackTrace"]);
+  return {
+    scriptId,
+    url: asString(value["url"]),
+    ...optionalNumericField("startLine", value["startLine"]),
+    ...optionalNumericField("startColumn", value["startColumn"]),
+    ...optionalNumericField("endLine", value["endLine"]),
+    ...optionalNumericField("endColumn", value["endColumn"]),
+    ...optionalNumericField("executionContextId", value["executionContextId"]),
+    ...optionalTextField("hash", value["hash"]),
+    ...optionalTextField("buildId", value["buildId"]),
+    ...value["executionContextAuxData"] === void 0 ? {} : { executionContextAuxData: value["executionContextAuxData"] },
+    ...optionalTextField("sourceMapURL", value["sourceMapURL"]),
+    ...optionalBooleanField("hasSourceURL", value["hasSourceURL"]),
+    ...optionalBooleanField("isModule", value["isModule"]),
+    ...optionalNumericField("length", value["length"]),
+    ...stackTrace === void 0 ? {} : { stackTrace }
   };
-  return params.data === void 0 ? base : { ...base, data: params.data };
+}
+function optionalNumericField(key, value) {
+  const number = optionalNumber(value);
+  return number === void 0 ? {} : { [key]: number };
+}
+function optionalBooleanField(key, value) {
+  const boolean = optionalBoolean(value);
+  return boolean === void 0 ? {} : { [key]: boolean };
 }
 function topFrameLocation(pause) {
   const top = pause.callFrames[0];
@@ -470,41 +664,146 @@ async function setBreakpoint(session, input) {
 async function removeBreakpoint(session, breakpointId) {
   await session.client.send("Debugger.removeBreakpoint", { breakpointId });
 }
+function validateCoordinate(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `${label} must be a non-negative integer, received: ${value.toString()}`
+    );
+  }
+}
+function validateScriptLocation(location, label) {
+  if (location.scriptId.trim().length === 0) {
+    throw new CfInspectorError("INVALID_ARGUMENT", `${label}.scriptId must not be empty`);
+  }
+  validateCoordinate(location.lineNumber, `${label}.lineNumber`);
+  if (location.columnNumber !== void 0) {
+    validateCoordinate(location.columnNumber, `${label}.columnNumber`);
+  }
+}
+function isSameScriptLocation(requested, actual) {
+  return requested.scriptId === actual.scriptId && requested.lineNumber === actual.lineNumber && (requested.columnNumber ?? 0) === (actual.columnNumber ?? 0);
+}
+async function getPossibleBreakpoints(session, options) {
+  validateScriptLocation(options.start, "start");
+  if (options.end !== void 0) {
+    validateScriptLocation(options.end, "end");
+    if (options.end.scriptId !== options.start.scriptId) {
+      throw new CfInspectorError("INVALID_ARGUMENT", "start and end must refer to the same scriptId");
+    }
+  }
+  const result = await session.client.send(
+    "Debugger.getPossibleBreakpoints",
+    {
+      start: options.start,
+      ...options.end === void 0 ? {} : { end: options.end },
+      ...options.restrictToFunction === void 0 ? {} : { restrictToFunction: options.restrictToFunction }
+    }
+  );
+  if (!Array.isArray(result.locations)) {
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      "Debugger.getPossibleBreakpoints did not return a locations array"
+    );
+  }
+  return toBreakLocations(result.locations);
+}
+async function setBreakpointAtLocation(session, input) {
+  validateScriptLocation(input.location, "location");
+  const result = await session.client.send("Debugger.setBreakpoint", {
+    location: input.location,
+    ...input.condition === void 0 || input.condition.length === 0 ? {} : { condition: input.condition }
+  });
+  const breakpointId = asString(result.breakpointId);
+  const actualLocation = toScriptLocation(result.actualLocation);
+  const wrongLocation = actualLocation !== void 0 && !isSameScriptLocation(input.location, actualLocation);
+  if (breakpointId.length === 0 || actualLocation === void 0 || wrongLocation) {
+    if (breakpointId.length > 0) {
+      try {
+        await removeBreakpoint(session, breakpointId);
+      } catch {
+      }
+    }
+    if (wrongLocation) {
+      throw new CfInspectorError(
+        "INVALID_BREAKPOINT",
+        "Debugger.setBreakpoint resolved the breakpoint at a different script, line, or column"
+      );
+    }
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      "Debugger.setBreakpoint did not return a breakpointId and actualLocation"
+    );
+  }
+  return {
+    breakpointId,
+    requestedLocation: input.location,
+    actualLocation
+  };
+}
 
 // src/inspector/discovery.ts
 init_types();
 import { request } from "http";
+import { performance } from "perf_hooks";
+var InvalidDiscoveryPayloadError = class extends CfInspectorError {
+};
 async function fetchJson(url, timeoutMs) {
-  return await new Promise((resolve, reject) => {
-    const req = request(url, { method: "GET" }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      res.on("end", () => {
-        try {
-          resolve(parseJsonResponse(chunks));
-        } catch (err) {
-          reject(parseDiscoveryError(url, err));
-        }
-      });
-      res.on("error", (err) => {
-        reject(newDiscoveryError(`Inspector discovery response error: ${err.message}`));
+  const deadline = performance.now() + timeoutMs;
+  let lastError;
+  while (performance.now() < deadline) {
+    try {
+      const remainingMs = deadline - performance.now();
+      if (remainingMs <= 0) {
+        break;
+      }
+      return await new Promise((resolve, reject) => {
+        const req = request(url, { method: "GET" }, (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          res.on("end", () => {
+            try {
+              resolve(parseJsonResponse(chunks));
+            } catch (err) {
+              reject(parseDiscoveryError(url, err));
+            }
+          });
+          res.on("error", (err) => {
+            reject(newDiscoveryError(`Inspector discovery response error: ${err.message}`));
+          });
+        });
+        const attemptTimeoutMs = Math.min(2e3, remainingMs);
+        req.setTimeout(attemptTimeoutMs, () => {
+          req.destroy(
+            new CfInspectorError(
+              "INSPECTOR_DISCOVERY_FAILED",
+              `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`
+            )
+          );
+        });
+        req.on("error", (err) => {
+          reject(err instanceof CfInspectorError ? err : formatDiscoveryRequestError(url, err));
+        });
+        req.end();
       });
-    });
-    req.setTimeout(timeoutMs, () => {
-      req.destroy(
-        new CfInspectorError(
-          "INSPECTOR_DISCOVERY_FAILED",
-          `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`
-        )
-      );
-    });
-    req.on("error", (err) => {
-      reject(err instanceof CfInspectorError ? err : formatDiscoveryRequestError(url, err));
-    });
-    req.end();
-  });
+    } catch (err) {
+      if (err instanceof InvalidDiscoveryPayloadError) {
+        throw err;
+      }
+      lastError = err;
+      const now = performance.now();
+      if (now < deadline) {
+        const sleepMs = Math.min(1e3, deadline - now);
+        await new Promise((r) => setTimeout(r, sleepMs));
+      }
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new CfInspectorError("INSPECTOR_DISCOVERY_FAILED", `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`);
 }
 function isNodeSystemError(err) {
   return err instanceof Error;
@@ -540,7 +839,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);
@@ -614,7 +916,7 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
 
 // src/inspector/pause.ts
 init_types();
-import { performance } from "perf_hooks";
+import { performance as performance2 } from "perf_hooks";
 function pauseMatches(pause, breakpointIds, pauseReasons) {
   if (pauseReasons !== void 0 && pauseReasons.length > 0) {
     return pauseReasons.includes(pause.reason);
@@ -625,7 +927,12 @@ function pauseMatches(pause, breakpointIds, pauseReasons) {
   return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
 }
 function remainingUntil(deadlineMs) {
-  return Math.max(0, deadlineMs - performance.now());
+  return Math.max(0, deadlineMs - performance2.now());
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted === true) {
+    throw new CfInspectorError("ABORTED", "Aborted while waiting for Debugger.paused");
+  }
 }
 function hasResumedSincePause(session, pause) {
   const pauseAt = pause.receivedAtMs;
@@ -645,20 +952,23 @@ function throwUnrelatedPauseTimeout(pause, timeoutMs) {
     pauseDetail(pause)
   );
 }
-async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, timeoutMs) {
+async function waitForUnmatchedPauseToResume(session, pause, deadlineMs, options) {
   if (hasResumedSincePause(session, pause)) {
     return;
   }
   const remainingMs = remainingUntil(deadlineMs);
   if (remainingMs <= 0) {
-    throwUnrelatedPauseTimeout(pause, timeoutMs);
+    throwUnrelatedPauseTimeout(pause, options.timeoutMs);
   }
   try {
-    await session.client.waitFor("Debugger.resumed", { timeoutMs: remainingMs });
-    session.debuggerState.lastResumedAtMs = performance.now();
+    await session.client.waitFor("Debugger.resumed", {
+      timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    });
+    session.debuggerState.lastResumedAtMs = performance2.now();
   } catch (err) {
     if (err instanceof CfInspectorError && err.code === "BREAKPOINT_NOT_HIT") {
-      throwUnrelatedPauseTimeout(pause, timeoutMs);
+      throwUnrelatedPauseTimeout(pause, options.timeoutMs);
     }
     throw err;
   }
@@ -675,13 +985,16 @@ async function handleUnmatchedPause(session, pause, options, deadlineMs) {
     return;
   }
   options.onUnmatchedPause?.(pause);
-  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options.timeoutMs);
+  await waitForUnmatchedPauseToResume(session, pause, deadlineMs, options);
 }
 async function waitForPause(session, options) {
-  const deadlineMs = performance.now() + options.timeoutMs;
+  throwIfAborted(options.signal);
+  const deadlineMs = performance2.now() + options.timeoutMs;
   const buffer = session.pauseBuffer;
   while (buffer.length > 0 || remainingUntil(deadlineMs) > 0) {
+    throwIfAborted(options.signal);
     while (buffer.length > 0) {
+      throwIfAborted(options.signal);
       const buffered = buffer.shift();
       if (buffered === void 0) {
         continue;
@@ -710,15 +1023,16 @@ async function waitForLivePause(session, options, deadlineMs) {
   try {
     params = await session.client.waitFor("Debugger.paused", {
       timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal },
       predicate: () => {
-        receivedAtMs = performance.now();
+        receivedAtMs = performance2.now();
         return true;
       }
     });
   } finally {
     session.pauseWaitGate.active = false;
   }
-  return toPauseEvent(params, receivedAtMs ?? performance.now(), session.scripts);
+  return toPauseEvent(params, receivedAtMs ?? performance2.now(), session.scripts);
 }
 
 // src/inspector/runtime.ts
@@ -729,15 +1043,31 @@ async function resume(session) {
 async function setPauseOnExceptions(session, state) {
   await session.client.send("Debugger.setPauseOnExceptions", { state });
 }
-async function evaluateOnFrame(session, callFrameId, expression) {
+async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
   return await session.client.send("Debugger.evaluateOnCallFrame", {
     callFrameId,
     expression,
     returnByValue: false,
     generatePreview: true,
-    silent: true
+    silent: true,
+    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect },
+    ...options.objectGroup === void 0 ? {} : { objectGroup: options.objectGroup }
   });
 }
+function isSideEffectRefusal(result) {
+  const classNames = [
+    result.result?.className,
+    result.exceptionDetails?.exception?.className
+  ];
+  const descriptions = [
+    result.result?.description,
+    result.exceptionDetails?.exception?.description
+  ];
+  const isEvalError = classNames.includes("EvalError");
+  return isEvalError && descriptions.some(
+    (description) => typeof description === "string" && description.toLowerCase().includes("possible side-effect in debug-evaluate")
+  );
+}
 async function evaluateGlobal(session, expression) {
   return await session.client.send("Runtime.evaluate", {
     expression,
@@ -787,9 +1117,42 @@ async function getProperties(session, objectId) {
   }
   return result.result;
 }
+async function getScriptSource(session, scriptId) {
+  if (scriptId.trim().length === 0) {
+    throw new CfInspectorError("INVALID_ARGUMENT", "scriptId must not be empty");
+  }
+  const result = await session.client.send(
+    "Debugger.getScriptSource",
+    { scriptId }
+  );
+  if (typeof result.scriptSource !== "string") {
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      "Debugger.getScriptSource did not return scriptSource"
+    );
+  }
+  return result.scriptSource;
+}
+async function stepInto(session, options = {}) {
+  await session.client.send("Debugger.stepInto", {
+    ...options.breakOnAsyncCall === void 0 ? {} : { breakOnAsyncCall: options.breakOnAsyncCall }
+  });
+}
+async function stepOver(session) {
+  await session.client.send("Debugger.stepOver");
+}
+async function stepOut(session) {
+  await session.client.send("Debugger.stepOut");
+}
+async function releaseObject(session, objectId) {
+  await session.client.send("Runtime.releaseObject", { objectId });
+}
+async function releaseObjectGroup(session, objectGroup) {
+  await session.client.send("Runtime.releaseObjectGroup", { objectGroup });
+}
 
 // src/inspector/session.ts
-import { performance as performance2 } from "perf_hooks";
+import { performance as performance3 } from "perf_hooks";
 
 // src/cdp/client.ts
 init_types();
@@ -892,54 +1255,70 @@ var CdpClient = class _CdpClient {
     if (this.closed) {
       throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
     }
-    return await new Promise((resolve, reject) => {
+    if (options.signal?.aborted === true) {
+      throw this.createWaitAbortError(method);
+    }
+    return await this.createEventWait(method, options);
+  }
+  createEventWait(method, options) {
+    return new Promise((resolve, reject) => {
       let settled = false;
+      let offEvent = () => void 0;
+      let offClose = () => void 0;
       const cleanup = () => {
         clearTimeout(timer);
         offEvent();
         offClose();
+        options.signal?.removeEventListener("abort", onAbort);
       };
-      const finish = (value) => {
+      const resolveOnce = (value) => {
+        if (settled) {
+          return;
+        }
         settled = true;
         cleanup();
         resolve(value);
       };
-      const offEvent = this.on(method, (raw) => {
-        if (settled) {
-          return;
-        }
-        const params = raw;
-        if (options.predicate) {
-          let accepted;
-          try {
-            accepted = options.predicate(params);
-          } catch {
-            return;
-          }
-          if (!accepted) {
-            return;
-          }
-        }
-        finish(params);
-      });
-      const offClose = this.onClose((err) => {
+      const rejectOnce = (error) => {
         if (settled) {
           return;
         }
         settled = true;
         cleanup();
-        reject(err);
-      });
+        reject(error);
+      };
+      const onAbort = () => {
+        rejectOnce(this.createWaitAbortError(method));
+      };
       const timer = setTimeout(() => {
-        if (settled) {
+        rejectOnce(this.createWaitTimeoutError(method, options.timeoutMs));
+      }, options.timeoutMs);
+      offEvent = this.on(method, (raw) => {
+        const params = raw;
+        if (!this.eventMatches(params, options.predicate)) {
           return;
         }
-        settled = true;
-        cleanup();
-        reject(this.createWaitTimeoutError(method, options.timeoutMs));
-      }, options.timeoutMs);
+        resolveOnce(params);
+      });
+      offClose = this.onClose((error) => {
+        rejectOnce(error);
+      });
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (options.signal?.aborted === true) {
+        onAbort();
+      }
     });
   }
+  eventMatches(params, predicate) {
+    if (predicate === void 0) {
+      return true;
+    }
+    try {
+      return predicate(params);
+    } catch {
+      return false;
+    }
+  }
   onClose(listener) {
     if (this.closed) {
       const reason = this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
@@ -1006,6 +1385,9 @@ var CdpClient = class _CdpClient {
       `Timed out waiting for ${method} after ${timeoutMs.toString()}ms`
     );
   }
+  createWaitAbortError(method) {
+    return new CfInspectorError("ABORTED", `Aborted while waiting for ${method}`);
+  }
   sendPayload(id, method, payload, timer, reject) {
     try {
       this.transport.send(payload);
@@ -1031,12 +1413,203 @@ 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();
 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;
@@ -1053,43 +1626,105 @@ 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 initSession(client, target) {
   const scripts = /* @__PURE__ */ new Map();
-  client.on("Debugger.scriptParsed", (raw) => {
-    const params = raw;
-    const scriptId = asString(params.scriptId);
-    const url = asString(params.url);
-    if (scriptId.length === 0) {
-      return;
-    }
-    scripts.set(scriptId, { scriptId, url });
-  });
+  registerScriptTracking(client, scripts);
   const pauseBuffer = [];
   const pauseWaitGate = { active: false };
   const debuggerState = {};
+  registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState);
+  await client.send("Runtime.enable");
+  await client.send("Debugger.enable");
+  return createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState);
+}
+function registerScriptTracking(client, scripts) {
+  client.on("Debugger.scriptParsed", (raw) => {
+    const script = toScriptInfo(raw);
+    if (script !== void 0) {
+      scripts.set(script.scriptId, script);
+    }
+  });
+}
+function registerPauseTracking(client, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   client.on("Debugger.paused", (raw) => {
     if (pauseWaitGate.active) {
       return;
     }
-    const params = raw;
-    const event = toPauseEvent(params, performance2.now(), scripts);
+    const event = toPauseEvent(raw, performance3.now(), scripts);
     if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
       pauseBuffer.shift();
     }
     pauseBuffer.push(event);
   });
   client.on("Debugger.resumed", () => {
-    debuggerState.lastResumedAtMs = performance2.now();
+    debuggerState.lastResumedAtMs = performance3.now();
   });
-  await client.send("Runtime.enable");
-  await client.send("Debugger.enable");
+}
+function createSession(client, target, scripts, pauseBuffer, pauseWaitGate, debuggerState) {
   return {
     client,
     target,
@@ -1107,9 +1742,61 @@ async function initSession(client, target) {
   };
 }
 
+// src/cli/captureParser.ts
+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;
+}
+
+// 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";
@@ -1137,9 +1824,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 {
@@ -1224,7 +1918,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) {
@@ -1232,8 +1931,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") {
@@ -1250,6 +1953,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);
@@ -1307,56 +2022,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;
   }
@@ -1409,18 +2156,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
@@ -1435,20 +2208,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;
   }
@@ -1470,16 +2246,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
@@ -1494,35 +2276,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
@@ -1542,23 +2328,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
+      )
     )
   );
 }
@@ -1578,7 +2389,8 @@ async function walkStack(session, callFrames, options) {
         session,
         frame,
         options.stackCaptures,
-        options.maxValueLength
+        options.maxValueLength,
+        options.throwOnSideEffect
       );
       return { ...base, captures };
     })
@@ -1600,14 +2412,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);
@@ -1630,24 +2453,49 @@ 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;
   }
 }
 
@@ -1735,7 +2583,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;
   }
@@ -1747,21 +2595,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) {
@@ -1791,6 +2655,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 },
@@ -1803,7 +2670,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;
     }
@@ -1843,13 +2710,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 {
@@ -1896,66 +2763,70 @@ async function waitForStop(session, options, registerMaxEventsSignal) {
 
 // src/cf/tunnel.ts
 import { startDebugger } from "@saptools/cf-debugger";
-async function openCfTunnel(target) {
-  const opts = {
-    region: target.region,
+function targetOptions(target) {
+  return {
     ...target.apiEndpoint === void 0 ? {} : { apiEndpoint: target.apiEndpoint },
-    org: target.org,
-    space: target.space,
-    app: target.app,
+    ...target.process === void 0 ? {} : { process: target.process },
+    ...target.instance === void 0 ? {} : { instance: target.instance },
+    ...target.nodePid === void 0 ? {} : { nodePid: target.nodePid }
+  };
+}
+function lifecycleOptions(target) {
+  return {
+    ...target.allowSshEnableRestart === void 0 ? {} : { allowSshEnableRestart: target.allowSshEnableRestart },
     ...target.tunnelReadyTimeoutMs === void 0 ? {} : { tunnelReadyTimeoutMs: target.tunnelReadyTimeoutMs },
     ...target.preferredPort === void 0 ? {} : { preferredPort: target.preferredPort },
     ...target.verbose === void 0 ? {} : { verbose: target.verbose },
     ...target.signal === void 0 ? {} : { signal: target.signal },
     ...target.onStatus === void 0 ? {} : { onStatus: target.onStatus }
   };
-  try {
-    const handle = await startDebugger(opts);
-    return {
-      localPort: handle.session.localPort,
-      handle,
-      dispose: async () => {
-        await handle.dispose();
-      }
-    };
-  } catch (err) {
-    return reuseExistingTunnelOrThrow(err, target.onStatus);
-  }
 }
-function reuseExistingTunnelOrThrow(err, onStatus) {
-  if (!isSessionAlreadyRunningError(err)) {
-    throw err;
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  const port = extractExistingTunnelPort(message);
-  if (port === void 0) {
-    throw err;
-  }
-  const warning = `Reusing existing tunnel on port ${port.toString()}`;
-  onStatus?.("ready", warning);
+function toStartDebuggerOptions(target) {
   return {
-    localPort: port,
-    dispose: () => Promise.resolve()
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    ...targetOptions(target),
+    ...lifecycleOptions(target)
   };
 }
-function isSessionAlreadyRunningError(err) {
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-  const code = err.code;
-  return code === "SESSION_ALREADY_RUNNING";
+async function openOwnedCfTunnel(target) {
+  const opts = toStartDebuggerOptions(target);
+  const handle = await startDebugger(opts);
+  return {
+    localPort: handle.session.localPort,
+    handle,
+    dispose: async () => {
+      await handle.dispose();
+    }
+  };
 }
-function extractExistingTunnelPort(message) {
-  const match = /on port (\d+)/i.exec(message);
-  if (match === null) {
+function isExistingSessionError(error) {
+  return error instanceof Error && "code" in error && error.code === "SESSION_ALREADY_RUNNING";
+}
+function existingTunnelPort(error) {
+  if (!isExistingSessionError(error)) {
     return void 0;
   }
-  const rawPort = match[1];
+  const rawPort = /\bon port (\d+)\b/iu.exec(error.message)?.[1];
   if (rawPort === void 0) {
     return void 0;
   }
   const port = Number.parseInt(rawPort, 10);
-  return Number.isNaN(port) ? void 0 : port;
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : void 0;
+}
+async function openCfTunnel(target) {
+  try {
+    return await openOwnedCfTunnel(target);
+  } catch (error) {
+    const localPort = existingTunnelPort(error);
+    if (localPort === void 0) {
+      throw error;
+    }
+    target.onStatus?.("ready", `Reusing existing tunnel on port ${localPort.toString()}`);
+    return { localPort, dispose: () => Promise.resolve() };
+  }
 }
 export {
   CfInspectorError,
@@ -1969,16 +2840,25 @@ export {
   evaluateGlobal,
   evaluateOnFrame,
   fetchInspectorVersion,
+  getPossibleBreakpoints,
   getProperties,
+  getScriptSource,
   listScripts,
   openCfTunnel,
+  openOwnedCfTunnel,
   parseBreakpointSpec,
   parseRemoteRoot,
+  releaseObject,
+  releaseObjectGroup,
   removeBreakpoint,
   resume,
   runSetupEvals,
   setBreakpoint,
+  setBreakpointAtLocation,
   setPauseOnExceptions,
+  stepInto,
+  stepOut,
+  stepOver,
   streamLogpoint,
   validateExpression,
   waitForPause,