@saptools/cf-inspector 0.3.19 → 0.4.1

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -35,10 +34,19 @@ __export(wsTransport_exports, {
   wsTransportFactory: () => wsTransportFactory
 });
 import { WebSocket } from "ws";
-async function wsTransportFactory(url) {
+async function wsTransportFactory(url, options = {}) {
   const socket = new WebSocket(url, { perMessageDeflate: false });
-  await waitForOpen(socket, url);
-  const wrappers = /* @__PURE__ */ new WeakMap();
+  await waitForOpen(socket, url, options.connectTimeoutMs);
+  const wrappers = /* @__PURE__ */ new Map();
+  function wrappersFor(event) {
+    const existing = wrappers.get(event);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const created = /* @__PURE__ */ new WeakMap();
+    wrappers.set(event, created);
+    return created;
+  }
   return {
     send(payload) {
       socket.send(payload);
@@ -50,11 +58,12 @@ async function wsTransportFactory(url) {
       return socket.readyState;
     },
     on(event, listener) {
-      const wrapped = wrapListener(event, listener, wrappers);
+      const wrapped = wrapListener(event, listener);
+      wrappersFor(event).set(listener, wrapped);
       socket.on(event, wrapped);
     },
     off(event, listener) {
-      const wrapped = wrappers.get(listener);
+      const wrapped = wrappersFor(event).get(listener);
       if (!wrapped) {
         return;
       }
@@ -62,14 +71,30 @@ async function wsTransportFactory(url) {
     }
   };
 }
-async function waitForOpen(socket, url) {
+async function waitForOpen(socket, url, timeoutMs) {
   await new Promise((resolve, reject) => {
-    const onOpen = () => {
+    let settled = false;
+    const cleanup = () => {
+      socket.off("open", onOpen);
       socket.off("error", onError);
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    };
+    const onOpen = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
       resolve();
     };
     const onError = (err) => {
-      socket.off("open", onOpen);
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
       reject(
         new CfInspectorError(
           "INSPECTOR_CONNECTION_FAILED",
@@ -77,29 +102,45 @@ async function waitForOpen(socket, url) {
         )
       );
     };
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      socket.on("error", () => {
+      });
+      try {
+        socket.terminate();
+      } catch {
+      }
+      reject(
+        new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          `WebSocket handshake to ${url} timed out after ${timeoutMs.toString()}ms`
+        )
+      );
+    }, timeoutMs);
     socket.once("open", onOpen);
     socket.once("error", onError);
   });
 }
-function wrapListener(event, listener, wrappers) {
+function wrapListener(event, listener) {
   if (event === "message") {
     const wrapped2 = (data) => {
       listener(data.toString("utf8"));
     };
-    wrappers.set(listener, wrapped2);
     return wrapped2;
   }
   if (event === "close") {
     const wrapped2 = () => {
       listener();
     };
-    wrappers.set(listener, wrapped2);
     return wrapped2;
   }
   const wrapped = (err) => {
     listener(err);
   };
-  wrappers.set(listener, wrapped);
   return wrapped;
 }
 var init_wsTransport = __esm({
@@ -212,9 +253,11 @@ function normalizeRegexRootPattern(pattern) {
   const withoutEndAnchor = withoutStartAnchor.endsWith("$") && !isEscaped(withoutStartAnchor, withoutStartAnchor.length - 1) ? withoutStartAnchor.slice(0, -1) : withoutStartAnchor;
   return stripTrailingSlash(withoutEndAnchor);
 }
-function buildFileUrlRegex(rootPattern, tail) {
-  const separator = rootPattern.endsWith("/") ? "" : "/";
-  return `^file://${rootPattern}${separator}${tail}$`;
+function buildFileUrlRegex(embeddedRoot, tail, separator) {
+  return `^file://${embeddedRoot}${separator}${tail}$`;
+}
+function rootSeparator(rawPattern) {
+  return rawPattern.endsWith("/") ? "" : "/";
 }
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
@@ -241,12 +284,12 @@ function buildBreakpointUrlRegex(input) {
       return `(?:^|/)${tail}$`;
     }
     case "literal": {
-      const escapedRoot = escapeRegExp(input.remoteRoot.value);
-      return buildFileUrlRegex(escapedRoot, tail);
+      const root = input.remoteRoot.value;
+      return buildFileUrlRegex(escapeRegExp(root), tail, rootSeparator(root));
     }
     case "regex": {
-      const rootPattern = normalizeRegexRootPattern(input.remoteRoot.pattern);
-      return buildFileUrlRegex(rootPattern, tail);
+      const root = normalizeRegexRootPattern(input.remoteRoot.pattern);
+      return buildFileUrlRegex(`(?:${root})`, tail, rootSeparator(root));
     }
   }
 }
@@ -338,12 +381,13 @@ function toCallFrames(value, scripts) {
   });
 }
 function toPauseEvent(params, receivedAtMs, scripts) {
-  return {
+  const base = {
     reason: asString(params.reason),
     hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
     callFrames: toCallFrames(params.callFrames, scripts),
     receivedAtMs
   };
+  return params.data === void 0 ? base : { ...base, data: params.data };
 }
 function topFrameLocation(pause) {
   const top = pause.callFrames[0];
@@ -362,6 +406,46 @@ function pauseDetail(pause) {
 }
 
 // src/inspector/breakpoints.ts
+var HITS_GLOBAL = "globalThis.__CFI_HITS";
+var counterKeyCounter = 0;
+function nextCounterKey(file, line) {
+  counterKeyCounter += 1;
+  return `${file}:${line.toString()}:${counterKeyCounter.toString()}`;
+}
+function validateHitCount(hitCount) {
+  if (hitCount === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(hitCount) || hitCount <= 0) {
+    throw new CfInspectorError(
+      "INVALID_HIT_COUNT",
+      `hitCount must be a positive integer, received: ${hitCount.toString()}`
+    );
+  }
+  return hitCount;
+}
+function buildHitCountedCondition(hitCount, counterKey, userCondition) {
+  const keyLiteral = JSON.stringify(counterKey);
+  const baseCondition = userCondition !== void 0 && userCondition.trim().length > 0 ? `(${userCondition})` : "true";
+  return [
+    "(function(){",
+    `var m=(${HITS_GLOBAL}=${HITS_GLOBAL}||{});`,
+    `var k=${keyLiteral};`,
+    "m[k]=(m[k]||0)+1;",
+    `if(m[k]<${hitCount.toString()})return false;`,
+    `return ${baseCondition};`,
+    "})()"
+  ].join("");
+}
+function resolveCondition(input) {
+  const condition = input.condition;
+  const hitCount = validateHitCount(input.hitCount);
+  if (hitCount === void 0) {
+    return condition !== void 0 && condition.length > 0 ? condition : void 0;
+  }
+  const counterKey = nextCounterKey(input.file, input.line);
+  return buildHitCountedCondition(hitCount, counterKey, condition);
+}
 async function setBreakpoint(session, input) {
   const remoteRoot = input.remoteRoot ?? { kind: "none" };
   const urlRegex = buildBreakpointUrlRegex({ file: input.file, remoteRoot });
@@ -369,8 +453,9 @@ async function setBreakpoint(session, input) {
     lineNumber: input.line - 1,
     urlRegex
   };
-  if (input.condition !== void 0 && input.condition.length > 0) {
-    params["condition"] = input.condition;
+  const condition = resolveCondition(input);
+  if (condition !== void 0) {
+    params["condition"] = condition;
   }
   const result = await session.client.send(
     "Debugger.setBreakpointByUrl",
@@ -516,7 +601,10 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
 // src/inspector/pause.ts
 init_types();
 import { performance } from "perf_hooks";
-function pauseMatches(pause, breakpointIds) {
+function pauseMatches(pause, breakpointIds, pauseReasons) {
+  if (pauseReasons !== void 0 && pauseReasons.length > 0) {
+    return pauseReasons.includes(pause.reason);
+  }
   if (breakpointIds === void 0 || breakpointIds.length === 0) {
     return true;
   }
@@ -584,13 +672,13 @@ async function waitForPause(session, options) {
       if (buffered === void 0) {
         continue;
       }
-      if (pauseMatches(buffered, options.breakpointIds)) {
+      if (pauseMatches(buffered, options.breakpointIds, options.pauseReasons)) {
         return buffered;
       }
       await handleUnmatchedPause(session, buffered, options, deadlineMs);
     }
     const pause = await waitForLivePause(session, options, deadlineMs);
-    if (pauseMatches(pause, options.breakpointIds)) {
+    if (pauseMatches(pause, options.breakpointIds, options.pauseReasons)) {
       return pause;
     }
     await handleUnmatchedPause(session, pause, options, deadlineMs);
@@ -624,6 +712,9 @@ init_types();
 async function resume(session) {
   await session.client.send("Debugger.resume");
 }
+async function setPauseOnExceptions(session, state) {
+  await session.client.send("Debugger.setPauseOnExceptions", { state });
+}
 async function evaluateOnFrame(session, callFrameId, expression) {
   return await session.client.send("Debugger.evaluateOnCallFrame", {
     callFrameId,
@@ -709,10 +800,19 @@ var CdpClient = class _CdpClient {
       return;
     }
     if (typeof parsed.method === "string") {
-      this.emitter.emit(parsed.method, parsed.params);
-      this.emitter.emit("event", { method: parsed.method, params: parsed.params });
+      this.safeEmit(parsed.method, parsed.params);
+      this.safeEmit("event", { method: parsed.method, params: parsed.params });
     }
   };
+  safeEmit(event, payload) {
+    const listeners = this.emitter.listeners(event);
+    for (const listener of listeners) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
+  }
   handleClose = () => {
     this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Inspector connection closed"));
   };
@@ -730,7 +830,8 @@ var CdpClient = class _CdpClient {
   }
   static async connect(options) {
     const factory = options.transportFactory ?? await loadDefaultFactory();
-    const transport = await factory(options.url);
+    const factoryOptions = options.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: options.connectTimeoutMs };
+    const transport = await factory(options.url, factoryOptions);
     return new _CdpClient(transport, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
   }
   async send(method, params = {}) {
@@ -780,8 +881,16 @@ var CdpClient = class _CdpClient {
           return;
         }
         const params = raw;
-        if (options.predicate && !options.predicate(params)) {
-          return;
+        if (options.predicate) {
+          let accepted;
+          try {
+            accepted = options.predicate(params);
+          } catch {
+            return;
+          }
+          if (!accepted) {
+            return;
+          }
         }
         finish(params);
       });
@@ -911,7 +1020,18 @@ async function connectInspector(options) {
       `No inspector targets available on ${host}:${options.port.toString()}`
     );
   }
-  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl });
+  const client = await CdpClient.connect({
+    url: target.webSocketDebuggerUrl,
+    connectTimeoutMs
+  });
+  try {
+    return await initSession(client, target);
+  } catch (err) {
+    client.dispose();
+    throw err;
+  }
+}
+async function initSession(client, target) {
   const scripts = /* @__PURE__ */ new Map();
   client.on("Debugger.scriptParsed", (raw) => {
     const params = raw;
@@ -1032,19 +1152,32 @@ function scalarFromVariable(variable) {
   }
   return value === "null" ? null : value;
 }
+function isArrayLikeChildren(children) {
+  let hasNumeric = false;
+  for (const child of children) {
+    if (child.name === "length") {
+      continue;
+    }
+    if (parseNumericIndex(child.name) === void 0) {
+      return false;
+    }
+    hasNumeric = true;
+  }
+  return hasNumeric;
+}
 function toStructuredValue(variable) {
   const children = variable.children;
   if (children === void 0 || children.length === 0) {
     return scalarFromVariable(variable);
   }
-  const indexed = children.flatMap((child) => {
-    const index = parseNumericIndex(child.name);
-    if (index === void 0) {
-      return [];
-    }
-    return [[index, toStructuredValue(child)]];
-  });
-  if (indexed.length > 0) {
+  if (isArrayLikeChildren(children)) {
+    const indexed = children.flatMap((child) => {
+      const index = parseNumericIndex(child.name);
+      if (index === void 0) {
+        return [];
+      }
+      return [[index, toStructuredValue(child)]];
+    });
     const maxIndex = Math.max(...indexed.map(([index]) => index));
     const out2 = Array.from({ length: maxIndex + 1 }, () => null);
     for (const [index, entry] of indexed) {
@@ -1174,6 +1307,93 @@ async function capturePropertyChildren(session, described, depth, maxValueLength
   }
 }
 
+// src/snapshot/exception.ts
+function asString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+async function materializeObject(session, objectId, maxValueLength) {
+  try {
+    const properties = await captureProperties(
+      session,
+      objectId,
+      MAX_SCOPE_VARIABLES,
+      MAX_VARIABLE_DEPTH,
+      maxValueLength
+    );
+    if (properties.length === 0) {
+      return void 0;
+    }
+    const structured = {};
+    for (const variable of properties) {
+      structured[variable.name] = toStructuredValue(variable);
+    }
+    return JSON.stringify(structured);
+  } catch {
+    return void 0;
+  }
+}
+async function readPropertyDescription(session, objectId, name) {
+  try {
+    const properties = await getProperties(session, objectId);
+    for (const prop of properties) {
+      if (prop.name !== name) {
+        continue;
+      }
+      const value = prop.value;
+      if (value === void 0) {
+        continue;
+      }
+      if (typeof value.value === "string") {
+        return value.value;
+      }
+      if (typeof value.description === "string") {
+        return value.description;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function captureException(session, pause, maxValueLength) {
+  if (pause.reason !== "exception" && pause.reason !== "promiseRejection") {
+    return void 0;
+  }
+  const data = pause.data;
+  if (typeof data !== "object" || data === null) {
+    return { error: "no exception data attached" };
+  }
+  const candidate = data;
+  const type = asString2(candidate.type);
+  const description = asString2(candidate.description);
+  if (typeof candidate.value === "string") {
+    return buildResult(type, description, JSON.stringify(candidate.value), maxValueLength);
+  }
+  if (typeof candidate.value === "number" || typeof candidate.value === "boolean") {
+    return buildResult(type, description, String(candidate.value), maxValueLength);
+  }
+  const objectId = asString2(candidate.objectId);
+  if (objectId === void 0) {
+    if (description !== void 0) {
+      return buildResult(type, description, description, maxValueLength);
+    }
+    return { error: "exception data has no objectId or value" };
+  }
+  const message = await readPropertyDescription(session, objectId, "message");
+  const rendered = await materializeObject(session, objectId, maxValueLength);
+  if (rendered !== void 0) {
+    const result = buildResult(type, description, rendered, maxValueLength);
+    return message === void 0 ? result : { ...result, description: limitValueLength(message, maxValueLength) };
+  }
+  return buildResult(type, description, description ?? "[exception]", maxValueLength);
+}
+function buildResult(type, description, value, maxValueLength) {
+  const safeValue = limitValueLength(value, maxValueLength);
+  const base = { value: safeValue };
+  const withType = type === void 0 ? base : { ...base, type };
+  return description === void 0 ? withType : { ...withType, description: limitValueLength(description, maxValueLength) };
+}
+
 // src/snapshot/objects.ts
 function objectIdFromEvalResult(result) {
   const inner = result.result;
@@ -1276,12 +1496,73 @@ async function captureScopes(session, frame, maxValueLength) {
   );
 }
 
+// src/snapshot/stack.ts
+var DEFAULT_STACK_DEPTH = 1;
+var MAX_STACK_DEPTH = 64;
+function clampDepth(depth, frameCount) {
+  if (depth <= 0) {
+    return 0;
+  }
+  return Math.min(depth, frameCount, MAX_STACK_DEPTH);
+}
+function buildBaseFrame(frame) {
+  const base = {
+    functionName: frame.functionName,
+    line: frame.lineNumber + 1,
+    column: frame.columnNumber + 1
+  };
+  return frame.url === void 0 ? base : { ...base, url: frame.url };
+}
+async function captureFrameExpression(session, callFrameId, expression, maxValueLength) {
+  try {
+    const result = await evaluateOnFrame(session, callFrameId, expression);
+    const captured = evalResultToCaptured(expression, result, maxValueLength);
+    return await withSerializedObjectCapture(session, expression, result, captured, maxValueLength);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { expression, error: limitValueLength(message, maxValueLength) };
+  }
+}
+async function captureFrameExpressions(session, frame, expressions, maxValueLength) {
+  if (expressions.length === 0) {
+    return [];
+  }
+  return await Promise.all(
+    expressions.map(
+      (expression) => captureFrameExpression(session, frame.callFrameId, expression, maxValueLength)
+    )
+  );
+}
+async function walkStack(session, callFrames, options) {
+  const depth = clampDepth(options.stackDepth, callFrames.length);
+  if (depth <= 1) {
+    return [];
+  }
+  const slice = callFrames.slice(0, depth);
+  return await Promise.all(
+    slice.map(async (frame) => {
+      const base = buildBaseFrame(frame);
+      if (options.stackCaptures.length === 0) {
+        return base;
+      }
+      const captures = await captureFrameExpressions(
+        session,
+        frame,
+        options.stackCaptures,
+        options.maxValueLength
+      );
+      return { ...base, captures };
+    })
+  );
+}
+
 // src/snapshot/capture.ts
 async function captureSnapshot(session, pause, options = {}) {
   const maxValueLength = resolveMaxValueLength(options.maxValueLength);
   const top = pause.callFrames[0];
   let topFrame;
   let captures = [];
+  let stack = [];
   if (top) {
     topFrame = {
       functionName: top.functionName,
@@ -1294,14 +1575,31 @@ async function captureSnapshot(session, pause, options = {}) {
       topFrame = { ...topFrame, scopes };
     }
     captures = await captureExpressions(session, top.callFrameId, options.captures, maxValueLength);
+    stack = await walkStack(session, pause.callFrames, {
+      stackDepth: options.stackDepth ?? DEFAULT_STACK_DEPTH,
+      stackCaptures: options.stackCaptures ?? [],
+      maxValueLength
+    });
   }
-  return {
-    reason: pause.reason,
-    hitBreakpoints: pause.hitBreakpoints,
+  const exception = await captureException(session, pause, maxValueLength);
+  return buildResult2({
+    pause,
+    topFrame,
+    captures,
+    stack,
+    exception
+  });
+}
+function buildResult2(input) {
+  const base = {
+    reason: input.pause.reason,
+    hitBreakpoints: input.pause.hitBreakpoints,
     capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...topFrame === void 0 ? {} : { topFrame },
-    captures
+    captures: input.captures
   };
+  const withFrame = input.topFrame === void 0 ? base : { ...base, topFrame: input.topFrame };
+  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) {
   if (captures === void 0 || captures.length === 0) {
@@ -1328,7 +1626,8 @@ async function captureExpression(session, callFrameId, expression, maxValueLengt
 import { randomBytes } from "crypto";
 var SENTINEL_PREFIX = "__CFI_LOG_";
 var SENTINEL_SUFFIX = "__";
-function buildLogpointCondition(sentinel, expression) {
+var HITS_GLOBAL2 = "globalThis.__CFI_LOG_HITS";
+function buildLoggingIife(sentinel, expression) {
   return [
     "(function(){",
     `var s=${JSON.stringify(sentinel)};`,
@@ -1343,12 +1642,53 @@ function buildLogpointCondition(sentinel, expression) {
     "})()"
   ].join("");
 }
+function buildHitGate(hitCount, counterKey) {
+  const keyLiteral = JSON.stringify(counterKey);
+  return [
+    "(function(){",
+    `var m=(${HITS_GLOBAL2}=${HITS_GLOBAL2}||{});`,
+    `var k=${keyLiteral};`,
+    "m[k]=(m[k]||0)+1;",
+    `return m[k]>=${hitCount.toString()};`,
+    "})()"
+  ].join("");
+}
+function combineGuards(guards) {
+  const filtered = guards.filter((guard) => guard.length > 0);
+  if (filtered.length === 0) {
+    return void 0;
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+  return filtered.map((guard) => `(${guard})`).join("&&");
+}
+function buildLogpointCondition(sentinel, expression, options = {}) {
+  const guards = [];
+  if (options.hitCount !== void 0) {
+    const counterKey = options.counterKey ?? sentinel;
+    guards.push(buildHitGate(options.hitCount, counterKey));
+  }
+  const userPredicate = options.predicate?.trim();
+  if (userPredicate !== void 0 && userPredicate.length > 0) {
+    guards.push(`(${userPredicate})`);
+  }
+  const iife = buildLoggingIife(sentinel, expression);
+  const guard = combineGuards(guards);
+  if (guard === void 0) {
+    return iife;
+  }
+  return `(${guard})?${iife}:false`;
+}
 function generateSentinel() {
   return `${SENTINEL_PREFIX}${randomBytes(8).toString("hex")}${SENTINEL_SUFFIX}`;
 }
 
+// src/logpoint/stream.ts
+init_types();
+
 // src/logpoint/events.ts
-function asString2(value) {
+function asString3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function readArg(arg, index) {
@@ -1395,17 +1735,58 @@ function parsePayload(ts, at, payload) {
 }
 
 // src/logpoint/stream.ts
+function validateMaxEvents(maxEvents) {
+  if (maxEvents === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(maxEvents) || maxEvents <= 0) {
+    throw new CfInspectorError(
+      "INVALID_ARGUMENT",
+      `maxEvents must be a positive integer, received: ${maxEvents.toString()}`
+    );
+  }
+  return maxEvents;
+}
+function validateHitCount2(hitCount) {
+  if (hitCount === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(hitCount) || hitCount <= 0) {
+    throw new CfInspectorError(
+      "INVALID_HIT_COUNT",
+      `hitCount must be a positive integer, received: ${hitCount.toString()}`
+    );
+  }
+  return hitCount;
+}
 async function streamLogpoint(session, options) {
+  const maxEvents = validateMaxEvents(options.maxEvents);
+  const hitCount = validateHitCount2(options.hitCount);
   const sentinel = generateSentinel();
-  const condition = buildLogpointCondition(sentinel, options.expression);
+  const condition = buildLogpointCondition(sentinel, options.expression, {
+    ...options.condition === void 0 ? {} : { predicate: options.condition },
+    ...hitCount === void 0 ? {} : { hitCount }
+  });
   let emitted = 0;
+  let maxEventsReached = false;
+  let stopMaxEvents;
   const offEvent = session.client.on("Runtime.consoleAPICalled", (raw) => {
+    if (maxEventsReached) {
+      return;
+    }
     const event = toLogpointEvent(raw, sentinel, options.location);
     if (event === void 0) {
       return;
     }
     emitted += 1;
-    options.onEvent(event);
+    try {
+      options.onEvent(event);
+    } catch {
+    }
+    if (maxEvents !== void 0 && emitted >= maxEvents) {
+      maxEventsReached = true;
+      stopMaxEvents?.();
+    }
   });
   let handle;
   try {
@@ -1421,7 +1802,12 @@ async function streamLogpoint(session, options) {
   }
   options.onBreakpointSet?.(handle);
   try {
-    const reason = await waitForStop(session, options);
+    const reason = await waitForStop(session, options, (signal) => {
+      stopMaxEvents = signal;
+      if (maxEventsReached) {
+        signal();
+      }
+    });
     return { handle, sentinel, emitted, stoppedReason: reason };
   } finally {
     offEvent();
@@ -1430,7 +1816,7 @@ async function streamLogpoint(session, options) {
 }
 function toLogpointEvent(raw, sentinel, location) {
   const params = raw;
-  if (asString2(params.type) !== "log") {
+  if (asString3(params.type) !== "log") {
     return void 0;
   }
   const ts = typeof params.timestamp === "number" ? params.timestamp : void 0;
@@ -1442,7 +1828,7 @@ async function removeBreakpointBestEffort(session, breakpointId) {
   } catch {
   }
 }
-async function waitForStop(session, options) {
+async function waitForStop(session, options, registerMaxEventsSignal) {
   return await new Promise((resolve) => {
     let settled = false;
     const finish = (reason) => {
@@ -1466,6 +1852,9 @@ async function waitForStop(session, options) {
     if (options.signal?.aborted === true) {
       finish("signal");
     }
+    registerMaxEventsSignal(() => {
+      finish("max-events");
+    });
     function cleanup() {
       if (timer !== void 0) {
         clearTimeout(timer);
@@ -1501,7 +1890,9 @@ async function openCfTunnel(target) {
 export {
   CfInspectorError,
   buildBreakpointUrlRegex,
+  buildHitCountedCondition,
   buildLogpointCondition,
+  captureException,
   captureSnapshot,
   connectInspector,
   discoverInspectorTargets,
@@ -1516,8 +1907,10 @@ export {
   removeBreakpoint,
   resume,
   setBreakpoint,
+  setPauseOnExceptions,
   streamLogpoint,
   validateExpression,
-  waitForPause
+  waitForPause,
+  walkStack
 };
 //# sourceMappingURL=index.js.map