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

package/lib/types/worker/inspection/network-store.d.ts

@@ -0,0 +1,110 @@
+/** Worker-owned repository of normalized fetch observations and captured bodies. */
+import type { InspectorHeader } from '../../shared/network/observation.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { IngestedInspectorRecord, InspectorRecordConsumer } from '../bridge/hub.ts';
+/** Bounded retention policy for observed network requests. */
+export interface NetworkStoreOptions {
+    readonly maxRetainedRequests: number;
+    readonly maxJournalBytes: number;
+}
+/** Captured body data returned without a CDP representation. */
+export interface CapturedNetworkBody {
+    readonly bytes: Uint8Array;
+    readonly truncated: boolean;
+    readonly captureError?: string;
+    readonly complete: boolean;
+}
+interface NetworkEventBase {
+    readonly requestKey: string;
+    readonly requestId: string;
+    readonly timestampMs: number;
+}
+/** Transport-independent changes emitted by the network repository. */
+export type NetworkStoreEvent = NetworkEventBase & {
+    readonly type: 'request-started';
+    readonly wallTimeMs: number;
+    readonly url: string;
+    readonly method: string;
+    readonly headers: readonly InspectorHeader[];
+    readonly hasBody: boolean;
+} | NetworkEventBase & {
+    readonly type: 'response-received';
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: readonly InspectorHeader[];
+    readonly mimeType: string;
+} | NetworkEventBase & {
+    readonly type: 'response-data';
+    readonly data: string;
+    readonly byteLength: number;
+} | NetworkEventBase & {
+    readonly type: 'event-source-message';
+    readonly eventName: string;
+    readonly eventId: string;
+    readonly data: string;
+} | NetworkEventBase & {
+    readonly type: 'request-finished';
+    readonly encodedDataLength: number;
+    readonly truncated: boolean;
+} | NetworkEventBase & {
+    readonly type: 'request-failed';
+    readonly errorText: string;
+    readonly canceled: boolean;
+} | {
+    readonly type: 'request-evicted';
+    readonly requestKey: string;
+};
+type JournalNetworkEvent = Exclude<NetworkStoreEvent, {
+    readonly type: 'response-data' | 'request-evicted';
+}>;
+/** Validated Network observation store independent of CDP connection state. */
+export declare class NetworkStore implements InspectorRecordConsumer {
+    private readonly options;
+    readonly topics: Set<string>;
+    private readonly requests;
+    private readonly journal;
+    private readonly completed;
+    private readonly listeners;
+    private journalBytes;
+    constructor(options: NetworkStoreOptions);
+    replace(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    append(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    close(source: InspectorSourceDescriptor, reason: string): void;
+    /**
+     * Read retained request lifecycle events.
+     * @returns Events in observation order.
+     */
+    replay(): readonly JournalNetworkEvent[];
+    /**
+     * Subscribe to live request changes and eviction.
+     * @param listener - Consumer called synchronously after each accepted change.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (event: NetworkStoreEvent) => void): () => void;
+    /**
+     * Read one retained request body.
+     * @param requestId - Public request id assigned by this store.
+     * @returns Captured bytes and truncation metadata.
+     */
+    requestBody(requestId: unknown): CapturedNetworkBody;
+    /**
+     * Read one retained response body after response headers have arrived.
+     * @param requestId - Public request id assigned by this store.
+     * @returns Captured bytes and truncation metadata.
+     */
+    responseBody(requestId: unknown): CapturedNetworkBody;
+    /** Release subscribers and all retained request data. */
+    dispose(): void;
+    private ingest;
+    private appendBody;
+    private complete;
+    private publish;
+    private emit;
+    private enforceRetention;
+    private evictCompletedFor;
+    private evict;
+    private requestById;
+}
+export {};
+//# sourceMappingURL=network-store.d.ts.map

package/lib/types/worker/inspection/query-router.d.ts

@@ -0,0 +1,78 @@
+/** Worker-side admission, execution, and bounded settlement of non-CDP queries. */
+import type { CordisRuntimeTreeReader } from '../../shared/cordis/reader.ts';
+import type { InspectorSourceGeneration, InspectorSourceId } from '../../shared/bridge/ids.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorQueryResponseFrame } from '../../shared/bridge/messages/query/frames.ts';
+/** Carrier operations owned by one Worker query peer. */
+export interface InspectorQueryPeerTransport {
+    /** Send one bounded Worker response. */
+    send(frame: InspectorQueryResponseFrame): void;
+    /** Reject a malformed peer whose request cannot be correlated safely. */
+    close(code: number, reason: string): void;
+}
+interface AcceptedGeneration {
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+}
+/** Creates isolated query peers over one shared semantic reader. */
+export declare class InspectorQueryRouter {
+    private readonly reader;
+    private readonly maxFrameBytes;
+    private readonly peers;
+    private readonly activeBySource;
+    constructor(reader: CordisRuntimeTreeReader, maxFrameBytes: number);
+    /**
+     * Create query state for one Host MessagePort or Client WebSocket.
+     * @param transport - Carrier response and rejection operations.
+     * @returns The peer that receives frames from this carrier only.
+    */
+    open(transport: InspectorQueryPeerTransport): InspectorQueryPeer;
+    /**
+     * Revoke query access when the source registry closes one generation.
+     * @param source - Closed source generation.
+     */
+    disconnect(source: InspectorSourceDescriptor): void;
+    /** Revoke every peer during Worker shutdown. */
+    close(): void;
+}
+/** Query protocol state associated with exactly one source carrier. */
+export declare class InspectorQueryPeer {
+    private readonly reader;
+    private readonly maxFrameBytes;
+    private readonly transport;
+    private readonly register;
+    private readonly isRegistered;
+    private readonly unregister;
+    private accepted;
+    private readonly inFlight;
+    private closed;
+    constructor(reader: CordisRuntimeTreeReader, maxFrameBytes: number, transport: InspectorQueryPeerTransport, register: (accepted: AcceptedGeneration) => void, isRegistered: (accepted: AcceptedGeneration) => boolean, unregister: () => void);
+    /**
+     * Admit the source generation after the source registry accepts it.
+     * @param sourceId - Stable source identity.
+     * @param generation - Active carrier generation.
+     */
+    accept(sourceId: InspectorSourceId, generation: InspectorSourceGeneration): void;
+    /**
+     * Revoke one generation while leaving its carrier available for a later source/open.
+     * @param sourceId - Stable source identity.
+     * @param generation - Generation being removed by the source registry.
+     */
+    revoke(sourceId: InspectorSourceId, generation: InspectorSourceGeneration): void;
+    /**
+     * Consume a decoded carrier value when it belongs to the query protocol.
+     * @param value - Untrusted source-to-Worker value.
+     * @returns Whether this peer owned the value.
+     */
+    receive(value: unknown): boolean;
+    /** Stop this peer and suppress completion from in-flight readers. */
+    close(): void;
+    private execute;
+    private rejectMalformed;
+    private sendFailure;
+    private canReply;
+    private deliver;
+    private rejectTransport;
+}
+export {};
+//# sourceMappingURL=query-router.d.ts.map

package/lib/types/worker/inspection/realm-store.d.ts

@@ -0,0 +1,58 @@
+/** Worker-owned registry of Host and Client realm definitions. */
+import type { ClientRuntimeRouter } from '../bridge/runtime-rpc.ts';
+import type { ClientSourceRouter } from '../bridge/source-rpc.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorRealm } from './realm.ts';
+/** Realm admission and removal observed by each DevTools connection. */
+export type InspectorRealmEvent = {
+    readonly type: 'opened';
+    readonly realm: InspectorRealm;
+} | {
+    readonly type: 'closed';
+    readonly realm: InspectorRealm;
+};
+/** Authoritative collection of all currently executable realms. */
+export declare class InspectorRealmRegistry {
+    readonly host: InspectorRealm;
+    private readonly clients;
+    private readonly clientSources;
+    private readonly clientsBySource;
+    private readonly listeners;
+    private readonly unsubscribeClients;
+    constructor(host: InspectorRealm, clients: ClientRuntimeRouter, clientSources: ClientSourceRouter);
+    /**
+     * Return the realm admission order used by every connection-local session set.
+     * @returns Host followed by active Clients.
+     */
+    realms(): InspectorRealm[];
+    /**
+     * Resolve one synthetic Client execution context.
+     * @param contextId - Numeric CDP execution-context id.
+     * @returns The active realm when the id belongs to a Client.
+     */
+    byContextId(contextId: number): InspectorRealm | undefined;
+    /**
+     * Resolve one globally unique Client execution context.
+     * @param uniqueId - CDP unique execution-context id.
+     * @returns The active realm when the id belongs to a Client.
+     */
+    byUniqueContextId(uniqueId: string): InspectorRealm | undefined;
+    /**
+     * Resolve the realm for one active source generation.
+     * @param source - Source identity retained by a Cordis tree node.
+     * @returns The matching active realm.
+     */
+    bySource(source: InspectorSourceDescriptor): InspectorRealm | undefined;
+    /**
+     * Subscribe to Client realm admission and removal.
+     * @param listener - Registry observer.
+     * @returns A disposer removing the observer.
+     */
+    subscribe(listener: (event: InspectorRealmEvent) => void): () => void;
+    /** Stop observing Client targets and clear registry listeners. */
+    close(): void;
+    private receiveClient;
+    private openClient;
+    private emit;
+}
+//# sourceMappingURL=realm-store.d.ts.map

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

@@ -0,0 +1,43 @@
+/** Worker-owned lifecycle model for active Host and Client JavaScript realms. */
+import type { InspectorSourceGeneration, InspectorSourceId } from '../../shared/bridge/ids.ts';
+import type { InspectorRealmCapabilities } from '../../shared/cdp/capabilities.ts';
+import type { InspectorRealmId } from '../../shared/cdp/ids.ts';
+import type { ConsoleBackend, DebuggerBackend, NativeDomainBackend, RealmCapability, RuntimeBackend, SourceBackend } from '../../shared/cdp/realm.ts';
+/** Stable description of one active realm generation. */
+export interface InspectorRealmDescriptor {
+    readonly realmId: InspectorRealmId;
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly kind: 'host' | 'client';
+    readonly label: string;
+}
+/** Execution-context ownership for one realm. */
+export type InspectorRealmContext = {
+    readonly kind: 'native';
+} | {
+    readonly kind: 'synthetic';
+    readonly id: number;
+    readonly uniqueId: string;
+    readonly origin: string;
+};
+/** Capabilities bound to one realm and one DevTools connection. */
+export interface InspectorRealmSession {
+    readonly descriptor: InspectorRealmDescriptor;
+    readonly context: InspectorRealmContext;
+    readonly runtime: RealmCapability<RuntimeBackend>;
+    readonly console: RealmCapability<ConsoleBackend>;
+    readonly sources: RealmCapability<SourceBackend>;
+    readonly debugger: RealmCapability<DebuggerBackend>;
+    readonly nativeDomains: RealmCapability<NativeDomainBackend>;
+    /** Release every connection-owned backend resource. */
+    close(): void;
+}
+/** Active realm that can create isolated state for each DevTools connection. */
+export interface InspectorRealm {
+    readonly descriptor: InspectorRealmDescriptor;
+    readonly context: InspectorRealmContext;
+    readonly capabilities: InspectorRealmCapabilities;
+    /** @returns Isolated backend state for one DevTools connection. */
+    openSession(): InspectorRealmSession;
+}
+//# sourceMappingURL=realm.d.ts.map

package/lib/types/worker/realms/client/bridge.d.ts

@@ -0,0 +1,18 @@
+/** Worker-side bridge dependencies for one connected Client realm. */
+import type { ClientRuntimeRouter, ClientRuntimeTarget } from '../../bridge/runtime-rpc.ts';
+import type { ClientSourceRouter } from '../../bridge/source-rpc.ts';
+/** Typed bridge services used by all Client realm backend adapters. */
+export interface ClientRealmBridge {
+    readonly target: ClientRuntimeTarget;
+    readonly runtime: ClientRuntimeRouter;
+    readonly sources: ClientSourceRouter;
+}
+/**
+ * Bind one Client source generation to the Worker bridge services that can address it.
+ * @param target - Active Client source generation and execution context.
+ * @param runtime - Runtime and Console RPC router.
+ * @param sources - Source-catalog RPC router.
+ * @returns The immutable Client realm bridge.
+ */
+export declare function createClientRealmBridge(target: ClientRuntimeTarget, runtime: ClientRuntimeRouter, sources: ClientSourceRouter): ClientRealmBridge;
+//# sourceMappingURL=bridge.d.ts.map

package/lib/types/worker/realms/client/console.d.ts

@@ -0,0 +1,21 @@
+/** ConsoleBackend over the typed Client Console event transport. */
+import type { ClientRuntimeSessionId } from '../../../shared/bridge/ids.ts';
+import type { RuntimeBackendObjectHandle } from '../../../shared/cdp/ids.ts';
+import type { RuntimeConsoleBackendEvent } from '../../../shared/cdp/index.ts';
+import type { ClientRuntimeRouter, ClientRuntimeTarget } from '../../bridge/runtime-rpc.ts';
+import type { ConsoleBackend } from '../../../shared/cdp/realm.ts';
+import type { ClientScriptIdentity } from './scripts.ts';
+/** Adapts session-local Client Console events to common Runtime values. */
+export declare class ClientConsoleBackend implements ConsoleBackend {
+    private readonly target;
+    private readonly sessionId;
+    private readonly router;
+    private readonly scriptIds;
+    private readonly disposers;
+    constructor(target: ClientRuntimeTarget, sessionId: ClientRuntimeSessionId, router: ClientRuntimeRouter, scriptIds: ClientScriptIdentity);
+    subscribe(listener: (event: RuntimeConsoleBackendEvent<RuntimeBackendObjectHandle>) => void): () => void;
+    clear(): Promise<void>;
+    /** Disable every active Console subscription for this connection. */
+    close(): void;
+}
+//# sourceMappingURL=console.d.ts.map

package/lib/types/worker/realms/client/debugger.d.ts

@@ -0,0 +1,8 @@
+/** Explicit Client debugger capability until a pause-safe page agent exists. */
+import type { DebuggerBackend, RealmCapability } from '../../../shared/cdp/realm.ts';
+/**
+ * Report the unavailable Client debugger backend.
+ * @returns The typed unsupported result used by every Client realm session.
+ */
+export declare function clientDebuggerCapability(): RealmCapability<DebuggerBackend>;
+//# sourceMappingURL=debugger.d.ts.map

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

@@ -0,0 +1,18 @@
+/** Client realm definition assembled from independent Runtime, Console, and Source backends. */
+import type { ClientRuntimeRouter, ClientRuntimeTarget } from '../../bridge/runtime-rpc.ts';
+import type { ClientSourceRouter } from '../../bridge/source-rpc.ts';
+import type { InspectorRealm, InspectorRealmDescriptor, InspectorRealmSession } from '../../inspection/realm.ts';
+/** Active Client realm exposed through the common Worker realm model. */
+export declare class ClientInspectorRealm implements InspectorRealm {
+    readonly descriptor: InspectorRealmDescriptor;
+    readonly context: InspectorRealm['context'];
+    readonly capabilities: InspectorRealm['capabilities'];
+    private readonly scriptIds;
+    private readonly bridge;
+    constructor(target: ClientRuntimeTarget, runtimeRouter: ClientRuntimeRouter, sourceRouter: ClientSourceRouter);
+    /** Active source generation represented by this realm. */
+    get target(): ClientRuntimeTarget;
+    /** Open one isolated set of Client backends for a DevTools connection. */
+    openSession(): InspectorRealmSession;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/worker/realms/client/runtime.d.ts

@@ -0,0 +1,28 @@
+/** RuntimeBackend over the typed Worker-to-Client transport. */
+import type { ClientRuntimeSessionId } from '../../../shared/bridge/ids.ts';
+import type { RuntimeBackendObjectHandle } from '../../../shared/cdp/ids.ts';
+import type { ClientRuntimeRouter, ClientRuntimeTarget } from '../../bridge/runtime-rpc.ts';
+import type { RuntimeBackend } from '../../../shared/cdp/realm.ts';
+import type { ClientScriptIdentity } from './scripts.ts';
+/** Adapts one connection-local Client Runtime session to the common backend API. */
+export declare class ClientRuntimeBackend implements RuntimeBackend {
+    private readonly target;
+    private readonly sessionId;
+    private readonly router;
+    private readonly scriptIds;
+    private closed;
+    constructor(target: ClientRuntimeTarget, sessionId: ClientRuntimeSessionId, router: ClientRuntimeRouter, scriptIds: ClientScriptIdentity);
+    enable(): Promise<void>;
+    disable(): Promise<void>;
+    evaluate(request: Parameters<RuntimeBackend['evaluate']>[0]): ReturnType<RuntimeBackend['evaluate']>;
+    getProperties(request: Parameters<RuntimeBackend['getProperties']>[0]): ReturnType<RuntimeBackend['getProperties']>;
+    callFunction(request: Parameters<RuntimeBackend['callFunction']>[0]): ReturnType<RuntimeBackend['callFunction']>;
+    awaitPromise(request: Parameters<RuntimeBackend['awaitPromise']>[0]): ReturnType<RuntimeBackend['awaitPromise']>;
+    globalLexicalScopeNames(context?: Parameters<RuntimeBackend['globalLexicalScopeNames']>[0]): Promise<readonly string[]>;
+    releaseObject(handle: RuntimeBackendObjectHandle): Promise<void>;
+    releaseObjectGroup(group: string): Promise<void>;
+    /** Close this connection's session and reject further requests. */
+    close(): void;
+    private request;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/worker/realms/client/scripts.d.ts

@@ -0,0 +1,15 @@
+/** Realm-stable translation between Client catalog keys and common Runtime script keys. */
+import type { RuntimeScriptKey } from '../../../shared/cdp/ids.ts';
+/** Allocates one shared script identity namespace for all backends in a Client realm. */
+export declare class ClientScriptIdentity {
+    private readonly contextId;
+    private readonly publicByLocal;
+    constructor(contextId: number);
+    /**
+     * Convert a Client-local key to the realm's public Runtime script key.
+     * @param localKey - Script key used on the Client wire.
+     * @returns Stable key shared by this realm's Runtime, Console, and Sources backends.
+     */
+    toRuntime(localKey: RuntimeScriptKey): RuntimeScriptKey;
+}
+//# sourceMappingURL=scripts.d.ts.map

package/lib/types/worker/realms/client/sources.d.ts

@@ -0,0 +1,30 @@
+/** Client SourceBackend over the bounded browser source-catalog transport. */
+import type { ClientSourceSessionId } from '../../../shared/bridge/ids.ts';
+import type { RuntimeScriptKey } from '../../../shared/cdp/ids.ts';
+import type { RuntimeScript } from '../../../shared/cdp/index.ts';
+import type { ClientRuntimeTarget } from '../../bridge/runtime-rpc.ts';
+import type { ClientSourceRouter } from '../../bridge/source-rpc.ts';
+import type { SourceBackend } from '../../../shared/cdp/realm.ts';
+import type { ClientScriptIdentity } from './scripts.ts';
+/** Presents one Client bundle catalog through the common read-only source model. */
+export declare class ClientSourceBackend implements SourceBackend {
+    private readonly target;
+    private readonly sessionId;
+    private readonly router;
+    private readonly scriptIds;
+    private readonly scripts;
+    private catalog;
+    private closed;
+    constructor(target: ClientRuntimeTarget, sessionId: ClientSourceSessionId, router: ClientSourceRouter, scriptIds: ClientScriptIdentity);
+    listScripts(): Promise<readonly RuntimeScript[]>;
+    getScriptSource(scriptKey: RuntimeScriptKey): Promise<string>;
+    getSourceMap(scriptKey: RuntimeScriptKey): Promise<string | undefined>;
+    subscribe(_listener: (script: RuntimeScript) => void): () => void;
+    /** Reject pending reads owned by this DevTools connection. */
+    close(): void;
+    private loadCatalog;
+    private register;
+    private route;
+    private read;
+}
+//# sourceMappingURL=sources.d.ts.map

package/lib/types/worker/realms/client/values.d.ts

@@ -0,0 +1,55 @@
+/** Conversion from Client wire values to realm-neutral Runtime values. */
+import type { ClientRuntimeExceptionDetails, ClientRuntimePropertyDescriptor, ClientRuntimeRemoteObject, ClientRuntimeResult } from '../../../shared/bridge/messages/runtime/index.ts';
+import { type ClientRemoteObjectHandle } from '../../../shared/bridge/ids.ts';
+import type { RuntimeBackendObjectHandle, RuntimeScriptKey } from '../../../shared/cdp/ids.ts';
+import type { RuntimeCompletion, RuntimeConsoleBackendEvent, RuntimeExceptionDetails, RuntimeInternalPropertyDescriptor, RuntimePropertyDescriptor, RuntimeRemoteObject } from '../../../shared/cdp/index.ts';
+/** Maps a Client-local script key into its realm-wide Runtime identity. */
+export type ClientScriptKeyMapper = (scriptKey: RuntimeScriptKey) => RuntimeScriptKey;
+/**
+ * Convert one Client completion and all nested objects.
+ * @param result - Successful Client Runtime command result.
+ * @param mapScriptKey - Realm-wide script identity mapper.
+ * @returns A realm-neutral Runtime completion.
+ */
+export declare function clientCompletion(result: Extract<ClientRuntimeResult, {
+    op: 'evaluate' | 'call-function' | 'await-promise';
+}>, mapScriptKey: ClientScriptKeyMapper): RuntimeCompletion<RuntimeBackendObjectHandle>;
+/**
+ * Convert one Client property descriptor and all nested objects.
+ * @param value - Client wire property descriptor.
+ * @returns A realm-neutral property descriptor.
+ */
+export declare function clientProperty(value: ClientRuntimePropertyDescriptor): RuntimePropertyDescriptor<RuntimeBackendObjectHandle>;
+/**
+ * Convert one Client internal property descriptor.
+ * @param value - Client wire internal property.
+ * @returns A realm-neutral internal property.
+ */
+export declare function clientInternalProperty(value: RuntimeInternalPropertyDescriptor<ClientRemoteObjectHandle>): RuntimeInternalPropertyDescriptor<RuntimeBackendObjectHandle>;
+/**
+ * Convert Client exception details and their optional object.
+ * @param value - Client wire exception details.
+ * @param mapScriptKey - Realm-wide script identity mapper.
+ * @returns Realm-neutral exception details.
+ */
+export declare function clientException(value: ClientRuntimeExceptionDetails, mapScriptKey: ClientScriptKeyMapper): RuntimeExceptionDetails<RuntimeBackendObjectHandle>;
+/**
+ * Convert a Client Console event recursively.
+ * @param value - Client wire Console event.
+ * @param mapScriptKey - Realm-wide script identity mapper.
+ * @returns A realm-neutral Console event.
+ */
+export declare function clientConsoleEvent(value: RuntimeConsoleBackendEvent<ClientRemoteObjectHandle>, mapScriptKey: ClientScriptKeyMapper): RuntimeConsoleBackendEvent<RuntimeBackendObjectHandle>;
+/**
+ * Convert a Client RemoteObject into the backend-neutral handle slot.
+ * @param value - Client wire RemoteObject.
+ * @returns A realm-neutral Runtime value.
+ */
+export declare function clientRemoteObject(value: ClientRuntimeRemoteObject): RuntimeRemoteObject<RuntimeBackendObjectHandle>;
+/**
+ * Rebrand a common backend handle for the Client transport that owns it.
+ * @param value - Backend handle from a routed Runtime request.
+ * @returns The same opaque text under its Client wire role.
+ */
+export declare function clientHandle(value: string): ClientRemoteObjectHandle;
+//# sourceMappingURL=values.d.ts.map

package/lib/types/worker/realms/host/bridge.d.ts

@@ -0,0 +1,49 @@
+/** Per-DevTools-connection bridge to the Host main thread's real V8 inspector target. */
+import type { NativeProtocolNotification } from '../../../shared/cdp/realm.ts';
+/** Notification emitted by Node's native inspector session. */
+export type HostInspectorNotification = NativeProtocolNotification;
+/** Connection-local carrier for requests and notifications from the Host V8 inspector. */
+export declare class HostInspectorSession {
+    private readonly contextName;
+    private readonly session;
+    private readonly listeners;
+    private connected;
+    private failure;
+    constructor(contextName: string);
+    /**
+     * Subscribe to native inspector notifications.
+     * @param listener - Consumer owned by one Worker domain adapter.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (message: HostInspectorNotification) => void): () => void;
+    /**
+     * Execute one Host V8 request for a Worker-owned composite Runtime operation.
+     * @param method - CDP method name.
+     * @param params - Validated request parameters.
+     * @returns The Host inspector result.
+     */
+    request(method: string, params: Readonly<Record<string, unknown>>): Promise<Readonly<Record<string, unknown>>>;
+    /** Disconnect this DevTools client's V8 session. */
+    close(): void;
+    private connect;
+    private rewriteContextName;
+}
+/** Serializes accepted native notifications and isolates sibling consumers. */
+export declare class HostNotificationChannel<Event> {
+    private readonly accepts;
+    private readonly project;
+    private readonly listeners;
+    private readonly unsubscribe;
+    private delivery;
+    constructor(target: HostInspectorSession, accepts: (message: HostInspectorNotification) => boolean, project: (message: HostInspectorNotification) => Promise<Event | undefined>);
+    /**
+     * Subscribe to projected native notifications.
+     * @param listener - Consumer invoked in subscription order.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (event: Event) => void): () => void;
+    /** Release the native notification subscription and all consumers. */
+    close(): void;
+    private receive;
+}
+//# sourceMappingURL=bridge.d.ts.map

package/lib/types/worker/realms/host/console.d.ts

@@ -0,0 +1,25 @@
+/** ConsoleBackend implementation over native Node Runtime notifications. */
+import type { RuntimeBackendObjectHandle } from '../../../shared/cdp/ids.ts';
+import type { RuntimeConsoleBackendEvent } from '../../../shared/cdp/index.ts';
+import type { HostInspectorSession } from './bridge.ts';
+import type { ConsoleBackend } from '../../../shared/cdp/realm.ts';
+import type { HostRuntimeBackend } from './runtime.ts';
+/** Converts native Runtime notifications to realm-neutral Console events. */
+export declare class HostConsoleBackend implements ConsoleBackend {
+    private readonly target;
+    private readonly runtime;
+    private readonly events;
+    constructor(target: HostInspectorSession, runtime: HostRuntimeBackend);
+    /**
+     * Subscribe to native Console and exception events.
+     * @param listener - Connection-local event consumer.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (event: RuntimeConsoleBackendEvent<RuntimeBackendObjectHandle>) => void): () => void;
+    clear(): Promise<void>;
+    /** Release the native notification subscription. */
+    close(): void;
+    private consoleEvent;
+    private exceptionEvent;
+}
+//# sourceMappingURL=console.d.ts.map

package/lib/types/worker/realms/host/debugger.d.ts

@@ -0,0 +1,25 @@
+/** DebuggerBackend implementation over one native Node inspector session. */
+import type { RuntimeBackendObjectHandle } from '../../../shared/cdp/ids.ts';
+import type { RuntimeDebuggerEvent } from '../../../shared/cdp/index.ts';
+import type { DebuggerBackend } from '../../../shared/cdp/realm.ts';
+import type { HostInspectorSession } from './bridge.ts';
+import type { HostRuntimeBackend } from './runtime.ts';
+/** Native Host debugger adapted to common commands, Runtime values, and events. */
+export declare class HostDebuggerBackend implements DebuggerBackend {
+    private readonly target;
+    private readonly runtime;
+    private readonly events;
+    constructor(target: HostInspectorSession, runtime: HostRuntimeBackend);
+    enable(request: Parameters<DebuggerBackend['enable']>[0]): Promise<Readonly<Record<string, unknown>>>;
+    disable(): Promise<Readonly<Record<string, unknown>>>;
+    pause(): Promise<Readonly<Record<string, unknown>>>;
+    resume(request: Parameters<DebuggerBackend['resume']>[0]): Promise<Readonly<Record<string, unknown>>>;
+    evaluateOnCallFrame(request: Parameters<DebuggerBackend['evaluateOnCallFrame']>[0]): ReturnType<DebuggerBackend['evaluateOnCallFrame']>;
+    subscribe(listener: (event: RuntimeDebuggerEvent<RuntimeBackendObjectHandle>) => void): () => void;
+    /** Release the native notification subscription. */
+    close(): void;
+    private paused;
+    private callFrame;
+    private scope;
+}
+//# sourceMappingURL=debugger.d.ts.map

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

@@ -0,0 +1,13 @@
+/** Host realm adapter backed by a connection-local Node inspector session. */
+import type { InspectorRealm, InspectorRealmDescriptor, InspectorRealmSession } from '../../inspection/realm.ts';
+/** Host realm definition that opens one native V8 session per DevTools connection. */
+export declare class HostInspectorRealm implements InspectorRealm {
+    private readonly label;
+    readonly descriptor: InspectorRealmDescriptor;
+    readonly context: InspectorRealm['context'];
+    readonly capabilities: InspectorRealm['capabilities'];
+    constructor(label: string);
+    /** Open a native Host inspector session for one DevTools connection. */
+    openSession(): InspectorRealmSession;
+}
+//# sourceMappingURL=index.d.ts.map