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

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

@@ -0,0 +1,67 @@
+/** Versioned envelopes for Client source catalog operations. */
+import type { ClientSourceRequestId, ClientSourceSessionId, InspectorSourceGeneration, InspectorSourceId } from '../../ids.ts';
+import { INSPECTOR_PROTOCOL_VERSION } from '../../version.ts';
+import type { ClientSourceCommand, ClientSourceError, ClientSourceResult } from './commands.ts';
+/** Source capability that permits read-only Client script discovery. */
+export interface ClientSourcesCapability {
+    readonly type: 'client-sources';
+}
+/** Worker request for one operation in a Client source catalog. */
+export interface ClientSourceRequestFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-sources/request';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientSourceSessionId;
+    readonly requestId: ClientSourceRequestId;
+    readonly command: ClientSourceCommand;
+}
+/** Client response to one source catalog operation. */
+export interface ClientSourceResponseFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-sources/response';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientSourceSessionId;
+    readonly requestId: ClientSourceRequestId;
+    readonly outcome: {
+        readonly ok: true;
+        readonly result: ClientSourceResult;
+    } | {
+        readonly ok: false;
+        readonly error: ClientSourceError;
+    };
+}
+/** One-way cleanup for in-flight operations owned by a closed DevTools session. */
+export interface ClientSourceSessionClosedFrame {
+    readonly v: typeof INSPECTOR_PROTOCOL_VERSION;
+    readonly t: 'client-sources/session-closed';
+    readonly sourceId: InspectorSourceId;
+    readonly generation: InspectorSourceGeneration;
+    readonly sessionId: ClientSourceSessionId;
+}
+/**
+ * Parse the marker capability for a Client source catalog.
+ * @param value - Untrusted capability declaration.
+ * @returns The validated marker capability.
+ */
+export declare function parseClientSourcesCapability(value: unknown): ClientSourcesCapability;
+/**
+ * Parse one Worker-to-Client source request.
+ * @param value - Untrusted decoded request.
+ * @returns The validated request frame.
+ */
+export declare function parseClientSourceRequestFrame(value: Record<string, unknown>): ClientSourceRequestFrame;
+/**
+ * Parse one Client-to-Worker source response.
+ * @param value - Untrusted decoded response.
+ * @returns The validated response frame.
+ */
+export declare function parseClientSourceResponseFrame(value: Record<string, unknown>): ClientSourceResponseFrame;
+/**
+ * Parse one Client source-session cleanup notification.
+ * @param value - Untrusted decoded notification.
+ * @returns The validated cleanup frame.
+ */
+export declare function parseClientSourceSessionClosedFrame(value: Record<string, unknown>): ClientSourceSessionClosedFrame;
+//# sourceMappingURL=frames.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+/** Source-side interfaces shared by MessagePort and WebSocket bridge implementations. */
+import type { InspectorJsonValue } from '../json.ts';
+import type { InspectorQuery, InspectorQueryRequester, InspectorQueryResultFor } from './messages/query/commands.ts';
+/** Transport-independent observation publisher. */
+export interface InspectorPublisher {
+    /** Publish one validated observation. */
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+}
+/** Publisher that also retains the latest value of stateful observation topics. */
+export interface InspectorStatePublisher extends InspectorPublisher {
+    /**
+     * Replace one topic's retained state and publish the replacement.
+     * @param topic - Domain-owned state topic.
+     * @param payload - Latest JSON state, replayed after source resynchronization.
+     * @param monotonicMs - Source-clock timestamp; defaults to `performance.now()`.
+     */
+    setState(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+}
+/** Shared capabilities exposed above a Host MessagePort or Client WebSocket carrier. */
+export interface InspectorConnection extends InspectorStatePublisher, InspectorQueryRequester {
+}
+/** Shared observation and query delegation inherited by both source transports. */
+export declare abstract class InspectorSourceConnection implements InspectorConnection {
+    protected abstract readonly publisher: InspectorStatePublisher;
+    protected abstract readonly queries: InspectorQueryRequester;
+    /** Publish one JSON observation without waiting on its carrier. */
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /** Retain and publish one state value for reconnect or replacement recovery. */
+    setState(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /** Execute one non-CDP query through the active source generation. */
+    request<Query extends InspectorQuery>(query: Query): Promise<InspectorQueryResultFor<Query>>;
+}
+//# sourceMappingURL=publisher.d.ts.map

package/lib/types/shared/bridge/query-reader.d.ts

@@ -0,0 +1,10 @@
+/** Query-backed adapter for the transport-independent Cordis tree reader. */
+import type { CordisRuntimeTreeReader } from '../cordis/reader.ts';
+import type { InspectorQueryRequester } from './messages/query/commands.ts';
+/**
+ * Create a reader that obtains the tree through the typed Inspector query protocol.
+ * @param requester - Active Host or Client query connection.
+ * @returns A non-CDP Cordis tree reader.
+ */
+export declare function createQueryCordisRuntimeTreeReader(requester: InspectorQueryRequester): CordisRuntimeTreeReader;
+//# sourceMappingURL=query-reader.d.ts.map

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

@@ -0,0 +1,62 @@
+/** Shared Host/Client owner of correlated non-CDP query requests. */
+import { type InspectorSourceGeneration, type InspectorSourceId } from './ids.ts';
+import type { InspectorQuery, InspectorQueryError, InspectorQueryRequester, InspectorQueryResultFor } from './messages/query/commands.ts';
+import type { InspectorQueryRequestFrame } from './messages/query/frames.ts';
+/** Active carrier write used by the shared query owner. */
+export interface InspectorQuerySender {
+    /**
+     * Send one validated query request frame.
+     * @param frame - Request belonging to the active source generation.
+     */
+    send(frame: InspectorQueryRequestFrame): void;
+}
+/** Bounds applied by one Host or Client query connection. */
+export interface InspectorQueryConnectionOptions {
+    readonly timeoutMs: number;
+    readonly maxFrameBytes: number;
+}
+/** Failure deliberately returned by the Worker query handler. */
+export declare class InspectorQueryRemoteError extends Error {
+    readonly code: InspectorQueryError['code'];
+    constructor(code: InspectorQueryError['code'], message: string);
+}
+/** Correlates requests for one reconnecting Host or Client source. */
+export declare class InspectorQueryConnection implements InspectorQueryRequester {
+    private readonly options;
+    private readonly pending;
+    private active;
+    private nextRequestId;
+    private closed;
+    constructor(options: InspectorQueryConnectionOptions);
+    /**
+     * Admit the source generation acknowledged by the Worker.
+     * @param sourceId - Stable source identity.
+     * @param generation - Newly accepted transport generation.
+     * @param sender - Carrier writer valid for that generation.
+     */
+    connect(sourceId: InspectorSourceId, generation: InspectorSourceGeneration, sender: InspectorQuerySender): void;
+    /**
+     * Execute a query against the currently accepted source generation.
+     * @param query - Closed typed query command.
+     * @returns The result with the same operation discriminant.
+     */
+    request<Query extends InspectorQuery>(query: Query): Promise<InspectorQueryResultFor<Query>>;
+    /**
+     * Consume a decoded carrier value when it is a query response.
+     * @param value - Untrusted Worker-to-source value.
+     * @returns Whether the value belonged to the query protocol.
+     */
+    receive(value: unknown): boolean;
+    /**
+     * Reject active requests while permitting a later source generation.
+     * @param reason - Failure reported to every pending caller.
+     */
+    disconnect(reason: string): void;
+    /**
+     * Permanently reject requests and prevent later reconnection.
+     * @param reason - Failure reported to every pending caller.
+     */
+    close(reason?: string): void;
+    private rejectPending;
+}
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1,3 @@
+/** Bridge-facing exports for the shared untrusted-value validation primitives. */
+export * from '../validation.ts';
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1,3 @@
+/** Current Inspector wire version. Pre-release peers reject every other version. */
+export declare const INSPECTOR_PROTOCOL_VERSION: 0;
+//# sourceMappingURL=version.d.ts.map

package/lib/types/shared/cdp/capabilities.d.ts

@@ -0,0 +1,17 @@
+/** Explicit operation support advertised by each Inspector realm. */
+/** Runtime operations implemented by a realm backend. */
+export type RuntimeOperation = 'evaluate' | 'get-properties' | 'call-function' | 'await-promise' | 'release-object' | 'release-object-group' | 'global-lexical-scope-names';
+/** Console operations implemented by a realm backend. */
+export type ConsoleOperation = 'events' | 'exceptions' | 'clear';
+/** Source catalog operations implemented by a realm backend. */
+export type SourceOperation = 'catalog' | 'content' | 'source-map';
+/** Active debugger operations implemented by a realm backend. */
+export type DebuggerOperation = 'breakpoint' | 'pause' | 'resume' | 'step' | 'call-frame';
+/** Complete capability declaration for one inspected realm. */
+export interface InspectorRealmCapabilities {
+    readonly runtime: readonly RuntimeOperation[];
+    readonly console: readonly ConsoleOperation[];
+    readonly sources: readonly SourceOperation[];
+    readonly debugger: readonly DebuggerOperation[];
+}
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1,28 @@
+/** Realm-neutral Console events emitted by Runtime backends. */
+import type { RuntimeRemoteObject } from './remote-object.ts';
+import type { RuntimeExceptionDetails, RuntimeStackTrace } from './errors.ts';
+/** Console API categories exposed by CDP Runtime. */
+export type RuntimeConsoleType = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
+/** One Console event associated with a single inspected realm. */
+export interface RuntimeConsoleEvent<Handle extends string> {
+    readonly type: RuntimeConsoleType;
+    readonly arguments: readonly RuntimeRemoteObject<Handle>[];
+    readonly timestamp: number;
+    readonly contextId?: number;
+    readonly stackTrace?: RuntimeStackTrace;
+}
+/** One uncaught exception observed in an inspected realm. */
+export interface RuntimeExceptionEvent<Handle extends string> {
+    readonly timestamp: number;
+    readonly contextId?: number;
+    readonly details: RuntimeExceptionDetails<Handle>;
+}
+/** Console-domain event emitted by a realm backend. */
+export type RuntimeConsoleBackendEvent<Handle extends string> = {
+    readonly type: 'console-api';
+    readonly event: RuntimeConsoleEvent<Handle>;
+} | {
+    readonly type: 'exception';
+    readonly event: RuntimeExceptionEvent<Handle>;
+};
+//# sourceMappingURL=console.d.ts.map

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

@@ -0,0 +1,69 @@
+/** Realm-neutral values used by active debugger backends. */
+import type { InspectorJsonValue } from '../json.ts';
+import type { RuntimeScriptKey } from './ids.ts';
+import type { RuntimeStackTrace } from './errors.ts';
+import type { RuntimeCompletion } from './operations.ts';
+import type { RuntimeRemoteObject } from './remote-object.ts';
+/** One source location independent of a CDP ScriptId allocation policy. */
+export interface RuntimeDebuggerLocation {
+    readonly scriptKey: RuntimeScriptKey;
+    readonly lineNumber: number;
+    readonly columnNumber?: number;
+}
+/** One lexical scope attached to a paused call frame. */
+export interface RuntimeDebuggerScope<Handle extends string> {
+    readonly type: string;
+    readonly object: RuntimeRemoteObject<Handle>;
+    readonly name?: string;
+    readonly startLocation?: RuntimeDebuggerLocation;
+    readonly endLocation?: RuntimeDebuggerLocation;
+}
+/** One paused JavaScript call frame. */
+export interface RuntimeDebuggerCallFrame<Handle extends string> {
+    readonly callFrameId: string;
+    readonly functionName: string;
+    readonly functionLocation?: RuntimeDebuggerLocation;
+    readonly location: RuntimeDebuggerLocation;
+    readonly url: string;
+    readonly scopeChain: readonly RuntimeDebuggerScope<Handle>[];
+    readonly thisObject: RuntimeRemoteObject<Handle>;
+    readonly returnValue?: RuntimeRemoteObject<Handle>;
+}
+/** Engine-independent evaluation request for one paused call frame. */
+export interface RuntimeCallFrameEvaluationRequest {
+    readonly callFrameId: string;
+    readonly expression: string;
+    readonly objectGroup?: string;
+    readonly includeCommandLineAPI?: boolean;
+    readonly silent?: boolean;
+    readonly returnByValue?: boolean;
+    readonly generatePreview?: boolean;
+    readonly throwOnSideEffect?: boolean;
+    readonly timeoutMs?: number;
+}
+/** Optional native script-cache limit requested while enabling Debugger. */
+export interface RuntimeDebuggerEnableRequest {
+    readonly maxScriptsCacheSize?: number;
+}
+/** Optional termination requested while resuming a native debugger. */
+export interface RuntimeDebuggerResumeRequest {
+    readonly terminateOnResume?: boolean;
+}
+/** Debugger lifecycle notification emitted by a realm backend. */
+export type RuntimeDebuggerEvent<Handle extends string> = {
+    readonly type: 'paused';
+    readonly callFrames: readonly RuntimeDebuggerCallFrame<Handle>[];
+    readonly reason: string;
+    readonly data?: InspectorJsonValue;
+    readonly hitBreakpoints?: readonly string[];
+    readonly asyncStackTrace?: RuntimeStackTrace;
+} | {
+    readonly type: 'resumed';
+} | {
+    readonly type: 'breakpoint-resolved';
+    readonly breakpointId: string;
+    readonly location: RuntimeDebuggerLocation;
+};
+/** Active debugger operation result containing a Runtime value. */
+export type RuntimeCallFrameEvaluation<Handle extends string> = RuntimeCompletion<Handle>;
+//# sourceMappingURL=debugger.d.ts.map

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

@@ -0,0 +1,27 @@
+/** Realm-neutral JavaScript exception and stack information. */
+import type { RuntimeScriptKey } from './ids.ts';
+import type { RuntimeRemoteObject } from './remote-object.ts';
+/** One source location in a Runtime exception stack. */
+export interface RuntimeCallFrame {
+    readonly functionName: string;
+    readonly scriptKey?: RuntimeScriptKey;
+    readonly url: string;
+    readonly lineNumber: number;
+    readonly columnNumber: number;
+}
+/** JavaScript stack information independent of a Debugger script id. */
+export interface RuntimeStackTrace {
+    readonly description?: string;
+    readonly callFrames: readonly RuntimeCallFrame[];
+    readonly parent?: RuntimeStackTrace;
+}
+/** JavaScript exception produced while executing one Runtime command. */
+export interface RuntimeExceptionDetails<Handle extends string> {
+    readonly text: string;
+    readonly lineNumber: number;
+    readonly columnNumber: number;
+    readonly url?: string;
+    readonly stackTrace?: RuntimeStackTrace;
+    readonly exception?: RuntimeRemoteObject<Handle>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,9 @@
+/** Opaque identifiers owned by normalized realm backends. */
+import type { InspectorId } from '../identity.ts';
+/** Worker identity of one active Host or Client realm incarnation. */
+export type InspectorRealmId = InspectorId<'InspectorRealmId'>;
+/** Backend-owned object handle interpreted only by its realm session. */
+export type RuntimeBackendObjectHandle = InspectorId<'RuntimeBackendObjectHandle'>;
+/** Backend-independent identity of one script in a realm catalog. */
+export type RuntimeScriptKey = InspectorId<'RuntimeScriptKey'>;
+//# sourceMappingURL=ids.d.ts.map

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

@@ -0,0 +1,11 @@
+/** Realm-neutral Runtime, Console, Source, and Debugger protocol types. */
+export * from './capabilities.ts';
+export * from './console.ts';
+export * from './debugger.ts';
+export * from './errors.ts';
+export * from './ids.ts';
+export * from './operations.ts';
+export * from './property.ts';
+export * from './remote-object.ts';
+export * from './sources.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/cdp/operations.d.ts

@@ -0,0 +1,86 @@
+/** Realm-neutral Runtime operations and results. */
+import type { InspectorJsonObject, InspectorJsonValue } from '../json.ts';
+import type { RuntimeExceptionDetails } from './errors.ts';
+import type { RuntimeInternalPropertyDescriptor, RuntimePrivatePropertyDescriptor, RuntimePropertyDescriptor } from './property.ts';
+import type { RuntimeRemoteObject } from './remote-object.ts';
+/** One argument supplied to a function in an inspected realm. */
+export type RuntimeCallArgument<Handle extends string> = {
+    readonly kind: 'value';
+    readonly value: InspectorJsonValue;
+} | {
+    readonly kind: 'unserializable';
+    readonly value: string;
+} | {
+    readonly kind: 'object';
+    readonly handle: Handle;
+} | {
+    readonly kind: 'undefined';
+};
+/** Backend-local selector for a native execution context within one realm. */
+export type RuntimeExecutionContext = {
+    readonly kind: 'numeric';
+    readonly id: number;
+} | {
+    readonly kind: 'unique';
+    readonly id: string;
+};
+/** Engine-independent evaluation options supported by Runtime backends. */
+export interface RuntimeEvaluateRequest {
+    readonly expression: string;
+    readonly context?: RuntimeExecutionContext;
+    readonly objectGroup?: string;
+    readonly includeCommandLineAPI?: boolean;
+    readonly silent?: boolean;
+    readonly returnByValue?: boolean;
+    readonly generatePreview?: boolean;
+    readonly userGesture?: boolean;
+    readonly awaitPromise?: boolean;
+    readonly disableBreaks?: boolean;
+    readonly replMode?: boolean;
+    readonly allowUnsafeEvalBlockedByCSP?: boolean;
+    readonly throwOnSideEffect?: boolean;
+    readonly serializationOptions?: InspectorJsonObject;
+    readonly timeoutMs?: number;
+}
+/** Property enumeration request for one backend object. */
+export interface RuntimeGetPropertiesRequest<Handle extends string> {
+    readonly handle: Handle;
+    readonly ownProperties?: boolean;
+    readonly accessorPropertiesOnly?: boolean;
+    readonly generatePreview?: boolean;
+    readonly nonIndexedPropertiesOnly?: boolean;
+}
+/** Function invocation request within one inspected realm. */
+export interface RuntimeCallFunctionRequest<Handle extends string> {
+    readonly functionDeclaration: string;
+    readonly context?: RuntimeExecutionContext;
+    readonly receiver?: Handle;
+    readonly arguments?: readonly RuntimeCallArgument<Handle>[];
+    readonly objectGroup?: string;
+    readonly silent?: boolean;
+    readonly returnByValue?: boolean;
+    readonly generatePreview?: boolean;
+    readonly userGesture?: boolean;
+    readonly awaitPromise?: boolean;
+    readonly throwOnSideEffect?: boolean;
+    readonly serializationOptions?: InspectorJsonObject;
+}
+/** Promise-await request for one retained backend object. */
+export interface RuntimeAwaitPromiseRequest<Handle extends string> {
+    readonly promise: Handle;
+    readonly returnByValue?: boolean;
+    readonly generatePreview?: boolean;
+}
+/** Shared result of evaluation, function calls, and promise awaiting. */
+export interface RuntimeCompletion<Handle extends string> {
+    readonly result: RuntimeRemoteObject<Handle>;
+    readonly exceptionDetails?: RuntimeExceptionDetails<Handle>;
+}
+/** Shared result of property enumeration. */
+export interface RuntimeProperties<Handle extends string> {
+    readonly properties: readonly RuntimePropertyDescriptor<Handle>[];
+    readonly internalProperties?: readonly RuntimeInternalPropertyDescriptor<Handle>[];
+    readonly privateProperties?: readonly RuntimePrivatePropertyDescriptor<Handle>[];
+    readonly exceptionDetails?: RuntimeExceptionDetails<Handle>;
+}
+//# sourceMappingURL=operations.d.ts.map

package/lib/types/shared/cdp/property.d.ts

@@ -0,0 +1,28 @@
+/** Realm-neutral property descriptors returned by Runtime backends. */
+import type { RuntimeRemoteObject } from './remote-object.ts';
+/** One JavaScript property descriptor returned without invoking accessors. */
+export interface RuntimePropertyDescriptor<Handle extends string> {
+    readonly name: string;
+    readonly value?: RuntimeRemoteObject<Handle>;
+    readonly writable?: boolean;
+    readonly get?: RuntimeRemoteObject<Handle>;
+    readonly set?: RuntimeRemoteObject<Handle>;
+    readonly configurable: boolean;
+    readonly enumerable: boolean;
+    readonly wasThrown?: boolean;
+    readonly isOwn?: boolean;
+    readonly symbol?: RuntimeRemoteObject<Handle>;
+}
+/** One engine-owned property such as `[[Prototype]]`. */
+export interface RuntimeInternalPropertyDescriptor<Handle extends string> {
+    readonly name: string;
+    readonly value?: RuntimeRemoteObject<Handle>;
+}
+/** One engine private property exposed when a backend supports it. */
+export interface RuntimePrivatePropertyDescriptor<Handle extends string> {
+    readonly name: string;
+    readonly value?: RuntimeRemoteObject<Handle>;
+    readonly get?: RuntimeRemoteObject<Handle>;
+    readonly set?: RuntimeRemoteObject<Handle>;
+}
+//# sourceMappingURL=property.d.ts.map

package/lib/types/shared/cdp/realm.d.ts

@@ -0,0 +1,137 @@
+/** Environment-independent backend interfaces for inspected JavaScript realms. */
+import type { RuntimeBackendObjectHandle, RuntimeScriptKey } from './ids.ts';
+import type { RuntimeAwaitPromiseRequest, RuntimeCallFunctionRequest, RuntimeCompletion, RuntimeConsoleBackendEvent, RuntimeDebuggerEvent, RuntimeDebuggerEnableRequest, RuntimeDebuggerResumeRequest, RuntimeCallFrameEvaluationRequest, RuntimeEvaluateRequest, RuntimeGetPropertiesRequest, RuntimeExecutionContext, RuntimeProperties, RuntimeScript } from './index.ts';
+/** Raw notification emitted by a native engine protocol backend. */
+export interface NativeProtocolNotification {
+    readonly method: string;
+    readonly params?: Readonly<Record<string, unknown>>;
+}
+/** Explicitly supported or unsupported realm capability. */
+export type RealmCapability<Backend> = {
+    readonly state: 'supported';
+    readonly backend: Backend;
+} | {
+    readonly state: 'unsupported';
+    readonly reason: string;
+};
+/** Runtime operations implemented inside one per-connection realm session. */
+export interface RuntimeBackend {
+    /** Prepare Runtime events and execution state for this connection. */
+    enable(): Promise<void>;
+    /** Disable Runtime events and release backend session state. */
+    disable(): Promise<void>;
+    /**
+     * Evaluate source in this realm.
+     * @param request - Engine-independent evaluation request.
+     * @returns Completion containing a value or JavaScript exception.
+     */
+    evaluate(request: RuntimeEvaluateRequest): Promise<RuntimeCompletion<RuntimeBackendObjectHandle>>;
+    /**
+     * Enumerate one retained object's properties.
+     * @param request - Property request containing this backend's object handle.
+     * @returns Property descriptors and optional exception details.
+     */
+    getProperties(request: RuntimeGetPropertiesRequest<RuntimeBackendObjectHandle>): Promise<RuntimeProperties<RuntimeBackendObjectHandle>>;
+    /**
+     * Invoke a function with references owned by this realm session.
+     * @param request - Function source, receiver, arguments, and result options.
+     * @returns Completion containing the invocation result or JavaScript exception.
+     */
+    callFunction(request: RuntimeCallFunctionRequest<RuntimeBackendObjectHandle>): Promise<RuntimeCompletion<RuntimeBackendObjectHandle>>;
+    /**
+     * Await one retained Promise.
+     * @param request - Promise handle and result options.
+     * @returns Completion containing the fulfilled value or rejection.
+     */
+    awaitPromise(request: RuntimeAwaitPromiseRequest<RuntimeBackendObjectHandle>): Promise<RuntimeCompletion<RuntimeBackendObjectHandle>>;
+    /**
+     * Read names visible in one backend execution context's global lexical scope.
+     * @param context - Native sub-context selector, or the realm default when omitted.
+     * @returns Names visible in the selected global lexical scope.
+     */
+    globalLexicalScopeNames(context?: RuntimeExecutionContext): Promise<readonly string[]>;
+    /**
+     * Release one backend object reference.
+     * @param handle - Handle owned by this realm session.
+     */
+    releaseObject(handle: RuntimeBackendObjectHandle): Promise<void>;
+    /**
+     * Release every backend object retained under one group.
+     * @param group - DevTools object-group name.
+     */
+    releaseObjectGroup(group: string): Promise<void>;
+}
+/** Realm Console event source. */
+export interface ConsoleBackend {
+    /**
+     * Subscribe to Console and uncaught-exception events.
+     * @param listener - Connection-local event consumer.
+     * @returns A disposer for the subscription.
+     */
+    subscribe(listener: (event: RuntimeConsoleBackendEvent<RuntimeBackendObjectHandle>) => void): () => void;
+    /** Clear backend-owned Console history when supported. */
+    clear(): Promise<void>;
+}
+/** Realm script catalog independent of CDP ScriptId allocation. */
+export interface SourceBackend {
+    /** @returns Every script currently known to this realm. */
+    listScripts(): Promise<readonly RuntimeScript[]>;
+    /**
+     * Read source text for one realm-local script key.
+     * @param scriptKey - Script identity allocated by this realm.
+     * @returns The complete source text.
+     */
+    getScriptSource(scriptKey: RuntimeScriptKey): Promise<string>;
+    /**
+     * Read an optional source map for one realm-local script key.
+     * @param scriptKey - Script identity allocated by this realm.
+     * @returns Source-map JSON when one exists.
+     */
+    getSourceMap(scriptKey: RuntimeScriptKey): Promise<string | undefined>;
+    /**
+     * Subscribe to scripts discovered after the initial catalog read.
+     * @param listener - Consumer of newly discovered scripts.
+     * @returns A disposer for the subscription.
+     */
+    subscribe(listener: (script: RuntimeScript) => void): () => void;
+}
+/** Active JavaScript debugging backend for one realm session. */
+export interface DebuggerBackend {
+    /** Enable debugger events for this connection. */
+    enable(request: RuntimeDebuggerEnableRequest): Promise<Readonly<Record<string, unknown>>>;
+    /** Disable debugger events for this connection. */
+    disable(): Promise<Readonly<Record<string, unknown>>>;
+    /** Pause this realm. */
+    pause(): Promise<Readonly<Record<string, unknown>>>;
+    /** Resume this realm. */
+    resume(request: RuntimeDebuggerResumeRequest): Promise<Readonly<Record<string, unknown>>>;
+    /**
+     * Evaluate an expression in one paused frame.
+     * @param request - Frame identity, expression, and result options.
+     * @returns A common Runtime completion.
+     */
+    evaluateOnCallFrame(request: RuntimeCallFrameEvaluationRequest): Promise<RuntimeCompletion<RuntimeBackendObjectHandle>>;
+    /**
+     * Subscribe to paused, resumed, and breakpoint events.
+     * @param listener - Connection-local debugger event consumer.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (event: RuntimeDebuggerEvent<RuntimeBackendObjectHandle>) => void): () => void;
+}
+/** Explicit Host-only native protocol adapter for domains not yet normalized. */
+export interface NativeDomainBackend {
+    /**
+     * Execute one native protocol request.
+     * @param method - CDP method owned by the native engine.
+     * @param params - Parsed CDP parameters.
+     * @returns Native response fields.
+     */
+    request(method: string, params: Readonly<Record<string, unknown>>): Promise<Readonly<Record<string, unknown>>>;
+    /**
+     * Subscribe to native protocol notifications.
+     * @param listener - Notification consumer.
+     * @returns A disposer removing the consumer.
+     */
+    subscribe(listener: (message: NativeProtocolNotification) => void): () => void;
+}
+//# sourceMappingURL=realm.d.ts.map

package/lib/types/shared/cdp/remote-object.d.ts

@@ -0,0 +1,44 @@
+/** Realm-neutral JavaScript value descriptions used by Inspector backends. */
+import type { InspectorObjectReference } from '../cordis/object-reference.ts';
+import type { InspectorJsonValue } from '../json.ts';
+/** Runtime value kinds represented by CDP `Runtime.RemoteObject`. */
+export type RuntimeRemoteObjectType = 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint';
+/** Runtime object subtype hints understood by Chrome DevTools. */
+export type RuntimeRemoteObjectSubtype = 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'dataview' | 'webassemblymemory' | 'wasmvalue';
+/** Shallow property rendered inline by DevTools. */
+export interface RuntimePropertyPreview {
+    readonly name: string;
+    readonly type: RuntimeRemoteObjectType | 'accessor';
+    readonly value?: string;
+    readonly valuePreview?: RuntimeObjectPreview;
+    readonly subtype?: RuntimeRemoteObjectSubtype;
+}
+/** Shallow object rendering that never carries a live-object reference. */
+export interface RuntimeObjectPreview {
+    readonly type: RuntimeRemoteObjectType;
+    readonly subtype?: RuntimeRemoteObjectSubtype;
+    readonly description?: string;
+    readonly overflow: boolean;
+    readonly properties: readonly RuntimePropertyPreview[];
+}
+/** Engine-independent description of one JavaScript value. */
+export interface RuntimeRemoteObjectDescriptor {
+    readonly type: RuntimeRemoteObjectType;
+    readonly subtype?: RuntimeRemoteObjectSubtype;
+    readonly className?: string;
+    readonly value?: InspectorJsonValue;
+    readonly unserializableValue?: string;
+    readonly description?: string;
+    readonly preview?: RuntimeObjectPreview;
+}
+/** Backend-owned reference to a retained object in one realm session. */
+export interface RuntimeBackendObjectReference<Handle extends string> {
+    readonly handle: Handle;
+}
+/** Realm-neutral value plus optional backend and Cordis identities. */
+export interface RuntimeRemoteObject<Handle extends string> {
+    readonly descriptor: RuntimeRemoteObjectDescriptor;
+    readonly object?: RuntimeBackendObjectReference<Handle>;
+    readonly semanticReference?: InspectorObjectReference;
+}
+//# sourceMappingURL=remote-object.d.ts.map