@graphrefly/ts 0.0.0 → 0.0.2

package/dist/adapters/index.d.ts

@@ -1,24 +1,76 @@
-export { A as AGENTIC_MEMORY_RECORD_CHANGE_FORMAT, a as AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT, b as AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION, c as AgenticMemoryRecordChangeFrame, d as AgenticMemoryRecordSnapshotFrame, e as AgenticMemoryRecordsPersistenceCursor, f as AgenticMemoryRecordsPersistenceError, g as AgenticMemoryRecordsPersistenceHandle, h as AgenticMemoryRecordsPersistenceStatus, i as AgenticMemoryRecordsRestoreState, L as LoadAgenticMemoryRecordsStateOptions, O as OpenPersistentAgenticMemoryRecordsOptions, j as OpenPersistentReactiveIndexOptions, k as OpenPersistentReactiveListOptions, l as OpenPersistentReactiveLogOptions, m as OpenPersistentReactiveMapOptions, P as PersistAgenticMemoryRecordsOptions, n as PersistReactiveCollectionOptions, o as PersistentAgenticMemoryRecords, p as PersistentReactiveIndex, q as PersistentReactiveList, r as PersistentReactiveLog, s as PersistentReactiveMap, R as ReactiveCollectionPersistenceCursor, t as ReactiveCollectionPersistenceError, u as ReactiveCollectionPersistenceHandle, v as ReactiveCollectionPersistenceStatus, w as agenticMemoryRecordChangeFrame, x as agenticMemoryRecordSnapshotFrame, y as agenticMemoryRecordsSnapshotKey, z as assertAgenticMemoryRecordChangeFrame, B as assertAgenticMemoryRecordSnapshotFrame, C as loadAgenticMemoryRecordsState, D as openPersistentAgenticMemoryRecords, E as openPersistentReactiveIndex, F as openPersistentReactiveList, G as openPersistentReactiveLog, H as openPersistentReactiveMap, I as persistAgenticMemoryRecords, J as persistReactiveCollection } from '../reactive-collection-storage-BNiEc-Gd.js';
-import { d as Graph } from '../graph-DfdF9zy4.js';
+export { A as AGENTIC_MEMORY_RECORD_CHANGE_FORMAT, a as AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT, b as AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION, c as AgenticMemoryRecordChangeFrame, d as AgenticMemoryRecordSnapshotFrame, e as AgenticMemoryRecordsPersistenceCursor, f as AgenticMemoryRecordsPersistenceError, g as AgenticMemoryRecordsPersistenceHandle, h as AgenticMemoryRecordsPersistenceStatus, i as AgenticMemoryRecordsRestoreState, L as LoadAgenticMemoryRecordsStateOptions, O as OpenPersistentAgenticMemoryRecordsOptions, j as OpenPersistentReactiveIndexOptions, k as OpenPersistentReactiveListOptions, l as OpenPersistentReactiveLogOptions, m as OpenPersistentReactiveMapOptions, P as PersistAgenticMemoryRecordsOptions, n as PersistReactiveCollectionOptions, o as PersistentAgenticMemoryRecords, p as PersistentReactiveIndex, q as PersistentReactiveList, r as PersistentReactiveLog, s as PersistentReactiveMap, R as ReactiveCollectionPersistenceCursor, t as ReactiveCollectionPersistenceError, u as ReactiveCollectionPersistenceHandle, v as ReactiveCollectionPersistenceStatus, w as agenticMemoryRecordChangeFrame, x as agenticMemoryRecordSnapshotFrame, y as agenticMemoryRecordsSnapshotKey, z as assertAgenticMemoryRecordChangeFrame, B as assertAgenticMemoryRecordSnapshotFrame, C as loadAgenticMemoryRecordsState, D as openPersistentAgenticMemoryRecords, E as openPersistentReactiveIndex, F as openPersistentReactiveList, G as openPersistentReactiveLog, H as openPersistentReactiveMap, I as persistAgenticMemoryRecords, J as persistReactiveCollection } from '../reactive-collection-storage-a4zD3665.js';
+import { d as Graph } from '../graph-ho5sotHP.js';
 import { R as RetryPolicy } from '../resilience-Dig3Q7n0.js';
