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

package/lib/types/shared/bridge/messages/control.d.ts

@@ -0,0 +1,64 @@
+/** Host-to-Worker lifecycle messages and Worker readiness results. */
+/** Fully resolved Worker configuration. */
+export interface InspectorWorkerConfig {
+    readonly host: '127.0.0.1';
+    /** First port to bind; zero delegates selection to the operating system. */
+    readonly startPort: number;
+    readonly targetId: string;
+    readonly clientToken: string;
+    readonly clientOrigins: readonly string[];
+    readonly maxSourceFrameBytes: number;
+    readonly maxSourceRecordsPerFrame: number;
+    readonly maxRetainedRequests: number;
+    readonly maxJournalBytes: number;
+    readonly clientRuntimeTimeoutMs: number;
+    readonly maxClientSourceBytes: number;
+    readonly maxCordisNodes: number;
+    readonly maxDisconnectedCordisTrees: number;
+}
+/** Structured-clone payload used to start the Inspector Worker. */
+export interface InspectorWorkerBoot<Port> {
+    readonly config: InspectorWorkerConfig;
+    readonly hostSourcePort: Port;
+}
+/** Host request to stop accepting traffic and close every Worker-owned resource. */
+export interface InspectorWorkerShutdown {
+    readonly type: 'shutdown';
+}
+/** Every control message sent from Host to Worker after boot. */
+export type InspectorHostControl = InspectorWorkerShutdown;
+/** Worker endpoint readiness. */
+export interface InspectorWorkerReady {
+    readonly type: 'ready';
+    readonly host: string;
+    readonly port: number;
+    readonly targetId: string;
+}
+/** Worker startup or runtime failure. */
+export interface InspectorWorkerFailure {
+    readonly type: 'failure';
+    readonly message: string;
+}
+/** Worker completed graceful shutdown. */
+export interface InspectorWorkerStopped {
+    readonly type: 'stopped';
+}
+/** Every control message sent from Worker to Host. */
+export type InspectorWorkerControl = InspectorWorkerReady | InspectorWorkerFailure | InspectorWorkerStopped;
+/** Browser bootstrap injected by the Host plugin. */
+export interface InspectorClientBootstrap {
+    readonly endpoint: string;
+    readonly protocol: string;
+    readonly maxQueuedRecords: number;
+    readonly maxQueuedBytes: number;
+    readonly maxRecordsPerFrame: number;
+    readonly maxFrameBytes: number;
+    readonly reconnectBaseMs: number;
+    readonly reconnectMaxMs: number;
+    readonly queryTimeoutMs: number;
+    readonly maxRuntimeObjectsPerSession: number;
+    readonly maxRuntimePropertiesPerResult: number;
+    readonly maxClientSourceBytes: number;
+    readonly maxCordisNodes: number;
+}
+//# sourceMappingURL=control.d.ts.map

package/lib/types/shared/bridge/messages/cordis.d.ts

@@ -0,0 +1,4 @@
+/** Bridge message metadata for Cordis runtime-tree snapshots. */
+/** Observation topic carrying the latest complete Cordis tree. */
+export declare const CORDIS_TREE_TOPIC = "cordis/tree";
+//# sourceMappingURL=cordis.d.ts.map

package/lib/types/shared/bridge/messages/network.d.ts

@@ -0,0 +1,4 @@
+/** Observation topic names carried by the internal bridge for captured fetches. */
+/** Complete set of fetch observation topics. */
+export declare const FETCH_TOPICS: readonly ["fetch/start", "fetch/request-body-chunk", "fetch/request-body-end", "fetch/response", "fetch/response-body-chunk", "fetch/end", "fetch/error"];
+//# sourceMappingURL=network.d.ts.map

package/lib/types/shared/bridge/messages/observation.d.ts

