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

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

@@ -0,0 +1,18 @@
+/** Realm-neutral script metadata used by source backends. */
+import type { RuntimeScriptKey } from './ids.ts';
+/** One script visible in a realm's source catalog. */
+export interface RuntimeScript {
+    readonly scriptKey: RuntimeScriptKey;
+    readonly url: string;
+    readonly hash: string;
+    readonly buildId?: string;
+    readonly sourceMapUrl?: string;
+    readonly startLine: number;
+    readonly startColumn: number;
+    readonly endLine: number;
+    readonly endColumn: number;
+    readonly executionContextId?: number;
+    readonly isModule?: boolean;
+    readonly length?: number;
+}
+//# sourceMappingURL=sources.d.ts.map

package/lib/types/shared/cordis/collector.d.ts

@@ -0,0 +1,26 @@
+/** Shared Host/Client projection from live Cordis objects to a bounded semantic tree. */
+import { Context } from '@deepseek-ai/cordis';
+import { type CordisTreeSnapshot } from './snapshot.ts';
+import { RealmObjectRegistry } from './object-registry.ts';
+/** Bounds applied before one snapshot enters a source frame. */
+export interface CordisTreeLimits {
+    readonly maxNodes: number;
+    readonly maxBytes: number;
+}
+/** Realm-local collector with a current live-object table. */
+export declare class CordisTreeCollector {
+    private readonly root;
+    private readonly limits;
+    /** Live-object table replaced atomically with each emitted snapshot. */
+    readonly objects: RealmObjectRegistry;
+    private revision;
+    constructor(root: Context, limits: CordisTreeLimits);
+    /**
+     * Capture the current reachable Context/Fiber tree.
+     * @returns A detached JSON snapshot whose retained objects replace the prior generation atomically.
+     */
+    snapshot(): CordisTreeSnapshot;
+    /** Release the realm-global resolver and every retained object. */
+    close(): void;
+}
+//# sourceMappingURL=collector.d.ts.map

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

@@ -0,0 +1,7 @@
+/** Opaque identifiers owned by a realm-local Cordis object registry. */
+import type { InspectorId } from '../identity.ts';
+/** Identity of one realm-local table that retains objects named in a snapshot. */
+export type InspectorObjectRegistryId = InspectorId<'InspectorObjectRegistryId'>;
+/** Opaque reference to one object retained by a realm-local registry. */
+export type InspectorObjectHandle = InspectorId<'InspectorObjectHandle'>;
+//# sourceMappingURL=ids.d.ts.map

package/lib/types/shared/cordis/model.d.ts

