@graphrefly/ts 0.0.1 → 0.0.3

package/dist/adapters/index.d.cts

@@ -1,25 +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-BNEldDyi.cjs';
-import { d as Graph } from '../graph-DCEWh4T2.cjs';
+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-BjoLsoiC.cjs';
+import { d as Graph } from '../graph-C1C-wb0L.cjs';
 import { R as RetryPolicy } from '../resilience-Dig3Q7n0.cjs';
-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-CcPIn7sy.cjs';
-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-CNJwmT-h.cjs';
-import '../agentic-memory-DfuVZ-lY.cjs';
+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-CTN3XoMl.cjs';
+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-BljX8RkQ.cjs';
+import '../agentic-memory-types-JDr7MPhh.cjs';
 import '../codec-BB7p8fJc.cjs';
-import '../semantic-memory-graph-DKuNzuWw.cjs';
+import '../semantic-memory-graph-types-Y73bbwVI.cjs';
 import '../append-log-DisvEReb.cjs';
-import '../reactive-collection-DNV0-gFi.cjs';
-import '../reactive-map-DRD1LJ2H.cjs';
+import '../reactive-collection-BYlWvtnp.cjs';
+import '../types-BUbbbh4f.cjs';
+import '../reactive-map-BHacbIqz.cjs';
 import '../core/index.cjs';
 import '../messages-CAzUPPJM.cjs';
-import '../describe-DYMw_l1C.cjs';
+import '../describe-BumQ-3_0.cjs';
 
-/**
- * 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 {
@@ -75,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;
@@ -166,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> {
@@ -199,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;
@@ -306,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. */
@@ -323,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";
@@ -497,57 +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;
 
-export { CRON_HANDLERS, type DecoratorBoundMethod, type DecoratorHostConstructor, EVENT_HANDLERS, GRAPHREFLY_MODULE_OPTIONS, GRAPHREFLY_REQUEST_GRAPH, GRAPHREFLY_ROOT_GRAPH, GraphCron, type GraphCronMeta, GraphInterval, type GraphIntervalMeta, type GraphMethodDecorator, type HttpRequestOf, INTERVAL_HANDLERS, OnGraphEvent, type OnGraphEventMeta, 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 WireBridgeAttempt, type WireBridgeBundle, type WireBridgeCommand, type WireBridgeEnvelope, type WireBridgeEnvelopeType, type WireBridgeEvent, type WireBridgeMetadata, type WireBridgeNack, type WireBridgeOptions, type WireBridgePayload, type WireBridgeStatus, getGraphToken, getNodeToken, remoteCall, remoteResponder, remoteResponderHandler, toHttp, toProcess, toWebSocket, webSocketSession, wireBridge, wireBridgeEnvelope, wireBridgeIdempotencyKey };
+/**
+ * Create a graph-visible D133 WebSocket SessionBundle.
+ *
+ * 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 webSocketSession(graph: Graph, request: WebSocketRequest, opts?: WebSocketSessionOptions): WebSocketSessionBundle;
+
+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 };