@@ -0,0 +1,110 @@
+/** Versioned source lifecycle, observation, and extension frames shared by both carriers. */
+import { type InspectorSourceGeneration, type InspectorSourceId } from '../ids.ts';
+import { type InspectorJsonValue } from '../../json.ts';
+import { INSPECTOR_PROTOCOL_VERSION } from '../version.ts';
+import { type ClientConsoleCapability, type ClientConsoleDisableFrame, type ClientConsoleEnableFrame, type ClientConsoleEventFrame, type ClientRuntimeCapability, type ClientRuntimeCancelFrame, type ClientRuntimeRequestFrame, type ClientRuntimeResponseAcknowledgedFrame, type ClientRuntimeResponseFrame, type ClientRuntimeSessionClosedFrame } from './runtime/index.ts';
+import { type ClientSourceRequestFrame, type ClientSourceResponseFrame, type ClientSourceSessionClosedFrame, type ClientSourcesCapability } from './sources/index.ts';
+export { INSPECTOR_PROTOCOL_VERSION } from '../version.ts';
+/** Realm producing observations. */
+export type InspectorSourceKind = 'host' | 'client';
+/** Optional protocols implemented by one source generation. */
+export type InspectorSourceCapability = ClientRuntimeCapability | ClientConsoleCapability | ClientSourcesCapability;
+/** One logical source and connection generation. */
+export interface InspectorSourceDescriptor {
+    /** Producer identity retained across transport reconnects. */
+    readonly sourceId: InspectorSourceId;
+    /** One transport admission, replaced on every reconnect. */
+    readonly generation: InspectorSourceGeneration;
+    readonly kind: InspectorSourceKind;
+    readonly label: string;
+    readonly timeOriginMs: number;
+    readonly capabilities: readonly InspectorSourceCapability[];
+}
+/** One domain-owned observation before its sequence is assigned. */
+export interface InspectorRecordInput {
+    readonly monotonicMs: number;
+    readonly topic: string;
+    readonly payload: InspectorJsonValue;
+}
+/** Initial source handshake. */
+export interface SourceOpenFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/open';
+    readonly source: InspectorSourceDescriptor;
+    readonly topics: readonly string[];
+}
+/** Replace one source's current state after opening or resynchronization. */
+export interface SourceReplaceFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/replace';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly nextSequence: number;
+    readonly records: readonly InspectorRecordInput[];
+}
+/** Append one contiguous observation batch. */
+export interface SourceAppendFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/append';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly firstSequence: number;
+    readonly droppedBefore: number;
+    readonly records: readonly InspectorRecordInput[];
+}
+/** Clean source closure. */
+export interface SourceCloseFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/close';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+}
+/** Every source-to-Worker frame. */
+export type SourceToWorkerFrame = SourceOpenFrame | SourceReplaceFrame | SourceAppendFrame | SourceCloseFrame | ClientConsoleEventFrame | ClientRuntimeResponseFrame | ClientSourceResponseFrame;
+/** Worker acceptance of one source generation. */
+export interface SourceAcceptedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/accepted';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+}
+/** Worker acknowledgement that releases one Host MessagePort batch credit. */
+export interface SourceAppendAcknowledgedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/append-acknowledged';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly nextSequence: number;
+}
+/** Worker request for a complete source-state replacement. */
+export interface SourceResnapshotFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/resnapshot';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly expectedSequence: number;
+    readonly reason: string;
+}
+/** Rejection of one malformed or incompatible source connection. */
+export interface SourceRejectedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'source/rejected';
+    readonly code: 'invalid-frame' | 'version-mismatch' | 'unauthorized';
+    readonly message: string;
+}
+/** Every Worker-to-source control frame. */
+export type WorkerToSourceFrame = SourceAcceptedFrame | SourceAppendAcknowledgedFrame | SourceResnapshotFrame | SourceRejectedFrame | ClientConsoleEnableFrame | ClientConsoleDisableFrame | ClientRuntimeCancelFrame | ClientRuntimeRequestFrame | ClientRuntimeResponseAcknowledgedFrame | ClientRuntimeSessionClosedFrame | ClientSourceRequestFrame | ClientSourceSessionClosedFrame;
+/**
+ * Parse and rebuild one Worker control frame received by a source.
+ * @param value - Untrusted decoded wire value.
+ * @returns The validated Worker-to-source frame.
+ */
+export declare function parseWorkerSourceFrame(value: unknown): WorkerToSourceFrame;
+/**
+ * Parse and rebuild one source frame received at a process or network boundary.
+ * @param value - Untrusted decoded wire value.
+ * @param maxRecords - Maximum records admitted in one frame.
+ * @returns The validated source-to-Worker frame.
+ */
+export declare function parseSourceFrame(value: unknown, maxRecords: number): SourceToWorkerFrame;
+//# sourceMappingURL=observation.d.ts.map