-import { N as Node, g as HttpRequest, w as ProcessCommand, O as WebSocketSend, h as HttpResponse, x as ProcessResult, M as WebSocketRequest, Q as WebSocketSendResult } from '../types-h12mNYbq.js';
-import '../solutions/index.js';
+import { N as Node, g as HttpRequest, w as ProcessCommand, O as WebSocketSend, h as HttpResponse, x as ProcessResult, M as WebSocketRequest, Q as WebSocketSendResult } from '../types-C9NOgNJw.js';
+export { E as ExternalStore, J as JotaiAtom, N as NanoAtom, a as NodeRecordFactory, R as ReadableStore, S as SignalLike, b as SubscribeValuesOptions, c as WritableJotaiAtom, d as WritableNanoAtom, W as WritableNode, e as WritableSignalLike, f as WritableStore, g as WritableStoreOptions, Z as ZustandStoreApi, h as externalStore, j as jotaiAtom, n as nanoAtom, i as nodeSnapshot, r as readableStore, k as recordReadableStore, s as signalFromNode, l as subscribeNodeValues, w as writableStore, z as zustandStore } from '../store-BmtEs9mG.js';
+import '../agentic-memory-types-CVSUS6XR.js';
 import '../codec-BB7p8fJc.js';
-import '../semantic-memory-graph-CxyXLms3.js';
+import '../semantic-memory-graph-types-Ci-OtahO.js';
 import '../append-log-DzKMmjxx.js';
-import '../reactive-collection-Cb1II1Fi.js';
-import '../reactive-map-BcB4KsQR.js';
+import '../reactive-collection-BXFrH0U2.js';
+import '../types-DL_05n2M.js';
+import '../reactive-map-jle5dnok.js';
 import '../core/index.js';
-import '../messages-BZqrGGm1.js';
-import '../describe-BZb7AS2y.js';
+import '../messages-CAzUPPJM.js';
+import '../describe-B_A5fbXH.js';
 
