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

package/lib/types/worker/bridge/hub.d.ts

@@ -0,0 +1,108 @@
+/** Worker-owned source generations, observation dispatch, and extension transport. */
+import { type InspectorRecordInput, type InspectorSourceDescriptor, type InspectorSourceKind, type WorkerToSourceFrame } from '../../shared/bridge/messages/observation.ts';
+import type { ClientConsoleEventFrame, ClientRuntimeResponseFrame } from '../../shared/bridge/messages/runtime/index.ts';
+import type { ClientSourceResponseFrame } from '../../shared/bridge/messages/sources/index.ts';
+/** One validated record with its source-local sequence. */
+export interface IngestedInspectorRecord extends InspectorRecordInput {
+    readonly sequence: number;
+}
+/** One connected source's reply and close operations. */
+export interface SourceConnection {
+    readonly kind: InspectorSourceKind;
+    send(frame: WorkerToSourceFrame): void;
+    close(code: number, reason: string): void;
+}
+/** Consumer of source lifecycle and records. */
+export interface InspectorRecordConsumer {
+    readonly topics: ReadonlySet<string>;
+    replace(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    append(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    close(source: InspectorSourceDescriptor, reason: string): void;
+}
+/** Source lifecycle and typed extension frames observed inside the Worker. */
+export type InspectorSourceEvent = {
+    readonly type: 'opened';
+    readonly source: InspectorSourceDescriptor;
+} | {
+    readonly type: 'closed';
+    readonly source: InspectorSourceDescriptor;
+    readonly reason: string;
+} | {
+    readonly type: 'client-runtime-response';
+    readonly source: InspectorSourceDescriptor;
+    readonly frame: ClientRuntimeResponseFrame;
+} | {
+    readonly type: 'client-console-event';
+    readonly source: InspectorSourceDescriptor;
+    readonly frame: ClientConsoleEventFrame;
+} | {
+    readonly type: 'client-source-response';
+    readonly source: InspectorSourceDescriptor;
+    readonly frame: ClientSourceResponseFrame;
+};
+/** Read-only diagnostic for `DSHInspector.getSources`. */
+export interface InspectorSourceView {
+    readonly sourceId: string;
+    readonly generation: string;
+    readonly kind: InspectorSourceKind;
+    readonly label: string;
+    readonly capabilities: readonly string[];
+    readonly expectedSequence: number;
+    readonly dropped: number;
+    readonly topics: Readonly<Record<string, number>>;
+}
+/** Serial Worker-side owner of every Host and Client source generation. */
+export declare class InspectorSourceRegistry {
+    private readonly consumers;
+    private readonly maxFrameBytes;
+    private readonly maxRecordsPerFrame;
+    private readonly sources;
+    private readonly statusListeners;
+    private readonly eventListeners;
+    constructor(consumers: readonly InspectorRecordConsumer[], maxFrameBytes: number, maxRecordsPerFrame: number);
+    /**
+     * Parse and apply one frame; malformed input closes only its source transport.
+     * @param connection - Carrier that delivered the frame.
+     * @param value - Untrusted decoded frame.
+     */
+    receive(connection: SourceConnection, value: unknown): void;
+    /**
+     * Remove every generation carried by a closed connection.
+     * @param connection - Closed source carrier.
+     * @param reason - Diagnostic propagated to domain consumers.
+     */
+    disconnect(connection: SourceConnection, reason: string): void;
+    /**
+     * Read current source status for the diagnostic CDP domain.
+     * @returns A detached status row for every active source.
+     */
+    describe(): InspectorSourceView[];
+    /**
+     * Subscribe to source status changes.
+     * @param listener - Status observer.
+     * @returns A disposer that removes the observer.
+     */
+    subscribeStatus(listener: () => void): () => void;
+    /**
+     * Subscribe to source admission, removal, and typed extension frames.
+     * @param listener - Source protocol observer.
+     * @returns A disposer that removes the observer.
+     */
+    subscribeEvents(listener: (event: InspectorSourceEvent) => void): () => void;
+    /**
+     * Send a typed control frame only to its still-active source generation.
+     * @param source - Expected active source generation.
+     * @param frame - Validated Worker-to-source frame.
+     * @returns Whether the generation was still active and accepted the send.
+     */
+    send(source: InspectorSourceDescriptor, frame: WorkerToSourceFrame): boolean;
+    /** Close every source and forget all state. */
+    close(): void;
+    private apply;
+    private open;
+    private assertTopics;
+    private count;
+    private notifyStatus;
+    private emit;
+}
+//# sourceMappingURL=hub.d.ts.map

package/lib/types/worker/bridge/runtime-rpc.d.ts

@@ -0,0 +1,90 @@
+/** Worker-owned routing between synthetic Client contexts and source generations. */
+import type { ClientRuntimeCapability, ClientRuntimeCommand, ClientRuntimeError, ClientRuntimeResult } from '../../shared/bridge/messages/runtime/index.ts';
+import { type ClientRemoteObjectHandle, type ClientRuntimeSessionId } from '../../shared/bridge/ids.ts';
+import { type InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorSourceRegistry } from './hub.ts';
+import type { RuntimeConsoleBackendEvent } from '../../shared/cdp/index.ts';
+/** One connected projection of a Client realm into a synthetic CDP execution context. */
+export interface ClientRuntimeTarget {
+    readonly contextId: number;
+    readonly uniqueContextId: string;
+    readonly source: InspectorSourceDescriptor;
+    readonly capability: ClientRuntimeCapability;
+}
+/** Runtime target admission or removal. */
+export type ClientRuntimeTargetEvent = {
+    readonly type: 'opened';
+    readonly target: ClientRuntimeTarget;
+} | {
+    readonly type: 'closed';
+    readonly target: ClientRuntimeTarget;
+};
+/** Error returned deliberately by the Client Runtime executor. */
+export declare class ClientRuntimeRemoteError extends Error {
+    readonly code: ClientRuntimeError['code'];
+    constructor(code: ClientRuntimeError['code'], message: string);
+}
+/** Runtime context registry and correlated Worker-to-Client request owner. */
+export declare class ClientRuntimeRouter {
+    private readonly sources;
+    private readonly timeoutMs;
+    private readonly targetsBySource;
+    private readonly pending;
+    private readonly consoleSubscriptions;
+    private readonly listeners;
+    private readonly unsubscribeSources;
+    private nextContextId;
+    private closed;
+    constructor(sources: InspectorSourceRegistry, timeoutMs: number);
+    /**
+     * Snapshot all active Client execution contexts.
+     * @returns Active targets in admission order.
+     */
+    targets(): ClientRuntimeTarget[];
+    /**
+     * Resolve the Client target for one active source generation.
+     * @param source - Source identity stored with a semantic node.
+     * @returns Its active Runtime target, when the generation still matches.
+     */
+    bySource(source: InspectorSourceDescriptor): ClientRuntimeTarget | undefined;
+    /**
+     * Subscribe to synthetic execution-context lifecycle.
+     * @param listener - Context lifecycle observer.
+     * @returns A disposer that removes the observer.
+     */
+    subscribe(listener: (event: ClientRuntimeTargetEvent) => void): () => void;
+    /**
+     * Enable Console events for one Client realm and DevTools session.
+     * @param target - Active Client realm.
+     * @param sessionId - DevTools Runtime session retaining event arguments.
+     * @param listener - Consumer of validated Client Console events.
+     * @returns A disposer that disables this Console session.
+     */
+    subscribeConsole(target: ClientRuntimeTarget, sessionId: ClientRuntimeSessionId, listener: (event: RuntimeConsoleBackendEvent<ClientRemoteObjectHandle>) => void): () => void;
+    /**
+     * Execute one typed command in its currently active source generation.
+     * @param target - Active Client source and context.
+     * @param sessionId - Calling DevTools Runtime session.
+     * @param command - Validated Client Runtime operation.
+     * @returns The correlated result, or a rejection on timeout or disconnect.
+     */
+    request(target: ClientRuntimeTarget, sessionId: ClientRuntimeSessionId, command: ClientRuntimeCommand): Promise<ClientRuntimeResult>;
+    /**
+     * Close one realm-local Runtime session without notifying sibling Client realms.
+     * @param target - Client realm that owns the session.
+     * @param sessionId - Closing DevTools Runtime session.
+     */
+    closeTargetSession(target: ClientRuntimeTarget, sessionId: ClientRuntimeSessionId): void;
+    /** Stop routing and reject every outstanding operation. */
+    close(): void;
+    private receiveSourceEvent;
+    private open;
+    private remove;
+    private consoleEvent;
+    private settle;
+    private acknowledgeClientResponse;
+    private cancelClientResponse;
+    private rejectPending;
+    private emit;
+}
+//# sourceMappingURL=runtime-rpc.d.ts.map

package/lib/types/worker/bridge/session.d.ts

@@ -0,0 +1,15 @@
+/** Shared cleanup delivery for Worker-owned Client sessions. */
+import type { ClientRuntimeSessionClosedFrame } from '../../shared/bridge/messages/runtime/index.ts';
+import type { ClientSourceSessionClosedFrame } from '../../shared/bridge/messages/sources/index.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorSourceRegistry } from './hub.ts';
+type ClientSessionClosedFrame = ClientRuntimeSessionClosedFrame | ClientSourceSessionClosedFrame;
+/**
+ * Send cleanup to an active Client generation when its transport is still usable.
+ * @param sources - Worker source registry owning the transport.
+ * @param source - Generation whose session closed.
+ * @param frame - Typed Runtime or source-catalog cleanup frame.
+ */
+export declare function sendClientSessionClosed(sources: InspectorSourceRegistry, source: InspectorSourceDescriptor, frame: ClientSessionClosedFrame): void;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/lib/types/worker/bridge/source-rpc.d.ts

@@ -0,0 +1,42 @@
+/** Worker-owned request routing for Client read-only source catalogs. */
+import type { ClientSourceCommand, ClientSourceError, ClientSourceResult } from '../../shared/bridge/messages/sources/index.ts';
+import { type ClientSourceSessionId } from '../../shared/bridge/ids.ts';
+import { type InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorSourceRegistry } from './hub.ts';
+/** Deliberate error returned by the Client source catalog. */
+export declare class ClientSourceRemoteError extends Error {
+    readonly code: ClientSourceError['code'];
+    constructor(code: ClientSourceError['code'], message: string);
+}
+/** Correlates bounded source requests with one active Client source generation. */
+export declare class ClientSourceRouter {
+    private readonly sources;
+    private readonly timeoutMs;
+    readonly maxContentBytes: number;
+    /** Maximum decoded bytes requested in one source-content response. */
+    readonly chunkBytes: number;
+    private readonly pending;
+    private readonly unsubscribeSources;
+    private closed;
+    constructor(sources: InspectorSourceRegistry, timeoutMs: number, maxContentBytes: number, maxFrameBytes: number);
+    /**
+     * Execute one operation against an active Client source generation.
+     * @param source - Client source that owns the script catalog.
+     * @param sessionId - DevTools connection-local source session.
+     * @param command - Validated read-only source command.
+     * @returns The correlated result.
+     */
+    request(source: InspectorSourceDescriptor, sessionId: ClientSourceSessionId, command: ClientSourceCommand): Promise<ClientSourceResult>;
+    /**
+     * Reject pending operations and notify one Client source session that it closed.
+     * @param source - Source generation owning the session.
+     * @param sessionId - Closing source session.
+     */
+    closeSession(source: InspectorSourceDescriptor, sessionId: ClientSourceSessionId): void;
+    /** Stop routing and reject every outstanding source operation. */
+    close(): void;
+    private receiveSourceEvent;
+    private settle;
+    private rejectPending;
+}
+//# sourceMappingURL=source-rpc.d.ts.map

package/lib/types/worker/cdp/domains/debugger/cdp-params.d.ts

@@ -0,0 +1,15 @@
+/** Validation for CDP Debugger requests handled by the shared domain. */
+import type { RuntimeCallFrameEvaluationRequest } from '../../../../shared/cdp/index.ts';
+/**
+ * Parse Debugger.evaluateOnCallFrame without silently accepting unsupported options.
+ * @param params - Untrusted CDP parameters.
+ * @returns The common call-frame evaluation request.
+ */
+export declare function parseCallFrameEvaluation(params: Readonly<Record<string, unknown>>): RuntimeCallFrameEvaluationRequest;
+/**
+ * Find a ScriptId carried directly or by a Debugger location parameter.
+ * @param params - Parsed CDP parameter record.
+ * @returns The targeted script id when the request names one.
+ */
+export declare function requestScriptId(params: Readonly<Record<string, unknown>>): string | undefined;
+//# sourceMappingURL=cdp-params.d.ts.map

package/lib/types/worker/cdp/domains/debugger/index.d.ts

@@ -0,0 +1,6 @@
+/** Shared Debugger domain exports. */
+export * from './cdp-params.ts';
+export * from './projector.ts';
+export * from './script-registry.ts';
+export * from './session.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/worker/cdp/domains/debugger/projector.d.ts

@@ -0,0 +1,22 @@
+/** CDP projection for realm-neutral scripts and debugger events. */
+import type { RuntimeDebuggerEvent, RuntimeScript } from '../../../../shared/cdp/index.ts';
+import type { RuntimeBackendObjectHandle } from '../../../../shared/cdp/ids.ts';
+import type { CdpNotification } from '../../protocol.ts';
+import type { InspectorRealmSession } from '../../../inspection/realm.ts';
+import type { RuntimeDomainSession } from '../runtime/index.ts';
+/**
+ * Project one common script descriptor to Debugger.scriptParsed.
+ * @param realm - Realm session that owns the script.
+ * @param script - Realm-neutral script descriptor.
+ * @returns A CDP scriptParsed notification.
+ */
+export declare function scriptParsedEvent(realm: InspectorRealmSession, script: RuntimeScript): CdpNotification;
+/**
+ * Project one common debugger event and all nested Runtime objects to CDP.
+ * @param realm - Realm session that emitted the event.
+ * @param event - Realm-neutral debugger event.
+ * @param runtime - Connection-local Runtime object projector.
+ * @returns The corresponding CDP notification.
+ */
+export declare function debuggerEvent(realm: InspectorRealmSession, event: RuntimeDebuggerEvent<RuntimeBackendObjectHandle>, runtime: RuntimeDomainSession): CdpNotification;
+//# sourceMappingURL=projector.d.ts.map

package/lib/types/worker/cdp/domains/debugger/script-registry.d.ts

@@ -0,0 +1,70 @@
+/** Connection-local routing from CDP ScriptId values to realm source backends. */
+import type { RuntimeScriptKey } from '../../../../shared/cdp/ids.ts';
+import type { RuntimeScript } from '../../../../shared/cdp/index.ts';
+import type { SourceBackend } from '../../../../shared/cdp/realm.ts';
+import type { InspectorRealmSession } from '../../../inspection/realm.ts';
+import { type CdpScriptId } from '../../ids.ts';
+/** One script and the realm source backend that owns its content. */
+export interface DebuggerScriptRoute {
+    readonly realm: InspectorRealmSession;
+    readonly source: SourceBackend;
+    readonly script: RuntimeScript;
+}
+/** Tracks active and retired scripts without exposing source transport ids. */
+export declare class DebuggerScriptRegistry {
+    private readonly routes;
+    private readonly retiredUnsupported;
+    /**
+     * Register one realm script under its globally unique Runtime script key.
+     * @param route - Script descriptor and owning realm session.
+     * @returns The CDP ScriptId and whether this is its first announcement.
+     */
+    register(route: DebuggerScriptRoute): {
+        readonly scriptId: CdpScriptId;
+        readonly fresh: boolean;
+    };
+    /**
+     * Resolve an active CDP ScriptId.
+     * @param scriptId - Connection-visible script id.
+     * @returns The active route when the script remains connected.
+     */
+    resolve(scriptId: string): DebuggerScriptRoute | undefined;
+    /**
+     * Resolve a script by its exact URL.
+     * @param url - Script URL from a CDP request.
+     * @returns The active route when one script has that URL.
+     */
+    byUrl(url: string): DebuggerScriptRoute | undefined;
+    /**
+     * Resolve a script by its exact content hash.
+     * @param hash - Script hash from a breakpoint request.
+     * @returns The active route when one script has that hash.
+     */
+    byHash(hash: string): DebuggerScriptRoute | undefined;
+    /**
+     * Resolve the first script whose URL matches a breakpoint regular expression.
+     * @param pattern - JavaScript regular-expression source accepted by CDP.
+     * @returns The first matching active route.
+     */
+    byUrlPattern(pattern: string): DebuggerScriptRoute | undefined;
+    /**
+     * Test whether a disconnected script belonged to a realm without active debugging.
+     * @param scriptId - Script id from a later CDP request.
+     * @returns Whether the id must still fail as an unsupported Client script.
+     */
+    wasUnsupported(scriptId: string): boolean;
+    /**
+     * Forget scripts for one closed realm while retaining their unsupported identity.
+     * @param realm - Realm session being removed.
+     */
+    removeRealm(realm: InspectorRealmSession): void;
+    /** Forget all active and retired script routes. */
+    clear(): void;
+}
+/**
+ * Preserve a branded script key as its CDP wire identifier.
+ * @param scriptKey - Realm-wide Runtime script key.
+ * @returns The corresponding CDP ScriptId text.
+ */
+export declare function cdpScriptId(scriptKey: RuntimeScriptKey): CdpScriptId;
+//# sourceMappingURL=script-registry.d.ts.map

package/lib/types/worker/cdp/domains/debugger/session.d.ts

@@ -0,0 +1,47 @@
+/** Per-DevTools Debugger and source routing across Host and Client realms. */
+import { type CdpRequest, type CdpTransport } from '../../protocol.ts';
+import type { InspectorRealmSessionSet } from '../../realm-sessions.ts';
+import type { RuntimeDomainSession } from '../runtime/index.ts';
+/** Owns Debugger lifecycle, shared script projection, and Host-native fallback. */
+export declare class DebuggerDomainSession {
+    private readonly transport;
+    private readonly realms;
+    private readonly runtime;
+    private readonly scripts;
+    private readonly sourceDisposers;
+    private readonly debuggerDisposers;
+    private readonly callFrameRealms;
+    private readonly unsubscribeRealms;
+    private readonly native;
+    private debuggerEnableRequest;
+    private enabled;
+    private closed;
+    constructor(transport: CdpTransport, realms: InspectorRealmSessionSet, runtime: RuntimeDomainSession);
+    /**
+     * Handle one Debugger request, including Client read-only source operations.
+     * @param request - Parsed CDP request.
+     * @returns Whether the method belongs to the Debugger domain.
+     */
+    handle(request: CdpRequest): boolean;
+    /** Release source and debugger subscriptions. */
+    close(): void;
+    private enable;
+    private disable;
+    private getScriptSource;
+    private searchInContent;
+    private evaluateOnCallFrame;
+    private pause;
+    private resume;
+    private forwardNative;
+    private unsupportedRoute;
+    private receiveRealm;
+    private enableRealm;
+    private attachCapabilities;
+    private publishCatalog;
+    private publishScript;
+    private publishDebuggerEvent;
+    private supportedDebugger;
+    private detachCapabilities;
+    private respond;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/types/worker/cdp/domains/dom/index.d.ts

@@ -0,0 +1,4 @@
+/** Cordis semantic DOM domain exports. */
+export { CordisDomBackend, type CordisDomChange, type CordisDomMutation } from './model.ts';
+export { CordisDomSession } from './session.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/worker/cdp/domains/dom/model.d.ts

@@ -0,0 +1,108 @@
+/** Worker projection from Cordis snapshots to a connection-neutral semantic DOM. */
+import type { InspectorSourceDescriptor } from '../../../../shared/bridge/messages/observation.ts';
+import type { InspectorObjectReference } from '../../../../shared/cordis/object-reference.ts';
+import type { InspectorRealmDescriptor } from '../../../inspection/realm.ts';
+import { type CdpBackendNodeId } from '../../ids.ts';
+import type { CordisTreeObjectRoute, CordisTreeStore } from '../../../inspection/cordis-store.ts';
+/** One Worker-global backend node independent of any DevTools connection. */
+export interface CordisDomNode {
+    readonly backendNodeId: CdpBackendNodeId;
+    readonly key: string;
+    readonly name: string;
+    readonly attributes: readonly (readonly [string, string])[];
+    readonly description: string;
+    readonly object?: CordisTreeObjectRoute;
+    readonly children: readonly CordisDomNode[];
+}
+/** Immutable document revision shared by all current DevTools sessions. */
+export interface CordisDomDocument {
+    readonly revision: number;
+    readonly root: CordisDomNode;
+    readonly byBackendId: ReadonlyMap<CdpBackendNodeId, CordisDomNode>;
+    readonly parentByBackendId: ReadonlyMap<CdpBackendNodeId, CdpBackendNodeId>;
+}
+/** One structural or attribute mutation between two projected documents. */
+export type CordisDomMutation = {
+    readonly type: 'document-updated';
+} | {
+    readonly type: 'child-inserted';
+    readonly parentBackendNodeId: CdpBackendNodeId;
+    readonly previousBackendNodeId: CdpBackendNodeId | 0;
+    readonly node: CordisDomNode;
+} | {
+    readonly type: 'child-removed';
+    readonly parentBackendNodeId: CdpBackendNodeId;
+    readonly node: CordisDomNode;
+} | {
+    readonly type: 'children-replaced';
+    readonly parentBackendNodeId: CdpBackendNodeId;
+    readonly children: readonly CordisDomNode[];
+} | {
+    readonly type: 'attribute-modified';
+    readonly backendNodeId: CdpBackendNodeId;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly type: 'attribute-removed';
+    readonly backendNodeId: CdpBackendNodeId;
+    readonly name: string;
+};
+/** A visible incremental mutation or an in-place source availability change. */
+export type CordisDomChange = {
+    readonly type: 'tree-mutated';
+    readonly mutations: readonly CordisDomMutation[];
+} | {
+    readonly type: 'source-disconnected';
+    readonly source: InspectorSourceDescriptor;
+};
+/** Assigns durable backend ids and projects the latest source snapshots. */
+export declare class CordisDomBackend {
+    private readonly trees;
+    private readonly backendIdByKey;
+    private readonly listeners;
+    private documentValue;
+    private nextBackendNodeId;
+    private nextRevision;
+    private readonly unsubscribe;
+    private readonly nodeByObject;
+    constructor(trees: CordisTreeStore);
+    /**
+     * Read the latest connection-neutral semantic document.
+     * @returns The current immutable document revision.
+     */
+    document(): CordisDomDocument;
+    /**
+     * Subscribe to full document replacements and in-place realm state changes.
+     * @param listener - Called after a new backend revision is installed.
+     * @returns A disposer removing the listener.
+     */
+    subscribe(listener: (event: CordisDomChange) => void): () => void;
+    /** Release repository subscriptions at Worker shutdown. */
+    close(): void;
+    /**
+     * Resolve one source-local object reference to its current projected node.
+     * @param source - Connected source generation that owns the reference.
+     * @param reference - Realm-local registry and object handle.
+     * @returns The current projected node, when present.
+     */
+    nodeForObject(source: InspectorSourceDescriptor, reference: InspectorObjectReference): CordisDomNode | undefined;
+    /**
+     * Resolve a reference when a Runtime route identifies only Host or Client ownership.
+     * @param kind - Host or Client ownership inferred by the Runtime adapter.
+     * @param reference - Realm-local registry and object handle.
+     * @returns The current projected node, when present.
+     */
+    nodeForObjectKind(kind: InspectorSourceDescriptor['kind'], reference: InspectorObjectReference): CordisDomNode | undefined;
+    /**
+     * Resolve one realm-neutral Runtime reference to its current projected node.
+     * @param realm - Realm that exposed the Runtime object.
+     * @param reference - Realm-local registry and object handle.
+     * @returns The current projected node, when present.
+     */
+    nodeForRealm(realm: InspectorRealmDescriptor, reference: InspectorObjectReference): CordisDomNode | undefined;
+    private build;
+    private entity;
+    private node;
+    private emit;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/types/worker/cdp/domains/dom/session.d.ts

@@ -0,0 +1,74 @@
+/** Per-DevTools-session read-only DOM projection over Cordis tree snapshots. */
+import type { InspectorObjectReference } from '../../../../shared/cordis/object-reference.ts';
+import { type CdpRequest, type CdpTransport } from '../../protocol.ts';
+import type { InspectorRealmDescriptor } from '../../../inspection/realm.ts';
+import type { RuntimeDomainSession } from '../runtime/index.ts';
+import type { RuntimeObjectPresentation } from '../runtime/object-table.ts';
+import type { CordisDomBackend } from './model.ts';
+import { type CdpRemoteObjectId } from '../../ids.ts';
+/**
+ * Connection-local NodeId, search, and RemoteObject mapping owner. Node payloads are depth-limited;
+ * withheld levels are fetched through `DOM.requestChildNodes` or pushed with the ancestor chain
+ * when a NodeId leaves through search or object lookup.
+ */
+export declare class CordisDomSession {
+    private readonly transport;
+    private readonly backend;
+    private readonly runtime;
+    private readonly nodeIdByBackend;
+    private readonly backendByNodeId;
+    private readonly childrenSent;
+    private readonly backendByObjectId;
+    private readonly objectIdsByGroup;
+    private readonly searches;
+    private readonly unsubscribe;
+    private nextNodeId;
+    private nextSearchId;
+    private enabled;
+    constructor(transport: CdpTransport, backend: CordisDomBackend, runtime: RuntimeDomainSession);
+    /**
+     * Handle one DOM command.
+     * @param request - Parsed CDP request.
+     * @returns Whether this adapter owns the method.
+     */
+    handle(request: CdpRequest): boolean;
+    /**
+     * Forget a Runtime object mapping before its owner releases the object.
+     * @param objectId - Connection-local Runtime object id.
+     */
+    releaseObject(objectId: unknown): void;
+    /**
+     * Recognize a Runtime object from any realm as one current Cordis node.
+     * @param objectId - Connection-local CDP object id.
+     * @param realm - Realm that exposed the object.
+     * @param reference - Realm-local semantic object identity.
+     * @param group - Runtime object group retaining the id.
+     * @returns Node presentation fields, when the object remains in the current tree.
+     */
+    bindObject(objectId: CdpRemoteObjectId, realm: InspectorRealmDescriptor, reference: InspectorObjectReference, group: string | undefined): RuntimeObjectPresentation | undefined;
+    /**
+     * Forget every DOM mapping retained under one Runtime object group.
+     * @param group - Runtime object-group name.
+     */
+    releaseObjectGroup(group: unknown): void;
+    /** Release connection-owned ids and subscriptions. */
+    close(): void;
+    private execute;
+    private resolveNode;
+    private bindObjectId;
+    private selectNode;
+    private fromNodeId;
+    private serialize;
+    /** Deliver the not-yet-sent ancestor levels of one node so its NodeId attaches to the frontend tree. */
+    private pushNodePath;
+    private forgetSubtree;
+    private nodeId;
+    private parentNodeId;
+    private resetDocument;
+    private updateDocument;
+    private sendMutation;
+    private pruneDocumentState;
+    private releaseSourceObjects;
+    private respond;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/types/worker/cdp/domains/native.d.ts

@@ -0,0 +1,25 @@
+/** Explicit adapter for Host-only native CDP methods during realm migration. */
+import { type CdpRequest, type CdpTransport } from '../protocol.ts';
+import type { NativeDomainBackend } from '../../../shared/cdp/realm.ts';
+/** Forwards one explicit Host-native domain through a transport-neutral Node session. */
+export declare class HostNativeDomainSession {
+    private readonly transport;
+    private readonly target;
+    private readonly unsubscribe;
+    constructor(transport: CdpTransport, target: NativeDomainBackend);
+    /**
+     * Execute one Host-native CDP request and send its correlated result.
+     * @param request - Parsed request owned by a native Host domain.
+     * @returns Whether this adapter owns the request's domain.
+     */
+    handle(request: CdpRequest): boolean;
+    /**
+     * Test whether this adapter owns a CDP method.
+     * @param method - CDP method name.
+     * @returns Whether the method belongs to an explicit Host-native domain.
+     */
+    owns(method: string): boolean;
+    /** Stop forwarding native notifications to this DevTools connection. */
+    close(): void;
+}
+//# sourceMappingURL=native.d.ts.map