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

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

@@ -0,0 +1,46 @@
+/** CDP Network projection over the Worker-owned normalized network store. */
+import type { NetworkStore } from '../../../inspection/network-store.ts';
+/** CDP session slice used by the Network domain. */
+export interface NetworkSink {
+    sendEvent(method: string, params: Readonly<Record<string, unknown>>): void;
+}
+/** Projects retained and live network observations into connection-local CDP state. */
+export declare class NetworkDomain {
+    private readonly store;
+    private readonly enabled;
+    private readonly streamedRequests;
+    private readonly pendingStarts;
+    private readonly requestTypes;
+    private readonly unsubscribe;
+    constructor(store: NetworkStore);
+    /**
+     * Enable Network for one DevTools connection and replay retained lifecycle events.
+     * @param session - Connection receiving replay and subsequent events.
+     */
+    enable(session: NetworkSink): void;
+    /**
+     * Stop Network events for one DevTools connection.
+     * @param session - Connection leaving the enabled set.
+     */
+    disable(session: NetworkSink): void;
+    /**
+     * Forget a closed DevTools connection.
+     * @param session - Closed DevTools connection.
+     */
+    detach(session: NetworkSink): void;
+    /** Release the repository subscription and all connection-local state. */
+    close(): void;
+    /**
+     * Handle one Worker-local Network method.
+     * @param method - CDP method name.
+     * @param params - Parsed request parameters.
+     * @param session - Calling DevTools connection.
+     * @returns The CDP result fields.
+     */
+    handle(method: string, params: Readonly<Record<string, unknown>>, session: NetworkSink): unknown;
+    private receive;
+    private send;
+    private sendRequestStart;
+    private stopRequest;
+}
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1,82 @@
+/** Validation and normalization of CDP Runtime parameters routed to a Client realm. */
+import type { RuntimeBackendObjectHandle } from '../../../../shared/cdp/ids.ts';
+import { type InspectorJsonValue } from '../../../../shared/json.ts';
+import type { RuntimeAwaitPromiseRequest, RuntimeCallFunctionRequest, RuntimeEvaluateRequest, RuntimeGetPropertiesRequest } from '../../../../shared/cdp/index.ts';
+/** Numeric or globally unique selector for one execution context. */
+export interface CdpExecutionContextSelector {
+    readonly contextId?: number;
+    readonly executionContextId?: number;
+    readonly uniqueContextId?: string;
+}
+/** Validated Runtime.evaluate parameters and their routing selector. */
+export interface ParsedEvaluate extends CdpExecutionContextSelector {
+    readonly request: RuntimeEvaluateRequest;
+}
+/** Client-independent call argument before object ids are routed. */
+export type CdpCallArgument = {
+    readonly kind: 'value';
+    readonly value: InspectorJsonValue;
+} | {
+    readonly kind: 'unserializable';
+    readonly value: string;
+} | {
+    readonly kind: 'object';
+    readonly objectId: string;
+} | {
+    readonly kind: 'undefined';
+};
+/** Validated Runtime.callFunctionOn parameters before object-id routing. */
+export interface ParsedCallFunction extends CdpExecutionContextSelector {
+    readonly objectId?: string;
+    readonly arguments: readonly CdpCallArgument[];
+    readonly request: Omit<RuntimeCallFunctionRequest<RuntimeBackendObjectHandle>, 'receiver' | 'arguments'>;
+}
+/**
+ * Parse realm-routed `Runtime.evaluate` parameters.
+ * @param params - Untrusted CDP parameters.
+ * @returns A context selector and normalized Runtime request.
+ */
+export declare function parseEvaluate(params: Readonly<Record<string, unknown>>): ParsedEvaluate;
+/**
+ * Parse realm-routed `Runtime.getProperties` parameters.
+ * @param params - Untrusted CDP parameters.
+ * @returns The external object id and handle-free Runtime request.
+ */
+export declare function parseGetProperties(params: Readonly<Record<string, unknown>>): {
+    readonly objectId: string;
+    readonly request: Omit<RuntimeGetPropertiesRequest<RuntimeBackendObjectHandle>, 'handle'>;
+};
+/**
+ * Parse Client-routed `Runtime.callFunctionOn` parameters.
+ * @param params - Untrusted CDP parameters.
+ * @returns Routing fields, arguments, and a handle-free Runtime request.
+ */
+export declare function parseCallFunction(params: Readonly<Record<string, unknown>>): ParsedCallFunction;
+/**
+ * Parse Client-routed `Runtime.awaitPromise` parameters.
+ * @param params - Untrusted CDP parameters.
+ * @returns The external promise id and handle-free Runtime request.
+ */
+export declare function parseAwaitPromise(params: Readonly<Record<string, unknown>>): {
+    readonly promiseObjectId: string;
+    readonly request: Omit<RuntimeAwaitPromiseRequest<RuntimeBackendObjectHandle>, 'promise'>;
+};
+/**
+ * Parse one required object id.
+ * @param params - Untrusted CDP parameters.
+ * @returns The object id.
+ */
+export declare function parseReleaseObject(params: Readonly<Record<string, unknown>>): string;
+/**
+ * Parse one required object-group name.
+ * @param params - Untrusted CDP parameters.
+ * @returns The object-group name.
+ */
+export declare function parseReleaseObjectGroup(params: Readonly<Record<string, unknown>>): string;
+/**
+ * Parse `Runtime.globalLexicalScopeNames` context selection.
+ * @param params - Untrusted CDP parameters.
+ * @returns The validated context selector.
+ */
+export declare function parseGlobalLexicalScopeNames(params: Readonly<Record<string, unknown>>): CdpExecutionContextSelector;
+//# sourceMappingURL=cdp-params.d.ts.map

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