@@ -0,0 +1,61 @@
+/** Consumer-neutral Cordis runtime tree shared by non-CDP readers. */
+import { type InspectorId } from '../identity.ts';
+/** Current consumer-neutral Cordis tree version. */
+export declare const CORDIS_RUNTIME_TREE_SCHEMA_VERSION: 0;
+/** Consumer-visible identity of one inspected Cordis runtime. */
+export type CordisRuntimeSourceId = InspectorId<'CordisRuntimeSourceId'>;
+/** Execution environment represented by one consumer-visible Cordis runtime. */
+export type CordisRuntimeSourceKind = 'host' | 'client';
+/** Availability of the realm represented by a retained tree. */
+export type CordisRuntimeConnection = {
+    readonly state: 'connected';
+} | {
+    readonly state: 'disconnected';
+    readonly reason: string;
+};
+/** Consumer-visible identity of one Cordis realm. */
+export interface CordisRuntimeSource {
+    readonly sourceId: CordisRuntimeSourceId;
+    readonly kind: CordisRuntimeSourceKind;
+    readonly label: string;
+}
+/** One Context in a consumer-neutral Cordis tree. */
+export interface CordisRuntimeContext {
+    readonly kind: 'context';
+    readonly children: readonly CordisRuntimeNode[];
+}
+/** One Fiber and its owned Context in a consumer-neutral Cordis tree. */
+export interface CordisRuntimeFiber {
+    readonly kind: 'fiber';
+    readonly uid: number;
+    readonly children: readonly [CordisRuntimeContext];
+}
+/** One semantic Cordis runtime node. */
+export type CordisRuntimeNode = CordisRuntimeContext | CordisRuntimeFiber;
+/** Latest retained topology and availability of one Cordis realm. */
+export interface CordisRuntimeRealm {
+    readonly source: CordisRuntimeSource;
+    readonly connection: CordisRuntimeConnection;
+    readonly revision: number;
+    readonly truncated: boolean;
+    readonly root: CordisRuntimeContext;
+}
+/** Latest Host and Client Cordis topology without routing or CDP identifiers. */
+export interface CordisRuntimeTree {
+    readonly schemaVersion: typeof CORDIS_RUNTIME_TREE_SCHEMA_VERSION;
+    readonly host: CordisRuntimeRealm | null;
+    readonly clients: readonly CordisRuntimeRealm[];
+}
+/**
+ * Decode a consumer-neutral tree received across an Inspector transport.
+ * @param value - Untrusted query result value.
+ * @returns A detached tree containing only public semantic fields.
+ */
+export declare function parseCordisRuntimeTree(value: unknown): CordisRuntimeTree;
+/**
+ * Project an inspected source id into the consumer-visible Cordis identity namespace.
+ * @param value - Stable source id carried by the current runtime observation.
+ * @returns The corresponding Cordis runtime source id.
+ */
+export declare function cordisRuntimeSourceId(value: string): CordisRuntimeSourceId;
+//# sourceMappingURL=model.d.ts.map

package/lib/types/shared/cordis/object-reference.d.ts

@@ -0,0 +1,14 @@
+/** Opaque references to live objects retained inside an observation source realm. */
+import type { InspectorObjectHandle, InspectorObjectRegistryId } from './ids.ts';
+/** Wire-safe identity of one live object; the source generation supplies the realm identity. */
+export interface InspectorObjectReference {
+    readonly registryId: InspectorObjectRegistryId;
+    readonly handle: InspectorObjectHandle;
+}
+/**
+ * Decode one source-local live-object reference.
+ * @param value - Untrusted wire value.
+ * @returns The validated opaque reference.
+ */
+export declare function parseInspectorObjectReference(value: unknown): InspectorObjectReference;
+//# sourceMappingURL=object-reference.d.ts.map

package/lib/types/shared/cordis/object-registry.d.ts