-/**
- * Graph-visible wire bridge envelope helpers (D134).
- *
- * This first slice is transport-free: commands become outbound envelope facts,
- * remote receipts enter only through the inbound fact node, and retry/ack timeout
- * state is surfaced through graph-visible attempts/status/errors nodes.
- */
+type CanonicalProtobufErrorCategory = "unknown_field" | "duplicate_singular" | "noncanonical_bytes" | "invalid_oneof" | "missing_required" | "invalid_wire_edge" | "default_emission" | "malformed";
+declare class CanonicalProtobufError extends Error {
+    readonly category: CanonicalProtobufErrorCategory;
+    constructor(category: CanonicalProtobufErrorCategory, message: string);
+}
+interface CanonicalWireBridgeMetadata {
+    readonly seq: bigint;
+    readonly cursor: bigint;
+    readonly idempotencyKey: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly timestampMs?: bigint;
+    readonly ackForSeq?: bigint;
+    readonly requestId?: string;
+}
+type CanonicalWireBridgeDataBody = {
+    readonly kind: "value";
+    readonly value: Uint8Array;
+} | {
+    readonly kind: "wire_edge";
+    readonly frame: CanonicalWireEdgeFrame;
+};
+interface CanonicalWireEdgeFrame {
+    readonly kind: "dirty" | "data";
+    readonly edgeId: string;
+    readonly causeId: string;
+    readonly value?: Uint8Array;
+}
+type CanonicalWireBridgePayload = {
+    readonly kind: "start";
+} | {
+    readonly kind: "data";
+    readonly body: CanonicalWireBridgeDataBody;
+} | {
+    readonly kind: "ack";
+} | {
+    readonly kind: "nack";
+    readonly error?: Uint8Array;
+} | {
+    readonly kind: "status";
+    readonly status: Uint8Array;
+} | {
+    readonly kind: "error";
+    readonly error: Uint8Array;
+} | {
+    readonly kind: "close";
+    readonly reason?: Uint8Array;
+};
+interface CanonicalWireBridgeEnvelope {
+    readonly sessionId: string;
+    readonly metadata: CanonicalWireBridgeMetadata;
+    readonly payload: CanonicalWireBridgePayload;
+}
+declare function decodeCanonicalWireBridgeEnvelope(bytes: Uint8Array): CanonicalWireBridgeEnvelope;
+declare function decodeCanonicalWireEdgeFrame(bytes: Uint8Array): CanonicalWireEdgeFrame;
+declare function encodeCanonicalWireEdgeFrame(frame: CanonicalWireEdgeFrame): Uint8Array;
+declare function encodeCanonicalWireBridgeEnvelope(envelope: CanonicalWireBridgeEnvelope): Uint8Array;
 
 type WireBridgeEnvelopeType = "start" | "data" | "ack" | "nack" | "status" | "error" | "close";
 interface WireBridgeMetadata {
@@ -74,6 +126,11 @@ type WireBridgeCommand<TData = unknown> = {
     readonly error: unknown;
     readonly idempotencyKey?: string;
     readonly requestId?: string;
+} | {
+    readonly kind: "ack-timeout";
+    readonly seq: number;
+    readonly attempt: number;
+    readonly observedAtMs?: number;
 } | {
     readonly kind: "close";
     readonly reason?: unknown;
@@ -165,8 +222,6 @@ interface WireBridgeOptions {
     readonly name?: string;
     readonly sessionId: string;
     readonly retry?: RetryPolicy;
-    /** Finite D134 ack timeout. Defaults to 30s so pending ack tracking is bounded. */
-    readonly ackTimeoutMs?: number;
     readonly now?: () => number;
 }
 interface WireBridgeBundle<TOutbound = unknown, TInbound = unknown> {
@@ -198,6 +253,60 @@ interface WireBridgeBundle<TOutbound = unknown, TInbound = unknown> {
         idempotencyKey?: string;
     }): void;
 }
+interface WireBridgeAckDriverIssue {
+    readonly code: "wire-bridge-ack-driver-clock-invalid" | "wire-bridge-ack-driver-clock-regressed";
+    readonly message: string;
+    readonly seq?: number;
+    readonly attempt?: number;
+    readonly observedAtMs?: number;
+    readonly nowMs?: number;
+}
+interface WireBridgeAckDriverStatus {
+    readonly state: "idle" | "active" | "timed-out" | "issues";
+    readonly pending: number;
+    readonly commands: number;
+    readonly issues: number;
+    readonly nowMs?: number;
+    readonly lastCommand?: Extract<WireBridgeCommand, {
+        readonly kind: "ack-timeout";
+    }>;
+    readonly lastIssue?: WireBridgeAckDriverIssue;
+}
+interface WireBridgeAckDriverOptions {
+    readonly name?: string;
+    readonly clock: Node<number>;
+    readonly timeoutMs: number;
+}
+interface WireBridgeAckDriverBundle {
+    readonly commands: Node<WireBridgeCommand<never>>;
+    readonly status: Node<WireBridgeAckDriverStatus>;
+    readonly issues: Node<WireBridgeAckDriverIssue>;
+    release(): void;
+}
+type WireBridgeProtobufData = Uint8Array | CanonicalWireBridgeDataBody;
+interface WireBridgeProtobufIssue {
+    readonly direction: "inbound" | "outbound";
+    readonly operation: "decode" | "encode";
+    readonly message: string;
+    readonly category?: CanonicalProtobufErrorCategory;
+}
+interface WireBridgeProtobufStatus {
+    readonly decoded: number;
+    readonly encoded: number;
+    readonly issues: number;
+    readonly state: "idle" | "active" | "issues";
+    readonly lastIssue?: WireBridgeProtobufIssue;
+}
+interface WireBridgeProtobufBundle {
+    readonly inboundBytes: Node<Uint8Array>;
+    readonly outboundBytes: Node<Uint8Array>;
+    readonly issues: Node<WireBridgeProtobufIssue>;
+    readonly status: Node<WireBridgeProtobufStatus>;
+    release(): void;
+}
+interface WireBridgeProtobufOptions {
+    readonly name?: string;
+}
 interface RemoteCallRequest<T = unknown> {
     readonly operation: string;
     readonly requestId: string;
@@ -305,6 +414,26 @@ interface RemoteResponderBundle<TRequest = unknown, TResponse = unknown> {
     readonly errors: Node<RemoteCallError>;
     release(): void;
 }
+
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+/** D147 remote dispatcher call helper over explicit wireBridge request/response facts. */
+declare function remoteCall<TRequest = unknown, TResponse = unknown>(graph: Graph, bridge: WireBridgeBundle<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>, opts?: RemoteCallOptions): RemoteCallBundle<TRequest, TResponse>;
+
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
 /** Stable D134 idempotency key helper scoped to one bridge session and sequence. */
 declare function wireBridgeIdempotencyKey(sessionId: string, seq: number): string;
 /** Create a D134 wire bridge envelope with ordered metadata. */
@@ -322,19 +451,52 @@ declare function wireBridgeEnvelope<TData = unknown>(input: {
     readonly requestId?: string;
 }): WireBridgeEnvelope<TData>;
 declare function wireBridge<TOutbound = unknown, TInbound = unknown>(graph: Graph, opts: WireBridgeOptions): WireBridgeBundle<TOutbound, TInbound>;
-/** D147 remote dispatcher call helper over explicit wireBridge request/response facts. */
-declare function remoteCall<TRequest = unknown, TResponse = unknown>(graph: Graph, bridge: WireBridgeBundle<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>, opts?: RemoteCallOptions): RemoteCallBundle<TRequest, TResponse>;
+/** D502 explicit graph-visible ack-timeout command driver for a wireBridge. */
+declare function wireBridgeAckDriver<TOutbound = unknown, TInbound = unknown>(graph: Graph, bridge: WireBridgeBundle<TOutbound, TInbound>, opts: WireBridgeAckDriverOptions): WireBridgeAckDriverBundle;
+/**
+ * D498 focused canonical protobuf byte adapter over an existing semantic wireBridge bundle.
+ *
+ * This helper owns no transport/session/retry policy and does not add wireBridge core options.
+ * Malformed bytes become graph-visible issue/invalid facts, never local protocol terminals.
+ */
+declare function wireBridgeProtobuf(graph: Graph, bridge: WireBridgeBundle<WireBridgeProtobufData, WireBridgeProtobufData>, opts?: WireBridgeProtobufOptions): WireBridgeProtobufBundle;
 declare function remoteResponderHandler<TRequest = unknown, TResponse = unknown>(operation: string, handle: RemoteResponderHandler<TRequest, TResponse>): RemoteResponderHandlerDefinition<TRequest, TResponse>;
 /** D147 remote responder over inbound wireBridge request facts and outbound command facts. */
 declare function remoteResponder<TRequest = unknown, TResponse = unknown>(graph: Graph, bridge: WireBridgeBundle<RemoteCallResponse<TResponse>, RemoteCallRequest<TRequest>>, opts?: RemoteResponderOptions<TRequest, TResponse>): RemoteResponderBundle<TRequest, TResponse>;
 
-/**
- * Graph-visible outbound environment adapters (D130/D132).
- *
- * Async transport work is confined to graph-local EnvironmentDrivers. Each
- * helper returns declared nodes for events/status/attempts/errors instead of a
- * hidden sink side channel.
- */
+interface WireEdgeGroupEdge {
+    readonly edgeId: string;
+    readonly outbound?: Node<Uint8Array>;
+}
+type WireEdgeGroupIssueCode = "wire-edge-group-missing-snapshot" | "wire-edge-group-unknown-edge" | "wire-edge-group-duplicate-dirty" | "wire-edge-group-duplicate-data" | "wire-edge-group-data-before-dirty" | "wire-edge-group-competing-cause" | "wire-edge-group-malformed-frame" | "wire-edge-group-incomplete-cause";
+interface WireEdgeGroupIssue {
+    readonly code: WireEdgeGroupIssueCode;
+    readonly message: string;
+    readonly edgeId?: string;
+    readonly causeId?: string;
+    readonly activeCauseId?: string;
+}
+interface WireEdgeGroupStatus {
+    readonly state: "idle" | "collecting" | "released" | "issues";
+    readonly expectedEdges: readonly string[];
+    readonly dirty: number;
+    readonly data: number;
+    readonly released: number;
+    readonly issues: number;
+    readonly activeCauseId?: string;
+    readonly lastIssue?: WireEdgeGroupIssue;
+}
+interface WireEdgeGroupOptions {
+    readonly name?: string;
+    readonly edges: readonly WireEdgeGroupEdge[];
+}
+interface WireEdgeGroupBundle {
+    readonly inbound: ReadonlyMap<string, Node<Uint8Array>>;
+    readonly status: Node<WireEdgeGroupStatus>;
+    readonly issues: Node<WireEdgeGroupIssue>;
+    release(): void;
+}
+declare function wireEdgeGroup(graph: Graph, bridge: WireBridgeBundle<WireBridgeProtobufData, WireBridgeProtobufData>, opts: WireEdgeGroupOptions): WireEdgeGroupBundle;
 
 type OutboundEvent<TValue, TResult> = {
     readonly kind: "attempt";
@@ -496,183 +658,33 @@ interface WebSocketSessionOptions {
     readonly retry?: RetryPolicy;
     readonly sendPolicy?: WebSocketSessionSendPolicy;
 }
+
 /**
- * Create a graph-visible D133 WebSocket SessionBundle.
+ * Graph-visible outbound environment adapters (D130/D132).
  *
- * The convenience start/send/close methods publish command facts only; hidden
- * session state is driven by the command node and graph-local EnvironmentDrivers.
+ * Async transport work is confined to graph-local EnvironmentDrivers. Each
+ * helper returns declared nodes for events/status/attempts/errors instead of a
+ * hidden sink side channel.
  */
-declare function webSocketSession(graph: Graph, request: WebSocketRequest, opts?: WebSocketSessionOptions): WebSocketSessionBundle;
+
 declare function toHttp<T>(graph: Graph, source: Node<T>, requestOf: HttpRequestOf<T>, opts?: OutboundAdapterOptions): OutboundBundle<T, HttpResponse>;
 declare function toProcess<T>(graph: Graph, source: Node<T>, commandOf: ProcessCommandOf<T>, opts?: OutboundAdapterOptions): OutboundBundle<T, ProcessResult>;
 declare function toWebSocket<T>(graph: Graph, source: Node<T>, request: WebSocketRequest, sendOf: WebSocketSendOf<T>, opts?: OutboundAdapterOptions): OutboundBundle<T, WebSocketSendResult>;
 
 /**
- * Dependency-free NestJS adapter tokens and method metadata.
+ * Graph-visible outbound environment adapters (D130/D132).
  *
- * The old compat layer imported `@nestjs/common` for DI decorators. Clean-slate keeps the
- * retainable token/metadata vocabulary here and leaves actual `Inject(...)` composition to
- * user-land NestJS code, so @graphrefly/ts keeps zero framework dependencies (D125/B61).
+ * Async transport work is confined to graph-local EnvironmentDrivers. Each
+ * helper returns declared nodes for events/status/attempts/errors instead of a
+ * hidden sink side channel.
  */
-/** Injection token for a root graph singleton. */
-declare const GRAPHREFLY_ROOT_GRAPH: unique symbol;
-/** Injection token for adapter module options. */
-declare const GRAPHREFLY_MODULE_OPTIONS: unique symbol;
-/** Injection token for a request-scoped graph. */
-declare const GRAPHREFLY_REQUEST_GRAPH: unique symbol;
-type DecoratorHostConstructor = abstract new (...args: unknown[]) => unknown;
-type DecoratorBoundMethod = (...args: unknown[]) => unknown;
-interface OnGraphEventMeta {
-    nodeName: string;
-    methodKey: string | symbol;
-}
-interface GraphIntervalMeta {
-    ms: number;
-    methodKey: string | symbol;
-}
-interface GraphCronMeta {
-    expr: string;
-    methodKey: string | symbol;
-}
-declare const EVENT_HANDLERS: Map<DecoratorHostConstructor, OnGraphEventMeta[]>;
-declare const INTERVAL_HANDLERS: Map<DecoratorHostConstructor, GraphIntervalMeta[]>;
-declare const CRON_HANDLERS: Map<DecoratorHostConstructor, GraphCronMeta[]>;
-type GraphMethodDecorator = MethodDecorator & ((value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void);
-/** Get the injection token for a named feature graph. */
-declare function getGraphToken(name: string): symbol;
-/** Get the injection token for a node at a qualified path. */
-declare function getNodeToken(path: string): symbol;
-/** Register a method as a DATA-event handler for a graph observe path. */
-declare function OnGraphEvent(nodeName: string): GraphMethodDecorator;
-/** Register fixed-interval metadata for a user-land NestJS scheduler bridge. */
-declare function GraphInterval(ms: number): GraphMethodDecorator;
-/** Register cron metadata for a user-land NestJS scheduler bridge. */
-declare function GraphCron(expr: string): GraphMethodDecorator;
 
 /**
- * Framework-neutral store adapters.
+ * Create a graph-visible D133 WebSocket SessionBundle.
  *
- * React/Vue/Solid/Svelte/Zustand/Jotai/Nanostores bindings can build on this
- * tiny Node-facing layer without importing framework packages or reviving the
- * old `compat` namespace (D125/B61).
- */
-
-/** A minimal readable store contract shared by Svelte/Nanostores-style adapters. */
-interface ReadableStore<T> {
-    get(): T | undefined;
-    subscribe(run: (value: T | undefined) => void): () => void;
-}
-/** A minimal writable store contract over a clean-slate writable node. */
-interface WritableStore<T> extends ReadableStore<T> {
-    set(value: T): void;
-    update(fn: (value: T | undefined) => T): void;
-}
-/** React `useSyncExternalStore`-compatible shape, without importing React. */
-interface ExternalStore<T> {
-    getSnapshot(): T | undefined;
-    getServerSnapshot(): T | undefined;
-    subscribe(onStoreChange: () => void): () => void;
-}
-/** Object-of-nodes factory used by record subscription adapters. */
-type NodeRecordFactory<K extends string, R extends Record<string, unknown>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/** Zustand-compatible store API over a caller-owned clean-slate state node. */
-interface ZustandStoreApi<T extends object> {
-    getState(): T;
-    setState(partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean): void;
-    getInitialState(): T;
-    subscribe(listener: (state: T, prevState: T) => void): () => void;
-    destroy(): void;
-}
-/** Jotai-style atom facade over a caller-owned node. */
-interface JotaiAtom<T> {
-    get(): T | undefined;
-    subscribe(callback: (value: T | undefined) => void): () => void;
-    readonly _node: Node<T>;
-}
-/** Writable Jotai-style atom facade over a caller-owned writable node. */
-interface WritableJotaiAtom<T> extends JotaiAtom<T> {
-    set(value: T): void;
-    update(fn: (value: T | undefined) => T): void;
-}
-/** Nanostores-style atom facade over a caller-owned node. */
-interface NanoAtom<T> {
-    get(): T | undefined;
-    subscribe(callback: (value: T | undefined) => void): () => void;
-    listen(callback: (value: T | undefined) => void): () => void;
-    readonly _node: Node<T>;
-}
-/** Writable Nanostores-style atom facade over a caller-owned writable node. */
-interface WritableNanoAtom<T> extends NanoAtom<T> {
-    set(value: T): void;
-    update(fn: (value: T | undefined) => T): void;
-}
-/** TC39-Signals-style facade over a caller-owned node. */
-interface SignalLike<T> {
-    get(): T | undefined;
-    subscribe(callback: (value: T | undefined) => void): () => void;
-    readonly _node: Node<T>;
-}
-/** Writable TC39-Signals-style facade over a caller-owned writable node. */
-interface WritableSignalLike<T> extends SignalLike<T> {
-    set(value: T): void;
-    update(fn: (value: T | undefined) => T): void;
-}
-interface SubscribeValuesOptions<T> {
-    /** Emit the current cache snapshot immediately. `undefined` means SENTINEL/no DATA. */
-    immediate?: boolean;
-    /** Suppress synchronous push-on-subscribe/replay DATA. Useful for change-only store listeners. */
-    changesOnly?: boolean;
-    onError?: (error: unknown) => void;
-    onComplete?: () => void;
-    /** Custom cache reader for wrappers that keep their own snapshot object. */
-    getSnapshot?: () => T | undefined;
-}
-interface WritableNode<T> extends Node<T> {
-    set(value: T): void;
-}
-interface WritableStoreOptions<T> extends SubscribeValuesOptions<T> {
-    /** Override writes for adapters that need a framework-owned reducer. */
-    write?: (node: WritableNode<T>, value: T) => void;
-}
-/** Read a node cache without activating it. */
-declare function nodeSnapshot<T>(node: Node<T>): T | undefined;
-/**
- * Subscribe to DATA values from a Node. Protocol internals stay below the adapter boundary:
- * DATA drives value listeners, ERROR/COMPLETE route to optional lifecycle callbacks.
+ * The convenience start/send/close methods publish command facts only; hidden
+ * session state is driven by the command node and graph-local EnvironmentDrivers.
  */
-declare function subscribeNodeValues<T>(node: Node<T>, run: (value: T | undefined) => void, opts?: SubscribeValuesOptions<T>): () => void;
-/** Build a Svelte/Nanostores-style readable store from a clean-slate Node. */
-declare function readableStore<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): ReadableStore<T>;
-/** Build a writable store over a StateNode or compatible clean-slate writable Node. */
-declare function writableStore<T>(node: WritableNode<T>, opts?: WritableStoreOptions<T>): WritableStore<T>;
-declare function writableStore<T>(node: Node<T>, opts: WritableStoreOptions<T> & {
-    write: (node: WritableNode<T>, value: T) => void;
-}): WritableStore<T>;
-/** Build the tiny shape React's `useSyncExternalStore` expects, without importing React. */
-declare function externalStore<T>(node: Node<T>, opts?: Pick<SubscribeValuesOptions<T>, "getSnapshot" | "onError" | "onComplete">): ExternalStore<T>;
-/** Alias for React-facing bindings; dependency-free so React stays a peer of user code. */
-declare const reactExternalStore: typeof externalStore;
-/** Alias for Svelte-style readable stores. */
-declare const svelteReadableStore: typeof readableStore;
-/** Alias for Svelte-style writable stores. */
-declare const svelteWritableStore: typeof writableStore;
-/** Build a framework-neutral keyed record store (the core of old useSubscribeRecord helpers). */
-declare function recordReadableStore<K extends string, R extends Record<string, unknown>>(keysNode: Node<readonly K[]>, factory: NodeRecordFactory<K, R>, opts?: SubscribeValuesOptions<Record<K, R>>): ReadableStore<Record<K, R>>;
-/** Build a Zustand-compatible StoreApi over a caller-owned clean-slate state node. */
-declare function zustandStore<T extends object>(node: WritableNode<T>, initialState?: T, opts?: WritableStoreOptions<T>): ZustandStoreApi<T>;
-declare function zustandStore<T extends object>(node: Node<T>, initialState: T | undefined, opts: WritableStoreOptions<T> & {
-    write: (node: WritableNode<T>, value: T) => void;
-}): ZustandStoreApi<T>;
-/** Build a Jotai-style atom facade over a caller-owned node. */
-declare function jotaiAtom<T>(node: WritableNode<T>, opts?: WritableStoreOptions<T>): WritableJotaiAtom<T>;
-declare function jotaiAtom<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): JotaiAtom<T>;
-/** Build a Nanostores-style atom facade over a caller-owned node. */
-declare function nanoAtom<T>(node: WritableNode<T>, opts?: WritableStoreOptions<T>): WritableNanoAtom<T>;
-declare function nanoAtom<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): NanoAtom<T>;
-/** Build a TC39-Signals-style facade over a caller-owned node. */
-declare function signalFromNode<T>(node: WritableNode<T>, opts?: WritableStoreOptions<T>): WritableSignalLike<T>;
-declare function signalFromNode<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): SignalLike<T>;
+declare function webSocketSession(graph: Graph, request: WebSocketRequest, opts?: WebSocketSessionOptions): WebSocketSessionBundle;
 
