@graphrefly/ts 0.0.0

package/dist/adapters/index.d.cts

@@ -0,0 +1,678 @@
+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-D-KmjE0J.cjs';
+import { d as Graph } from '../graph-s23RbbFO.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-bNMSWKqF.cjs';
+import '../solutions/index.cjs';
+import '../codec-BB7p8fJc.cjs';
+import '../semantic-memory-graph-BYoIlP35.cjs';
+import '../append-log-DisvEReb.cjs';
+import '../reactive-collection-BxBqtIOE.cjs';
+import '../reactive-map-D-g3dv8I.cjs';
+import '../core/index.cjs';
+import '../messages-BZqrGGm1.cjs';
+import '../describe-Ciu8SUnN.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 WireBridgeEnvelopeType = "start" | "data" | "ack" | "nack" | "status" | "error" | "close";
+interface WireBridgeMetadata {
+    /** Monotonic envelope sequence within the bridge session. */
+    readonly seq: number;
+    /** Monotonic accepted inbound cursor observed by the sending side. */
+    readonly cursor: number;
+    /** D151: correlation/idempotency metadata, not an authoritative duplicate lookup key. */
+    readonly idempotencyKey: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly timestampMs?: number;
+    /** D151 ack/nack correlation target; receipt duplicate recognition still uses seq/cursor. */
+    readonly ackForSeq?: number;
+    readonly requestId?: string;
+}
+type WireBridgePayload<TData = unknown> = {
+    readonly kind: "data";
+    readonly value: TData;
+} | {
+    readonly kind: "error";
+    readonly error: unknown;
+} | {
+    readonly kind: "status";
+    readonly status: unknown;
+} | {
+    readonly kind: "close";
+    readonly reason?: unknown;
+};
+interface WireBridgeEnvelope<TData = unknown> {
+    readonly sessionId: string;
+    readonly type: WireBridgeEnvelopeType;
+    readonly payload?: WireBridgePayload<TData>;
+    readonly metadata: WireBridgeMetadata;
+}
+type WireBridgeCommand<TData = unknown> = {
+    readonly kind: "start";
+    readonly idempotencyKey?: string;
+    readonly requestId?: string;
+} | {
+    readonly kind: "send";
+    readonly payload: TData;
+    readonly idempotencyKey?: string;
+    readonly requestId?: string;
+} | {
+    readonly kind: "ack";
+    readonly ackForSeq: number;
+    readonly idempotencyKey?: string;
+    readonly requestId?: string;
+} | {
+    readonly kind: "nack";
+    readonly ackForSeq: number;
+    readonly error: unknown;
+    readonly idempotencyKey?: string;
+    readonly requestId?: string;
+} | {
+    readonly kind: "close";
+    readonly reason?: unknown;
+    readonly idempotencyKey?: string;
+};
+type WireBridgeEvent<TOutbound = unknown, TInbound = unknown> = {
+    readonly kind: "outbound";
+    readonly envelope: WireBridgeEnvelope<TOutbound>;
+} | {
+    readonly kind: "inbound";
+    readonly envelope: WireBridgeEnvelope<TInbound>;
+} | {
+    readonly kind: "ack";
+    readonly ackForSeq: number;
+    readonly envelope: WireBridgeEnvelope<TInbound>;
+    readonly outbound: WireBridgeEnvelope<TOutbound>;
+} | {
+    readonly kind: "nack";
+    readonly ackForSeq: number;
+    readonly envelope: WireBridgeEnvelope<TInbound>;
+    readonly outbound: WireBridgeEnvelope<TOutbound>;
+    readonly error: unknown;
+} | {
+    readonly kind: "timeout";
+    readonly seq: number;
+    readonly attempt: number;
+} | {
+    readonly kind: "retry";
+    readonly seq: number;
+    readonly attempt: number;
+    readonly delayMs: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "exhausted";
+    readonly seq: number;
+    readonly attempt: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "cursor";
+    readonly cursor: number;
+} | {
+    readonly kind: "duplicate";
+    readonly seq: number;
+    readonly cursor: number;
+} | {
+    readonly kind: "out-of-order";
+    readonly seq: number;
+    readonly expected: number;
+} | {
+    readonly kind: "session-mismatch";
+    readonly expected: string;
+    readonly actual: string;
+} | {
+    readonly kind: "late-receipt";
+    readonly receipt: "ack" | "nack";
+    readonly ackForSeq: number;
+} | {
+    readonly kind: "invalid";
+    readonly error: string;
+};
+interface WireBridgeAck {
+    readonly ackForSeq: number;
+    readonly envelope: WireBridgeEnvelope;
+}
+interface WireBridgeNack {
+    readonly ackForSeq: number;
+    readonly envelope: WireBridgeEnvelope;
+    readonly error: unknown;
+}
+interface WireBridgeAttempt {
+    readonly seq: number;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+}
+interface WireBridgeStatus {
+    readonly sessionId: string;
+    readonly state: "idle" | "started" | "open" | "waiting" | "closed" | "errored" | "exhausted";
+    readonly cursor: number;
+    readonly nextSeq: number;
+    readonly pending: number;
+    readonly attempts: number;
+    readonly acked: number;
+    readonly nacked: number;
+    readonly errors: number;
+    readonly lastSeq?: number;
+    readonly lastDelayMs?: number;
+}
+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> {
+    readonly sessionId: string;
+    readonly command: Node<WireBridgeCommand<TOutbound>>;
+    readonly outbound: Node<WireBridgeEnvelope<TOutbound>>;
+    readonly inbound: Node<WireBridgeEnvelope<TInbound>>;
+    readonly events: Node<WireBridgeEvent<TOutbound, TInbound>>;
+    readonly acks: Node<WireBridgeAck>;
+    readonly nacks: Node<WireBridgeNack>;
+    readonly status: Node<WireBridgeStatus>;
+    readonly errors: Node<unknown>;
+    readonly cursor: Node<number>;
+    readonly attempts: Node<WireBridgeAttempt>;
+    start(): void;
+    send(payload: TOutbound, opts?: {
+        idempotencyKey?: string;
+        requestId?: string;
+    }): void;
+    ack(ackForSeq: number, opts?: {
+        idempotencyKey?: string;
+        requestId?: string;
+    }): void;
+    nack(ackForSeq: number, error: unknown, opts?: {
+        idempotencyKey?: string;
+        requestId?: string;
+    }): void;
+    close(reason?: unknown, opts?: {
+        idempotencyKey?: string;
+    }): void;
+}
+interface RemoteCallRequest<T = unknown> {
+    readonly operation: string;
+    readonly requestId: string;
+    readonly payload: T;
+}
+type RemoteCallResponse<T = unknown> = {
+    readonly kind: "result";
+    readonly operation: string;
+    readonly requestId: string;
+    readonly payload: T;
+} | {
+    readonly kind: "error";
+    readonly operation: string;
+    readonly requestId: string;
+    readonly error: string;
+} | {
+    readonly kind: "status";
+    readonly operation: string;
+    readonly requestId: string;
+    readonly status: string;
+};
+interface RemoteCallResult<T = unknown> {
+    readonly operation: string;
+    readonly requestId: string;
+    readonly payload: T;
+}
+type RemoteCallStatusState = "idle" | "requested" | "responded" | "errored" | "timed-out" | "bridge-errored";
+interface RemoteCallStatus {
+    readonly state: RemoteCallStatusState;
+    readonly operation?: string;
+    readonly requestId?: string;
+    readonly pending: number;
+    readonly completed: number;
+    readonly errors: number;
+    readonly timeouts: number;
+}
+interface RemoteCallError {
+    readonly operation?: string;
+    readonly requestId?: string;
+    readonly error: string;
+}
+interface RemoteCallTimeout {
+    readonly operation?: string;
+    readonly requestId: string;
+    readonly error: string;
+}
+interface RemoteCallOptions {
+    readonly name?: string;
+}
+interface RemoteCallBundle<TRequest = unknown, TResponse = unknown> {
+    readonly responses: Node<RemoteCallResponse<TResponse>>;
+    readonly results: Node<RemoteCallResult<TResponse>>;
+    readonly status: Node<RemoteCallStatus>;
+    readonly errors: Node<RemoteCallError>;
+    readonly timeouts: Node<RemoteCallTimeout>;
+    call(operation: string, requestId: string, payload: TRequest, opts?: {
+        readonly idempotencyKey?: string;
+    }): RemoteCallRequest<TRequest>;
+    timeout(requestId: string, operation: string | undefined, error: string): RemoteCallTimeout;
+}
+type RemoteResponderHandler<TRequest = unknown, TResponse = unknown> = (request: RemoteCallRequest<TRequest>) => TResponse;
+interface RemoteResponderHandlerDefinition<TRequest = unknown, TResponse = unknown> {
+    readonly operation: string;
+    readonly handle: RemoteResponderHandler<TRequest, TResponse>;
+}
+type RemoteResponderEvent<TRequest = unknown, TResponse = unknown> = {
+    readonly kind: "request";
+    readonly request: RemoteCallRequest<TRequest>;
+    readonly seq: number;
+} | {
+    readonly kind: "response";
+    readonly requestId: string;
+    readonly operation: string;
+    readonly command: WireBridgeCommand<RemoteCallResponse<TResponse>>;
+} | {
+    readonly kind: "rejected";
+    readonly requestId?: string;
+    readonly operation?: string;
+    readonly error: string;
+    readonly command?: WireBridgeCommand<RemoteCallResponse<TResponse>>;
+} | {
+    readonly kind: "invalid";
+    readonly error: string;
+};
+type RemoteResponderStatusState = "idle" | "responded" | "rejected" | "errored";
+interface RemoteResponderStatus {
+    readonly state: RemoteResponderStatusState;
+    readonly operation?: string;
+    readonly requestId?: string;
+    readonly handled: number;
+    readonly rejected: number;
+    readonly errors: number;
+}
+interface RemoteResponderOptions<TRequest = unknown, TResponse = unknown> {
+    readonly name?: string;
+    readonly handlers?: readonly RemoteResponderHandlerDefinition<TRequest, TResponse>[];
+    /** Default false: non-owned operations are ignored so multiple responders may share one bridge. */
+    readonly rejectUnknown?: boolean;
+}
+interface RemoteResponderBundle<TRequest = unknown, TResponse = unknown> {
+    readonly events: Node<RemoteResponderEvent<TRequest, TResponse>>;
+    readonly responseCommands: Node<WireBridgeCommand<RemoteCallResponse<TResponse>>>;
+    readonly requests: Node<RemoteCallRequest<TRequest>>;
+    readonly status: Node<RemoteResponderStatus>;
+    readonly errors: Node<RemoteCallError>;
+    release(): void;
+}
+/** 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. */
+declare function wireBridgeEnvelope<TData = unknown>(input: {
+    readonly sessionId: string;
+    readonly type: WireBridgeEnvelopeType;
+    readonly seq: number;
+    readonly cursor?: number;
+    readonly payload?: WireBridgePayload<TData>;
+    readonly idempotencyKey?: string;
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
+    readonly timestampMs?: number;
+    readonly ackForSeq?: number;
+    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>;
+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.
+ */
+
+type OutboundEvent<TValue, TResult> = {
+    readonly kind: "attempt";
+    readonly value: TValue;
+    readonly attempt: number;
+} | {
+    readonly kind: "retry";
+    readonly value: TValue;
+    readonly attempt: number;
+    readonly delayMs: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "sent";
+    readonly value: TValue;
+    readonly attempt: number;
+    readonly result: TResult;
+} | {
+    readonly kind: "failed";
+    readonly value: TValue;
+    readonly attempt: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "exhausted";
+    readonly value: TValue;
+    readonly attempt: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "upstream-complete";
+} | {
+    readonly kind: "upstream-error";
+    readonly error: unknown;
+};
+interface OutboundStatus {
+    readonly state: "idle" | "running" | "waiting" | "succeeded" | "failed" | "exhausted" | "completed";
+    readonly inFlight: number;
+    readonly attempt: number;
+    readonly sent: number;
+    readonly failed: number;
+    readonly lastDelayMs?: number;
+}
+interface OutboundBundle<TValue, TResult> {
+    readonly events: Node<OutboundEvent<TValue, TResult>>;
+    readonly status: Node<OutboundStatus>;
+    readonly attempts: Node<number>;
+    readonly errors: Node<unknown>;
+}
+interface OutboundAdapterOptions {
+    readonly name?: string;
+    readonly retry?: RetryPolicy;
+}
+type HttpRequestOf<T> = (value: T) => HttpRequest;
+type ProcessCommandOf<T> = (value: T) => ProcessCommand;
+type WebSocketSendOf<T> = (value: T) => WebSocketSend;
+/** D133 command facts for a graph-visible WebSocket SessionBundle. */
+type WebSocketSessionCommand = {
+    readonly kind: "start";
+} | {
+    readonly kind: "send";
+    readonly message: WebSocketSend;
+} | {
+    readonly kind: "close";
+    readonly code?: number;
+    readonly reason?: string;
+};
+/** Inbound facts emitted by the live WebSocket session connection. */
+type WebSocketSessionInbound = {
+    readonly kind: "text";
+    readonly data: string;
+} | {
+    readonly kind: "binary";
+    readonly data: Uint8Array;
+};
+/** Observable lifecycle facts for bounded D133 reconnect/session progress. */
+type WebSocketSessionLifecycle = {
+    readonly kind: "starting";
+    readonly attempt: number;
+    readonly maxAttempts: number;
+} | {
+    readonly kind: "open";
+    readonly attempt: number;
+} | {
+    readonly kind: "sent";
+    readonly message: WebSocketSend;
+} | {
+    readonly kind: "closing";
+    readonly code?: number;
+    readonly reason?: string;
+} | {
+    readonly kind: "closed";
+    readonly code?: number;
+    readonly reason?: string;
+} | {
+    readonly kind: "retrying";
+    readonly attempt: number;
+    readonly nextAttempt: number;
+    readonly delayMs: number;
+    readonly error: unknown;
+} | {
+    readonly kind: "exhausted";
+    readonly attempt: number;
+    readonly error: unknown;
+};
+/** D175 graph-visible outbound disposition for a WebSocket SessionBundle send. */
+type WebSocketSessionOutbound = {
+    readonly kind: "queued";
+    readonly seq: number;
+    readonly message: WebSocketSend;
+} | {
+    readonly kind: "sending";
+    readonly seq: number;
+    readonly message: WebSocketSend;
+} | {
+    readonly kind: "sent";
+    readonly seq: number;
+    readonly message: WebSocketSend;
+} | {
+    readonly kind: "rejected";
+    readonly seq: number;
+    readonly message: WebSocketSend;
+    readonly error: unknown;
+} | {
+    readonly kind: "canceled";
+    readonly seq: number;
+    readonly message: WebSocketSend;
+    readonly reason: unknown;
+};
+/** Current graph-visible WebSocket session status projection. */
+interface WebSocketSessionStatus {
+    readonly state: "idle" | "connecting" | "open" | "closing" | "closed" | "waiting" | "exhausted" | "errored";
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly sent: number;
+    readonly received: number;
+    readonly errors: number;
+    readonly lastDelayMs?: number;
+}
+/** D133 SessionBundle: all session commands, inbound data, attempts, status, and errors are nodes. */
+interface WebSocketSessionBundle {
+    readonly command: Node<WebSocketSessionCommand>;
+    readonly inbound: Node<WebSocketSessionInbound>;
+    readonly lifecycle: Node<WebSocketSessionLifecycle>;
+    readonly outbound: Node<WebSocketSessionOutbound>;
+    readonly status: Node<WebSocketSessionStatus>;
+    readonly errors: Node<unknown>;
+    readonly attempts: Node<number>;
+    start(): void;
+    send(message: WebSocketSend | string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+type WebSocketSessionSendPolicy = {
+    readonly kind?: "reject";
+} | {
+    readonly kind: "buffer";
+    readonly maxPending: number;
+};
+/** Options for the D133 WebSocket SessionBundle; retry is bounded unless configured otherwise. */
+interface WebSocketSessionOptions {
+    readonly name?: string;
+    readonly retry?: RetryPolicy;
+    readonly sendPolicy?: WebSocketSessionSendPolicy;
+}
+/**
+ * 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;
+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.
+ *
+ * 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).
+ */
+/** 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.
+ *
+ * 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.
+ */
+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>;
+
+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 };