@@ -0,0 +1,80 @@
+/** Realm-local retention and identity for live objects referenced by Inspector snapshots. */
+import { type InspectorObjectHandle } from './ids.ts';
+import type { InspectorObjectReference } from './object-reference.ts';
+/** Self-contained function sent through CDP to identify its `this` object in the inspected realm. */
+export declare const IDENTIFY_REALM_OBJECT_FUNCTION: string;
+/** One realm's bounded table of objects retained by its latest semantic snapshot. */
+export declare class RealmObjectRegistry {
+    /** Realm-unique id carried by every reference from this registry. */
+    readonly id: import("../identity.ts").InspectorId<"InspectorObjectRegistryId">;
+    private readonly known;
+    private retained;
+    private nextHandle;
+    private disposed;
+    constructor();
+    /**
+     * Start one replacement generation.
+     * @returns A collector that atomically installs exactly the retained objects on commit.
+     */
+    begin(): RealmObjectGeneration;
+    /**
+     * Resolve one current opaque handle.
+     * @param handle - Handle from the latest committed snapshot.
+     * @returns The live object, when it remains retained.
+     */
+    resolve(handle: InspectorObjectHandle): object | undefined;
+    /**
+     * Identify one object retained by the latest snapshot. Cordis plugin calls may return nested thenable facades;
+     * only objects whose prototype path consists exclusively of those `then` wrappers resolve to the retained Fiber.
+     * @param value - Candidate live value.
+     * @returns Its wire reference, when present in this registry.
+     */
+    identify(value: unknown): InspectorObjectReference | undefined;
+    /** Remove this registry from the realm and release all strong references. */
+    close(): void;
+    /**
+     * Assign a stable handle and retain a value in one pending generation.
+     * @param value - Object represented by the pending snapshot.
+     * @param next - Pending generation's strong-reference table.
+     * @returns The registry id and stable object handle.
+     */
+    retain(value: object, next: Map<InspectorObjectHandle, object>): InspectorObjectReference;
+    /**
+     * Replace the current strong-reference set with one completed generation.
+     * @param next - Complete object table for the committed snapshot.
+     */
+    commit(next: Map<InspectorObjectHandle, object>): void;
+}
+/** Mutable object set assembled before one snapshot becomes visible. */
+export declare class RealmObjectGeneration {
+    private readonly owner;
+    private readonly retained;
+    private committed;
+    constructor(owner: RealmObjectRegistry);
+    /**
+     * Retain one object and obtain its stable opaque reference.
+     * @param value - Context or Fiber represented in the snapshot.
+     * @returns Source-local wire reference.
+     */
+    retain(value: object): InspectorObjectReference;
+    /**
+     * Stop retaining an object omitted while bounding the pending snapshot.
+     * @param handle - Opaque handle removed from this pending generation.
+     */
+    release(handle: InspectorObjectHandle): void;
+    /** Atomically replace the registry's retained set. */
+    commit(): void;
+}
+/**
+ * Build an expression that resolves one reference inside its owning realm.
+ * @param reference - Validated source-local object reference.
+ * @returns Side-effect-free JavaScript expression for Runtime evaluation.
+ */
+export declare function realmObjectExpression(reference: InspectorObjectReference): string;
+/**
+ * Identify a retained object across all Inspector collectors in this realm.
+ * @param value - Runtime value returned to a debugger.
+ * @returns Its source-local reference, when the value is a visible entity.
+ */
+export declare function identifyRealmObject(value: unknown): InspectorObjectReference | undefined;
+//# sourceMappingURL=object-registry.d.ts.map

package/lib/types/shared/cordis/observer.d.ts

@@ -0,0 +1,15 @@
+/** Lifecycle-driven Cordis tree publication shared by Host and Client plugin faces. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CordisTreeSnapshot } from './snapshot.ts';
+import { type CordisTreeLimits } from './collector.ts';
+/** Receives one complete semantic snapshot after a coalesced Cordis mutation. */
+export type CordisTreeSnapshotListener = (snapshot: CordisTreeSnapshot) => void;
+/**
+ * Observe one Cordis realm and publish immutable tree replacements.
+ * @param ctx - Plugin context whose root is inspected and whose effects own listeners.
+ * @param listener - Consumer of complete snapshots in the inspected realm.
+ * @param limits - Snapshot node and encoded-byte limits.
+ * @returns A disposer that unregisters listeners and releases retained objects.
+ */
+export declare function observeCordisTree(ctx: Context, listener: CordisTreeSnapshotListener, limits: CordisTreeLimits): () => void;
+//# sourceMappingURL=observer.d.ts.map

package/lib/types/shared/cordis/projector.d.ts

@@ -0,0 +1,34 @@
+/** Pure projection from routed Cordis snapshots to the consumer-neutral tree. */
+import type { CordisTreeSnapshot } from './snapshot.ts';
+import { type CordisRuntimeSourceKind, type CordisRuntimeTree } from './model.ts';
+/** Whether a retained routed snapshot still has a live source generation. */
+export type CordisTreeSourceConnection = {
+    readonly state: 'connected';
+} | {
+    readonly state: 'disconnected';
+    readonly reason: string;
+};
+/** One source generation and its latest routed Cordis snapshot. */
+export interface CordisTreeSource {
+    readonly sourceId: string;
+    readonly kind: CordisRuntimeSourceKind;
+    readonly label: string;
+}
+/** One source generation and its latest routed Cordis snapshot. */
+export interface CordisTreeSourceSnapshot<Source extends CordisTreeSource = CordisTreeSource> {
+    readonly source: Source;
+    readonly snapshot: CordisTreeSnapshot;
+    readonly connection: CordisTreeSourceConnection;
+}
+/** Routed Host and Client snapshots before consumer-neutral projection. */
+export interface CordisInspectionTree<Source extends CordisTreeSource = CordisTreeSource> {
+    readonly host: CordisTreeSourceSnapshot<Source> | null;
+    readonly clients: readonly CordisTreeSourceSnapshot<Source>[];
+}
+/**
+ * Strip transport and live-object routing fields from retained Cordis snapshots.
+ * @param tree - Worker-owned routed snapshots.
+ * @returns A detached semantic tree safe for non-CDP consumers.
+ */
+export declare function projectCordisRuntimeTree<Source extends CordisTreeSource>(tree: CordisInspectionTree<Source>): CordisRuntimeTree;
+//# sourceMappingURL=projector.d.ts.map

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

