@saptools/cf-inspector 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -193,6 +193,15 @@ type InspectorIsolate = {
     readonly kind: "worker";
     readonly workerId: string;
 };
+type ArmedCommand = "snapshot" | "watch" | "exception" | "log";
+interface ArmedEvent {
+    readonly event: "breakpoint-armed";
+    readonly schemaVersion: 1;
+    readonly command: ArmedCommand;
+    readonly sessions: number;
+    readonly resolvedLocations: number | null;
+    readonly timeoutMs: number | null;
+}
 interface ScriptInfo {
     readonly scriptId: string;
     readonly url: string;
@@ -210,6 +219,9 @@ interface ScriptInfo {
     readonly length?: number;
     readonly stackTrace?: StackTraceInfo;
 }
+interface ListedScriptInfo extends ScriptInfo {
+    readonly isolate: InspectorIsolate;
+}
 interface InspectorConnectOptions {
     readonly port: number;
     readonly host?: string;
@@ -409,6 +421,14 @@ declare function waitForPause(session: InspectorSession, options: WaitForPauseOp
 interface SessionBreakpointSetup {
     readonly handles: readonly BreakpointHandle[];
 }
+interface SessionBreakpointOutcome {
+    readonly session: InspectorSession;
+    readonly setup: SessionBreakpointSetup;
+}
+interface FanoutReadyOptions {
+    readonly includeNewSessions?: boolean;
+    readonly onReady?: (outcomes: readonly SessionBreakpointOutcome[]) => void;
+}
 interface IsolatePause {
     readonly session: InspectorSession;
     readonly pause: PauseEvent;
@@ -426,13 +446,14 @@ declare class BreakpointFanout {
     private readonly detachError;
     private activeRace;
     private pauseReasons;
+    private pendingSetupError;
+    private preserveReadinessErrors;
     constructor(group: InspectorSessionGroup, setupSession: (session: InspectorSession, trackHandle: (handle: BreakpointHandle) => void) => Promise<SessionBreakpointSetup>, pauseReasons?: readonly string[]);
-    ready(): Promise<void>;
+    ready(options?: FanoutReadyOptions): Promise<void>;
     trackHandle(session: InspectorSession, handle: BreakpointHandle): void;
-    availableOutcomes(): readonly {
-        readonly session: InspectorSession;
-        readonly setup: SessionBreakpointSetup;
-    }[];
+    availableOutcomes(): readonly SessionBreakpointOutcome[];
+    private outcomesFor;
+    private takePendingSetupError;
     waitForFirst(timeoutMs: number, options?: Omit<WaitForPauseOptions, "timeoutMs" | "breakpointIds" | "signal">, signal?: AbortSignal): Promise<IsolatePause>;
     resumePaused(except?: InspectorSession): Promise<number>;
     cleanup(timeoutMs?: number, preservePaused?: InspectorSession): Promise<FanoutCleanupSummary>;
@@ -516,6 +537,7 @@ interface LogpointStreamOptions {
     readonly condition?: string;
     readonly maxValueLength?: number;
     readonly signal?: AbortSignal;
+    readonly eventGate?: () => boolean;
     readonly onEvent: (event: LogpointEvent) => void;
     readonly onBreakpointSet?: (handle: BreakpointHandle) => void;
 }
@@ -551,4 +573,4 @@ interface OpenedTunnel {
 declare function openOwnedCfTunnel(target: TunnelTarget): Promise<OpenedTunnel>;
 declare function openCfTunnel(target: TunnelTarget): Promise<OpenedTunnel>;
 
-export { type BreakLocation, BreakpointFanout, type BreakpointHandle, type BreakpointLocation, type CallFrameInfo, type CaptureSnapshotOptions, type CapturedExpression, CfInspectorError, type CfInspectorErrorCode, type DebuggerState, type EvaluateOnFrameOptions, type ExactBreakpointHandle, type ExceptionSnapshot, type FrameSnapshot, type GetPossibleBreakpointsOptions, type InspectorConnectOptions, type InspectorIsolate, type InspectorSession, type InspectorSessionGroup, type InspectorTarget, type InspectorWorkerTarget, type LogpointConditionOptions, type LogpointEvent, type LogpointStopReason, type LogpointStreamOptions, type LogpointStreamResult, type OpenedTunnel, type PauseEvent, type PauseOnExceptionsState, type RemoteObjectInfo, type RemoteRootSetting, type ResolvedLocation, type ScopeInfo, type ScopeSnapshot, type ScriptInfo, type ScriptLocation, type SetBreakpointAtLocationInput, type SetBreakpointInput, type SnapshotCaptureResult, type SnapshotResult, type StackTraceFrameInfo, type StackTraceIdInfo, type StackTraceInfo, type StepIntoOptions, type TunnelTarget, type VariableSnapshot, type WaitForPauseOptions, type WalkStackOptions, type WatchEvent, buildBreakpointUrlRegex, buildHitCountedCondition, buildLogpointCondition, captureException, captureSnapshot, connectInspector, connectInspectorGroup, discoverInspectorTargets, evaluateGlobal, evaluateOnFrame, fetchInspectorVersion, getPossibleBreakpoints, getProperties, getScriptSource, listScripts, openCfTunnel, openOwnedCfTunnel, parseBreakpointSpec, parseRemoteRoot, releaseObject, releaseObjectGroup, removeBreakpoint, resume, runSetupEvals, setAsyncCallStackDepth, setBreakpoint, setBreakpointAtLocation, setPauseOnExceptions, startInspectorKeepalive, stepInto, stepOut, stepOver, streamLogpoint, validateExpression, waitForPause, walkStack };
+export { type ArmedCommand, type ArmedEvent, type BreakLocation, BreakpointFanout, type BreakpointHandle, type BreakpointLocation, type CallFrameInfo, type CaptureSnapshotOptions, type CapturedExpression, CfInspectorError, type CfInspectorErrorCode, type DebuggerState, type EvaluateOnFrameOptions, type ExactBreakpointHandle, type ExceptionSnapshot, type FanoutReadyOptions, type FrameSnapshot, type GetPossibleBreakpointsOptions, type InspectorConnectOptions, type InspectorIsolate, type InspectorSession, type InspectorSessionGroup, type InspectorTarget, type InspectorWorkerTarget, type ListedScriptInfo, type LogpointConditionOptions, type LogpointEvent, type LogpointStopReason, type LogpointStreamOptions, type LogpointStreamResult, type OpenedTunnel, type PauseEvent, type PauseOnExceptionsState, type RemoteObjectInfo, type RemoteRootSetting, type ResolvedLocation, type ScopeInfo, type ScopeSnapshot, type ScriptInfo, type ScriptLocation, type SessionBreakpointOutcome, type SetBreakpointAtLocationInput, type SetBreakpointInput, type SnapshotCaptureResult, type SnapshotResult, type StackTraceFrameInfo, type StackTraceIdInfo, type StackTraceInfo, type StepIntoOptions, type TunnelTarget, type VariableSnapshot, type WaitForPauseOptions, type WalkStackOptions, type WatchEvent, buildBreakpointUrlRegex, buildHitCountedCondition, buildLogpointCondition, captureException, captureSnapshot, connectInspector, connectInspectorGroup, discoverInspectorTargets, evaluateGlobal, evaluateOnFrame, fetchInspectorVersion, getPossibleBreakpoints, getProperties, getScriptSource, listScripts, openCfTunnel, openOwnedCfTunnel, parseBreakpointSpec, parseRemoteRoot, releaseObject, releaseObjectGroup, removeBreakpoint, resume, runSetupEvals, setAsyncCallStackDepth, setBreakpoint, setBreakpointAtLocation, setPauseOnExceptions, startInspectorKeepalive, stepInto, stepOut, stepOver, streamLogpoint, validateExpression, waitForPause, walkStack };

package/dist/index.js

@@ -1220,6 +1220,8 @@ var BreakpointFanout = class {
   detachError;
   activeRace;
   pauseReasons = [];
+  pendingSetupError;
+  preserveReadinessErrors = false;
   constructor(group, setupSession, pauseReasons = []) {
     this.pauseReasons = pauseReasons;
     this.detach = group.onSession((session) => {
@@ -1245,13 +1247,51 @@ var BreakpointFanout = class {
       this.activeRace?.remove(session);
     });
     this.detachError = group.onError((error) => {
+      if (this.setupErrors.length === 0 && this.pendingSetupError === void 0) {
+        this.pendingSetupError = error;
+      }
       for (const reject of this.setupErrors) {
         reject(error);
       }
     });
   }
-  async ready() {
-    await Promise.all([...this.records.values()].map((record) => record.setup));
+  async ready(options = {}) {
+    if (options.includeNewSessions !== true) {
+      const records = [...this.records.values()];
+      await Promise.all(records.map((record) => record.setup));
+      options.onReady?.(this.outcomesFor(records));
+      return;
+    }
+    this.preserveReadinessErrors = true;
+    const pendingError = this.takePendingSetupError();
+    if (pendingError !== void 0) {
+      throw pendingError;
+    }
+    let rejectGroupError = () => void 0;
+    const groupError = new Promise((_resolve, reject) => {
+      rejectGroupError = reject;
+    });
+    this.setupErrors.push(rejectGroupError);
+    try {
+      let stableRecords;
+      while (stableRecords === void 0) {
+        const records = [...this.records.values()];
+        await Promise.race([
+          Promise.all(records.map((record) => record.setup)),
+          groupError
+        ]);
+        const stable = records.length === this.records.size && records.every((record) => this.records.get(record.session) === record);
+        if (stable) {
+          stableRecords = records;
+        }
+      }
+      options.onReady?.(this.outcomesFor(stableRecords));
+    } finally {
+      const index = this.setupErrors.indexOf(rejectGroupError);
+      if (index >= 0) {
+        this.setupErrors.splice(index, 1);
+      }
+    }
   }
   trackHandle(session, handle) {
     const record = this.records.get(session);
@@ -1260,11 +1300,19 @@ var BreakpointFanout = class {
     }
   }
   availableOutcomes() {
-    return [...this.records.values()].map((record) => ({
+    return this.outcomesFor([...this.records.values()]);
+  }
+  outcomesFor(records) {
+    return records.map((record) => ({
       session: record.session,
       setup: { handles: record.handles }
     }));
   }
+  takePendingSetupError() {
+    const error = this.pendingSetupError;
+    this.pendingSetupError = void 0;
+    return error;
+  }
   async waitForFirst(timeoutMs, options = {}, signal) {
     if (this.activeRace !== void 0) {
       throw new CfInspectorError("INVALID_ARGUMENT", "A fan-out pause race is already active");
@@ -1273,6 +1321,12 @@ var BreakpointFanout = class {
     this.pauseReasons = options.pauseReasons ?? [];
     this.activeRace = race;
     this.setupErrors.push(race.reject);
+    if (this.preserveReadinessErrors) {
+      const pendingError = this.takePendingSetupError();
+      if (pendingError !== void 0) {
+        race.reject(pendingError);
+      }
+    }
     for (const record of this.records.values()) {
       race.add(record);
     }
@@ -3227,6 +3281,9 @@ async function streamLogpoint(session, options) {
     if (event === void 0) {
       return;
     }
+    if (options.eventGate?.() === false) {
+      return;
+    }
     emitted += 1;
     try {
       options.onEvent(event);