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

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

@@ -0,0 +1,108 @@
+/** Host controller that owns the Inspector Worker and Host observation source. */
+import type { InspectorClientBootstrap } from '../../shared/bridge/messages/control.ts';
+import type { InspectorConnection } from '../../shared/bridge/publisher.ts';
+/** User-facing Host options; every memory and lifecycle bound is configurable. */
+export interface InspectorOptions {
+    /** Loopback address used by the Worker HTTP and WebSocket endpoint. */
+    readonly host?: '127.0.0.1';
+    /** First port to bind; occupied ports advance until one is available. */
+    readonly port?: number;
+    /** Additional exact browser origins admitted to the Client ingest socket. */
+    readonly clientOrigins?: readonly string[];
+    /** Whether to observe calls made through the current global fetch function. */
+    readonly captureFetch?: boolean;
+    /** Maximum request-body prefix retained for one fetch. */
+    readonly maxRequestBodyBytes?: number;
+    /** Maximum response-body prefix retained for one fetch. */
+    readonly maxResponseBodyBytes?: number;
+    /** Maximum raw bytes encoded into one body observation. */
+    readonly maxBodyChunkBytes?: number;
+    /** Maximum total request and response body bytes retained by the Worker. */
+    readonly maxJournalBytes?: number;
+    /** Maximum active and completed fetch requests retained by the Worker. */
+    readonly maxRetainedRequests?: number;
+    /** Maximum encoded bytes accepted in one source transport frame. */
+    readonly maxSourceFrameBytes?: number;
+    /** Maximum observation records accepted in one source batch. */
+    readonly maxSourceRecordsPerFrame?: number;
+    /** Maximum records waiting in one producer queue. */
+    readonly maxQueuedRecords?: number;
+    /** Maximum encoded bytes waiting in one producer queue. */
+    readonly maxQueuedBytes?: number;
+    /** Maximum time allowed for the Worker to become ready. */
+    readonly startupTimeoutMs?: number;
+    /** Grace period before a stopping Worker is terminated. */
+    readonly stopTimeoutMs?: number;
+    /** Initial upper bound for randomized Client reconnect delay. */
+    readonly clientReconnectBaseMs?: number;
+    /** Maximum upper bound for randomized Client reconnect delay. */
+    readonly clientReconnectMaxMs?: number;
+    /** Deadline for one Worker-to-Client Runtime or Sources request. */
+    readonly clientRuntimeTimeoutMs?: number;
+    /** Deadline for one non-CDP semantic query. */
+    readonly queryTimeoutMs?: number;
+    /** Maximum live object handles retained per Client Runtime session. */
+    readonly maxClientRuntimeObjects?: number;
+    /** Maximum descriptors returned by one Client property request. */
+    readonly maxClientRuntimeProperties?: number;
+    /** Maximum encoded bytes read for one Client script or source map. */
+    readonly maxClientSourceBytes?: number;
+    /** Maximum Context and Fiber nodes retained in one realm snapshot. */
+    readonly maxCordisNodes?: number;
+    /** Disconnected Cordis snapshots retained after their live realm closes. */
+    readonly maxDisconnectedCordisTrees?: number;
+}
+/** Fully resolved options used by one running Inspector. */
+export interface InspectorSpec {
+    readonly host: '127.0.0.1';
+    readonly port: number;
+    readonly clientOrigins: readonly string[];
+    readonly captureFetch: boolean;
+    readonly maxRequestBodyBytes: number;
+    readonly maxResponseBodyBytes: number;
+    readonly maxBodyChunkBytes: number;
+    readonly maxJournalBytes: number;
+    readonly maxRetainedRequests: number;
+    readonly maxSourceFrameBytes: number;
+    readonly maxSourceRecordsPerFrame: number;
+    readonly maxQueuedRecords: number;
+    readonly maxQueuedBytes: number;
+    readonly startupTimeoutMs: number;
+    readonly stopTimeoutMs: number;
+    readonly clientReconnectBaseMs: number;
+    readonly clientReconnectMaxMs: number;
+    readonly clientRuntimeTimeoutMs: number;
+    readonly queryTimeoutMs: number;
+    readonly maxClientRuntimeObjects: number;
+    readonly maxClientRuntimeProperties: number;
+    readonly maxClientSourceBytes: number;
+    readonly maxCordisNodes: number;
+    readonly maxDisconnectedCordisTrees: number;
+}
+/** Addresses and browser bootstrap of one bound Worker. */
+export interface InspectorEndpoint {
+    readonly httpUrl: string;
+    readonly webSocketDebuggerUrl: string;
+    readonly devtoolsFrontendUrl: string;
+    readonly client: InspectorClientBootstrap;
+}
+/** Running Host-side Inspector owner. */
+export interface InspectorHandle {
+    readonly endpoint: InspectorEndpoint;
+    readonly source: InspectorConnection;
+    /** Stop capture and wait for the Worker to release every socket and V8 session. */
+    close(): Promise<void>;
+}
+/**
+ * Resolve and validate all deployment-varying Inspector choices.
+ * @param options - Partial caller configuration.
+ * @returns A complete immutable configuration.
+ */
+export declare function resolveInspectorOptions(options?: InspectorOptions): InspectorSpec;
+/**
+ * Start the Worker, create the Host source, and install full fetch capture by default.
+ * @param options - Partial caller configuration.
+ * @returns The ready endpoint and its quiescent shutdown handle.
+ */
+export declare function startInspector(options?: InspectorOptions): Promise<InspectorHandle>;
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1,16 @@
+/** Dispatch of validated Worker frames accepted by the Host MessagePort. */
+import type { SourceAcceptedFrame, SourceAppendAcknowledgedFrame, SourceRejectedFrame, SourceResnapshotFrame, WorkerToSourceFrame } from '../../shared/bridge/messages/observation.ts';
+/** Operations invoked for source-lifecycle frames addressed to the Host. */
+export interface HostBridgeFrameHandlers {
+    accepted(frame: SourceAcceptedFrame): void;
+    acknowledged(frame: SourceAppendAcknowledgedFrame): void;
+    resnapshot(frame: SourceResnapshotFrame): void;
+    rejected(frame: SourceRejectedFrame): void;
+}
+/**
+ * Dispatch one validated Worker frame and reject Client-only commands on the Host carrier.
+ * @param frame - Decoded Worker-to-source frame.
+ * @param handlers - Host source-lifecycle operations.
+ */
+export declare function dispatchBridgeFrame(frame: WorkerToSourceFrame, handlers: HostBridgeFrameHandlers): void;
+//# sourceMappingURL=dispatcher.d.ts.map

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