@@ -0,0 +1,13 @@
+/** Shared Host/Client publication of browser-safe Cordis snapshots. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { InspectorStatePublisher } from '../bridge/publisher.ts';
+import type { CordisTreeLimits } from './collector.ts';
+/**
+ * Observe one Cordis runtime and retain its latest source snapshot.
+ * @param ctx - Plugin context whose root is inspected.
+ * @param publisher - Active Host or Client source publisher.
+ * @param limits - Snapshot node and encoded-byte limits.
+ * @returns A disposer that stops observation and releases retained objects.
+ */
+export declare function publishCordisTree(ctx: Context, publisher: InspectorStatePublisher, limits: CordisTreeLimits): () => void;
+//# sourceMappingURL=publisher.d.ts.map

package/lib/types/shared/cordis/reader.d.ts

@@ -0,0 +1,18 @@
+/** Environment-independent Cordis runtime tree reader. */
+import type { CordisRuntimeTree } from './model.ts';
+/** Read-only access to the latest committed consumer-neutral Cordis tree. */
+export interface CordisRuntimeTreeReader {
+    /**
+     * Read the latest Worker snapshot without activating CDP domains.
+     * @returns A detached Host and Client Cordis tree.
+     * @throws When the source transport is unavailable, closes, times out, or rejects the query.
+     */
+    getTree(): Promise<CordisRuntimeTree>;
+}
+/**
+ * Create a reader around a local committed-tree projection.
+ * @param read - Synchronous or asynchronous latest-tree read.
+ * @returns A reader suitable for query and CDP adapters.
+ */
+export declare function createCordisRuntimeTreeReader(read: () => CordisRuntimeTree | Promise<CordisRuntimeTree>): CordisRuntimeTreeReader;
+//# sourceMappingURL=reader.d.ts.map

package/lib/types/shared/cordis/snapshot.d.ts

@@ -0,0 +1,39 @@
+/** CDP-independent snapshot model for a Cordis Context and Fiber tree. */
+import { type InspectorObjectHandle, type InspectorObjectRegistryId } from './ids.ts';
+/** Current serialized Cordis tree model version. */
+export declare const CORDIS_TREE_SCHEMA_VERSION: 0;
+/** Maximum nesting accepted from one realm snapshot. */
+export declare const CORDIS_TREE_MAX_DEPTH = 256;
+interface CordisTreeNodeBase {
+    readonly objectHandle: InspectorObjectHandle;
+}
+/** One Context entity in a Cordis tree snapshot. */
+export interface CordisContextTreeNode extends CordisTreeNodeBase {
+    readonly kind: 'context';
+    readonly children: readonly CordisTreeNode[];
+}
+/** One Fiber entity in a Cordis tree snapshot. */
+export interface CordisFiberTreeNode extends CordisTreeNodeBase {
+    readonly kind: 'fiber';
+    readonly uid: number;
+    readonly children: readonly [CordisContextTreeNode];
+}
+/** One semantic entity node in preorder. */
+export type CordisTreeNode = CordisContextTreeNode | CordisFiberTreeNode;
+/** Immutable, serializable state of one realm's reachable Cordis tree. */
+export interface CordisTreeSnapshot {
+    readonly schemaVersion: typeof CORDIS_TREE_SCHEMA_VERSION;
+    readonly revision: number;
+    readonly objectRegistryId: InspectorObjectRegistryId;
+    readonly root: CordisContextTreeNode;
+    readonly truncated: boolean;
+}
+/**
+ * Decode and validate one complete Cordis tree replacement.
+ * @param value - Untrusted observation payload.
+ * @param maxNodes - Maximum nodes admitted from one source.
+ * @returns A detached, validated snapshot.
+ */
+export declare function parseCordisTreeSnapshot(value: unknown, maxNodes: number): CordisTreeSnapshot;
+export {};
+//# sourceMappingURL=snapshot.d.ts.map

