@deepseek-ai/dsh-experimental-inspector 0.1.6-alpha.1

package/lib/types/client/bridge/controller.d.ts

@@ -0,0 +1,10 @@
+/** Browser Client bridge construction for the Cordis plugin entry. */
+import type { InspectorClientBootstrap } from '../../shared/bridge/messages/control.ts';
+import { ClientInspectorSource } from './transport.ts';
+/**
+ * Start the browser source transport for one validated Host bootstrap.
+ * @param bootstrap - Host-injected endpoint and resource limits.
+ * @returns The active reconnecting Client source after its tab identity is claimed.
+ */
+export declare function startInspectorClient(bootstrap: InspectorClientBootstrap): Promise<ClientInspectorSource>;
+//# sourceMappingURL=controller.d.ts.map

package/lib/types/client/bridge/dispatcher.d.ts

@@ -0,0 +1,26 @@
+/** Dispatch of validated Worker frames to browser-realm capability handlers. */
+import type { ClientConsoleDisableFrame, ClientConsoleEnableFrame, ClientRuntimeCancelFrame, ClientRuntimeRequestFrame, ClientRuntimeResponseAcknowledgedFrame, ClientRuntimeSessionClosedFrame } from '../../shared/bridge/messages/runtime/index.ts';
+import type { ClientSourceRequestFrame, ClientSourceSessionClosedFrame } from '../../shared/bridge/messages/sources/index.ts';
+import type { SourceAcceptedFrame, SourceAppendAcknowledgedFrame, SourceRejectedFrame, SourceResnapshotFrame, WorkerToSourceFrame } from '../../shared/bridge/messages/observation.ts';
+/** Operations invoked for each Worker-to-Client frame family. */
+export interface ClientBridgeFrameHandlers {
+    accepted(frame: SourceAcceptedFrame): void;
+    acknowledged(frame: SourceAppendAcknowledgedFrame): void;
+    resnapshot(frame: SourceResnapshotFrame): void;
+    rejected(frame: SourceRejectedFrame): void;
+    runtime(frame: ClientRuntimeRequestFrame): void;
+    runtimeCanceled(frame: ClientRuntimeCancelFrame): void;
+    runtimeAcknowledged(frame: ClientRuntimeResponseAcknowledgedFrame): void;
+    runtimeClosed(frame: ClientRuntimeSessionClosedFrame): void;
+    consoleEnabled(frame: ClientConsoleEnableFrame): void;
+    consoleDisabled(frame: ClientConsoleDisableFrame): void;
+    sources(frame: ClientSourceRequestFrame): void;
+    sourcesClosed(frame: ClientSourceSessionClosedFrame): void;
+}
+/**
+ * Dispatch one validated Worker frame without exposing transport details to domain adapters.
+ * @param frame - Decoded Worker-to-source frame.
+ * @param handlers - Browser-realm operations for each frame family.
+ */
+export declare function dispatchBridgeFrame(frame: WorkerToSourceFrame, handlers: ClientBridgeFrameHandlers): void;
+//# sourceMappingURL=dispatcher.d.ts.map

package/lib/types/client/bridge/lifecycle.d.ts

