@saptools/cf-inspector 0.3.16 → 0.3.18

package/dist/index.d.ts

@@ -147,6 +147,10 @@ declare class CdpClient {
     onClose(listener: (err: Error) => void): () => void;
     dispose(): void;
     get isClosed(): boolean;
+    private handleResponse;
+    private createRequestTimer;
+    private createWaitTimeoutError;
+    private sendPayload;
     private markClosed;
 }
 
@@ -171,7 +175,7 @@ declare function fetchInspectorVersion(host: string, port: number, timeoutMs: nu
  * Internal coordination flag between the always-on `Debugger.paused` buffer in
  * `connectInspector` and an active `waitForPause`. When `active` is true, the
  * buffer listener skips pushing the live event so it cannot be replayed by a
- * subsequent `waitForPause` call. See `connectInspector` for the full rationale.
+ * subsequent `waitForPause` call.
  */
 interface PauseWaitGate {
     active: boolean;
@@ -202,47 +206,40 @@ interface CdpEvalResult {
         };
     };
 }
-declare function connectInspector(options: InspectorConnectOptions): Promise<InspectorSession>;
+interface CdpProperty {
+    name?: unknown;
+    value?: {
+        type?: unknown;
+        value?: unknown;
+        description?: unknown;
+        objectId?: unknown;
+    };
+}
 interface SetBreakpointInput extends BreakpointLocation {
     readonly remoteRoot?: RemoteRootSetting;
     readonly condition?: string;
 }
-declare function setBreakpoint(session: InspectorSession, input: SetBreakpointInput): Promise<BreakpointHandle>;
-declare function removeBreakpoint(session: InspectorSession, breakpointId: string): Promise<void>;
 interface WaitForPauseOptions {
     readonly timeoutMs: number;
     readonly breakpointIds?: readonly string[];
     readonly unmatchedPausePolicy?: "wait-for-resume" | "fail";
     readonly onUnmatchedPause?: (pause: PauseEvent) => void;
 }
+
+declare function setBreakpoint(session: InspectorSession, input: SetBreakpointInput): Promise<BreakpointHandle>;
+declare function removeBreakpoint(session: InspectorSession, breakpointId: string): Promise<void>;
+
 declare function waitForPause(session: InspectorSession, options: WaitForPauseOptions): Promise<PauseEvent>;
+
 declare function resume(session: InspectorSession): Promise<void>;
 declare function evaluateOnFrame(session: InspectorSession, callFrameId: string, expression: string): Promise<CdpEvalResult>;
 declare function evaluateGlobal(session: InspectorSession, expression: string): Promise<CdpEvalResult>;
 declare function listScripts(session: InspectorSession): readonly ScriptInfo[];
-/**
- * Pre-compile a JS expression on the inspectee using Runtime.compileScript so
- * syntax errors surface as a CfInspectorError("INVALID_EXPRESSION") instead of
- * being silently swallowed by V8 when wired into a breakpoint condition or a
- * logpoint. Without this guard, a typo in --condition or --expr causes the
- * breakpoint to silently never fire — the user would see BREAKPOINT_NOT_HIT
- * after the timeout and have no idea why.
- *
- * persistScript: false — we don't actually want the compiled script around;
- * we just want V8 to parse it and report any SyntaxError.
- */
 declare function validateExpression(session: InspectorSession, expression: string): Promise<void>;
-interface CdpProperty {
-    name?: unknown;
-    value?: {
-        type?: unknown;
-        value?: unknown;
-        description?: unknown;
-        objectId?: unknown;
-    };
-}
 declare function getProperties(session: InspectorSession, objectId: string): Promise<readonly CdpProperty[]>;
 
+declare function connectInspector(options: InspectorConnectOptions): Promise<InspectorSession>;
+
 interface CaptureSnapshotOptions {
     readonly captures?: readonly string[];
     readonly includeScopes?: boolean;
@@ -250,6 +247,8 @@ interface CaptureSnapshotOptions {
 }
 declare function captureSnapshot(session: InspectorSession, pause: PauseEvent, options?: CaptureSnapshotOptions): Promise<SnapshotCaptureResult>;
 
+declare function buildLogpointCondition(sentinel: string, expression: string): string;
+
 interface LogpointEvent {
     readonly ts: string;
     readonly at: string;
@@ -257,6 +256,7 @@ interface LogpointEvent {
     readonly error?: string;
     readonly raw?: string;
 }
+
 interface LogpointStreamOptions {
     readonly location: BreakpointLocation;
     readonly expression: string;
@@ -264,31 +264,14 @@ interface LogpointStreamOptions {
     readonly durationMs?: number;
     readonly signal?: AbortSignal;
     readonly onEvent: (event: LogpointEvent) => void;
-    /**
-     * Fires once, immediately after `Debugger.setBreakpointByUrl` returns, with
-     * the resolved breakpoint handle. Useful for surfacing warnings such as a BP
-     * that did not bind to any script — the caller can warn the user before
-     * the stream window elapses.
-     */
     readonly onBreakpointSet?: (handle: BreakpointHandle) => void;
 }
 interface LogpointStreamResult {
     readonly handle: BreakpointHandle;
     readonly sentinel: string;
-    /** Emitted log count, including parse errors that kept the sentinel. */
     readonly emitted: number;
     readonly stoppedReason: "duration" | "signal" | "transport-closed";
 }
-/**
- * Serialize a CDP-side IIFE that runs the user's expression as a "logpoint":
- * never pauses (always returns false), tags each emitted log with a unique
- * sentinel so we can distinguish our logs from app traffic, and wraps both the
- * user expression and JSON.stringify in try/catch so a thrown expression still
- * surfaces an error event instead of silently breaking the breakpoint.
- *
- * Exported for unit testing — the wire format is part of the contract.
- */
-declare function buildLogpointCondition(sentinel: string, expression: string): string;
 declare function streamLogpoint(session: InspectorSession, options: LogpointStreamOptions): Promise<LogpointStreamResult>;
 
 interface TunnelTarget {