package/lib/types/shared/bridge/messages/query/codec.d.ts

@@ -0,0 +1,40 @@
+/** Exact decoders for non-CDP Inspector query frames. */
+import type { InspectorQueryRequestFrame, InspectorQueryRequestId, InspectorQueryResponseFrame } from './frames.ts';
+import type { InspectorSourceGeneration, InspectorSourceId } from '../../ids.ts';
+/** Correlation fields recoverable before a query body is accepted. */
+export interface InspectorQueryFrameIdentity {
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly requestId: InspectorQueryRequestId;
+}
+/**
+ * Test whether a decoded carrier value belongs to the query request protocol.
+ * @param value - Decoded carrier value.
+ * @returns Whether the query request decoder owns the value.
+ */
+export declare function isInspectorQueryRequestEnvelope(value: unknown): boolean;
+/**
+ * Test whether a decoded carrier value belongs to the query response protocol.
+ * @param value - Decoded carrier value.
+ * @returns Whether the query response decoder owns the value.
+ */
+export declare function isInspectorQueryResponseEnvelope(value: unknown): boolean;
+/**
+ * Decode one source-to-Worker query request.
+ * @param value - Untrusted decoded carrier value.
+ * @returns The detached, validated request frame.
+ */
+export declare function parseInspectorQueryRequestFrame(value: unknown): InspectorQueryRequestFrame;
+/**
+ * Decode correlation fields used to reject a malformed request without timing out its caller.
+ * @param value - Candidate query request frame.
+ * @returns Validated source and request identities.
+ */
+export declare function parseInspectorQueryFrameIdentity(value: unknown): InspectorQueryFrameIdentity;
+/**
+ * Decode one Worker-to-source query response.
+ * @param value - Untrusted decoded carrier value.
+ * @returns The detached, validated response frame.
+ */
+export declare function parseInspectorQueryResponseFrame(value: unknown): InspectorQueryResponseFrame;
+//# sourceMappingURL=codec.d.ts.map

package/lib/types/shared/bridge/messages/query/commands.d.ts

@@ -0,0 +1,35 @@
+/** Closed non-CDP Inspector query and result model. */
+import type { CordisRuntimeTree } from '../../../cordis/model.ts';
+/** Read the latest committed Cordis runtime tree. */
+export interface CordisTreeGetQuery {
+    readonly op: 'cordis-tree/get';
+}
+/** Query operations accepted by the Inspector Worker. */
+export type InspectorQuery = CordisTreeGetQuery;
+/** Result of reading the latest committed Cordis runtime tree. */
+export interface CordisTreeGetResult {
+    readonly op: 'cordis-tree/get';
+    readonly tree: CordisRuntimeTree;
+}
+/** Results correlated to {@link InspectorQuery} by `op`. */
+export type InspectorQueryResult = CordisTreeGetResult;
+/** Result member corresponding to one query member. */
+export type InspectorQueryResultFor<Query extends InspectorQuery> = Extract<InspectorQueryResult, {
+    op: Query['op'];
+}>;
+/** Stable Worker-side query failure. */
+export interface InspectorQueryError {
+    readonly code: 'invalid-request' | 'stale-source' | 'result-too-large' | 'internal-error';
+    readonly message: string;
+}
+/** Host/Client interface implemented by the shared correlated-query owner. */
+export interface InspectorQueryRequester {
+    /**
+     * Execute one query against the current connected source generation.
+     * @param query - Closed typed query command.
+     * @returns The result with the same operation discriminant.
+     * @throws When transport or Worker processing cannot settle the request successfully.
+     */
+    request<Query extends InspectorQuery>(query: Query): Promise<InspectorQueryResultFor<Query>>;
+}
+//# sourceMappingURL=commands.d.ts.map

package/lib/types/shared/bridge/messages/query/frames.d.ts