@@ -0,0 +1,3 @@
+/** Client-aware Runtime domain exports. */
+export { RuntimeDomainSession } from './session.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/worker/cdp/domains/runtime/object-table.d.ts

@@ -0,0 +1,117 @@
+/** Per-CDP-connection routing and projection for every realm's Runtime objects. */
+import type { RuntimeCompletion, RuntimeConsoleBackendEvent, RuntimeProperties, RuntimeRemoteObject } from '../../../../shared/cdp/index.ts';
+import type { InspectorObjectReference } from '../../../../shared/cordis/object-reference.ts';
+import type { RuntimeBackendObjectHandle } from '../../../../shared/cdp/ids.ts';
+import type { InspectorRealmDescriptor, InspectorRealmSession } from '../../../inspection/realm.ts';
+import { type CdpRemoteObjectId, type InspectorConnectionId } from '../../ids.ts';
+/** Object retained behind one connection-local CDP object id. */
+export interface RuntimeObjectRoute {
+    readonly realm: InspectorRealmSession;
+    readonly handle: RuntimeBackendObjectHandle;
+    readonly group: string | undefined;
+}
+/** Semantic presentation applied when an object belongs to a projected node. */
+export interface RuntimeObjectPresentation {
+    readonly subtype: 'node';
+    readonly className: string;
+    readonly description: string;
+}
+/** Observer of newly exposed Runtime object ids. */
+export type RuntimeObjectObserver = (objectId: CdpRemoteObjectId, realm: InspectorRealmDescriptor, reference: InspectorObjectReference, group: string | undefined) => RuntimeObjectPresentation | undefined;
+/** CDP Runtime payload derived from one realm completion. */
+export interface CdpRuntimeCompletion {
+    readonly result: Readonly<Record<string, unknown>>;
+    readonly exceptionDetails?: Readonly<Record<string, unknown>>;
+}
+/** CDP Runtime payload derived from one realm's property descriptors. */
+export interface CdpGetPropertiesResult {
+    readonly result: readonly Readonly<Record<string, unknown>>[];
+    readonly internalProperties?: readonly Readonly<Record<string, unknown>>[];
+    readonly privateProperties?: readonly Readonly<Record<string, unknown>>[];
+    readonly exceptionDetails?: Readonly<Record<string, unknown>>;
+}
+/** One CDP notification projected from a realm Console event. */
+export interface CdpRuntimeEvent {
+    readonly method: 'Runtime.consoleAPICalled' | 'Runtime.exceptionThrown';
+    readonly params: Readonly<Record<string, unknown>>;
+}
+/** Maps every realm's backend handles to object ids scoped to one CDP connection. */
+export declare class RuntimeObjectTable {
+    private readonly connectionId;
+    private readonly routes;
+    private nextObjectId;
+    private nextExceptionId;
+    private observer;
+    constructor(connectionId: InspectorConnectionId);
+    /**
+     * Install Cordis object recognition after Runtime and DOM sessions are assembled.
+     * @param observer - Callback mapping a semantic reference to node presentation.
+     */
+    setObserver(observer: RuntimeObjectObserver): void;
+    /**
+     * Resolve one connection-local object id.
+     * @param objectId - CDP object id allocated by this table.
+     * @returns Its realm and backend handle when current.
+     */
+    resolve(objectId: string): RuntimeObjectRoute | undefined;
+    /**
+     * Convert a realm completion to CDP fields.
+     * @param realm - Realm session that produced the value.
+     * @param value - Engine-independent completion.
+     * @param group - Object group inherited by exposed handles.
+     * @returns CDP Runtime completion fields.
+     */
+    completion(realm: InspectorRealmSession, value: RuntimeCompletion<RuntimeBackendObjectHandle>, group: string | undefined): CdpRuntimeCompletion;
+    /**
+     * Convert realm property descriptors to CDP fields.
+     * @param realm - Realm session that owns returned object references.
+     * @param value - Engine-independent property result.
+     * @param group - Object group inherited from the inspected object.
+     * @returns CDP Runtime property result fields.
+     */
+    properties(realm: InspectorRealmSession, value: RuntimeProperties<RuntimeBackendObjectHandle>, group: string | undefined): CdpGetPropertiesResult;
+    /**
+     * Project one realm Console event to a CDP Runtime notification.
+     * @param realm - Realm session that emitted the event.
+     * @param value - Realm-neutral Console or exception event.
+     * @returns CDP method and parameters.
+     */
+    consoleEvent(realm: InspectorRealmSession, value: RuntimeConsoleBackendEvent<RuntimeBackendObjectHandle>): CdpRuntimeEvent;
+    /**
+     * List realm sessions retaining at least one object in a group.
+     * @param group - DevTools object-group name.
+     * @returns Distinct realm sessions that must receive the release.
+     */
+    realmsInGroup(group: string): InspectorRealmSession[];
+    /**
+     * Forget one externally visible object id.
+     * @param objectId - Released CDP object id.
+     */
+    release(objectId: string): void;
+    /**
+     * Forget all ids retained under one object group.
+     * @param group - Released object-group name.
+     */
+    releaseGroup(group: string): void;
+    /**
+     * Forget every object owned by one closed realm session.
+     * @param realm - Closed realm session.
+     */
+    releaseRealm(realm: InspectorRealmSession): void;
+    /** Forget every object exposed on this DevTools connection. */
+    clear(): void;
+    /**
+     * Project one common Runtime value and retain its backend handle for this connection.
+     * @param realm - Realm session that owns the value.
+     * @param value - Realm-neutral Runtime value.
+     * @param group - Object group assigned to any exposed handle.
+     * @returns CDP RemoteObject fields.
+     */
+    remote(realm: InspectorRealmSession, value: RuntimeRemoteObject<RuntimeBackendObjectHandle>, group: string | undefined): Readonly<Record<string, unknown>>;
+    private property;
+    private internalProperty;
+    private privateProperty;
+    private exception;
+    private expose;
+}
+//# sourceMappingURL=object-table.d.ts.map

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