-export { CRON_HANDLERS, type DecoratorBoundMethod, type DecoratorHostConstructor, EVENT_HANDLERS, type ExternalStore, GRAPHREFLY_MODULE_OPTIONS, GRAPHREFLY_REQUEST_GRAPH, GRAPHREFLY_ROOT_GRAPH, GraphCron, type GraphCronMeta, GraphInterval, type GraphIntervalMeta, type GraphMethodDecorator, type HttpRequestOf, INTERVAL_HANDLERS, type JotaiAtom, type NanoAtom, type NodeRecordFactory, OnGraphEvent, type OnGraphEventMeta, type OutboundAdapterOptions, type OutboundBundle, type OutboundEvent, type OutboundStatus, type ProcessCommandOf, type ReadableStore, type RemoteCallBundle, type RemoteCallError, type RemoteCallOptions, type RemoteCallRequest, type RemoteCallResponse, type RemoteCallResult, type RemoteCallStatus, type RemoteCallStatusState, type RemoteCallTimeout, type RemoteResponderBundle, type RemoteResponderEvent, type RemoteResponderHandler, type RemoteResponderHandlerDefinition, type RemoteResponderOptions, type RemoteResponderStatus, type RemoteResponderStatusState, type SignalLike, type SubscribeValuesOptions, type WebSocketSendOf, type WebSocketSessionBundle, type WebSocketSessionCommand, type WebSocketSessionInbound, type WebSocketSessionLifecycle, type WebSocketSessionOptions, type WebSocketSessionOutbound, type WebSocketSessionSendPolicy, type WebSocketSessionStatus, type WireBridgeAck, type WireBridgeAttempt, type WireBridgeBundle, type WireBridgeCommand, type WireBridgeEnvelope, type WireBridgeEnvelopeType, type WireBridgeEvent, type WireBridgeMetadata, type WireBridgeNack, type WireBridgeOptions, type WireBridgePayload, type WireBridgeStatus, type WritableJotaiAtom, type WritableNanoAtom, type WritableNode, type WritableSignalLike, type WritableStore, type WritableStoreOptions, type ZustandStoreApi, externalStore, getGraphToken, getNodeToken, jotaiAtom, nanoAtom, nodeSnapshot, reactExternalStore, readableStore, recordReadableStore, remoteCall, remoteResponder, remoteResponderHandler, signalFromNode, subscribeNodeValues, svelteReadableStore, svelteWritableStore, toHttp, toProcess, toWebSocket, webSocketSession, wireBridge, wireBridgeEnvelope, wireBridgeIdempotencyKey, writableStore, zustandStore };
+export { CanonicalProtobufError, type CanonicalProtobufErrorCategory, type CanonicalWireBridgeDataBody, type CanonicalWireBridgeEnvelope, type CanonicalWireBridgeMetadata, type CanonicalWireBridgePayload, type CanonicalWireEdgeFrame, type HttpRequestOf, type OutboundAdapterOptions, type OutboundBundle, type OutboundEvent, type OutboundStatus, type ProcessCommandOf, type RemoteCallBundle, type RemoteCallError, type RemoteCallOptions, type RemoteCallRequest, type RemoteCallResponse, type RemoteCallResult, type RemoteCallStatus, type RemoteCallStatusState, type RemoteCallTimeout, type RemoteResponderBundle, type RemoteResponderEvent, type RemoteResponderHandler, type RemoteResponderHandlerDefinition, type RemoteResponderOptions, type RemoteResponderStatus, type RemoteResponderStatusState, type WebSocketSendOf, type WebSocketSessionBundle, type WebSocketSessionCommand, type WebSocketSessionInbound, type WebSocketSessionLifecycle, type WebSocketSessionOptions, type WebSocketSessionOutbound, type WebSocketSessionSendPolicy, type WebSocketSessionStatus, type WireBridgeAck, type WireBridgeAckDriverBundle, type WireBridgeAckDriverIssue, type WireBridgeAckDriverOptions, type WireBridgeAckDriverStatus, type WireBridgeAttempt, type WireBridgeBundle, type WireBridgeCommand, type WireBridgeEnvelope, type WireBridgeEnvelopeType, type WireBridgeEvent, type WireBridgeMetadata, type WireBridgeNack, type WireBridgeOptions, type WireBridgePayload, type WireBridgeProtobufBundle, type WireBridgeProtobufData, type WireBridgeProtobufIssue, type WireBridgeProtobufOptions, type WireBridgeProtobufStatus, type WireBridgeStatus, type WireEdgeGroupBundle, type WireEdgeGroupEdge, type WireEdgeGroupIssue, type WireEdgeGroupIssueCode, type WireEdgeGroupOptions, type WireEdgeGroupStatus, decodeCanonicalWireBridgeEnvelope, decodeCanonicalWireEdgeFrame, encodeCanonicalWireBridgeEnvelope, encodeCanonicalWireEdgeFrame, remoteCall, remoteResponder, remoteResponderHandler, toHttp, toProcess, toWebSocket, webSocketSession, wireBridge, wireBridgeAckDriver, wireBridgeEnvelope, wireBridgeIdempotencyKey, wireBridgeProtobuf, wireEdgeGroup };