@@ -0,0 +1,31 @@
+/** Versioned frames for source-to-Worker non-CDP queries. */
+import type { InspectorId, InspectorSourceGeneration, InspectorSourceId } from '../../ids.ts';
+import { INSPECTOR_PROTOCOL_VERSION } from '../../version.ts';
+import type { InspectorQuery, InspectorQueryError, InspectorQueryResult } from './commands.ts';
+/** Identity of one in-flight Inspector query. */
+export type InspectorQueryRequestId = InspectorId<'InspectorQueryRequestId'>;
+/** Source request for one Worker-owned query operation. */
+export interface InspectorQueryRequestFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'query/request';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly requestId: InspectorQueryRequestId;
+    readonly query: InspectorQuery;
+}
+/** Worker response correlated to one source query request. */
+export interface InspectorQueryResponseFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'query/response';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly requestId: InspectorQueryRequestId;
+    readonly outcome: {
+        readonly ok: true;
+        readonly result: InspectorQueryResult;
+    } | {
+        readonly ok: false;
+        readonly error: InspectorQueryError;
+    };
+}
+//# sourceMappingURL=frames.d.ts.map

package/lib/types/shared/bridge/messages/query/index.d.ts

@@ -0,0 +1,5 @@
+/** Public exports for the non-CDP Inspector query protocol. */
+export * from './codec.ts';
+export * from './commands.ts';
+export * from './frames.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/bridge/messages/runtime/command-codec.d.ts

@@ -0,0 +1,9 @@
+/** Exact wire decoder for Client Runtime commands. */
+import type { ClientRuntimeCommand } from './commands.ts';
+/**
+ * Parse and rebuild one Runtime command before it enters the Client realm.
+ * @param value - Untrusted command value.
+ * @returns The validated command union member.
+ */
+export declare function parseClientRuntimeCommand(value: unknown): ClientRuntimeCommand;
+//# sourceMappingURL=command-codec.d.ts.map

package/lib/types/shared/bridge/messages/runtime/commands.d.ts

@@ -0,0 +1,76 @@
+/** Closed command/result protocol for Runtime operations executed by a Client. */
+import type { ClientRemoteObjectHandle } from '../../ids.ts';
+import type { RuntimeExceptionDetails, RuntimeInternalPropertyDescriptor, RuntimeCallArgument, RuntimeAwaitPromiseRequest, RuntimeCallFunctionRequest, RuntimeCompletion, RuntimeEvaluateRequest, RuntimeGetPropertiesRequest, RuntimePropertyDescriptor, RuntimeRemoteObject } from '../../../cdp/index.ts';
+/** Runtime object serialized with one Client-session handle when retained. */
+export type ClientRuntimeRemoteObject = RuntimeRemoteObject<ClientRemoteObjectHandle>;
+/** Property descriptor whose retained values use Client-session handles. */
+export type ClientRuntimePropertyDescriptor = RuntimePropertyDescriptor<ClientRemoteObjectHandle>;
+/** Internal property descriptor whose retained values use Client-session handles. */
+export type ClientRuntimeInternalPropertyDescriptor = RuntimeInternalPropertyDescriptor<ClientRemoteObjectHandle>;
+/** Exception details whose retained value uses a Client-session handle. */
+export type ClientRuntimeExceptionDetails = RuntimeExceptionDetails<ClientRemoteObjectHandle>;
+/** One argument supplied to a function in the Client realm. */
+export type ClientCallArgument = RuntimeCallArgument<ClientRemoteObjectHandle>;
+/** Evaluate source text in the Client global execution context. */
+export interface ClientRuntimeEvaluateCommand extends RuntimeEvaluateRequest {
+    readonly op: 'evaluate';
+}
+/** Enumerate properties of one retained Client object. */
+export interface ClientRuntimeGetPropertiesCommand extends RuntimeGetPropertiesRequest<ClientRemoteObjectHandle> {
+    readonly op: 'get-properties';
+}
+/** Invoke a function declaration with Client-local receivers and arguments. */
+export interface ClientRuntimeCallFunctionCommand extends RuntimeCallFunctionRequest<ClientRemoteObjectHandle> {
+    readonly op: 'call-function';
+}
+/** Await one retained Client promise. */
+export interface ClientRuntimeAwaitPromiseCommand extends RuntimeAwaitPromiseRequest<ClientRemoteObjectHandle> {
+    readonly op: 'await-promise';
+}
+/** Release one retained Client object. */
+export interface ClientRuntimeReleaseObjectCommand {
+    readonly op: 'release-object';
+    readonly handle: ClientRemoteObjectHandle;
+}
+/** Release every Client object retained under one DevTools object group. */
+export interface ClientRuntimeReleaseObjectGroupCommand {
+    readonly op: 'release-object-group';
+    readonly objectGroup: string;
+}
+/** Read names visible in the Client global lexical scope. */
+export interface ClientRuntimeGlobalLexicalScopeNamesCommand {
+    readonly op: 'global-lexical-scope-names';
+}
+/** Closed command set implemented by the Client Runtime transport. */
+export type ClientRuntimeCommand = ClientRuntimeEvaluateCommand | ClientRuntimeGetPropertiesCommand | ClientRuntimeCallFunctionCommand | ClientRuntimeAwaitPromiseCommand | ClientRuntimeReleaseObjectCommand | ClientRuntimeReleaseObjectGroupCommand | ClientRuntimeGlobalLexicalScopeNamesCommand;
+/** Shared result of evaluation, function calls, and promise awaiting. */
+export type ClientRuntimeCompletion = RuntimeCompletion<ClientRemoteObjectHandle>;
+/** Result discriminant mirrors the command and prevents cross-method settlement. */
+export type ClientRuntimeResult = {
+    readonly op: 'evaluate';
+    readonly completion: ClientRuntimeCompletion;
+} | {
+    readonly op: 'get-properties';
+    readonly properties: readonly ClientRuntimePropertyDescriptor[];
+    readonly internalProperties?: readonly ClientRuntimeInternalPropertyDescriptor[];
+    readonly exceptionDetails?: ClientRuntimeExceptionDetails;
+} | {
+    readonly op: 'call-function';
+    readonly completion: ClientRuntimeCompletion;
+} | {
+    readonly op: 'await-promise';
+    readonly completion: ClientRuntimeCompletion;
+} | {
+    readonly op: 'release-object';
+} | {
+    readonly op: 'release-object-group';
+} | {
+    readonly op: 'global-lexical-scope-names';
+    readonly names: readonly string[];
+};
+/** Stable transport-level failures distinct from evaluated JavaScript exceptions. */
+export interface ClientRuntimeError {
+    readonly code: 'invalid-request' | 'object-not-found' | 'unsupported' | 'timeout' | 'result-too-large' | 'internal-error';
+    readonly message: string;
+}
+//# sourceMappingURL=commands.d.ts.map