package/lib/types/shared/identity.d.ts

@@ -0,0 +1,12 @@
+/** Shared branded-identifier construction without assigning protocol ownership. */
+import type { Branded } from '@deepseek-ai/dsh-brand';
+/** String branded with one Inspector identity role. */
+export type InspectorId<Role extends string> = Branded<Role>;
+/**
+ * Validate and brand a non-empty identifier received from or sent across a runtime boundary.
+ * @param value - Untrusted identifier text.
+ * @param label - Field name used in validation errors.
+ * @returns The role-branded identifier.
+ */
+export declare function inspectorId<Role extends string>(value: string, label: string): InspectorId<Role>;
+//# sourceMappingURL=identity.d.ts.map

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

@@ -0,0 +1,18 @@
+/** Environment-independent Inspector models and bridge protocol exports. */
+export * from './bridge/messages/control.ts';
+export * from './bridge/control-codec.ts';
+export * from './cordis/snapshot.ts';
+export * from './bridge/messages/cordis.ts';
+export * from './bridge/messages/runtime/index.ts';
+export * from './bridge/messages/sources/index.ts';
+export * from './bridge/messages/network.ts';
+export * from './network/observation.ts';
+export * from './bridge/ids.ts';
+export * from './json.ts';
+export * from './cordis/object-reference.ts';
+export * from './bridge/messages/query/index.ts';
+export * from './bridge/query-reader.ts';
+export * from './bridge/rpc.ts';
+export * from './cdp/index.ts';
+export * from './bridge/messages/observation.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/json.d.ts

@@ -0,0 +1,35 @@
+/** JSON values admitted by every Inspector cross-realm message. */
+/** JSON scalar accepted by Inspector transports. */
+export type InspectorJsonPrimitive = null | boolean | number | string;
+/** Recursively JSON-compatible value accepted by Inspector transports. */
+export type InspectorJsonValue = InspectorJsonPrimitive | readonly InspectorJsonValue[] | InspectorJsonObject;
+/** JSON-compatible object accepted by Inspector transports. */
+export interface InspectorJsonObject {
+    readonly [key: string]: InspectorJsonValue;
+}
+/**
+ * Test that a value can cross both MessagePort and JSON WebSocket carriers without coercion.
+ * @param value - Candidate wire value.
+ * @returns Whether the value is lossless JSON data.
+ */
+export declare function isJsonValue(value: unknown): value is InspectorJsonValue;
+/**
+ * Require a plain JSON object and return it with a narrowed type.
+ * @param value - Candidate wire value.
+ * @param label - Field name used in validation errors.
+ * @returns The validated JSON object.
+ */
+export declare function requireJsonObject(value: unknown, label: string): InspectorJsonObject;
+/**
+ * Compute the UTF-8 byte length of a JSON wire value.
+ * @param value - Validated JSON value.
+ * @returns Its encoded byte length.
+ */
+export declare function jsonByteLength(value: InspectorJsonValue): number;
+/**
+ * Test whether a value is a plain object with string own keys.
+ * @param value - Candidate object.
+ * @returns Whether the value has `Object.prototype` or a null prototype.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=json.d.ts.map

package/lib/types/shared/network/event-source.d.ts

@@ -0,0 +1,20 @@
+/** Incremental UTF-8 parser for Server-Sent Events carried by captured responses. */
+import type { InspectorEventSourceMessage } from './observation.ts';
+/** Parse response bytes into consumer-neutral Server-Sent Event messages. */
+export declare class InspectorEventSourceParser {
+    private readonly decoder;
+    private line;
+    private eventName;
+    private eventId;
+    private data;
+    private afterCarriageReturn;
+    /**
+     * Consume one response-body chunk.
+     * @param bytes - Next bytes in response order.
+     * @returns Complete events terminated by an empty line in this chunk.
+     */
+    push(bytes: Uint8Array): readonly InspectorEventSourceMessage[];
+    private consume;
+    private parseLine;
+}
+//# sourceMappingURL=event-source.d.ts.map