@@ -0,0 +1,97 @@
+/** Per-DevTools-session Runtime routing across uniform Host and Client realms. */
+import type { InspectorSourceDescriptor } from '../../../../shared/bridge/messages/observation.ts';
+import type { RuntimeBackendObjectHandle } from '../../../../shared/cdp/ids.ts';
+import type { RuntimeCompletion, RuntimeRemoteObject } from '../../../../shared/cdp/index.ts';
+import { type CdpRequest, type CdpTransport } from '../../protocol.ts';
+import type { InspectorRealmSession } from '../../../inspection/realm.ts';
+import type { InspectorRealmSessionSet } from '../../realm-sessions.ts';
+import { type RuntimeObjectObserver } from './object-table.ts';
+import type { RuntimeObjectRoute } from './object-table.ts';
+/** Runtime router layered over the common per-connection realm sessions. */
+export declare class RuntimeDomainSession {
+    private readonly transport;
+    private readonly realms;
+    private readonly objects;
+    private readonly announcedContexts;
+    private readonly consoleDisposers;
+    private readonly unsubscribeRealms;
+    private enabled;
+    private closed;
+    constructor(transport: CdpTransport, realms: InspectorRealmSessionSet);
+    /**
+     * Handle methods that require cross-realm Runtime coordination.
+     * @param request - Parsed CDP request.
+     * @returns Whether this domain owns the method or object id.
+     */
+    handle(request: CdpRequest): boolean;
+    /** Release this connection's object routes and realm subscription. */
+    close(): void;
+    /**
+     * Install semantic object recognition shared with the DOM adapter.
+     * @param observer - Callback invoked for objects carrying semantic references.
+     */
+    setObjectObserver(observer: RuntimeObjectObserver): void;
+    /**
+     * Resolve a connection-local CDP object id for another domain adapter.
+     * @param objectId - CDP object id allocated by this Runtime session.
+     * @returns Its realm and backend handle when still live.
+     */
+    objectRoute(objectId: string): RuntimeObjectRoute | undefined;
+    /**
+     * Project a completion produced by another domain through this connection's object table.
+     * @param realm - Realm session that owns the completion.
+     * @param completion - Realm-neutral result and exception fields.
+     * @param group - Object group assigned to exposed handles.
+     * @returns CDP Runtime result fields.
+     */
+    projectCompletion(realm: InspectorRealmSession, completion: RuntimeCompletion<RuntimeBackendObjectHandle>, group: string | undefined): object;
+    /**
+     * Project one Runtime value produced by another domain.
+     * @param realm - Realm session that owns the value.
+     * @param value - Realm-neutral Runtime value.
+     * @param group - Object group assigned to an exposed handle.
+     * @returns CDP RemoteObject fields.
+     */
+    projectRemoteObject(realm: InspectorRealmSession, value: RuntimeRemoteObject<RuntimeBackendObjectHandle>, group: string | undefined): Readonly<Record<string, unknown>>;
+    /**
+     * Forget connection-local ids retained for another domain's object group.
+     * @param group - Object group whose projected ids have expired.
+     */
+    releaseProjectedGroup(group: string): void;
+    /**
+     * Replace common object ids with native backend handles in a Host-only request.
+     * @param params - Parsed CDP parameters that may contain nested object ids.
+     * @returns A detached parameter record suitable for the native Host protocol.
+     */
+    nativeParameters(params: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+    /**
+     * Resolve one realm-registry expression to a connection-local object id.
+     * @param source - Source generation that owns the Cordis tree node.
+     * @param expression - Side-effect-free realm object lookup.
+     * @param objectGroup - Optional DevTools retention group.
+     * @returns The CDP RemoteObject fields.
+     */
+    resolveObject(source: InspectorSourceDescriptor, expression: string, objectGroup: string | undefined): Promise<Readonly<Record<string, unknown>>>;
+    private enable;
+    private disable;
+    private evaluate;
+    private getProperties;
+    private callFunction;
+    private awaitPromise;
+    private releaseObject;
+    private releaseObjectGroup;
+    private globalLexicalScopeNames;
+    private discardConsoleEntries;
+    private realmFromSelector;
+    private realmFromOptionalSelector;
+    private backendContext;
+    private routeArgument;
+    private unsupportedNativeRoute;
+    private receiveRealm;
+    private attachConsole;
+    private announce;
+    private destroy;
+    private respond;
+    private sendError;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/types/worker/cdp/ids.d.ts

@@ -0,0 +1,37 @@
+/** Opaque identifiers owned by one Worker-side Chrome DevTools connection. */
+import type { InspectorId } from '../../shared/identity.ts';
+declare const cdpNumericIdBrand: unique symbol;
+/** Number branded with one Chrome CDP identity role. */
+export type CdpNumericId<Role extends string> = number & {
+    readonly [cdpNumericIdBrand]: Role;
+};
+/** Identity of one DevTools connection inside the Worker. */
+export type InspectorConnectionId = InspectorId<'InspectorConnectionId'>;
+/** Runtime object id scoped to one DevTools connection. */
+export type CdpRemoteObjectId = InspectorId<'CdpRemoteObjectId'>;
+/** Debugger script id scoped to one DevTools connection. */
+export type CdpScriptId = InspectorId<'CdpScriptId'>;
+/** Debugger call-frame id scoped to one paused DevTools session. */
+export type CdpCallFrameId = InspectorId<'CdpCallFrameId'>;
+/** Runtime execution-context id scoped to one DevTools target. */
+export type CdpExecutionContextId = CdpNumericId<'CdpExecutionContextId'>;
+/** DOM frontend node id scoped to one DevTools document. */
+export type CdpNodeId = CdpNumericId<'CdpNodeId'>;
+/** DOM backend node id stable across connection-local document projections. */
+export type CdpBackendNodeId = CdpNumericId<'CdpBackendNodeId'>;
+/**
+ * Validate and brand a string id allocated or accepted by the CDP adapter.
+ * @param value - CDP identifier text.
+ * @param label - Field named in validation failures.
+ * @returns The branded CDP identifier.
+ */
+export declare function cdpStringId<Role extends string>(value: string, label: string): InspectorId<Role>;
+/**
+ * Validate and brand a positive numeric id allocated by the CDP adapter.
+ * @param value - CDP identifier number.
+ * @param label - Field named in validation failures.
+ * @returns The branded numeric identifier.
+ */
+export declare function cdpNumericId<Role extends string>(value: number, label: string): CdpNumericId<Role>;
+export {};
+//# sourceMappingURL=ids.d.ts.map

package/lib/types/worker/cdp/protocol.d.ts

@@ -0,0 +1,46 @@
+/** Minimal CDP request and transport types owned by the Worker. */
+/** Parsed client request. */
+export interface CdpRequest {
+    readonly id: number;
+    readonly method: string;
+    readonly params: Readonly<Record<string, unknown>>;
+}
+/** Outbound CDP event. */
+export interface CdpNotification {
+    readonly method: string;
+    readonly params: Readonly<Record<string, unknown>>;
+}
+/** A connected DevTools transport. */
+export interface CdpTransport {
+    send(payload: unknown): void;
+    close(): void;
+}
+/**
+ * Parse one DevTools request before routing it.
+ * @param value - Untrusted decoded WebSocket payload.
+ * @returns The validated request envelope.
+ */
+export declare function parseCdpRequest(value: unknown): CdpRequest;
+/**
+ * Build a stable CDP error response.
+ * @param id - Request id copied from the caller.
+ * @param code - JSON-RPC error code.
+ * @param message - Human-readable failure reason.
+ * @returns The CDP error envelope.
+ */
+export declare function cdpError(id: number, code: number, message: string): object;
+/**
+ * Send one failed CDP operation using the domain error code.
+ * @param transport - Connection receiving the response.
+ * @param request - Request supplying the response id.
+ * @param error - Rejection or synchronous error to render.
+ */
+export declare function sendCdpFailure(transport: CdpTransport, request: CdpRequest, error: unknown): void;
+/**
+ * Settle an asynchronous CDP operation through one transport.
+ * @param transport - Connection receiving the response.
+ * @param request - Request supplying the response id.
+ * @param operation - Domain operation that produces the result.
+ */
+export declare function respondToCdpRequest(transport: CdpTransport, request: CdpRequest, operation: () => Promise<object>): void;
+//# sourceMappingURL=protocol.d.ts.map

package/lib/types/worker/cdp/realm-sessions.d.ts

@@ -0,0 +1,64 @@
+/** Per-DevTools-connection sessions opened from the shared realm registry. */
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorRealmRegistry } from '../inspection/realm-store.ts';
+import type { InspectorRealmSession } from '../inspection/realm.ts';
+import type { InspectorConnectionId } from './ids.ts';
+/** Realm-session lifecycle observed by connection-local CDP domains. */
+export type InspectorRealmSessionEvent = {
+    readonly type: 'opened';
+    readonly session: InspectorRealmSession;
+} | {
+    readonly type: 'closed';
+    readonly session: InspectorRealmSession;
+};
+/** Owns exactly one backend session per active realm for one DevTools connection. */
+export declare class InspectorRealmSessionSet {
+    private readonly realms;
+    /** Opaque identity shared by every domain and object table on this DevTools connection. */
+    readonly connectionId: InspectorConnectionId;
+    private readonly sessions;
+    private readonly listeners;
+    private readonly unsubscribeRealms;
+    private closed;
+    constructor(realms: InspectorRealmRegistry);
+    /**
+     * Return active sessions in the registry's deterministic order.
+     * @returns Host followed by connected Clients.
+     */
+    all(): InspectorRealmSession[];
+    /**
+     * Return the required Host session.
+     * @returns The connection-local Host realm session.
+     */
+    host(): InspectorRealmSession;
+    /**
+     * Resolve one synthetic Client context.
+     * @param contextId - Numeric CDP execution-context id.
+     * @returns Its realm session when currently connected.
+     */
+    byContextId(contextId: number): InspectorRealmSession | undefined;
+    /**
+     * Resolve one globally unique Client context.
+     * @param uniqueId - CDP unique execution-context id.
+     * @returns Its realm session when currently connected.
+     */
+    byUniqueContextId(uniqueId: string): InspectorRealmSession | undefined;
+    /**
+     * Resolve one active source generation to this connection's realm session.
+     * @param source - Source identity retained by a Cordis tree node.
+     * @returns The matching realm session.
+     */
+    bySource(source: InspectorSourceDescriptor): InspectorRealmSession | undefined;
+    /**
+     * Subscribe to connection-local realm session lifecycle.
+     * @param listener - Session observer.
+     * @returns A disposer removing the observer.
+     */
+    subscribe(listener: (event: InspectorRealmSessionEvent) => void): () => void;
+    /** Close all realm sessions and stop tracking the registry. */
+    close(): void;
+    private receiveRealm;
+    private open;
+    private emit;
+}
+//# sourceMappingURL=realm-sessions.d.ts.map

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

@@ -0,0 +1,34 @@
+/** One DevTools connection: explicit local-domain routing plus a private Host V8 session. */
+import { type CdpTransport } from './protocol.ts';
+import { NetworkDomain, type NetworkSink } from './domains/network/session.ts';
+import { type CdpTargetDescriptor } from './target.ts';
+import { type CordisDomBackend } from './domains/dom/index.ts';
+import type { InspectorSourceRegistry } from '../bridge/hub.ts';
+import type { InspectorRealmRegistry } from '../inspection/realm-store.ts';
+import type { CordisRuntimeTreeReader } from '../../shared/cordis/reader.ts';
+/** Per-connection CDP dispatcher. */
+export declare class CdpSession implements NetworkSink {
+    private readonly transport;
+    private readonly target;
+    private readonly sources;
+    private readonly network;
+    private readonly cordisTrees;
+    private readonly realms;
+    private readonly nativeDomains;
+    private readonly runtime;
+    private readonly debugger;
+    private readonly dom;
+    private diagnosticsEnabled;
+    private readonly unsubscribeSources;
+    constructor(transport: CdpTransport, target: CdpTargetDescriptor, sources: InspectorSourceRegistry, network: NetworkDomain, realmRegistry: InspectorRealmRegistry, domBackend: CordisDomBackend, cordisTrees: CordisRuntimeTreeReader);
+    /**
+     * Parse and dispatch one raw CDP request. Invalid frames close this client only.
+     * @param value - Untrusted decoded WebSocket payload.
+     */
+    receive(value: unknown): void;
+    /** Push one CDP event. */
+    sendEvent(method: string, params: Readonly<Record<string, unknown>>): void;
+    /** Release every connection-owned V8 and domain resource. */
+    close(): void;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/types/worker/cdp/target.d.ts

@@ -0,0 +1,17 @@
+/** Minimal page-target CDP methods required to expose Network, Console, and Sources together. */
+import type { CdpRequest } from './protocol.ts';
+/** Sentinel distinguishing an unowned method from an owned method returning undefined. */
+export declare const CDP_METHOD_NOT_HANDLED: unique symbol;
+/** Page-target identity used by discovery and scaffold responses. */
+export interface CdpTargetDescriptor {
+    readonly targetId: string;
+    readonly title: string;
+}
+/**
+ * Handle one Worker-local identity or page scaffold method.
+ * @param request - Parsed CDP request.
+ * @param target - Synthetic page-target identity.
+ * @returns A response result or the unowned-method sentinel.
+ */
+export declare function handleScaffold(request: CdpRequest, target: CdpTargetDescriptor): object | typeof CDP_METHOD_NOT_HANDLED;
+//# sourceMappingURL=target.d.ts.map

package/lib/types/worker/entry.d.ts

@@ -0,0 +1,3 @@
+/** Node Worker bootstrap for the experimental Inspector. */
+export {};
+//# sourceMappingURL=entry.d.ts.map

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

@@ -0,0 +1,11 @@
+/** Cordis tree query execution independent of its source carrier. */
+import type { CordisRuntimeTreeReader } from '../../shared/cordis/reader.ts';
+import type { InspectorQuery, InspectorQueryResult } from '../../shared/bridge/messages/query/commands.ts';
+/**
+ * Execute one closed Inspector query against the shared semantic reader.
+ * @param reader - Latest committed Cordis tree reader.
+ * @param query - Validated query command.
+ * @returns The result corresponding to the query operation.
+ */
+export declare function executeInspectorQuery(reader: CordisRuntimeTreeReader, query: InspectorQuery): Promise<InspectorQueryResult>;
+//# sourceMappingURL=cordis-query.d.ts.map

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

@@ -0,0 +1,94 @@
+/** Worker-owned repository of CDP-independent Cordis tree snapshots. */
+import { type CordisTreeNode } from '../../shared/cordis/snapshot.ts';
+import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts';
+import type { InspectorSourceGeneration, InspectorSourceId } from '../../shared/bridge/ids.ts';
+import type { InspectorObjectReference } from '../../shared/cordis/object-reference.ts';
+import { type CordisInspectionTree as SharedCordisInspectionTree, type CordisTreeSourceSnapshot as SharedCordisTreeSourceSnapshot } from '../../shared/cordis/projector.ts';
+import type { CordisRuntimeTree } from '../../shared/cordis/model.ts';
+import type { IngestedInspectorRecord, InspectorRecordConsumer } from '../bridge/hub.ts';
+/** Routed Worker snapshot retaining its complete source-generation descriptor. */
+export type CordisTreeSourceSnapshot = SharedCordisTreeSourceSnapshot<InspectorSourceDescriptor>;
+/** Routed Host and Client snapshots retained by the Worker. */
+export type CordisInspectionTree = SharedCordisInspectionTree<InspectorSourceDescriptor>;
+export type { CordisTreeSourceConnection } from '../../shared/cordis/projector.ts';
+/** One object-backed tree node with its owning source generation. */
+export interface CordisTreeObjectRoute extends CordisTreeSourceSnapshot {
+    readonly node: CordisTreeNode;
+}
+/** Store mutation consumed by presentation adapters. */
+export type CordisTreeStoreEvent = {
+    readonly type: 'snapshot-changed';
+    readonly source: InspectorSourceDescriptor;
+} | {
+    readonly type: 'source-disconnected';
+    readonly source: InspectorSourceDescriptor;
+};
+/** Independent bounds for live tree size and retained disconnected snapshots. */
+export interface CordisTreeStoreOptions {
+    readonly maxNodes: number;
+    readonly maxDisconnectedTrees: number;
+}
+/** Validated latest-value store consumed independently by CDP and future query adapters. */
+export declare class CordisTreeStore implements InspectorRecordConsumer {
+    private readonly options;
+    readonly topics: Set<string>;
+    private readonly trees;
+    private readonly disconnected;
+    private readonly listeners;
+    constructor(options: CordisTreeStoreOptions);
+    /** Replace all retained state for one source generation. */
+    replace(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    /** Apply later state replacements, ignoring unrelated observation topics. */
+    append(source: InspectorSourceDescriptor, records: readonly IngestedInspectorRecord[]): void;
+    /** Freeze a closed source generation's last tree and invalidate its object routes. */
+    close(source: InspectorSourceDescriptor, reason: string): void;
+    /**
+     * Read all current realm snapshots without CDP identifiers.
+     * @returns Snapshots in source admission order.
+     */
+    snapshots(): CordisTreeSourceSnapshot[];
+    /**
+     * Compose the common realm model into Host and Client slots.
+     * @returns A detached view whose Host and Client entries share one type.
+     */
+    tree(): CordisInspectionTree;
+    /**
+     * Read a detached semantic tree without object-routing or CDP identifiers.
+     * @returns The latest retained Host and Client topology.
+     */
+    readTree(): CordisRuntimeTree;
+    /**
+     * Resolve a source-local object reference to its semantic tree node.
+     * @param source - Active source generation.
+     * @param reference - Realm-local registry and object handle.
+     * @returns The matching node while its source remains connected.
+     */
+    resolveObject(source: InspectorSourceDescriptor, reference: InspectorObjectReference): CordisTreeObjectRoute | undefined;
+    /**
+     * Resolve a source-local object without requiring the source's presentation fields.
+     * @param sourceId - Logical source identity.
+     * @param generation - Active source generation.
+     * @param reference - Realm-local object reference.
+     * @returns The matching live tree node.
+     */
+    resolveObjectIdentity(sourceId: InspectorSourceId, generation: InspectorSourceGeneration, reference: InspectorObjectReference): CordisTreeObjectRoute | undefined;
+    /**
+     * Resolve a live reference when only its source realm kind is known.
+     * @param kind - Host or Client ownership inferred by the Runtime adapter.
+     * @param reference - Realm-local registry and object handle.
+     * @returns The matching connected node, when present.
+     */
+    resolveObjectInKind(kind: InspectorSourceDescriptor['kind'], reference: InspectorObjectReference): CordisTreeObjectRoute | undefined;
+    /**
+     * Subscribe to accepted tree replacements and source availability changes.
+     * @param listener - Repository observer.
+     * @returns A disposer removing the observer.
+     */
+    subscribe(listener: (event: CordisTreeStoreEvent) => void): () => void;
+    private latest;
+    private install;
+    private remove;
+    private route;
+    private emit;
+}
+//# sourceMappingURL=cordis-store.d.ts.map