package/lib/types/shared/bridge/messages/runtime/console-frames.d.ts

@@ -0,0 +1,52 @@
+/** Typed transport for Client Console sessions and events. */
+import type { ClientRemoteObjectHandle, ClientRuntimeSessionId, InspectorSourceGeneration, InspectorSourceId } from '../../ids.ts';
+import type { RuntimeConsoleBackendEvent } from '../../../cdp/index.ts';
+import { INSPECTOR_PROTOCOL_VERSION } from '../../version.ts';
+/** Source capability that permits Client Console event forwarding. */
+export interface ClientConsoleCapability {
+    readonly type: 'client-console';
+}
+/** Worker request to start Console observation for one DevTools session. */
+export interface ClientConsoleEnableFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-console/enable';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+}
+/** Worker request to stop Console observation for one DevTools session. */
+export interface ClientConsoleDisableFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-console/disable';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+}
+/** Client Console event carrying objects retained for one DevTools session. */
+export interface ClientConsoleEventFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-console/event';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+    readonly event: RuntimeConsoleBackendEvent<ClientRemoteObjectHandle>;
+}
+/**
+ * Parse the marker capability for Client Console forwarding.
+ * @param value - Untrusted capability declaration.
+ * @returns The validated marker capability.
+ */
+export declare function parseClientConsoleCapability(value: unknown): ClientConsoleCapability;
+/**
+ * Parse a Worker-to-Client Console lifecycle frame.
+ * @param value - Untrusted decoded frame.
+ * @returns A validated enable or disable frame.
+ */
+export declare function parseClientConsoleControlFrame(value: Record<string, unknown>): ClientConsoleEnableFrame | ClientConsoleDisableFrame;
+/**
+ * Parse one Client-to-Worker Console event.
+ * @param value - Untrusted decoded frame.
+ * @returns A validated Console event frame.
+ */
+export declare function parseClientConsoleEventFrame(value: Record<string, unknown>): ClientConsoleEventFrame;
+//# sourceMappingURL=console-frames.d.ts.map