package/lib/types/shared/network/observation.d.ts

@@ -0,0 +1,52 @@
+/** Full-capture fetch observations sent to the Inspector Worker. */
+/** One header entry; arrays retain duplicate header names. */
+export type InspectorHeader = readonly [name: string, value: string];
+/** Common request identity. */
+export interface FetchIdentity {
+    readonly requestId: string;
+}
+/** A high-level global fetch call began. */
+export interface FetchStartPayload extends FetchIdentity {
+    readonly url: string;
+    readonly method: string;
+    readonly headers: InspectorHeader[];
+    readonly hasBody: boolean;
+    readonly wallTimeMs: number;
+}
+/** One captured request-body chunk. */
+export interface FetchBodyChunkPayload extends FetchIdentity {
+    readonly data: string;
+}
+/** Terminal state of one captured request body. */
+export interface FetchRequestBodyEndPayload extends FetchIdentity {
+    readonly capturedBytes: number;
+    readonly truncated: boolean;
+    readonly captureError?: string;
+}
+/** Fetch resolved with response headers. */
+export interface FetchResponsePayload extends FetchIdentity {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: InspectorHeader[];
+    readonly mimeType: string;
+}
+/** One captured response-body chunk. */
+/** Fetch capture reached a terminal response-body state. */
+export interface FetchEndPayload extends FetchIdentity {
+    readonly capturedBytes: number;
+    readonly responseBodyTruncated: boolean;
+    readonly responseCaptureError?: string;
+}
+/** One parsed Server-Sent Event independent of its CDP projection. */
+export interface InspectorEventSourceMessage {
+    readonly eventName: string;
+    readonly eventId: string;
+    readonly data: string;
+}
+/** Fetch rejected before returning a Response. */
+export interface FetchErrorPayload extends FetchIdentity {
+    readonly message: string;
+    readonly canceled: boolean;
+}
+//# sourceMappingURL=observation.d.ts.map

package/lib/types/shared/service.d.ts

