@saptools/cf-inspector 0.5.0 → 0.6.1

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) {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
       return [];
     }
-    const candidate = entry;
-    const scriptId = asString(candidate.scriptId);
-    if (scriptId.length === 0) {
-      return [];
-    }
-    const url = typeof candidate.url === "string" ? candidate.url : void 0;
-    const lineNumber = asNumber(candidate.lineNumber);
-    const result = url === void 0 ? { scriptId, lineNumber, columnNumber: asNumber(candidate.columnNumber) } : { scriptId, url, lineNumber, columnNumber: asNumber(candidate.columnNumber) };
-    return [result];
+    const url = typeof entry["url"] === "string" ? entry["url"] : void 0;
+    return [url === void 0 ? location : { ...location, url }];
   });
 }
-function toScopeChain(value) {
+function toBreakLocations(value) {
   if (!Array.isArray(value)) {
     return [];
   }
   return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) {
+    const location = toScriptLocation(entry);
+    if (location === void 0 || !isRecord(entry)) {
       return [];
     }
-    const candidate = entry;
-    const type = asString(candidate.type);
-    if (type.length === 0) {
-      return [];
-    }
-    const objectId = typeof candidate.object?.objectId === "string" ? candidate.object.objectId : void 0;
-    const name = typeof candidate.name === "string" ? candidate.name : void 0;
-    const base = name === void 0 ? { type } : { type, name };
-    return [objectId === void 0 ? base : { ...base, objectId }];
+    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,6 +664,83 @@ 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();
@@ -658,6 +929,11 @@ function pauseMatches(pause, breakpointIds, pauseReasons) {
 function remainingUntil(deadlineMs) {
   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;
   const resumedAt = session.debuggerState.lastResumedAtMs;
@@ -676,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 });
+    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;
   }
@@ -706,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) {
+  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;
@@ -741,6 +1023,7 @@ async function waitForLivePause(session, options, deadlineMs) {
   try {
     params = await session.client.waitFor("Debugger.paused", {
       timeoutMs: remainingMs,
+      ...options.signal === void 0 ? {} : { signal: options.signal },
       predicate: () => {
         receivedAtMs = performance2.now();
         return true;
@@ -760,6 +1043,9 @@ async function resume(session) {
 async function setPauseOnExceptions(session, state) {
   await session.client.send("Debugger.setPauseOnExceptions", { state });
 }
+async function setAsyncCallStackDepth(session, maxDepth) {
+  await session.client.send("Debugger.setAsyncCallStackDepth", { maxDepth });
+}
 async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
   return await session.client.send("Debugger.evaluateOnCallFrame", {
     callFrameId,
@@ -767,7 +1053,8 @@ async function evaluateOnFrame(session, callFrameId, expression, options = {}) {
     returnByValue: false,
     generatePreview: true,
     silent: true,
-    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect }
+    ...options.throwOnSideEffect === void 0 ? {} : { throwOnSideEffect: options.throwOnSideEffect },
+    ...options.objectGroup === void 0 ? {} : { objectGroup: options.objectGroup }
   });
 }
 function isSideEffectRefusal(result) {
@@ -833,6 +1120,39 @@ 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 performance3 } from "perf_hooks";
@@ -938,54 +1258,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");
@@ -1052,6 +1388,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);
@@ -1356,24 +1695,29 @@ function workerToInspectorTarget(worker) {
 }
 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, performance3.now(), scripts);
+    const event = toPauseEvent(raw, performance3.now(), scripts);
     if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
       pauseBuffer.shift();
     }
@@ -1382,8 +1726,8 @@ async function initSession(client, target) {
   client.on("Debugger.resumed", () => {
     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,
@@ -2422,66 +2766,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,
@@ -2495,16 +2843,26 @@ export {
   evaluateGlobal,
   evaluateOnFrame,
   fetchInspectorVersion,
+  getPossibleBreakpoints,
   getProperties,
+  getScriptSource,
   listScripts,
   openCfTunnel,
+  openOwnedCfTunnel,
   parseBreakpointSpec,
   parseRemoteRoot,
+  releaseObject,
+  releaseObjectGroup,
   removeBreakpoint,
   resume,
   runSetupEvals,
+  setAsyncCallStackDepth,
   setBreakpoint,
+  setBreakpointAtLocation,
   setPauseOnExceptions,
+  stepInto,
+  stepOut,
+  stepOver,
   streamLogpoint,
   validateExpression,
   waitForPause,