package/lib/types/shared/bridge/messages/runtime/frames.d.ts

@@ -0,0 +1,98 @@
+/** Versioned envelopes for Worker-to-Client Runtime operations. */
+import type { ClientRuntimeRequestId, ClientRuntimeSessionId, InspectorSourceGeneration, InspectorSourceId } from '../../ids.ts';
+import { INSPECTOR_PROTOCOL_VERSION } from '../../version.ts';
+import type { ClientRuntimeCommand, ClientRuntimeError, ClientRuntimeResult } from './commands.ts';
+/** Source capability that permits synthetic Runtime execution contexts. */
+export interface ClientRuntimeCapability {
+    readonly type: 'client-runtime';
+    readonly origin: string;
+}
+/** Worker request for one operation in a specific source generation and DevTools session. */
+export interface ClientRuntimeRequestFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-runtime/request';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+    readonly requestId: ClientRuntimeRequestId;
+    readonly command: ClientRuntimeCommand;
+}
+/** Worker cancellation of one outstanding Client Runtime request. */
+export interface ClientRuntimeCancelFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-runtime/cancel';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+    readonly requestId: ClientRuntimeRequestId;
+}
+/** Worker acknowledgement that commits one successful Client Runtime response. */
+export interface ClientRuntimeResponseAcknowledgedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-runtime/response-acknowledged';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+    readonly requestId: ClientRuntimeRequestId;
+}
+/** Client response to one typed Runtime request. */
+export interface ClientRuntimeResponseFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-runtime/response';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+    readonly requestId: ClientRuntimeRequestId;
+    readonly outcome: {
+        readonly ok: true;
+        readonly result: ClientRuntimeResult;
+    } | {
+        readonly ok: false;
+        readonly error: ClientRuntimeError;
+    };
+}
+/** One-way cleanup when a DevTools connection or its Runtime domain closes. */
+export interface ClientRuntimeSessionClosedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-runtime/session-closed';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientRuntimeSessionId;
+}
+/**
+ * Parse and rebuild a Client Runtime capability.
+ * @param value - Untrusted capability declaration.
+ * @returns The validated capability.
+ */
+export declare function parseClientRuntimeCapability(value: unknown): ClientRuntimeCapability;
+/**
+ * Parse and rebuild one Worker-to-Client Runtime request.
+ * @param value - Untrusted request frame.
+ * @returns The validated request frame.
+ */
+export declare function parseClientRuntimeRequestFrame(value: Record<string, unknown>): ClientRuntimeRequestFrame;
+/**
+ * Parse and rebuild one Worker-to-Client Runtime cancellation.
+ * @param value - Untrusted cancellation frame.
+ * @returns The validated cancellation frame.
+ */
+export declare function parseClientRuntimeCancelFrame(value: Record<string, unknown>): ClientRuntimeCancelFrame;
+/**
+ * Parse and rebuild one Worker acknowledgement for a Client Runtime response.
+ * @param value - Untrusted acknowledgement frame.
+ * @returns The validated acknowledgement frame.
+ */
+export declare function parseClientRuntimeResponseAcknowledgedFrame(value: Record<string, unknown>): ClientRuntimeResponseAcknowledgedFrame;
+/**
+ * Parse and rebuild one Client-to-Worker Runtime response.
+ * @param value - Untrusted response frame.
+ * @returns The validated response frame.
+ */
+export declare function parseClientRuntimeResponseFrame(value: Record<string, unknown>): ClientRuntimeResponseFrame;
+/**
+ * Parse and rebuild one Runtime-session cleanup notification.
+ * @param value - Untrusted cleanup frame.
+ * @returns The validated cleanup frame.
+ */
+export declare function parseClientRuntimeSessionClosedFrame(value: Record<string, unknown>): ClientRuntimeSessionClosedFrame;
+//# sourceMappingURL=frames.d.ts.map

package/lib/types/shared/bridge/messages/runtime/index.d.ts

@@ -0,0 +1,5 @@
+/** Public types and boundary decoders for the Client Runtime wire protocol. */
+export * from './commands.ts';
+export * from './console-frames.ts';
+export * from './frames.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/bridge/messages/runtime/value-codec.d.ts