@@ -0,0 +1,23 @@
+/** Cordis service API shared by the Host and Client plugin faces. */
+import type { CordisRuntimeTreeReader } from './cordis/reader.ts';
+import type { InspectorJsonValue } from './json.ts';
+import type { InspectorConnection } from './bridge/publisher.ts';
+/** Shared Host/Client service façade over the realm's source publisher. */
+export interface InspectorService {
+    /**
+     * Publish one JSON observation without waiting for Worker delivery.
+     * @param topic - Domain-owned topic name.
+     * @param payload - JSON value validated before it reaches the carrier.
+     * @param monotonicMs - Source-clock timestamp; defaults to `performance.now()`.
+     */
+    publish(topic: string, payload: InspectorJsonValue, monotonicMs?: number): void;
+    /** Read-only Cordis topology queries independent of CDP sessions. */
+    readonly cordis: CordisRuntimeTreeReader;
+}
+/**
+ * Create the shared service façade without exposing the carrier implementation.
+ * @param connection - Realm-local observation and query transport.
+ * @returns The Cordis service value.
+ */
+export declare function createInspectorService(connection: InspectorConnection): InspectorService;
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1,52 @@
+/** Shared exact-object readers for versioned Inspector wire protocols. */
+import { type InspectorId } from './identity.ts';
+/**
+ * Require a plain object containing only the listed fields.
+ * @param value - Candidate object.
+ * @param keys - Complete field allowlist.
+ * @param label - Object name used in validation errors.
+ * @returns The validated plain object.
+ */
+export declare function exactObject(value: unknown, keys: readonly string[], label: string): Record<string, unknown>;
+/**
+ * Reject fields outside one versioned object's declared field set.
+ * @param value - Plain object being validated.
+ * @param keys - Complete field allowlist.
+ * @param label - Object name used in validation errors.
+ */
+export declare function exactKeys(value: Record<string, unknown>, keys: readonly string[], label: string): void;
+/**
+ * Read one non-empty opaque identifier.
+ * @param value - Candidate identifier.
+ * @param label - Field name used in validation errors.
+ * @returns The role-branded identifier.
+ */
+export declare function wireId<Role extends string>(value: unknown, label: string): InspectorId<Role>;
+/**
+ * Read one optional string field.
+ * @param value - Object containing the field.
+ * @param key - Field name.
+ * @returns An empty object or the validated field.
+ */
+export declare function optionalString<Key extends string>(value: Record<string, unknown>, key: Key): {
+    readonly [Property in Key]?: string;
+};
+/**
+ * Read one optional boolean field.
+ * @param value - Object containing the field.
+ * @param key - Field name.
+ * @returns An empty object or the validated field.
+ */
+export declare function optionalBoolean<Key extends string>(value: Record<string, unknown>, key: Key): {
+    readonly [Property in Key]?: boolean;
+};
+/**
+ * Read one optional non-negative finite number field.
+ * @param value - Object containing the field.
+ * @param key - Field name.
+ * @returns An empty object or the validated field.
+ */
+export declare function optionalNonNegativeNumber<Key extends string>(value: Record<string, unknown>, key: Key): {
+    readonly [Property in Key]?: number;
+};
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1,49 @@
+/** Worker-owned HTTP discovery, DevTools CDP, and Client-ingest endpoints. */
+import type { InspectorWorkerConfig } from '../../shared/bridge/messages/control.ts';
+import type { NetworkDomain } from '../cdp/domains/network/session.ts';
+import type { CordisDomBackend } from '../cdp/domains/dom/index.ts';
+import type { CordisRuntimeTreeReader } from '../../shared/cordis/reader.ts';
+import type { InspectorQueryRouter } from '../inspection/query-router.ts';
+import type { InspectorRealmRegistry } from '../inspection/realm-store.ts';
+import type { InspectorSourceRegistry } from './hub.ts';
+/** Bound endpoint information returned to the Host controller. */
+export interface InspectorEndpointInfo {
+    readonly host: string;
+    readonly port: number;
+    readonly targetId: string;
+}
+/** Worker-owned network endpoint. */
+export declare class InspectorEndpoint {
+    private readonly config;
+    private readonly sources;
+    private readonly network;
+    private readonly realms;
+    private readonly cordisDom;
+    private readonly cordisTrees;
+    private readonly queries;
+    private server;
+    private readonly cdpServer;
+    private readonly ingestServer;
+    private readonly cdpSessions;
+    private readonly ingestConnections;
+    constructor(config: InspectorWorkerConfig, sources: InspectorSourceRegistry, network: NetworkDomain, realms: InspectorRealmRegistry, cordisDom: CordisDomBackend, cordisTrees: CordisRuntimeTreeReader, queries: InspectorQueryRouter);
+    /**
+     * Bind the loopback endpoint.
+     * @returns The actual bound address and target id.
+     */
+    start(): Promise<InspectorEndpointInfo>;
+    /** Stop admission, dispose CDP sessions, terminate sockets, and await server close. */
+    close(): Promise<void>;
+    private handleHttp;
+    private handleUpgrade;
+    private acceptCdp;
+    private acceptIngest;
+    private authorizedClient;
+    private target;
+    private cdpUrl;
+    private boundPort;
+    private createServer;
+    private requireServer;
+    private json;
+}
+//# sourceMappingURL=endpoint.d.ts.map