@@ -0,0 +1,42 @@
+/** Failure containment and shutdown coordination for the Inspector Worker. */
+import type { Worker } from 'node:worker_threads';
+import type { InspectorWorkerControl } from '../../shared/bridge/messages/control.ts';
+/** Tracks Worker termination without removing the listener that contains runtime errors. */
+export declare class InspectorWorkerLifecycle {
+    private readonly worker;
+    private readonly exitResolution;
+    private readonly failureResolution;
+    private failure;
+    private running;
+    private expectedExit;
+    private notified;
+    private onUnexpectedExit;
+    private exitCodeValue;
+    /** Worker exit code once its `exit` event has fired. */
+    get exitCode(): number | undefined;
+    constructor(worker: Worker);
+    /**
+     * Wait for the validated ready frame while also observing startup failure and exit.
+     * @param timeoutMs - Readiness deadline in milliseconds.
+     * @returns The Worker's bound endpoint fields.
+     */
+    waitForReady(timeoutMs: number): Promise<Extract<InspectorWorkerControl, {
+        type: 'ready';
+    }>>;
+    /**
+     * Begin reporting an unexpected runtime exit through one contained callback.
+     * @param listener - Failure observer that must not throw.
+     */
+    markRunning(listener: (error: Error) => void): void;
+    /** Mark subsequent Worker termination as owner-requested. */
+    expectExit(): void;
+    /** Terminate the Worker during failed initialization. */
+    terminate(): Promise<void>;
+    /**
+     * Request graceful shutdown and terminate after the deadline.
+     * @param timeoutMs - Grace period before forced termination.
+     */
+    stop(timeoutMs: number): Promise<void>;
+    private notifyUnexpectedExit;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

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

@@ -0,0 +1,31 @@
+/** Buffered Host observation publication over a dedicated Worker MessagePort. */
+import type { MessagePort } from 'node:worker_threads';
+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 Host publisher with microtask-coalesced MessagePort writes. */
+export declare class HostBridgePublisher implements InspectorStatePublisher {
+    private readonly port;
+    private readonly source;
+    private readonly records;
+    private flushScheduled;
+    private inFlightNextSequence;
+    private closed;
+    constructor(port: MessagePort, source: InspectorSourceDescriptor, options: InspectorSourceBufferOptions);
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    setState(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /** Send the retained state as a complete source replacement. */
+    replace(): void;
+    /** Send one queued batch when no earlier MessagePort batch awaits acknowledgement. */
+    flush(): void;
+    /**
+     * Release one in-flight batch and schedule the next bounded transfer.
+     * @param nextSequence - First sequence expected by the Worker after the accepted batch.
+     */
+    acknowledge(nextSequence: number): void;
+    /** Send at most one final batch, discard later queued observations, and reject publication. */
+    close(): void;
+    private scheduleFlush;
+}
+//# sourceMappingURL=publisher.d.ts.map

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

@@ -0,0 +1,15 @@
+/** Host-side non-CDP query bridge over the Worker MessagePort. */
+import type { MessagePort } from 'node:worker_threads';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import { InspectorQueryConnection, type InspectorQueryConnectionOptions } from '../../shared/bridge/rpc.ts';
+/** Owns query correlation for one Host source generation. */
+export declare class HostBridgeRpc extends InspectorQueryConnection {
+    private readonly port;
+    constructor(port: MessagePort, options: InspectorQueryConnectionOptions);
+    /**
+     * Connect query writes after the Worker accepts the Host source.
+     * @param source - Accepted Host source descriptor.
+     */
+    connectPort(source: InspectorSourceDescriptor): void;
+}
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1,28 @@
+/** Host-realm observation publisher over a dedicated MessagePort. */
+import type { MessagePort } from 'node:worker_threads';
+import { InspectorSourceConnection } from '../../shared/bridge/publisher.ts';
+import { HostBridgePublisher } from './publisher.ts';
+import { HostBridgeRpc } from './rpc.ts';
+/** Buffer limits for one source publisher. */
+export interface HostSourceOptions {
+    readonly label: string;
+    readonly topics: readonly string[];
+    readonly maxQueuedRecords: number;
+    readonly maxQueuedBytes: number;
+    readonly maxRecordsPerFrame: number;
+    readonly maxFrameBytes: number;
+    readonly queryTimeoutMs: number;
+}
+/** Non-blocking Host source; queue overflow is represented by `droppedBefore` on the next batch. */
+export declare class HostInspectorSource extends InspectorSourceConnection {
+    private readonly port;
+    private readonly source;
+    protected readonly publisher: HostBridgePublisher;
+    private closed;
+    protected readonly queries: HostBridgeRpc;
+    constructor(port: MessagePort, options: HostSourceOptions);
+    /** Flush pending observations and close the source port. */
+    close(): void;
+    private receive;
+}
+//# sourceMappingURL=transport.d.ts.map

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

@@ -0,0 +1,14 @@
+/** Host Console is served directly by the Worker-side Node inspector adapter. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host Console transport ownership.
+ * @returns No Host-main-thread Console bridge capability.
+ */
+export declare function consoleBridgeCapability(): InspectorSourceCapability | undefined;
+/**
+ * Reject a Client Console control frame that was routed to the Host source.
+ * @param operation - Misrouted Console frame type.
+ * @returns This function never returns.
+ */
+export declare function rejectConsoleBridgeCommand(operation: string): never;
+//# sourceMappingURL=console.d.ts.map

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

@@ -0,0 +1,8 @@
+/** Host debugging is served directly by the Worker-side Node inspector adapter. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host debugger transport ownership.
+ * @returns No Host-main-thread Debugger bridge capability.
+ */
+export declare function debuggerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=debugger.d.ts.map

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

@@ -0,0 +1,6 @@
+/** Explicit failure for Client-style CDP bridge commands misrouted to the Host. */
+/** Host Runtime uses the Worker-side Node inspector session instead of source RPC. */
+export declare class HostCdpBridgeUnavailableError extends Error {
+    constructor(operation: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,8 @@
+/** Host heap profiling is served directly by the Worker-side Node inspector adapter. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host heap profiler transport ownership.
+ * @returns No Host-main-thread HeapProfiler bridge capability.
+ */
+export declare function heapProfilerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=heap-profiler.d.ts.map

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

@@ -0,0 +1,10 @@
+/** Source-side CDP capability declarations for the Host realm. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Collect Host source-bridge capabilities.
+ * @param _origin - Unused Host origin supplied for parity with the Client adapter.
+ * @param _hasSources - Unused source availability supplied for parity with the Client adapter.
+ * @returns No capabilities because the Worker attaches to Host V8 directly.
+ */
+export declare function bridgeCapabilities(_origin: string, _hasSources: boolean): readonly InspectorSourceCapability[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,8 @@
+/** Host RemoteObject handles never cross the Host source bridge. */
+/**
+ * Reject an object operation that must use the Worker-owned native inspector session.
+ * @param operation - Misrouted object operation.
+ * @returns This function never returns.
+ */
+export declare function rejectObjectBridgeOperation(operation: string): never;
+//# sourceMappingURL=objects.d.ts.map

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

@@ -0,0 +1,8 @@
+/** Host CPU profiling is served directly by the Worker-side Node inspector adapter. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host CPU profiler transport ownership.
+ * @returns No Host-main-thread Profiler bridge capability.
+ */
+export declare function profilerBridgeCapability(): InspectorSourceCapability | undefined;
+//# sourceMappingURL=profiler.d.ts.map

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

@@ -0,0 +1,7 @@
+/** Host property enumeration never crosses the Host source bridge. */
+/**
+ * Reject a property request that must use the Worker-owned native inspector session.
+ * @returns This function never returns.
+ */
+export declare function rejectPropertyBridgeOperation(): never;
+//# sourceMappingURL=properties.d.ts.map

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

@@ -0,0 +1,16 @@
+/** Host Runtime is served directly by the Worker-side Node inspector adapter. */
+import type { ClientRuntimeCommand } from '../../shared/bridge/messages/runtime/index.ts';
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host Runtime transport ownership.
+ * @param _origin - Ignored because Host Runtime does not cross the source bridge.
+ * @returns No Host-main-thread Runtime bridge capability.
+ */
+export declare function runtimeBridgeCapability(_origin: string): InspectorSourceCapability | undefined;
+/**
+ * Reject a Client Runtime command that was routed to the Host source.
+ * @param command - Misrouted Client Runtime operation.
+ * @returns This function never returns.
+ */
+export declare function rejectRuntimeBridgeCommand(command: ClientRuntimeCommand): never;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,14 @@
+/** Host Sources are served directly by the Worker-side Node inspector adapter. */
+import type { InspectorSourceCapability } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Describe Host Sources transport ownership.
+ * @param _available - Ignored because Host Sources do not cross the source bridge.
+ * @returns No Host-main-thread Sources bridge capability.
+ */
+export declare function sourcesBridgeCapability(_available: boolean): InspectorSourceCapability | undefined;
+/**
+ * Reject a Client Sources request that was routed to the Host source.
+ * @returns This function never returns.
+ */
+export declare function rejectSourcesBridgeCommand(): never;
+//# sourceMappingURL=sources.d.ts.map

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

@@ -0,0 +1,4 @@
+/** Host stack and call-frame data remain owned by the Worker-side Node inspector session. */
+/** Stable explanation used for Host bridge rejections. */
+export declare const HOST_CDP_BRIDGE_REASON = "Host Runtime is attached directly from the Inspector Worker";
+//# sourceMappingURL=stack.d.ts.map

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

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

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

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

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

@@ -0,0 +1,23 @@
+/** Full `globalThis.fetch` capture that publishes without delaying response delivery. */
+import type { InspectorPublisher } from '../../shared/bridge/publisher.ts';
+/** Observation topics published by the Host network adapter. */
+export declare const NETWORK_TOPICS: readonly string[];
+/** Byte limits for request and response clone capture. */
+export interface FetchCaptureOptions {
+    readonly maxRequestBodyBytes: number;
+    readonly maxResponseBodyBytes: number;
+    readonly maxChunkBytes: number;
+}
+/** Active global fetch wrapper. */
+export interface FetchObserver {
+    /** Restore the prior fetch implementation, cancel clone readers, and await their settlement. */
+    stop(): Promise<void>;
+}
+/**
+ * Install full fetch capture for every later call through `globalThis.fetch`.
+ * @param publisher - Host source that receives fetch lifecycle records.
+ * @param options - Per-body capture limits.
+ * @returns The owner that stops capture and awaits pending body readers.
+ */
+export declare function installFetchObserver(publisher: InspectorPublisher, options: FetchCaptureOptions): FetchObserver;
+//# sourceMappingURL=network.d.ts.map

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

@@ -0,0 +1,9 @@
+/** Stable descriptor for the Host observation source generation. */
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+/**
+ * Create the descriptor for one Host-to-Worker MessagePort generation.
+ * @param label - Human-readable Host execution-context label.
+ * @returns The complete Host source descriptor.
+ */
+export declare function createHostRealmSource(label: string): InspectorSourceDescriptor;
+//# sourceMappingURL=realm.d.ts.map

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

@@ -0,0 +1,19 @@
+/** Host Cordis plugin for the cross-realm Inspector Worker and full fetch capture. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type InspectorOptions } from './bridge/controller.ts';
+export { resolveInspectorOptions, startInspector } from './bridge/controller.ts';
+export type { InspectorEndpoint, InspectorHandle, InspectorOptions, InspectorSpec } from './bridge/controller.ts';
+export type { CordisRuntimeTreeReader } from '../shared/cordis/reader.ts';
+export type { CordisRuntimeConnection, CordisRuntimeContext, CordisRuntimeFiber, CordisRuntimeNode, CordisRuntimeRealm, CordisRuntimeSource, CordisRuntimeTree, } from '../shared/cordis/model.ts';
+export type { InspectorClientBootstrap } from '../shared/bridge/messages/control.ts';
+export type { InspectorRecordInput, InspectorSourceDescriptor, InspectorSourceKind } from '../shared/bridge/messages/observation.ts';
+export type { InspectorJsonObject, InspectorJsonPrimitive, InspectorJsonValue } from '../shared/json.ts';
+export type { CordisContextTreeNode, CordisFiberTreeNode, CordisTreeNode, CordisTreeSnapshot, } from '../shared/cordis/snapshot.ts';
+/** Configuration consumed by the Host implementation after package-entry validation. */
+export interface HostPluginConfig extends Omit<InspectorOptions, 'clientOrigins'> {
+    /** Browser origins allowed to open the Client ingest WebSocket. */
+    clientOrigins?: string[];
+}
+/** Start the Worker, expose `ctx.inspector`, and inject the matching Client bootstrap. */
+export declare function apply(ctx: Context, config: HostPluginConfig): Promise<void>;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,50 @@
+/** Repository-facing Host package entry over the mirrored implementation tree. */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type InspectorOptions } from './host/bridge/controller.ts';
+import type { CordisRuntimeTreeReader } from './shared/cordis/reader.ts';
+import type { InspectorJsonValue } from './shared/json.ts';
+export { resolveInspectorOptions, startInspector } from './host/plugin.ts';
+export type { InspectorEndpoint, InspectorHandle, InspectorOptions, InspectorSpec } from './host/plugin.ts';
+export type { CordisRuntimeTreeReader } from './shared/cordis/reader.ts';
+export type { CordisRuntimeConnection, CordisRuntimeContext, CordisRuntimeFiber, CordisRuntimeNode, CordisRuntimeRealm, CordisRuntimeSource, CordisRuntimeTree, } from './shared/cordis/model.ts';
+export type { InspectorClientBootstrap } from './shared/bridge/messages/control.ts';
+export type { InspectorRecordInput, InspectorSourceDescriptor, InspectorSourceKind, } from './shared/bridge/messages/observation.ts';
+export type { InspectorJsonObject, InspectorJsonPrimitive, InspectorJsonValue } from './shared/json.ts';
+export type { CordisContextTreeNode, CordisFiberTreeNode, CordisTreeNode, CordisTreeSnapshot, } from './shared/cordis/snapshot.ts';
+/** Shared Host/Client service façade over the realm's source publisher. */
+export interface InspectorService {
+    /**
+     * Publish one JSON observation without waiting for Worker delivery.
+     * @param topic - Domain-owned topic name.
+     * @param payload - JSON value validated before it reaches the carrier.
+     * @param monotonicMs - Source-clock timestamp; defaults to `performance.now()`.
+     */
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /** Read-only Cordis topology queries independent of CDP sessions. */
+    readonly cordis: CordisRuntimeTreeReader;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Publish Host-realm observations and query the shared Inspector state. */
+        inspector: InspectorService;
+    }
+}
+/** Cordis plugin name shared with the Client face. */
+export declare const name = "experimental-inspector";
+/** Host service required to inject the Client connection bootstrap into index.html. */
+export declare const inject: string[];
+/** Host plugin configuration. Fetch capture is enabled by default. */
+export interface Config extends Omit<InspectorOptions, 'clientOrigins'> {
+    /** Browser origins allowed to open the Client ingest WebSocket. */
+    clientOrigins?: string[];
+}
+/** Runtime validation for {@link Config}. */
+export declare const Config: z<Config>;
+/**
+ * Apply the Host implementation from the repository-standard package entry.
+ * @param ctx - Host Cordis plugin context.
+ * @param config - Validated Inspector configuration.
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/bridge/buffer.d.ts

@@ -0,0 +1,62 @@
+/** Realm-neutral bounded buffering for Host and Client observation sources. */
+import type { InspectorSourceGeneration, InspectorSourceId } from './ids.ts';
+import { type InspectorJsonValue } from '../json.ts';
+import type { SourceAppendFrame, SourceReplaceFrame } from './messages/observation.ts';
+/** Limits and declared topics shared by both source transports. */
+export interface InspectorSourceBufferOptions {
+    readonly topics: readonly string[];
+    readonly maxQueuedRecords: number;
+    readonly maxQueuedBytes: number;
+    readonly maxRecordsPerFrame: number;
+    readonly maxFrameBytes: number;
+}
+/**
+ * Owns retained state, queued events, and source-local sequencing independently
+ * of whether frames travel over MessagePort or WebSocket.
+ */
+export declare class InspectorSourceBuffer {
+    private readonly options;
+    private readonly queue;
+    private readonly state;
+    private queuedBytes;
+    private nextSequence;
+    private expectedSequence;
+    constructor(options: InspectorSourceBufferOptions);
+    /** Whether at least one observation is waiting for transport. */
+    get hasPending(): boolean;
+    /**
+     * Validate and enqueue one observation, dropping the oldest prefix as needed.
+     * A record larger than one transport frame is dropped after consuming its sequence number.
+     * @param topic - Declared domain topic.
+     * @param payload - Lossless JSON payload.
+     * @param monotonicMs - Finite source-clock timestamp.
+     */
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs: number): void;
+    /**
+     * Replace one retained topic and enqueue the same observation for live delivery.
+     * @param topic - Declared state topic.
+     * @param payload - Lossless JSON payload retained for replacement frames.
+     * @param monotonicMs - Finite source-clock timestamp.
+     */
+    setState(topic: string, payload: InspectorJsonValue, monotonicMs: number): void;
+    /**
+     * Build a complete state replacement and absorb every preceding queue drop.
+     * @param sourceId - Logical source identity.
+     * @param generation - Current transport generation.
+     * @returns A replacement frame whose sequence is the next append position.
+     */
+    replacement(sourceId: InspectorSourceId, generation: InspectorSourceGeneration): SourceReplaceFrame;
+    /**
+     * Remove and sequence the next transport-sized observation batch.
+     * @param sourceId - Logical source identity.
+     * @param generation - Current transport generation.
+     * @returns The next append frame, or `undefined` when the queue is empty.
+     */
+    takeBatch(sourceId: InspectorSourceId, generation: InspectorSourceGeneration): SourceAppendFrame | undefined;
+    /** Discard observations that have not entered a transport frame. */
+    discardPending(): void;
+    private record;
+    private enqueue;
+    private stateFits;
+}
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1,4 @@
+/** Bridge-facing exports for lossless JSON values and common wire validators. */
+export * from '../json.ts';
+export * from '../validation.ts';
+//# sourceMappingURL=codec.d.ts.map

package/lib/types/shared/bridge/control-codec.d.ts

@@ -0,0 +1,27 @@
+/** Exact decoders for Host, Worker, and injected Client lifecycle values. */
+import type { InspectorClientBootstrap, InspectorHostControl, InspectorWorkerConfig, InspectorWorkerControl } from './messages/control.ts';
+/**
+ * Decode the structured-cloned Worker configuration.
+ * @param value - Untrusted workerData config value.
+ * @returns The validated Worker configuration.
+ */
+export declare function parseInspectorWorkerConfig(value: unknown): InspectorWorkerConfig;
+/**
+ * Decode one Host-to-Worker lifecycle command.
+ * @param value - Untrusted control message.
+ * @returns The validated Host command.
+ */
+export declare function parseInspectorHostControl(value: unknown): InspectorHostControl;
+/**
+ * Decode one Worker-to-Host lifecycle event.
+ * @param value - Untrusted control message.
+ * @returns The validated Worker event.
+ */
+export declare function parseInspectorWorkerControl(value: unknown): InspectorWorkerControl;
+/**
+ * Decode bootstrap data injected into the browser global.
+ * @param value - Untrusted injected value.
+ * @returns The validated Client bootstrap.
+ */
+export declare function parseInspectorClientBootstrap(value: unknown): InspectorClientBootstrap;
+//# sourceMappingURL=control-codec.d.ts.map

package/lib/types/shared/bridge/ids.d.ts

@@ -0,0 +1,19 @@
+/** Opaque identifiers owned by the cross-realm Inspector bridge. */
+import type { InspectorId } from '../identity.ts';
+export { inspectorId } from '../identity.ts';
+export type { InspectorId } from '../identity.ts';
+/** Stable identity of one logical observation source. */
+export type InspectorSourceId = InspectorId<'InspectorSourceId'>;
+/** Identity of one source connection generation. */
+export type InspectorSourceGeneration = InspectorId<'InspectorSourceGeneration'>;
+/** Identity of one DevTools connection's Client Runtime state. */
+export type ClientRuntimeSessionId = InspectorId<'ClientRuntimeSessionId'>;
+/** Identity of one in-flight Worker-to-Client Runtime operation. */
+export type ClientRuntimeRequestId = InspectorId<'ClientRuntimeRequestId'>;
+/** Identity of one DevTools connection's Client source catalog session. */
+export type ClientSourceSessionId = InspectorId<'ClientSourceSessionId'>;
+/** Identity of one in-flight Worker-to-Client source operation. */
+export type ClientSourceRequestId = InspectorId<'ClientSourceRequestId'>;
+/** Opaque reference to an object retained inside one Client Runtime session. */
+export type ClientRemoteObjectHandle = InspectorId<'ClientRemoteObjectHandle'>;
+//# sourceMappingURL=ids.d.ts.map