@@ -0,0 +1,20 @@
+/** Reconnection lifecycle for the browser Client bridge. */
+/** Owns one bounded-backoff timer and prevents reconnection after disposal. */
+export declare class ClientBridgeLifecycle {
+    private readonly baseDelayMs;
+    private readonly maxDelayMs;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private closed;
+    constructor(baseDelayMs: number, maxDelayMs: number);
+    /** Reset backoff after the Worker accepts a source generation. */
+    connected(): void;
+    /**
+     * Schedule the next reconnect attempt unless one is already pending.
+     * @param connect - Operation that opens the next transport generation.
+     */
+    reconnect(connect: () => void): void;
+    /** Stop pending and future reconnect attempts. */
+    close(): void;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/types/client/bridge/publisher.d.ts

@@ -0,0 +1,42 @@
+/** Buffered Client observation publication across reconnecting WebSockets. */
+import { type InspectorSourceBufferOptions } from '../../shared/bridge/buffer.ts';
+import type { InspectorJsonValue } from '../../shared/json.ts';
+import type { InspectorStatePublisher } from '../../shared/bridge/publisher.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+/** Non-blocking Client publisher whose bounded state survives transport reconnects. */
+export declare class ClientBridgePublisher implements InspectorStatePublisher {
+    private readonly maxBufferedBytes;
+    private readonly records;
+    private active;
+    private flushTimer;
+    private closed;
+    constructor(options: InspectorSourceBufferOptions, maxBufferedBytes: number);
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    setState(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /**
+     * Install one unopened transport generation.
+     * @param socket - WebSocket carrying the generation.
+     * @param source - Source identity and generation sent by the socket.
+     */
+    connect(socket: WebSocket, source: InspectorSourceDescriptor): void;
+    /**
+     * Send retained state and queued observations after Worker acceptance.
+     * @param socket - Accepted active WebSocket.
+     */
+    accept(socket: WebSocket): void;
+    /**
+     * Resend retained state for the active generation.
+     * @param socket - WebSocket that received the resnapshot request.
+     */
+    replace(socket: WebSocket): void;
+    /**
+     * Forget one closed transport while retaining buffered state for reconnect.
+     * @param socket - WebSocket whose close event fired.
+     */
+    disconnect(socket: WebSocket): void;
+    /** Stop delayed writes and reject later publication. */
+    close(): void;
+    private flush;
+    private scheduleFlush;
+}
+//# sourceMappingURL=publisher.d.ts.map

package/lib/types/client/bridge/rpc.d.ts

@@ -0,0 +1,13 @@
+/** Client-side non-CDP query bridge over the active Worker WebSocket. */
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import { InspectorQueryConnection } from '../../shared/bridge/rpc.ts';
+/** Owns query correlation across reconnecting Client source generations. */
+export declare class ClientBridgeRpc extends InspectorQueryConnection {
+    /**
+     * Connect query writes to one accepted Client WebSocket generation.
+     * @param source - Accepted source descriptor.
+     * @param socket - Active source WebSocket.
+     */
+    connectSocket(source: InspectorSourceDescriptor, socket: WebSocket): void;
+}
+//# sourceMappingURL=rpc.d.ts.map

package/lib/types/client/bridge/transport.d.ts

@@ -0,0 +1,34 @@
+/** Client observation and Runtime endpoint over the Inspector Worker's ingest WebSocket. */
+import type { InspectorClientBootstrap } from '../../shared/bridge/messages/control.ts';
+import { InspectorSourceConnection } from '../../shared/bridge/publisher.ts';
+import { ClientSourceCatalog } from '../cdp/sources.ts';
+import { ClientRealmSource } from '../inspection/realm.ts';
+import { ClientBridgePublisher } from './publisher.ts';
+import { ClientBridgeRpc } from './rpc.ts';
+/** Reconnecting Client source whose bounded queue never blocks page work. */
+export declare class ClientInspectorSource extends InspectorSourceConnection {
+    private readonly bootstrap;
+    private readonly sourceCatalog;
+    private readonly realmSource;
+    protected readonly publisher: ClientBridgePublisher;
+    private socket;
+    private generation;
+    private accepted;
+    private closed;
+    private readonly runtime;
+    private readonly runtimeRequests;
+    private readonly console;
+    protected readonly queries: ClientBridgeRpc;
+    private readonly lifecycle;
+    constructor(bootstrap: InspectorClientBootstrap, label?: string, sourceCatalog?: ClientSourceCatalog | undefined, realmSource?: ClientRealmSource);
+    /** Permanently stop reconnecting and close the active source generation. */
+    close(): void;
+    private connect;
+    private executeRuntime;
+    private acknowledgeRuntime;
+    private cancelRuntime;
+    private cancelRuntimeSession;
+    private cancelRuntimeRequests;
+    private executeSourceRequest;
+}
+//# sourceMappingURL=transport.d.ts.map

package/lib/types/client/cdp/console.d.ts

@@ -0,0 +1,45 @@
+/** Client Console observation shared by every active DevTools Runtime session. */
+import type { ClientRemoteObjectHandle, ClientRuntimeSessionId } from '../../shared/bridge/ids.ts';
+import type { ClientConsoleCapability } from '../../shared/bridge/messages/runtime/index.ts';
+import type { RuntimeConsoleBackendEvent } from '../../shared/cdp/index.ts';
+import type { ClientRuntimeExecutor } from './runtime.ts';
+import { type ClientScriptKeyResolver } from './stack.ts';
+/**
+ * Describe browser-side Console observation.
+ * @returns The Console capability advertised by a browser Client source.
+ */
+export declare function consoleBridgeCapability(): ClientConsoleCapability;
+/** Receives one Console event whose object handles belong to the given session. */
+export type ClientConsoleSink = (sessionId: ClientRuntimeSessionId, event: RuntimeConsoleBackendEvent<ClientRemoteObjectHandle>) => void;
+/** Installs one transparent console/error observer and fans out session-local values. */
+export declare class ClientConsoleObserver {
+    private readonly runtime;
+    private readonly sink;
+    private readonly resolveScript;
+    private readonly sessions;
+    private readonly installed;
+    private active;
+    private closed;
+    constructor(runtime: ClientRuntimeExecutor, sink: ClientConsoleSink, resolveScript?: ClientScriptKeyResolver);
+    /**
+     * Start producing events for one DevTools Runtime session.
+     * @param sessionId - Session whose object table retains event arguments.
+     */
+    enable(sessionId: ClientRuntimeSessionId): void;
+    /**
+     * Stop producing events and release Console objects for one session.
+     * @param sessionId - Session being disabled or closed.
+     */
+    disable(sessionId: ClientRuntimeSessionId): void;
+    /** Restore original browser hooks and clear every active session. */
+    close(): void;
+    /** Stop observing the current source generation while allowing a later reconnect. */
+    reset(): void;
+    private install;
+    private uninstall;
+    private readonly onError;
+    private readonly onUnhandledRejection;
+    private captureConsole;
+    private captureException;
+}
+//# sourceMappingURL=console.d.ts.map

package/lib/types/client/cdp/debugger.d.ts

@@ -0,0 +1,8 @@
+/** Client active debugging is not exposed by the source bridge. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe unavailable browser-side active debugging.
+ * @returns No source capability until a pause-safe Client debugger agent exists.
+ */
+export declare function debuggerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=debugger.d.ts.map

package/lib/types/client/cdp/errors.d.ts

@@ -0,0 +1,8 @@
+/** Client Runtime failures that belong to the transport rather than evaluated JavaScript. */
+import type { ClientRuntimeError } from '../../shared/bridge/messages/runtime/index.ts';
+/** Failure returned through the typed Client Runtime error outcome. */
+export declare class ClientRuntimeExecutionError extends Error {
+    readonly code: ClientRuntimeError['code'];
+    constructor(code: ClientRuntimeError['code'], message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/types/client/cdp/heap-profiler.d.ts

@@ -0,0 +1,8 @@
+/** Client heap profiling is not exposed by the source bridge. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe unavailable browser-side heap profiling.
+ * @returns No source capability for Client heap profiling.
+ */
+export declare function heapProfilerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=heap-profiler.d.ts.map

package/lib/types/client/cdp/index.d.ts

@@ -0,0 +1,10 @@
+/** Source-side CDP capability declarations for the browser Client realm. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Client operations that require Worker-to-page bridge messages.
+ * @param origin - Origin assigned to the synthetic execution context.
+ * @param hasSources - Whether the Client bundle source was discovered.
+ * @returns Capabilities included in the Client source handshake.
+ */
+export declare function bridgeCapabilities(origin: string, hasSources: boolean): readonly InspectorSourceCapability[];
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/cdp/objects.d.ts

@@ -0,0 +1,69 @@
+/** Client-local object handles and CDP-compatible RemoteObject serialization. */
+import { type ClientRemoteObjectHandle } from '../../shared/bridge/ids.ts';
+import type { ClientRuntimeRemoteObject } from '../../shared/bridge/messages/runtime/index.ts';
+/** Opaque set of handles allocated by one Client Runtime operation. */
+export type ClientObjectAllocation = symbol;
+/** Serialization choices inherited by child RemoteObjects. */
+export interface ClientRuntimeObjectOptions {
+    readonly group?: string;
+    readonly generatePreview?: boolean;
+    readonly returnByValue?: boolean;
+}
+/** Per-DevTools-session owner of all live Client object references. */
+export declare class ClientObjectStore {
+    private readonly maxObjects;
+    private readonly objects;
+    private readonly groups;
+    private readonly allocations;
+    private nextOrdinal;
+    constructor(maxObjects: number);
+    /**
+     * Start tracking handles allocated by one independently settling operation.
+     * @returns An opaque allocation identity.
+     */
+    beginAllocation(): ClientObjectAllocation;
+    /**
+     * Keep an operation's handles and release its allocation bookkeeping.
+     * @param allocation - Allocation returned by {@link beginAllocation}.
+     */
+    commitAllocation(allocation: ClientObjectAllocation): void;
+    /**
+     * Resolve one handle or fail without exposing another session's objects.
+     * @param handle - Client-local object handle.
+     * @returns The retained JavaScript value.
+     */
+    get(handle: ClientRemoteObjectHandle): unknown;
+    /**
+     * Read the object group inherited by values reached through one handle.
+     * @param handle - Client-local object handle.
+     * @returns Its object group, or `undefined` when it is ungrouped.
+     */
+    group(handle: ClientRemoteObjectHandle): string | undefined;
+    /**
+     * Convert a live value to the JSON-safe RemoteObject protocol.
+     * @param value - Value owned by this Client realm.
+     * @param options - Object group and serialization options.
+     * @param allocation - Optional operation that owns any newly retained handle.
+     * @returns A primitive value or opaque Client handle with display metadata.
+     */
+    serialize(value: unknown, options?: ClientRuntimeObjectOptions, allocation?: ClientObjectAllocation): ClientRuntimeRemoteObject;
+    /**
+     * Release exactly one handle. Releasing an unknown handle is idempotent.
+     * @param handle - Client-local object handle.
+     */
+    release(handle: ClientRemoteObjectHandle): void;
+    /**
+     * Release every handle in one DevTools object group.
+     * @param group - DevTools object-group name.
+     */
+    releaseGroup(group: string): void;
+    /**
+     * Discard exactly the handles allocated by one failed operation.
+     * @param allocation - Allocation returned by {@link beginAllocation}.
+     */
+    rollback(allocation: ClientObjectAllocation): void;
+    /** Release the whole DevTools session. */
+    clear(): void;
+    private register;
+}
+//# sourceMappingURL=objects.d.ts.map

package/lib/types/client/cdp/profiler.d.ts

@@ -0,0 +1,8 @@
+/** Client CPU profiling is not exposed by the source bridge. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe unavailable browser-side CPU profiling.
+ * @returns No source capability for Client CPU profiling.
+ */
+export declare function profilerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=profiler.d.ts.map

package/lib/types/client/cdp/properties.d.ts

@@ -0,0 +1,16 @@
+/** Lazy Client property enumeration for `Runtime.getProperties`. */
+import type { ClientRuntimeGetPropertiesCommand, ClientRuntimeInternalPropertyDescriptor, ClientRuntimePropertyDescriptor } from '../../shared/bridge/messages/runtime/index.ts';
+import { ClientObjectStore, type ClientObjectAllocation } from './objects.ts';
+/**
+ * Read property descriptors without invoking getters.
+ * @param objects - Object table that owns the requested handle.
+ * @param command - Validated property request.
+ * @param maxProperties - Maximum descriptors returned by this operation.
+ * @param allocation - Current operation's object-allocation identity.
+ * @returns Own or inherited descriptors and the immediate prototype.
+ */
+export declare function getClientProperties(objects: ClientObjectStore, command: ClientRuntimeGetPropertiesCommand, maxProperties: number, allocation: ClientObjectAllocation): {
+    readonly properties: readonly ClientRuntimePropertyDescriptor[];
+    readonly internalProperties?: readonly ClientRuntimeInternalPropertyDescriptor[];
+};
+//# sourceMappingURL=properties.d.ts.map

package/lib/types/client/cdp/runtime.d.ts

@@ -0,0 +1,79 @@
+/** Client-realm executor for the typed Runtime command protocol. */
+import type { ClientRuntimeCapability, ClientRuntimeRequestFrame, ClientRuntimeResponseFrame } from '../../shared/bridge/messages/runtime/index.ts';
+import type { ClientRemoteObjectHandle, ClientRuntimeRequestId, ClientRuntimeSessionId } from '../../shared/bridge/ids.ts';
+import type { RuntimeConsoleBackendEvent, RuntimeConsoleType, RuntimeStackTrace } from '../../shared/cdp/index.ts';
+import { type ClientScriptKeyResolver } from './stack.ts';
+/**
+ * Describe browser-side Runtime execution.
+ * @param origin - Origin assigned to the synthetic execution context.
+ * @returns The Runtime capability advertised by a browser Client source.
+ */
+export declare function runtimeBridgeCapability(origin: string): ClientRuntimeCapability;
+/** Client-side limits injected by the Host deployment. */
+export interface ClientRuntimeLimits {
+    readonly maxObjectsPerSession: number;
+    readonly maxPropertiesPerResult: number;
+    readonly maxResponseBytes: number;
+}
+/** Executes Runtime requests while isolating object handles by DevTools session. */
+export declare class ClientRuntimeExecutor {
+    private readonly limits;
+    private readonly resolveScript;
+    private readonly sessions;
+    private readonly responseAllocations;
+    constructor(limits: ClientRuntimeLimits, resolveScript?: ClientScriptKeyResolver);
+    /**
+     * Execute one request and preserve its source, generation, session, and request identities.
+     * @param frame - Validated command envelope from the Worker.
+     * @param signal - Optional cancellation for an operation awaiting user code.
+     * @param deferObjectCommit - Keep new object handles provisional until {@link acknowledge}.
+     * @returns A success or transport-error response for the same request.
+     */
+    execute(frame: ClientRuntimeRequestFrame, signal?: AbortSignal, deferObjectCommit?: boolean): Promise<ClientRuntimeResponseFrame>;
+    /**
+     * Commit handles after the Worker accepts one Runtime response.
+     * @param sessionId - Session that owns the response.
+     * @param requestId - Correlation id acknowledged by the Worker.
+     */
+    acknowledge(sessionId: ClientRuntimeSessionId, requestId: ClientRuntimeRequestId): void;
+    /**
+     * Roll back handles from a canceled or otherwise unaccepted Runtime response.
+     * @param sessionId - Session that owns the response.
+     * @param requestId - Correlation id rejected by the Worker.
+     */
+    cancel(sessionId: ClientRuntimeSessionId, requestId: ClientRuntimeRequestId): void;
+    /**
+     * Release all values retained for one closed DevTools connection.
+     * @param sessionId - Runtime session owned by that DevTools connection.
+     */
+    closeSession(sessionId: ClientRuntimeSessionId): void;
+    /**
+     * Release one object group without closing the surrounding Runtime session.
+     * @param sessionId - Session that owns the retained objects.
+     * @param group - Object-group name to release.
+     */
+    releaseObjectGroup(sessionId: ClientRuntimeSessionId, group: string): void;
+    /**
+     * Serialize one Console call for a specific DevTools Runtime session.
+     * @param sessionId - Session receiving the Console event.
+     * @param type - Console API operation.
+     * @param values - Original arguments from the page call.
+     * @param timestamp - Epoch timestamp in milliseconds.
+     * @param stackTrace - Browser call frames captured before deferred delivery.
+     * @returns A wire-safe event whose object handles belong only to this session.
+     */
+    consoleEvent(sessionId: ClientRuntimeSessionId, type: RuntimeConsoleType, values: readonly unknown[], timestamp: number, stackTrace?: RuntimeStackTrace): RuntimeConsoleBackendEvent<ClientRemoteObjectHandle> | undefined;
+    /**
+     * Serialize one uncaught Client exception for a DevTools Runtime session.
+     * @param sessionId - Session receiving the exception event.
+     * @param error - Thrown or rejected value.
+     * @param timestamp - Epoch timestamp in milliseconds.
+     * @param stackTrace - Browser call frames attached to the failure.
+     * @returns A wire-safe exception event.
+     */
+    exceptionEvent(sessionId: ClientRuntimeSessionId, error: unknown, timestamp: number, stackTrace?: RuntimeStackTrace): RuntimeConsoleBackendEvent<ClientRemoteObjectHandle> | undefined;
+    /** Release all sessions when a source generation ends or reconnects. */
+    reset(): void;
+    private session;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/client/cdp/sources.d.ts

@@ -0,0 +1,52 @@
+/** Browser-side catalog for the Inspector Client bundle and its source map. */
+import type { ClientSourceCommand, ClientSourceError, ClientSourceResult, ClientSourcesCapability } from '../../shared/bridge/messages/sources/index.ts';
+import type { RuntimeScriptKey } from '../../shared/cdp/ids.ts';
+/**
+ * Describe browser-side source access.
+ * @param available - Whether the Client bundle was discovered.
+ * @returns The Sources capability when this Client discovered its bundle.
+ */
+export declare function sourcesBridgeCapability(available: boolean): ClientSourcesCapability | undefined;
+/** One lazily loaded browser script exposed by a Client source catalog. */
+export interface ClientSourceAsset {
+    readonly scriptKey: RuntimeScriptKey;
+    readonly url: string;
+    readonly hash: string;
+    readonly sourceMapUrl?: string;
+    readonly isModule?: boolean;
+    loadSource(): Promise<string>;
+    loadSourceMap?(): Promise<string | undefined>;
+}
+/** Deliberate error serialized by the Client source transport. */
+export declare class ClientSourceCatalogError extends Error {
+    readonly code: ClientSourceError['code'];
+    constructor(code: ClientSourceError['code'], message: string);
+}
+/** Executes bounded, read-only operations over Client script assets. */
+export declare class ClientSourceCatalog {
+    private readonly assets;
+    constructor(assets: readonly ClientSourceAsset[]);
+    /**
+     * Resolve a stack-frame URL to this catalog's local script key.
+     * @param url - Absolute or page-relative stack-frame URL.
+     * @returns The matching script key when the URL belongs to this catalog.
+     */
+    scriptKeyForUrl(url: string): RuntimeScriptKey | undefined;
+    /**
+     * Execute one validated source operation.
+     * @param command - Read-only catalog command.
+     * @param maxContentBytes - Maximum encoded bytes admitted for one asset.
+     * @returns Script metadata or one bounded content chunk.
+     */
+    execute(command: ClientSourceCommand, maxContentBytes: number): Promise<ClientSourceResult>;
+    private describe;
+    private source;
+    private sourceBytes;
+    private sourceMapBytes;
+}
+/**
+ * Discover this package's bundle URL from the Host-injected web boot graph.
+ * @returns A lazy catalog, or `undefined` outside the assembled web application.
+ */
+export declare function discoverInspectorClientSourceCatalog(): ClientSourceCatalog | undefined;
+//# sourceMappingURL=sources.d.ts.map

package/lib/types/client/cdp/stack.d.ts

@@ -0,0 +1,27 @@
+/** Browser stack parsing for realm-neutral Runtime and Console events. */
+import type { RuntimeScriptKey } from '../../shared/cdp/ids.ts';
+import type { RuntimeStackTrace } from '../../shared/cdp/index.ts';
+/** Resolve a browser stack-frame URL to a Client catalog script key. */
+export type ClientScriptKeyResolver = (url: string) => RuntimeScriptKey | undefined;
+/**
+ * Capture the caller stack of a wrapped Client Console method.
+ * @param resolveScript - Resolver for Client catalog script keys.
+ * @returns Parsed call frames when the browser supplies a stack.
+ */
+export declare function captureClientConsoleStack(resolveScript: ClientScriptKeyResolver): RuntimeStackTrace | undefined;
+/**
+ * Parse the stack attached to an uncaught Client value when available.
+ * @param value - Thrown or rejected value.
+ * @param resolveScript - Resolver for Client catalog script keys.
+ * @returns Parsed call frames when the value has a recognized stack string.
+ */
+export declare function clientErrorStack(value: unknown, resolveScript?: ClientScriptKeyResolver): RuntimeStackTrace | undefined;
+/**
+ * Parse V8- and Firefox-style textual frames into the common stack model.
+ * @param stack - Browser stack text.
+ * @param resolveScript - Resolver for Client catalog script keys.
+ * @param skipFrames - Parsed observer frames omitted from the result.
+ * @returns Parsed call frames, or `undefined` when none remain.
+ */
+export declare function parseClientStack(stack: string | undefined, resolveScript: ClientScriptKeyResolver, skipFrames: number): RuntimeStackTrace | undefined;
+//# sourceMappingURL=stack.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,3 @@
+/** Browser Client entry for the experimental Inspector Cordis plugin. */
+export * from './plugin.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/inspection/cordis.d.ts

@@ -0,0 +1,3 @@
+/** Client entry for the shared Cordis snapshot publisher. */
+export { publishCordisTree } from '../../shared/cordis/publisher.ts';
+//# sourceMappingURL=cordis.d.ts.map

package/lib/types/client/inspection/network.d.ts

@@ -0,0 +1,4 @@
+/** Client network observation is not enabled in the current source producer. */
+/** Observation topics published by the Client network adapter. */
+export declare const NETWORK_TOPICS: readonly string[];
+//# sourceMappingURL=network.d.ts.map

package/lib/types/client/inspection/realm.d.ts

@@ -0,0 +1,27 @@
+/** Stable Client source identity with a fresh descriptor for each WebSocket generation. */
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+/** Owns one browser realm's stable source id across transport reconnects. */
+export declare class ClientRealmSource {
+    private readonly label;
+    private releaseClaim?;
+    /** Logical source id retained across reconnecting transport generations. */
+    readonly sourceId: InspectorSourceDescriptor['sourceId'];
+    constructor(label: string, sourceId?: import("../../shared/index.ts").InspectorSourceId, releaseClaim?: (() => void) | undefined);
+    /**
+     * Claim the tab identity before opening its source transport. Browsers with
+     * Web Locks reject a copied `sessionStorage` identity while its original tab
+     * remains live; a fresh id is persisted and claimed instead.
+     * @param label - Human-readable Client label reported to the Worker.
+     * @returns The claimed realm source.
+     */
+    static claim(label: string): Promise<ClientRealmSource>;
+    /**
+     * Create the descriptor for one newly admitted transport generation.
+     * @param hasSources - Whether the built Client bundle is available for source reads.
+     * @returns A source descriptor with a fresh generation.
+     */
+    connect(hasSources: boolean): InspectorSourceDescriptor;
+    /** Release this page's identity claim. */
+    close(): void;
+}
+//# sourceMappingURL=realm.d.ts.map

package/lib/types/client/plugin.d.ts

@@ -0,0 +1,28 @@
+/** Client Cordis plugin that publishes browser observations directly to the Inspector Worker. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type InspectorService as SharedInspectorService } from '../shared/service.ts';
+export type { CordisRuntimeTreeReader } from '../shared/cordis/reader.ts';
+export type { CordisRuntimeConnection, CordisRuntimeContext, CordisRuntimeFiber, CordisRuntimeNode, CordisRuntimeRealm, CordisRuntimeSource, CordisRuntimeTree, } from '../shared/cordis/model.ts';
+/** Client-facing Inspector service backed by the shared implementation. */
+export interface InspectorService extends SharedInspectorService {
+}
+declare global {
+    /** Host-injected Inspector Client connection parameters. */
+    var __DSH_INSPECTOR__: unknown;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Publish Client-realm observations and query the shared Inspector state. */
+        inspector: InspectorService;
+    }
+}
+/** Cordis plugin name shared with the Host face. */
+export declare const name = "experimental-inspector";
+/** This transport root has no Client service dependencies. */
+export declare const inject: string[];
+/**
+ * Mount the Client source and shared `ctx.inspector` publishing API.
+ * @param ctx - Client Cordis context whose page identity and lifecycle own the source.
+ */
+export declare function apply(ctx: Context): Promise<void>;
+//# sourceMappingURL=plugin.d.ts.map