@@ -0,0 +1,28 @@
+/** Exact wire decoder for Client Runtime results and RemoteObject data. */
+import type { RuntimeStackTrace } from '../../../cdp/index.ts';
+import type { ClientRuntimeExceptionDetails, ClientRuntimeRemoteObject, ClientRuntimeResult } from './commands.ts';
+/**
+ * Parse and rebuild one successful Client Runtime result.
+ * @param value - Untrusted result value.
+ * @returns The validated result union member.
+ */
+export declare function parseClientRuntimeResult(value: unknown): ClientRuntimeResult;
+/**
+ * Decode one Client Runtime object carrying an optional session-local handle.
+ * @param value - Untrusted wire value.
+ * @returns The validated realm-neutral object value.
+ */
+export declare function parseClientRuntimeRemoteObject(value: unknown): ClientRuntimeRemoteObject;
+/**
+ * Decode Client exception details used by command results and events.
+ * @param value - Untrusted wire value.
+ * @returns Validated exception details.
+ */
+export declare function parseClientRuntimeExceptionDetails(value: unknown): ClientRuntimeExceptionDetails;
+/**
+ * Decode a stack trace carried by a Client Runtime or Console frame.
+ * @param value - Untrusted stack-trace value.
+ * @returns The validated realm-neutral stack trace.
+ */
+export declare function parseClientRuntimeStackTrace(value: unknown): RuntimeStackTrace;
+//# sourceMappingURL=value-codec.d.ts.map

package/lib/types/shared/bridge/messages/sources/codec.d.ts

@@ -0,0 +1,15 @@
+/** Exact decoders for Client source catalog operations and values. */
+import type { ClientSourceCommand, ClientSourceResult } from './commands.ts';
+/**
+ * Parse one Worker-to-Client source command.
+ * @param value - Untrusted decoded command.
+ * @returns The validated command.
+ */
+export declare function parseClientSourceCommand(value: unknown): ClientSourceCommand;
+/**
+ * Parse one successful Client source result.
+ * @param value - Untrusted decoded result.
+ * @returns The validated result.
+ */
+export declare function parseClientSourceResult(value: unknown): ClientSourceResult;
+//# sourceMappingURL=codec.d.ts.map

package/lib/types/shared/bridge/messages/sources/commands.d.ts

@@ -0,0 +1,42 @@
+/** Operations and values exchanged with a Client realm's read-only source catalog. */
+import type { RuntimeScriptKey } from '../../../cdp/ids.ts';
+import type { RuntimeScript } from '../../../cdp/index.ts';
+/** Script metadata that excludes the Worker-owned execution-context id. */
+export type ClientScriptDescriptor = Omit<RuntimeScript, 'executionContextId'>;
+/** Content stored for one Client script. */
+export type ClientSourceContentKind = 'source' | 'source-map';
+/** Read-only operation accepted by the Client source catalog. */
+export type ClientSourceCommand = {
+    readonly op: 'list-scripts';
+} | {
+    readonly op: 'get-content-chunk';
+    readonly scriptKey: RuntimeScriptKey;
+    readonly content: ClientSourceContentKind;
+    readonly offset: number;
+    readonly maxBytes: number;
+};
+/** Successful result of one Client source operation. */
+export type ClientSourceResult = {
+    readonly op: 'list-scripts';
+    readonly scripts: readonly ClientScriptDescriptor[];
+} | {
+    readonly op: 'get-content-chunk';
+    readonly scriptKey: RuntimeScriptKey;
+    readonly content: ClientSourceContentKind;
+    readonly available: false;
+} | {
+    readonly op: 'get-content-chunk';
+    readonly scriptKey: RuntimeScriptKey;
+    readonly content: ClientSourceContentKind;
+    readonly available: true;
+    readonly offset: number;
+    readonly nextOffset: number;
+    readonly data: string;
+    readonly eof: boolean;
+};
+/** Deliberate failure returned by the Client source catalog. */
+export interface ClientSourceError {
+    readonly code: 'invalid-request' | 'script-not-found' | 'load-failed' | 'result-too-large' | 'internal-error';
+    readonly message: string;
+}
+//# sourceMappingURL=commands.d.ts.map