@graphrefly/graphrefly 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1517 @@
+import { N as Node, A as Actor, a as NodeOptions, b as NodeActions, c as NodeFn } from './meta-BsF6Sag9.cjs';
+export { C as COMPLETE, D as DATA, d as DEFAULT_ACTOR, e as DIRTY, f as DescribeNodeOutput, E as ERROR, G as GuardAction, g as GuardDenied, h as GuardDeniedDetails, H as HashFn, I as INVALIDATE, M as Message, i as Messages, j as NodeDescribeKind, k as NodeGuard, l as NodeSink, m as NodeStatus, n as NodeTransportOptions, o as NodeVersionInfo, O as OnMessageHandler, P as PAUSE, p as PolicyAllow, q as PolicyDeny, r as PolicyRuleData, R as RESOLVED, s as RESUME, S as SubscribeHints, T as TEARDOWN, V as V0, t as V1, u as VersioningLevel, v as VersioningOptions, w as accessHintForGuard, x as advanceVersion, y as createVersioning, z as defaultHash, B as describeNode, F as isKnownMessageType, J as isPhase2Message, K as isTerminalMessage, L as isV1, Q as knownMessageTypes, U as messageTier, W as metaSnapshot, X as node, Y as normalizeActor, Z as policy, _ as policyFromRules, $ as propagatesToMeta } from './meta-BsF6Sag9.cjs';
+import { i as index$a, c as cqrs } from './index-D_geH2Bm.cjs';
+import { Ref, WatchSource } from 'vue';
+import { G as Graph, a as GraphOptions, b as GraphAutoCheckpointHandle, A as AutoCheckpointAdapter, c as GraphAutoCheckpointOptions } from './graph-CL_ZDAj9.cjs';
+export { D as DescribeFilter, d as GRAPH_META_SEGMENT, e as GraphActorOptions, f as GraphCheckpointRecord, g as GraphDescribeOutput, h as GraphDiagramDirection, i as GraphDiagramOptions, j as GraphDiffChange, k as GraphDiffResult, l as GraphDumpOptions, m as GraphFactoryContext, n as GraphNodeFactory, o as GraphObserveAll, p as GraphObserveOne, q as GraphPersistSnapshot, r as GraphSpyHandle, s as GraphSpyOptions, t as GraphSpyTheme, u as GraphSpyThemeName, O as ObserveEvent, v as ObserveOptions, w as ObserveResult, R as ReachableDirection, x as ReachableOptions, T as TraceEntry, y as reachable } from './graph-CL_ZDAj9.cjs';
+export { D as DynGet, a as DynamicNodeFn, b as DynamicNodeImpl, c as DynamicNodeOptions, P as PipeOperator, d as batch, i as core, e as derived, f as dynamicNode, g as effect, h as emitWithBatch, j as isBatching, m as monotonicNs, p as partitionForBatch, k as pipe, l as producer, s as state, w as wallClockNs } from './index-C5mqLhMX.cjs';
+import { N as NodeInput, D as DistillBundle, E as Extraction, R as ReactiveListSnapshot, a as ReactiveMapSnapshot } from './index-B6SsZs2h.cjs';
+export { A as AdapterHandlers, b as AsyncSourceOpts, B as BackoffPreset, c as BackoffStrategy, d as BatchMessage, e as BridgeMessage, C as CSVRow, f as CheckpointAdapter, g as CircuitBreaker, h as CircuitBreakerOptions, i as CircuitOpenError, j as CircuitState, k as ClickHouseClientLike, l as ClickHouseRow, m as CronSchedule, n as DictCheckpointAdapter, o as DistillOptions, p as ErrorMessage, q as EventTargetLike, r as ExponentialBackoffOptions, F as FSEvent, s as FSEventType, t as FileCheckpointAdapter, u as FromCSVOptions, v as FromClickHouseWatchOptions, w as FromCronOptions, x as FromFSWatchOptions, y as FromGitHookOptions, z as FromHTTPOptions, G as FromKafkaOptions, H as FromMCPOptions, I as FromNDJSONOptions, J as FromOTelOptions, K as FromPrometheusOptions, L as FromRedisStreamOptions, M as FromStatsDOptions, O as FromSyslogOptions, P as GitEvent, Q as GitHookType, S as HTTPBundle, T as IndexRow, U as IndexedDbCheckpointSpec, V as InitMessage, W as JitterMode, X as KafkaConsumerLike, Y as KafkaMessage, Z as KafkaProducerLike, _ as MCPClientLike, $ as MemoryCheckpointAdapter, a0 as MergeMapOptions, a1 as NS_PER_MS, a2 as NS_PER_SEC, a3 as OTelBundle, a4 as OTelLog, a5 as OTelMetric, a6 as OTelRegister, a7 as OTelSpan, a8 as PrometheusMetric, a9 as PubSubHub, aa as ReactiveIndexBundle, ab as ReactiveIndexOptions, ac as ReactiveIndexSnapshot, ad as ReactiveListBundle, ae as ReactiveListOptions, af as ReactiveMapBundle, ag as ReactiveMapOptions, ah as ReadyMessage, ai as RedisClientLike, aj as RedisStreamEntry, ak as RetryOptions, al as SignalMessage, am as SinkTransportError, an as SqliteCheckpointAdapter, ao as StatsDMetric, ap as StatsDRegister, aq as StatusValue, ar as SyslogMessage, as as SyslogRegister, at as TapObserver, au as ThrottleOptions, av as ToKafkaOptions, aw as ToRedisStreamOptions, ax as ToSSEOptions, ay as ToWebSocketOptions, az as ToWebSocketTransportError, aA as TokenBucket, aB as ValueMessage, aC as VerifiableBundle, aD as VerifiableOptions, aE as VerifyValue, aF as WatermarkController, aG as WatermarkOptions, aH as WebSocketLike, aI as WebSocketMessageEventLike, aJ as WebSocketRegister, aK as WebhookRegister, aL as WithBreakerBundle, aM as WithStatusBundle, aN as WorkerBridge, aO as WorkerBridgeOptions, aP as WorkerSelfHandle, aQ as WorkerSelfOptions, aR as WorkerTransport, aS as audit, aT as buffer, aU as bufferCount, aV as bufferTime, aW as cached, aX as catchError, aY as checkpointNodeValue, aZ as circuitBreaker, a_ as combine, a$ as combineLatest, b0 as concat, b1 as concatMap, b2 as constant, b3 as createTransport, b4 as createWatermarkController, b5 as debounce, b6 as debounceTime, b7 as decorrelatedJitter, b8 as delay, b9 as deserializeError, ba as distill, bb as distinctUntilChanged, bc as elementAt, bd as empty, be as escapeRegexChar, bf as exhaustMap, bg as exponential, bh as extra, bi as fibonacci, bj as filter, bk as find, bl as first, bm as firstValueFrom, bn as flatMap, bo as forEach, bp as fromAny, bq as fromAsyncIter, br as fromCSV, bs as fromClickHouseWatch, bt as fromCron, bu as fromEvent, bv as fromFSWatch, bw as fromGitHook, bx as fromHTTP, by as fromIDBRequest, bz as fromIDBTransaction, bA as fromIter, bB as fromKafka, bC as fromMCP, bD as fromNDJSON, bE as fromOTel, bF as fromPrometheus, bG as fromPromise, bH as fromRedisStream, bI as fromStatsD, bJ as fromSyslog, bK as fromTimer, bL as fromWebSocket, bM as fromWebhook, bN as gate, bO as globToRegExp, bP as interval, bQ as last, bR as linear, bS as map, bT as matchesAnyPattern, bU as matchesCron, bV as merge, bW as mergeMap, bX as nameToSignal, bY as never, bZ as of, b_ as pairwise, b$ as parseCron, c0 as parsePrometheusText, c1 as parseStatsD, c2 as parseSyslog, c3 as pausable, c4 as pubsub, c5 as race, c6 as rateLimiter, c7 as reactiveIndex, c8 as reactiveList, c9 as reactiveMap, ca as reduce, cb as repeat, cc as replay, cd as rescue, ce as resolveBackoffPreset, cf as restoreGraphCheckpoint, cg as restoreGraphCheckpointIndexedDb, ch as retry, ci as sample, cj as saveGraphCheckpoint, ck as saveGraphCheckpointIndexedDb, cl as scan, cm as serializeError, cn as share, co as shareReplay, cp as signalToName, cq as skip, cr as startWith, cs as switchMap, ct as take, cu as takeUntil, cv as takeWhile, cw as tap, cx as throttle, cy as throttleTime, cz as throwError, cA as timeout, cB as toArray, cC as toKafka, cD as toRedisStream, cE as toSSE, cF as toWebSocket, cG as tokenBucket, cH as tokenTracker, cI as verifiable, cJ as window, cK as windowCount, cL as windowTime, cM as withBreaker, cN as withLatestFrom, cO as withMaxAttempts, cP as withStatus, cQ as workerBridge, cR as workerSelf, cS as zip } from './index-B6SsZs2h.cjs';
+export { D as DeltaCheckpoint, E as EvictedSubgraphInfo, a as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, W as WALEntry, c as createDagCborCodec, b as createDagCborZstdCodec, i as graph, n as negotiateCodec, r as replayWAL } from './index-BvhgZRHK.cjs';
+import { R as ReactiveLogSnapshot } from './reactive-log-BfvfNWQh.cjs';
+export { a as ReactiveLogBundle, b as ReactiveLogOptions, l as logSlice, o as observeGraph$, c as observeNode$, r as reactiveLog, t as toMessages$, d as toObservable } from './reactive-log-BfvfNWQh.cjs';
+import { i as index$b } from './index-C3BMRmmp.cjs';
+import '@nestjs/common';
+import '@nestjs/core';
+import 'rxjs';
+
+/**
+ * Options for creating an atom.
+ *
+ * @category compat
+ */
+interface AtomOptions {
+    /** Optional identifier for the underlying node. */
+    name?: string;
+    /** Optional companion meta nodes. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * A read-only Jotai-compatible atom.
+ *
+ * @category compat
+ */
+interface ReadableAtom<T> {
+    /** Returns the current cached value. */
+    get(): T;
+    /** Subscribes to value changes. Returns an unsubscribe function. */
+    subscribe(callback: (value: T) => void): () => void;
+    /** Access to companion meta nodes. */
+    readonly meta: Record<string, Node>;
+    /** @internal The underlying GraphReFly node. */
+    _node: Node<T>;
+}
+/**
+ * A writable Jotai-compatible atom.
+ *
+ * @category compat
+ */
+interface WritableAtom<T> extends ReadableAtom<T> {
+    /** Sets a new value. */
+    set(value: T): void;
+    /** Updates the value using a transformation function. */
+    update(fn: (current: T) => T): void;
+}
+/** Function type for reading other atoms inside a derived atom. */
+type GetFn = <V>(a: ReadableAtom<V>) => V;
+/** Function type for writing to other atoms inside a writable derived atom. */
+type SetFn = <V>(a: WritableAtom<V>, value: V) => void;
+/** Function that computes the atom's value. */
+type ReadFn<T> = (get: GetFn) => T;
+/** Function that handles writes to the atom. */
+type WriteFn<T> = (get: GetFn, set: SetFn, value: T) => void;
+/**
+ * Creates a Jotai-compatible atom built on GraphReFly primitives.
+ *
+ * Supports three overloads:
+ * 1. `atom(initial)` — Writable primitive atom (wraps `state()`).
+ * 2. `atom(read)` — Read-only derived atom (wraps `dynamicNode()`).
+ * 3. `atom(read, write)` — Writable derived atom.
+ *
+ * @param initialOrRead - Initial value or a read function.
+ * @param writeOrOptions - Write function or options object.
+ * @param options - Optional configuration.
+ * @returns WritableAtom or ReadableAtom.
+ *
+ * @example
+ * ```ts
+ * const count = atom(0);
+ * count.set(1);
+ * const doubled = atom((get) => get(count)! * 2);
+ * ```
+ *
+ * @category compat
+ */
+declare function atom$1<T>(initial: T, options?: AtomOptions): WritableAtom<T>;
+declare function atom$1<T>(read: ReadFn<T>, options?: AtomOptions): ReadableAtom<T>;
+declare function atom$1<T>(read: ReadFn<T>, write: WriteFn<T>, options?: AtomOptions): WritableAtom<T>;
+
+type index$9_AtomOptions = AtomOptions;
+type index$9_GetFn = GetFn;
+type index$9_ReadFn<T> = ReadFn<T>;
+type index$9_ReadableAtom<T> = ReadableAtom<T>;
+type index$9_SetFn = SetFn;
+type index$9_WritableAtom<T> = WritableAtom<T>;
+type index$9_WriteFn<T> = WriteFn<T>;
+declare namespace index$9 {
+  export { type index$9_AtomOptions as AtomOptions, type index$9_GetFn as GetFn, type index$9_ReadFn as ReadFn, type index$9_ReadableAtom as ReadableAtom, type index$9_SetFn as SetFn, type index$9_WritableAtom as WritableAtom, type index$9_WriteFn as WriteFn, atom$1 as atom };
+}
+
+/**
+ * A Nanostores-compatible atom.
+ *
+ * @category compat
+ */
+interface NanoAtom<T> {
+    /** Get current value. */
+    get(): T;
+    /** Set a new value (writable atoms only). */
+    set(value: T): void;
+    /** Subscribe to value changes. Callback receives the new value.
+     * Returns unsubscribe function. Called immediately with current value. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible computed store.
+ *
+ * @category compat
+ */
+interface NanoComputed<T> {
+    /** Get current value. */
+    get(): T;
+    /** Subscribe to value changes. Called immediately with current value.
+     * Returns unsubscribe function. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible map.
+ *
+ * @category compat
+ */
+interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
+    /** Set a single key. */
+    setKey<K extends keyof T>(key: K, value: T[K]): void;
+}
+/**
+ * Creates a nanostores-compatible atom.
+ *
+ * @param initial - Initial value.
+ * @returns `NanoAtom<T>`
+ *
+ * @category compat
+ */
+declare function atom<T>(initial: T): NanoAtom<T>;
+/**
+ * Creates a nanostores-compatible computed store.
+ *
+ * @param stores - One or more atoms/computed stores.
+ * @param fn - Compute function.
+ * @returns `NanoComputed<T>`
+ *
+ * @category compat
+ */
+declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
+declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
+declare function computed<T, A, B, C>(stores: [
+    NanoAtom<A> | NanoComputed<A>,
+    NanoAtom<B> | NanoComputed<B>,
+    NanoAtom<C> | NanoComputed<C>
+], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
+/**
+ * Creates a nanostores-compatible map.
+ *
+ * @param initial - Initial object value.
+ * @returns `NanoMap<T>`
+ *
+ * @category compat
+ */
+declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
+/**
+ * Returns the current value of the store.
+ *
+ * @category compat
+ */
+declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
+/**
+ * Adds a listener for the store start (first listener connected).
+ *
+ * @category compat
+ */
+declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store stop (last listener disconnected).
+ *
+ * @category compat
+ */
+declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store mount (first listener connected).
+ *
+ * @returns A cleanup function called when the last listener is removed.
+ * @category compat
+ */
+declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
+/**
+ * Batches multiple store updates.
+ *
+ * @category compat
+ */
+declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
+
+type index$8_NanoAtom<T> = NanoAtom<T>;
+type index$8_NanoComputed<T> = NanoComputed<T>;
+type index$8_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index$8_action: typeof action;
+declare const index$8_atom: typeof atom;
+declare const index$8_computed: typeof computed;
+declare const index$8_getValue: typeof getValue;
+declare const index$8_map: typeof map;
+declare const index$8_onMount: typeof onMount;
+declare const index$8_onStart: typeof onStart;
+declare const index$8_onStop: typeof onStop;
+declare namespace index$8 {
+  export { type index$8_NanoAtom as NanoAtom, type index$8_NanoComputed as NanoComputed, type index$8_NanoMap as NanoMap, index$8_action as action, index$8_atom as atom, index$8_computed as computed, index$8_getValue as getValue, index$8_map as map, index$8_onMount as onMount, index$8_onStart as onStart, index$8_onStop as onStop };
+}
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe$3<T>(node: Node<T>): T | undefined;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore$3<T>(node: Node<T>): [T | undefined, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory$3<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord$3<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$3<K, R>): Record<K, R>;
+
+declare namespace index$7 {
+  export { type NodeFactory$3 as NodeFactory, useStore$3 as useStore, useSubscribe$3 as useSubscribe, useSubscribeRecord$3 as useSubscribeRecord };
+}
+
+/**
+ * Options for creating signals.
+ *
+ * @category compat
+ */
+interface SignalOptions {
+    /** Optional identifier for the underlying node. */
+    name?: string;
+    /** Custom equality function for change detection. */
+    equals?: (a: any, b: any) => boolean;
+}
+/**
+ * Common interface for all reactive signals.
+ *
+ * @category compat
+ */
+interface AnySignal<T> {
+    /** Returns the current value of the signal. */
+    get(): T;
+    /** @internal The underlying GraphReFly node. */
+    _node: Node<T>;
+}
+/**
+ * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
+ * Automatically registers itself as a dependency if read inside a `Computed`.
+ *
+ * @example
+ * ```ts
+ * const count = new Signal.State(0);
+ * count.get(); // 0
+ * count.set(1);
+ * count.get(); // 1
+ * ```
+ */
+declare class SignalState<T> implements AnySignal<T> {
+    /** @internal */
+    _node: Node<T>;
+    private readonly _equals;
+    constructor(initial: T, opts?: SignalOptions);
+    get(): T;
+    set(value: T): void;
+}
+/**
+ * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
+ * Automatically tracks dependencies when `get()` is called on other signals
+ * during its computation.
+ *
+ * @example
+ * ```ts
+ * const count = new Signal.State(0);
+ * const doubled = new Signal.Computed(() => count.get() * 2);
+ * ```
+ */
+declare class SignalComputed<T> implements AnySignal<T> {
+    /** @internal */
+    _node: Node<T>;
+    constructor(computation: () => T, opts?: SignalOptions);
+    get(): T;
+}
+/**
+ * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
+ * Provides auto-tracking conforming to the TS39 signals proposal.
+ *
+ * @category compat
+ */
+declare const Signal: {
+    readonly State: typeof SignalState;
+    readonly Computed: typeof SignalComputed;
+    /**
+     * Subscribes to changes on a signal.
+     * Returns an unsubscribe callback.
+     *
+     * @example
+     * ```ts
+     * const count = new Signal.State(0);
+     * const unsub = Signal.sub(count, v => console.log(v));
+     * ```
+     */
+    readonly sub: <T>(signal: AnySignal<T>, callback: ((value: T) => void) | {
+        data?: (value: T) => void;
+        error?: (err: unknown) => void;
+        complete?: () => void;
+    }) => (() => void);
+};
+
+type index$6_AnySignal<T> = AnySignal<T>;
+declare const index$6_Signal: typeof Signal;
+type index$6_SignalComputed<T> = SignalComputed<T>;
+declare const index$6_SignalComputed: typeof SignalComputed;
+type index$6_SignalOptions = SignalOptions;
+type index$6_SignalState<T> = SignalState<T>;
+declare const index$6_SignalState: typeof SignalState;
+declare namespace index$6 {
+  export { type index$6_AnySignal as AnySignal, index$6_Signal as Signal, index$6_SignalComputed as SignalComputed, type index$6_SignalOptions as SignalOptions, index$6_SignalState as SignalState };
+}
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe$2<T>(node: Node<T>): Accessor<T | undefined>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore$2<T>(node: Node<T>): [Accessor<T | undefined>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory$2<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord$2<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$2<K, R>): Accessor<Record<K, R>>;
+
+type index$5_Accessor<T> = Accessor<T>;
+declare namespace index$5 {
+  export { type index$5_Accessor as Accessor, type NodeFactory$2 as NodeFactory, useStore$2 as useStore, useSubscribe$2 as useSubscribe, useSubscribeRecord$2 as useSubscribeRecord };
+}
+
+/** Svelte store contract — implements the minimal `subscribe` method. */
+interface SvelteReadable<T> {
+    subscribe(run: (value: T) => void): () => void;
+}
+/** Svelte writable store contract. */
+interface SvelteWritable<T> extends SvelteReadable<T> {
+    set(value: T): void;
+    update(updater: (value: T) => T): void;
+}
+/**
+ * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useSubscribe$1<T>(node: Node<T>): SvelteReadable<T | undefined>;
+/**
+ * Bind a writable `Node<T>` as a Svelte writable store.
+ * Reads and writes adapt seamlessly.
+ * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useStore$1<T>(node: Node<T>): SvelteWritable<T | undefined>;
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory$1<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord$1<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$1<K, R>): SvelteReadable<Record<K, R>>;
+
+type index$4_SvelteReadable<T> = SvelteReadable<T>;
+type index$4_SvelteWritable<T> = SvelteWritable<T>;
+declare namespace index$4 {
+  export { type NodeFactory$1 as NodeFactory, type index$4_SvelteReadable as SvelteReadable, type index$4_SvelteWritable as SvelteWritable, useStore$1 as useStore, useSubscribe$1 as useSubscribe, useSubscribeRecord$1 as useSubscribeRecord };
+}
+
+/**
+ * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.
+ * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Readonly<Ref<T | undefined>>;
+/**
+ * Bind a writable `Node<T>` as a Vue `Ref<T>`. Reads and writes are bidirectional.
+ * Value sets always dispatch `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): Ref<T | undefined>;
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord` factory. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records. When keys change,
+ * old subscriptions are torn down and new ones created automatically.
+ * Must be called during Vue `setup()`.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keys: WatchSource<K[] | undefined>, factory: NodeFactory<K, R>): Readonly<Ref<Record<K, R>>>;
+
+type index$3_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index$3_useStore: typeof useStore;
+declare const index$3_useSubscribe: typeof useSubscribe;
+declare const index$3_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index$3 {
+  export { type index$3_NodeFactory as NodeFactory, index$3_useStore as useStore, index$3_useSubscribe as useSubscribe, index$3_useSubscribeRecord as useSubscribeRecord };
+}
+
+/** Zustand-compatible Store API. */
+interface StoreApi<T> {
+    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;
+}
+/** Function type for initializing the store. */
+type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
+/**
+ * Creates a Zustand-compatible store backed by a GraphReFly state node.
+ * returns an object that is both a Graph and a StoreApi.
+ *
+ * @example
+ * ```ts
+ * const store = create((set) => ({
+ *   count: 0,
+ *   inc: () => set((s) => ({ count: s.count + 1 }))
+ * }));
+ * store.getState().inc();
+ * ```
+ *
+ * @category compat
+ */
+declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
+
+type index$2_StateCreator<T> = StateCreator<T>;
+type index$2_StoreApi<T> = StoreApi<T>;
+declare const index$2_create: typeof create;
+declare namespace index$2 {
+  export { type index$2_StateCreator as StateCreator, type index$2_StoreApi as StoreApi, index$2_create as create };
+}
+
+/**
+ * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
+ *
+ * Framework adapters are optional peers. Install only what you use:
+ * - `@graphrefly/graphrefly-ts/compat/react` -> `react`, `react-dom`
+ * - `@graphrefly/graphrefly-ts/compat/vue` -> `vue`
+ * - `@graphrefly/graphrefly-ts/compat/svelte` -> `svelte`
+ * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
+ */
+
+declare namespace index$1 {
+  export { index$9 as jotai, index$8 as nanostores, index$a as nestjs, index$7 as react, index$6 as signals, index$5 as solid, index$4 as svelte, index$3 as vue, index$2 as zustand };
+}
+
+/**
+ * Memory patterns (roadmap §4.3).
+ *
+ * Domain-layer helpers composed from GraphRefly primitives. `vectorIndex` uses
+ * an exact-search backend by default; an HNSW adapter can be injected as an
+ * optional dependency.
+ */
+
+type CollectionPolicy = "fifo" | "lru";
+type VectorBackend = "flat" | "hnsw";
+type LightCollectionEntry<T> = {
+    readonly id: string;
+    readonly value: T;
+    readonly createdAtNs: number;
+    readonly lastAccessNs: number;
+};
+type LightCollectionOptions = {
+    name?: string;
+    maxSize?: number;
+    policy?: CollectionPolicy;
+};
+type LightCollectionBundle<T> = {
+    readonly entries: Node<ReadonlyMap<string, LightCollectionEntry<T>>>;
+    upsert: (id: string, value: T) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    get: (id: string) => T | undefined;
+    has: (id: string) => boolean;
+};
+type CollectionEntry<T> = LightCollectionEntry<T> & {
+    readonly baseScore: number;
+};
+type RankedCollectionEntry<T> = CollectionEntry<T> & {
+    readonly score: number;
+};
+type CollectionOptions<T> = {
+    maxSize?: number;
+    policy?: CollectionPolicy;
+    /**
+     * Produces a base score at insert/update time.
+     */
+    score?: (value: T) => number;
+    /**
+     * Exponential decay rate per second. 0 disables decay.
+     */
+    decayRate?: number;
+    /**
+     * Minimum score floor after decay.
+     */
+    minScore?: number;
+};
+type CollectionGraph<T> = Graph & {
+    upsert: (id: string, value: T, opts?: {
+        score?: number;
+    }) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    getItem: (id: string) => CollectionEntry<T> | undefined;
+};
+type VectorRecord<TMeta> = {
+    readonly id: string;
+    readonly vector: readonly number[];
+    readonly meta?: TMeta;
+};
+type VectorSearchResult<TMeta> = {
+    readonly id: string;
+    readonly score: number;
+    readonly meta?: TMeta;
+};
+type HnswAdapter<TMeta> = {
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type VectorIndexOptions<TMeta> = {
+    backend?: VectorBackend;
+    dimension?: number;
+    /**
+     * Optional dependency seam for HNSW.
+     */
+    hnswFactory?: () => HnswAdapter<TMeta>;
+};
+type VectorIndexBundle<TMeta> = {
+    readonly backend: VectorBackend;
+    readonly entries: Node<ReadonlyMap<string, VectorRecord<TMeta>>>;
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k?: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type KnowledgeEdge<TRelation extends string = string> = {
+    readonly from: string;
+    readonly to: string;
+    readonly relation: TRelation;
+    readonly weight: number;
+};
+type KnowledgeGraphGraph<TEntity, TRelation extends string = string> = Graph & {
+    upsertEntity: (id: string, value: TEntity) => void;
+    removeEntity: (id: string) => void;
+    link: (from: string, to: string, relation: TRelation, weight?: number) => void;
+    unlink: (from: string, to: string, relation?: TRelation) => void;
+    related: (id: string, relation?: TRelation) => ReadonlyArray<KnowledgeEdge<TRelation>>;
+};
+declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: number, minScore?: number): number;
+declare function lightCollection<T>(opts?: LightCollectionOptions): LightCollectionBundle<T>;
+declare function collection<T>(name: string, opts?: CollectionOptions<T>): CollectionGraph<T>;
+declare function vectorIndex<TMeta>(opts?: VectorIndexOptions<TMeta>): VectorIndexBundle<TMeta>;
+declare function knowledgeGraph<TEntity, TRelation extends string = string>(name: string): KnowledgeGraphGraph<TEntity, TRelation>;
+
+type memory_CollectionEntry<T> = CollectionEntry<T>;
+type memory_CollectionGraph<T> = CollectionGraph<T>;
+type memory_CollectionOptions<T> = CollectionOptions<T>;
+type memory_CollectionPolicy = CollectionPolicy;
+type memory_HnswAdapter<TMeta> = HnswAdapter<TMeta>;
+type memory_KnowledgeEdge<TRelation extends string = string> = KnowledgeEdge<TRelation>;
+type memory_KnowledgeGraphGraph<TEntity, TRelation extends string = string> = KnowledgeGraphGraph<TEntity, TRelation>;
+type memory_LightCollectionBundle<T> = LightCollectionBundle<T>;
+type memory_LightCollectionEntry<T> = LightCollectionEntry<T>;
+type memory_LightCollectionOptions = LightCollectionOptions;
+type memory_RankedCollectionEntry<T> = RankedCollectionEntry<T>;
+type memory_VectorBackend = VectorBackend;
+type memory_VectorIndexBundle<TMeta> = VectorIndexBundle<TMeta>;
+type memory_VectorIndexOptions<TMeta> = VectorIndexOptions<TMeta>;
+type memory_VectorRecord<TMeta> = VectorRecord<TMeta>;
+type memory_VectorSearchResult<TMeta> = VectorSearchResult<TMeta>;
+declare const memory_collection: typeof collection;
+declare const memory_decay: typeof decay;
+declare const memory_knowledgeGraph: typeof knowledgeGraph;
+declare const memory_lightCollection: typeof lightCollection;
+declare const memory_vectorIndex: typeof vectorIndex;
+declare namespace memory {
+  export { type memory_CollectionEntry as CollectionEntry, type memory_CollectionGraph as CollectionGraph, type memory_CollectionOptions as CollectionOptions, type memory_CollectionPolicy as CollectionPolicy, type memory_HnswAdapter as HnswAdapter, type memory_KnowledgeEdge as KnowledgeEdge, type memory_KnowledgeGraphGraph as KnowledgeGraphGraph, type memory_LightCollectionBundle as LightCollectionBundle, type memory_LightCollectionEntry as LightCollectionEntry, type memory_LightCollectionOptions as LightCollectionOptions, type memory_RankedCollectionEntry as RankedCollectionEntry, type memory_VectorBackend as VectorBackend, type memory_VectorIndexBundle as VectorIndexBundle, type memory_VectorIndexOptions as VectorIndexOptions, type memory_VectorRecord as VectorRecord, type memory_VectorSearchResult as VectorSearchResult, memory_collection as collection, memory_decay as decay, memory_knowledgeGraph as knowledgeGraph, memory_lightCollection as lightCollection, memory_vectorIndex as vectorIndex };
+}
+
+/**
+ * AI surface patterns (roadmap §4.4).
+ *
+ * Domain-layer factories for LLM-backed agents, chat, tool registries, and
+ * agentic memory. Composed from core + extra + Phase 3–4.3 primitives.
+ */
+
+/** A single chat message in a conversation. */
+type ChatMessage = {
+    readonly role: "system" | "user" | "assistant" | "tool";
+    readonly content: string;
+    readonly name?: string;
+    readonly toolCallId?: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly metadata?: Record<string, unknown>;
+};
+/** A tool invocation request from an LLM. */
+type ToolCall = {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+};
+/** The response from an LLM invocation. */
+type LLMResponse = {
+    readonly content: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly usage?: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+    };
+    readonly finishReason?: string;
+    readonly metadata?: Record<string, unknown>;
+};
+/** Provider-agnostic LLM client adapter protocol. */
+type LLMAdapter = {
+    invoke(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): NodeInput<LLMResponse>;
+    stream(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): AsyncIterable<string>;
+};
+type LLMInvokeOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: readonly ToolDefinition[];
+    systemPrompt?: string;
+    signal?: AbortSignal;
+};
+/** A tool definition for LLM consumption. */
+type ToolDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly handler: (args: Record<string, unknown>) => NodeInput<unknown>;
+    /**
+     * V0 version of the backing node at `knobsAsTools()` call time (§6.0b).
+     * Snapshot — re-call `knobsAsTools()` to refresh.
+     */
+    readonly version?: {
+        id: string;
+        version: number;
+    };
+};
+type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
+type FromLLMOptions = {
+    name?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: readonly ToolDefinition[];
+    systemPrompt?: string;
+};
+/**
+ * Reactive LLM invocation adapter. Returns a derived node that re-invokes
+ * the LLM whenever the messages dep changes.
+ *
+ * Uses `switchMap` internally — new invocations cancel stale in-flight ones.
+ */
+declare function fromLLM(adapter: LLMAdapter, messages: NodeInput<readonly ChatMessage[]>, opts?: FromLLMOptions): Node<LLMResponse | null>;
+type FromLLMStreamOptions = FromLLMOptions;
+/**
+ * Bundle returned by {@link fromLLMStream}. `node` is the reactive log of
+ * token chunks; `dispose` tears down the internal effect and log.
+ */
+type LLMStreamHandle = {
+    /** Reactive log node accumulating token chunks. */
+    node: Node<ReactiveLogSnapshot<string>>;
+    /** Tear down the internal effect, abort any in-flight stream, and release resources. */
+    dispose: () => void;
+};
+/**
+ * Streaming LLM invocation. Returns a `{ node, dispose }` bundle where
+ * `node` is a `reactiveLog`-backed node that accumulates token chunks as
+ * they arrive from `adapter.stream()`.
+ *
+ * An `effect` watches the messages input; new values abort the in-flight
+ * stream and clear the log before starting a new one. Call `dispose()` to
+ * tear down the effect and release resources.
+ */
+declare function fromLLMStream(adapter: LLMAdapter, messages: NodeInput<readonly ChatMessage[]>, opts?: FromLLMStreamOptions): LLMStreamHandle;
+type ChatStreamOptions = {
+    graph?: GraphOptions;
+    maxMessages?: number;
+};
+declare class ChatStreamGraph extends Graph {
+    private readonly _log;
+    private readonly _keepaliveSubs;
+    readonly messages: Node<ReactiveLogSnapshot<ChatMessage>>;
+    readonly latest: Node<ChatMessage | undefined>;
+    readonly messageCount: Node<number>;
+    constructor(name: string, opts?: ChatStreamOptions);
+    append(role: ChatMessage["role"], content: string, extra?: Partial<ChatMessage>): void;
+    appendToolResult(callId: string, content: string): void;
+    clear(): void;
+    allMessages(): readonly ChatMessage[];
+    destroy(): void;
+}
+declare function chatStream(name: string, opts?: ChatStreamOptions): ChatStreamGraph;
+type ToolRegistryOptions = {
+    graph?: GraphOptions;
+};
+declare class ToolRegistryGraph extends Graph {
+    readonly definitions: Node<ReadonlyMap<string, ToolDefinition>>;
+    readonly schemas: Node<readonly ToolDefinition[]>;
+    private readonly _keepaliveSubs;
+    constructor(name: string, opts?: ToolRegistryOptions);
+    register(tool: ToolDefinition): void;
+    unregister(name: string): void;
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
+    getDefinition(name: string): ToolDefinition | undefined;
+    destroy(): void;
+}
+declare function toolRegistry(name: string, opts?: ToolRegistryOptions): ToolRegistryGraph;
+/**
+ * Assembles a system prompt from reactive sections. Each section is a
+ * `NodeInput<string>` — the prompt updates when any section changes.
+ */
+type SystemPromptHandle = Node<string> & {
+    dispose: () => void;
+};
+declare function systemPromptBuilder(sections: readonly NodeInput<string>[], opts?: {
+    separator?: string;
+    name?: string;
+}): SystemPromptHandle;
+type LLMExtractorOptions = {
+    adapter: LLMAdapter;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+};
+/**
+ * Returns an `extractFn` callback for `distill()` that invokes an LLM to
+ * extract structured memories from raw input.
+ *
+ * The system prompt should instruct the LLM to return JSON matching
+ * `Extraction<TMem>` shape: `{ upsert: [{ key, value }], remove?: [key] }`.
+ */
+declare function llmExtractor<TRaw, TMem>(systemPrompt: string, opts: LLMExtractorOptions): (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+type LLMConsolidatorOptions = LLMExtractorOptions;
+/**
+ * Returns a `consolidateFn` callback for `distill()` that invokes an LLM to
+ * cluster and merge related memories.
+ */
+declare function llmConsolidator<TMem>(systemPrompt: string, opts: LLMConsolidatorOptions): (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+/** Scores for the three admission dimensions. Each 0–1. */
+type AdmissionScores = {
+    readonly persistence: number;
+    readonly structure: number;
+    readonly personalValue: number;
+};
+type AdmissionScore3DOptions = {
+    /** Custom scoring function. Default: rule-based (all dimensions 0.5). */
+    scoreFn?: (raw: unknown) => AdmissionScores;
+    /** Minimum persistence score to admit (default 0.3). */
+    persistenceThreshold?: number;
+    /** Minimum personalValue score to admit (default 0.3). */
+    personalValueThreshold?: number;
+    /** Require structure score > 0 to admit (default false). */
+    requireStructured?: boolean;
+};
+/**
+ * Creates a 3D admission filter function compatible with `agentMemory`'s
+ * `admissionFilter` option. Scores each candidate on persistence, structure,
+ * and personalValue, then applies thresholds.
+ */
+declare function admissionFilter3D(opts?: AdmissionScore3DOptions): (raw: unknown) => boolean;
+type MemoryTier = "permanent" | "active" | "archived";
+type MemoryTiersOptions<TMem> = {
+    /** Exponential decay rate per second for active tier.
+     *  Default: 7-day half-life ≈ ln(2)/(7×86400) ≈ 0.00000114. */
+    decayRate?: number;
+    /** Max entries in the active tier before archiving lowest-scored (default 1000). */
+    maxActive?: number;
+    /** Score threshold below which active entries get archived (default 0.1). */
+    archiveThreshold?: number;
+    /** Predicate: true → entry belongs in permanent tier (default: never). */
+    permanentFilter?: (key: string, mem: TMem) => boolean;
+    /** Persistence adapter for the archive tier. Omit to disable archiving. */
+    archiveAdapter?: AutoCheckpointAdapter;
+    /** Auto-checkpoint options for archive adapter. */
+    archiveCheckpointOptions?: GraphAutoCheckpointOptions;
+};
+type MemoryTiersBundle<TMem> = {
+    /** Permanent tier: never evicted. */
+    readonly permanent: LightCollectionBundle<TMem>;
+    /** Active entries node (reactive, holds ReactiveMapSnapshot). */
+    readonly activeEntries: Node<unknown>;
+    /** Archive checkpoint handle (null if no adapter). */
+    readonly archiveHandle: GraphAutoCheckpointHandle | null;
+    /** Classify a key into its current tier. */
+    tierOf: (key: string) => MemoryTier;
+    /** Move a key to the permanent tier. */
+    markPermanent: (key: string, value: TMem) => void;
+};
+type RetrievalQuery = {
+    readonly text?: string;
+    readonly vector?: readonly number[];
+    readonly entityIds?: readonly string[];
+};
+type RetrievalPipelineOptions<TMem> = {
+    /** Max candidates from vector search (default 20). */
+    topK?: number;
+    /** KG expansion depth in hops (default 1). */
+    graphDepth?: number;
+    /** Token budget for final packing (default 2000). */
+    budget?: number;
+    /** Cost function for budget packing. */
+    cost: (mem: TMem) => number;
+    /** Score function for ranking. */
+    score: (mem: TMem, context: unknown) => number;
+};
+/** A single entry in the retrieval result, with causal trace metadata. */
+type RetrievalEntry<TMem> = {
+    readonly key: string;
+    readonly value: TMem;
+    readonly score: number;
+    readonly sources: ReadonlyArray<"vector" | "graph" | "store">;
+};
+/** Causal trace for a retrieval run. */
+type RetrievalTrace<TMem> = {
+    readonly vectorCandidates: ReadonlyArray<VectorSearchResult<TMem>>;
+    readonly graphExpanded: ReadonlyArray<string>;
+    readonly ranked: ReadonlyArray<RetrievalEntry<TMem>>;
+    readonly packed: ReadonlyArray<RetrievalEntry<TMem>>;
+};
+type AgentMemoryOptions<TMem = unknown> = {
+    graph?: GraphOptions;
+    /** LLM adapter for extraction and consolidation. */
+    adapter?: LLMAdapter;
+    /** System prompt for the extractor LLM. */
+    extractPrompt?: string;
+    /** Custom extractFn (overrides adapter + extractPrompt). */
+    extractFn?: (raw: unknown, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+    /** System prompt for the consolidation LLM. */
+    consolidatePrompt?: string;
+    /** Custom consolidateFn (overrides adapter + consolidatePrompt). */
+    consolidateFn?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+    /** Reactive trigger for consolidation (caller supplies e.g. `fromTimer`). */
+    consolidateTrigger?: NodeInput<unknown>;
+    /** Score function for budget packing (required). */
+    score: (mem: TMem, context: unknown) => number;
+    /** Cost function for budget packing (required). */
+    cost: (mem: TMem) => number;
+    /** Token budget for compact view (default 2000). */
+    budget?: number;
+    /** Context node for scoring. */
+    context?: NodeInput<unknown>;
+    /** Admission filter (default: admit all). */
+    admissionFilter?: (candidate: unknown) => boolean;
+    /** Vector index dimensions (> 0 enables vector index for retrieval). */
+    vectorDimensions?: number;
+    /** Extract embedding vector from a memory entry (enables vector index). */
+    embedFn?: (mem: TMem) => readonly number[] | undefined;
+    /** Enable knowledge graph for entity/relation tracking. */
+    enableKnowledgeGraph?: boolean;
+    /** Extract entities and relations from a memory entry. */
+    entityFn?: (key: string, mem: TMem) => {
+        entities?: Array<{
+            id: string;
+            value: unknown;
+        }>;
+        relations?: Array<{
+            from: string;
+            to: string;
+            relation: string;
+            weight?: number;
+        }>;
+    } | undefined;
+    /** 3-tier storage configuration. Omit to use single-tier (existing behavior). */
+    tiers?: MemoryTiersOptions<TMem>;
+    /** Retrieval pipeline configuration. Requires vector index or knowledge graph. */
+    retrieval?: {
+        /** Max candidates from vector search (default 20). */
+        topK?: number;
+        /** KG expansion depth in hops (default 1). */
+        graphDepth?: number;
+    };
+    /** Periodic reflection/consolidation configuration. */
+    reflection?: {
+        /** Interval in ms between consolidation runs (default 300_000 = 5 min). */
+        interval?: number;
+        /** Enable/disable periodic reflection (default true when consolidateFn is available). */
+        enabled?: boolean;
+    };
+};
+type AgentMemoryGraph<TMem = unknown> = Graph & {
+    readonly distillBundle: DistillBundle<TMem>;
+    readonly compact: Node<Array<{
+        key: string;
+        value: TMem;
+        score: number;
+    }>>;
+    readonly size: Node<number>;
+    /** Vector index bundle (null if not enabled). */
+    readonly vectors: VectorIndexBundle<TMem> | null;
+    /** Knowledge graph (null if not enabled). */
+    readonly kg: KnowledgeGraphGraph<unknown, string> | null;
+    /** Memory tiers bundle (null if not configured). */
+    readonly memoryTiers: MemoryTiersBundle<TMem> | null;
+    /** Retrieval result node (null if no retrieval pipeline configured). */
+    readonly retrieval: Node<ReadonlyArray<RetrievalEntry<TMem>>> | null;
+    /** Latest retrieval trace for observability (null if no retrieval pipeline). */
+    readonly retrievalTrace: Node<RetrievalTrace<TMem> | null> | null;
+    /** Execute a retrieval query (null if no retrieval pipeline). */
+    readonly retrieve: ((query: RetrievalQuery) => ReadonlyArray<RetrievalEntry<TMem>>) | null;
+};
+declare function agentMemory<TMem = unknown>(name: string, source: NodeInput<unknown>, opts: AgentMemoryOptions<TMem>): AgentMemoryGraph<TMem>;
+type AgentLoopOptions = {
+    graph?: GraphOptions;
+    adapter: LLMAdapter;
+    tools?: readonly ToolDefinition[];
+    systemPrompt?: string;
+    maxTurns?: number;
+    stopWhen?: (response: LLMResponse) => boolean;
+    onToolCall?: (call: ToolCall) => void;
+    maxMessages?: number;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+};
+declare class AgentLoopGraph extends Graph {
+    readonly chat: ChatStreamGraph;
+    readonly tools: ToolRegistryGraph;
+    readonly status: Node<AgentLoopStatus>;
+    readonly turnCount: Node<number>;
+    readonly lastResponse: Node<LLMResponse | null>;
+    private readonly _statusState;
+    private readonly _turnCountState;
+    private readonly _adapter;
+    private readonly _maxTurns;
+    private readonly _stopWhen?;
+    private readonly _onToolCall?;
+    private readonly _systemPrompt?;
+    private readonly _model?;
+    private readonly _temperature?;
+    private readonly _maxTokens?;
+    private _running;
+    private _abortController;
+    constructor(name: string, opts: AgentLoopOptions);
+    /**
+     * Start the agent loop with a user message. The loop runs reactively:
+     * think (LLM call) → act (tool execution) → repeat until done.
+     *
+     * Messages accumulate across calls. Call `chat.clear()` before `run()`
+     * to reset conversation history.
+     */
+    run(userMessage: string): Promise<LLMResponse | null>;
+    private _invokeLLM;
+    private _shouldStop;
+    destroy(): void;
+}
+declare function agentLoop(name: string, opts: AgentLoopOptions): AgentLoopGraph;
+/** OpenAI function-calling tool schema. */
+type OpenAIToolSchema = {
+    readonly type: "function";
+    readonly function: {
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: Record<string, unknown>;
+    };
+};
+/** MCP (Model Context Protocol) tool schema. */
+type McpToolSchema = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+};
+/** Result of {@link knobsAsTools}. */
+type KnobsAsToolsResult = {
+    /** OpenAI function-calling tool schemas. */
+    readonly openai: readonly OpenAIToolSchema[];
+    /** MCP tool schemas. */
+    readonly mcp: readonly McpToolSchema[];
+    /** GraphReFly ToolDefinitions with handlers that call `graph.set()`. */
+    readonly definitions: readonly ToolDefinition[];
+};
+/**
+ * Derive tool schemas from a graph's writable (knob) nodes.
+ *
+ * Knobs are state nodes whose `meta.access` is `"llm"`, `"both"`, or absent
+ * (default: writable). Each knob becomes a tool that calls `graph.set()`.
+ *
+ * Speaks **domain language** (spec §5.4): the returned schemas use node names
+ * and meta descriptions — no protocol internals exposed.
+ *
+ * @param graph - The graph to introspect.
+ * @param actor - Optional actor for guard-scoped describe.
+ * @returns OpenAI, MCP, and GraphReFly tool schemas.
+ */
+declare function knobsAsTools(graph: Graph, actor?: Actor): KnobsAsToolsResult;
+type GaugesAsContextOptions = {
+    /** Group gauges by `meta.tags` (default true). */
+    groupByTags?: boolean;
+    /** Separator between gauge lines (default "\n"). */
+    separator?: string;
+    /**
+     * V0 delta mode (§6.0b): only include nodes whose `v.version` exceeds
+     * the corresponding entry in this map. Nodes without V0 or not in the
+     * map are always included. Callers maintain this map across calls.
+     *
+     * The `id` field guards against node replacement: if a node is removed
+     * and re-added under the same name (new id), it is always included.
+     */
+    sinceVersion?: ReadonlyMap<string, {
+        id: string;
+        version: number;
+    }>;
+};
+/**
+ * Format a graph's readable (gauge) nodes as a context string for LLM
+ * system prompts.
+ *
+ * Gauges are nodes with `meta.description` or `meta.format`. Values are
+ * formatted using `meta.format` and `meta.unit` hints.
+ *
+ * @param graph - The graph to introspect.
+ * @param actor - Optional actor for guard-scoped describe.
+ * @param options - Formatting options.
+ * @returns A formatted string ready for system prompt injection.
+ */
+declare function gaugesAsContext(graph: Graph, actor?: Actor, options?: GaugesAsContextOptions): string;
+/** Validation result from {@link validateGraphDef}. */
+type GraphDefValidation = {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+};
+/**
+ * Validate an LLM-generated graph definition before passing to
+ * `Graph.fromSnapshot()`.
+ *
+ * Checks:
+ * - Required fields: `name`, `nodes`, `edges`
+ * - Node types are valid enum values
+ * - Edge `from`/`to` reference existing nodes
+ * - No duplicate edge entries
+ *
+ * @param def - The graph definition to validate (parsed JSON).
+ * @returns Validation result with errors array.
+ */
+declare function validateGraphDef(def: unknown): GraphDefValidation;
+type GraphFromSpecOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Callback to construct topology before values are applied (passed to `Graph.fromSnapshot`). */
+    build?: (g: Graph) => void;
+    /** Extra instructions appended to the system prompt. */
+    systemPromptExtra?: string;
+};
+/**
+ * Ask an LLM to compose a Graph from a natural-language description.
+ *
+ * The LLM returns a JSON graph definition which is validated and then
+ * constructed via `Graph.fromSnapshot()`.
+ *
+ * @param naturalLanguage - The problem/use-case description.
+ * @param adapter - LLM adapter for the generation call.
+ * @param opts - Model options and optional `build` callback for node factories.
+ * @returns A constructed Graph.
+ * @throws On invalid LLM output or validation failure.
+ */
+declare function graphFromSpec(naturalLanguage: string, adapter: LLMAdapter, opts?: GraphFromSpecOptions): Promise<Graph>;
+/** A single operation in a strategy plan. */
+type StrategyOperation = {
+    readonly type: "add_node";
+    readonly name: string;
+    readonly nodeType: string;
+    readonly meta?: Record<string, unknown>;
+    readonly initial?: unknown;
+} | {
+    readonly type: "remove_node";
+    readonly name: string;
+} | {
+    readonly type: "connect";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "disconnect";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "set_value";
+    readonly name: string;
+    readonly value: unknown;
+} | {
+    readonly type: "update_meta";
+    readonly name: string;
+    readonly key: string;
+    readonly value: unknown;
+};
+/** Structured strategy plan returned by {@link suggestStrategy}. */
+type StrategyPlan = {
+    readonly summary: string;
+    readonly operations: readonly StrategyOperation[];
+    readonly reasoning: string;
+};
+type SuggestStrategyOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    actor?: Actor;
+};
+/**
+ * Ask an LLM to analyze a graph and suggest topology/parameter changes
+ * to solve a stated problem.
+ *
+ * Returns a structured plan — does NOT auto-apply. The caller reviews
+ * and selectively applies operations.
+ *
+ * @param graph - The graph to analyze.
+ * @param problem - Natural-language problem statement.
+ * @param adapter - LLM adapter for the analysis call.
+ * @param opts - Model and actor options.
+ * @returns A structured strategy plan.
+ * @throws On invalid LLM output.
+ */
+declare function suggestStrategy(graph: Graph, problem: string, adapter: LLMAdapter, opts?: SuggestStrategyOptions): Promise<StrategyPlan>;
+
+type ai_AdmissionScore3DOptions = AdmissionScore3DOptions;
+type ai_AdmissionScores = AdmissionScores;
+type ai_AgentLoopGraph = AgentLoopGraph;
+declare const ai_AgentLoopGraph: typeof AgentLoopGraph;
+type ai_AgentLoopOptions = AgentLoopOptions;
+type ai_AgentLoopStatus = AgentLoopStatus;
+type ai_AgentMemoryGraph<TMem = unknown> = AgentMemoryGraph<TMem>;
+type ai_AgentMemoryOptions<TMem = unknown> = AgentMemoryOptions<TMem>;
+type ai_ChatMessage = ChatMessage;
+type ai_ChatStreamGraph = ChatStreamGraph;
+declare const ai_ChatStreamGraph: typeof ChatStreamGraph;
+type ai_ChatStreamOptions = ChatStreamOptions;
+type ai_FromLLMOptions = FromLLMOptions;
+type ai_FromLLMStreamOptions = FromLLMStreamOptions;
+type ai_GaugesAsContextOptions = GaugesAsContextOptions;
+type ai_GraphDefValidation = GraphDefValidation;
+type ai_GraphFromSpecOptions = GraphFromSpecOptions;
+type ai_KnobsAsToolsResult = KnobsAsToolsResult;
+type ai_LLMAdapter = LLMAdapter;
+type ai_LLMConsolidatorOptions = LLMConsolidatorOptions;
+type ai_LLMExtractorOptions = LLMExtractorOptions;
+type ai_LLMInvokeOptions = LLMInvokeOptions;
+type ai_LLMResponse = LLMResponse;
+type ai_LLMStreamHandle = LLMStreamHandle;
+type ai_McpToolSchema = McpToolSchema;
+type ai_MemoryTier = MemoryTier;
+type ai_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
+type ai_MemoryTiersOptions<TMem> = MemoryTiersOptions<TMem>;
+type ai_OpenAIToolSchema = OpenAIToolSchema;
+type ai_RetrievalEntry<TMem> = RetrievalEntry<TMem>;
+type ai_RetrievalPipelineOptions<TMem> = RetrievalPipelineOptions<TMem>;
+type ai_RetrievalQuery = RetrievalQuery;
+type ai_RetrievalTrace<TMem> = RetrievalTrace<TMem>;
+type ai_StrategyOperation = StrategyOperation;
+type ai_StrategyPlan = StrategyPlan;
+type ai_SuggestStrategyOptions = SuggestStrategyOptions;
+type ai_SystemPromptHandle = SystemPromptHandle;
+type ai_ToolCall = ToolCall;
+type ai_ToolDefinition = ToolDefinition;
+type ai_ToolRegistryGraph = ToolRegistryGraph;
+declare const ai_ToolRegistryGraph: typeof ToolRegistryGraph;
+type ai_ToolRegistryOptions = ToolRegistryOptions;
+declare const ai_admissionFilter3D: typeof admissionFilter3D;
+declare const ai_agentLoop: typeof agentLoop;
+declare const ai_agentMemory: typeof agentMemory;
+declare const ai_chatStream: typeof chatStream;
+declare const ai_fromLLM: typeof fromLLM;
+declare const ai_fromLLMStream: typeof fromLLMStream;
+declare const ai_gaugesAsContext: typeof gaugesAsContext;
+declare const ai_graphFromSpec: typeof graphFromSpec;
+declare const ai_knobsAsTools: typeof knobsAsTools;
+declare const ai_llmConsolidator: typeof llmConsolidator;
+declare const ai_llmExtractor: typeof llmExtractor;
+declare const ai_suggestStrategy: typeof suggestStrategy;
+declare const ai_systemPromptBuilder: typeof systemPromptBuilder;
+declare const ai_toolRegistry: typeof toolRegistry;
+declare const ai_validateGraphDef: typeof validateGraphDef;
+declare namespace ai {
+  export { type ai_AdmissionScore3DOptions as AdmissionScore3DOptions, type ai_AdmissionScores as AdmissionScores, ai_AgentLoopGraph as AgentLoopGraph, type ai_AgentLoopOptions as AgentLoopOptions, type ai_AgentLoopStatus as AgentLoopStatus, type ai_AgentMemoryGraph as AgentMemoryGraph, type ai_AgentMemoryOptions as AgentMemoryOptions, type ai_ChatMessage as ChatMessage, ai_ChatStreamGraph as ChatStreamGraph, type ai_ChatStreamOptions as ChatStreamOptions, type ai_FromLLMOptions as FromLLMOptions, type ai_FromLLMStreamOptions as FromLLMStreamOptions, type ai_GaugesAsContextOptions as GaugesAsContextOptions, type ai_GraphDefValidation as GraphDefValidation, type ai_GraphFromSpecOptions as GraphFromSpecOptions, type ai_KnobsAsToolsResult as KnobsAsToolsResult, type ai_LLMAdapter as LLMAdapter, type ai_LLMConsolidatorOptions as LLMConsolidatorOptions, type ai_LLMExtractorOptions as LLMExtractorOptions, type ai_LLMInvokeOptions as LLMInvokeOptions, type ai_LLMResponse as LLMResponse, type ai_LLMStreamHandle as LLMStreamHandle, type ai_McpToolSchema as McpToolSchema, type ai_MemoryTier as MemoryTier, type ai_MemoryTiersBundle as MemoryTiersBundle, type ai_MemoryTiersOptions as MemoryTiersOptions, type ai_OpenAIToolSchema as OpenAIToolSchema, type ai_RetrievalEntry as RetrievalEntry, type ai_RetrievalPipelineOptions as RetrievalPipelineOptions, type ai_RetrievalQuery as RetrievalQuery, type ai_RetrievalTrace as RetrievalTrace, type ai_StrategyOperation as StrategyOperation, type ai_StrategyPlan as StrategyPlan, type ai_SuggestStrategyOptions as SuggestStrategyOptions, type ai_SystemPromptHandle as SystemPromptHandle, type ai_ToolCall as ToolCall, type ai_ToolDefinition as ToolDefinition, ai_ToolRegistryGraph as ToolRegistryGraph, type ai_ToolRegistryOptions as ToolRegistryOptions, ai_admissionFilter3D as admissionFilter3D, ai_agentLoop as agentLoop, ai_agentMemory as agentMemory, ai_chatStream as chatStream, ai_fromLLM as fromLLM, ai_fromLLMStream as fromLLMStream, ai_gaugesAsContext as gaugesAsContext, ai_graphFromSpec as graphFromSpec, ai_knobsAsTools as knobsAsTools, ai_llmConsolidator as llmConsolidator, ai_llmExtractor as llmExtractor, ai_suggestStrategy as suggestStrategy, ai_systemPromptBuilder as systemPromptBuilder, ai_toolRegistry as toolRegistry, ai_validateGraphDef as validateGraphDef };
+}
+
+/**
+ * Messaging patterns (roadmap §4.2).
+ *
+ * Pulsar-inspired messaging features modeled as graph factories:
+ * - `topic()` for append-only topic streams
+ * - `subscription()` for cursor-based consumers
+ * - `jobQueue()` for queue claim/ack flow
+ */
+
+type TopicOptions = {
+    graph?: GraphOptions;
+    retainedLimit?: number;
+};
+declare class TopicGraph<T> extends Graph {
+    private readonly _log;
+    private readonly _keepaliveDisposers;
+    readonly events: Node<ReactiveLogSnapshot<T>>;
+    readonly latest: Node<T | undefined>;
+    constructor(name: string, opts?: TopicOptions);
+    destroy(): void;
+    publish(value: T): void;
+    retained(): readonly T[];
+}
+type SubscriptionOptions = {
+    graph?: GraphOptions;
+    cursor?: number;
+};
+declare class SubscriptionGraph<T> extends Graph {
+    private readonly _keepaliveDisposers;
+    readonly source: Node<ReactiveLogSnapshot<T>>;
+    readonly cursor: Node<number>;
+    readonly available: Node<readonly T[]>;
+    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
+    destroy(): void;
+    ack(count?: number): number;
+    pull(limit?: number, opts?: {
+        ack?: boolean;
+    }): readonly T[];
+}
+type JobState = "queued" | "inflight";
+type JobEnvelope<T> = {
+    id: string;
+    payload: T;
+    attempts: number;
+    metadata: Readonly<Record<string, unknown>>;
+    state: JobState;
+};
+type JobQueueOptions = {
+    graph?: GraphOptions;
+};
+declare class JobQueueGraph<T> extends Graph {
+    private readonly _pending;
+    private readonly _jobs;
+    private readonly _keepaliveDisposers;
+    private _seq;
+    readonly pending: Node<ReactiveListSnapshot<string>>;
+    readonly jobs: Node<ReactiveMapSnapshot<string, JobEnvelope<T>>>;
+    readonly depth: Node<number>;
+    constructor(name: string, opts?: JobQueueOptions);
+    destroy(): void;
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    claim(limit?: number): readonly JobEnvelope<T>[];
+    ack(id: string): boolean;
+    nack(id: string, opts?: {
+        requeue?: boolean;
+    }): boolean;
+}
+type JobFlowOptions = {
+    graph?: GraphOptions;
+    stages?: readonly string[];
+    maxPerPump?: number;
+};
+declare class JobFlowGraph<T> extends Graph {
+    private readonly _stageNames;
+    private readonly _queues;
+    private readonly _keepaliveDisposers;
+    private readonly _completed;
+    readonly completed: Node<ReactiveLogSnapshot<JobEnvelope<T>>>;
+    readonly completedCount: Node<number>;
+    constructor(name: string, opts?: JobFlowOptions);
+    destroy(): void;
+    stages(): readonly string[];
+    queue(stage: string): JobQueueGraph<T>;
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    retainedCompleted(): readonly JobEnvelope<T>[];
+}
+type TopicBridgeOptions<TIn, TOut> = {
+    graph?: GraphOptions;
+    cursor?: number;
+    maxPerPump?: number;
+    map?: (value: TIn) => TOut | undefined;
+};
+declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
+    private readonly _sourceSub;
+    private readonly _target;
+    private readonly _keepaliveDisposers;
+    readonly bridgedCount: Node<number>;
+    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
+    destroy(): void;
+}
+/**
+ * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
+ */
+declare function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>;
+/**
+ * Creates a cursor-based subscription graph over a topic.
+ */
+declare function subscription<T>(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions): SubscriptionGraph<T>;
+/**
+ * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
+ */
+declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
+/**
+ * Creates an autonomous multi-stage queue chain graph.
+ */
+declare function jobFlow<T>(name: string, opts?: JobFlowOptions): JobFlowGraph<T>;
+/**
+ * Creates an autonomous cursor-based topic relay graph.
+ */
+declare function topicBridge<TIn, TOut = TIn>(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>): TopicBridgeGraph<TIn, TOut>;
+
+type messaging_JobEnvelope<T> = JobEnvelope<T>;
+type messaging_JobFlowGraph<T> = JobFlowGraph<T>;
+declare const messaging_JobFlowGraph: typeof JobFlowGraph;
+type messaging_JobFlowOptions = JobFlowOptions;
+type messaging_JobQueueGraph<T> = JobQueueGraph<T>;
+declare const messaging_JobQueueGraph: typeof JobQueueGraph;
+type messaging_JobQueueOptions = JobQueueOptions;
+type messaging_JobState = JobState;
+type messaging_SubscriptionGraph<T> = SubscriptionGraph<T>;
+declare const messaging_SubscriptionGraph: typeof SubscriptionGraph;
+type messaging_SubscriptionOptions = SubscriptionOptions;
+type messaging_TopicBridgeGraph<TIn, TOut = TIn> = TopicBridgeGraph<TIn, TOut>;
+declare const messaging_TopicBridgeGraph: typeof TopicBridgeGraph;
+type messaging_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
+type messaging_TopicGraph<T> = TopicGraph<T>;
+declare const messaging_TopicGraph: typeof TopicGraph;
+type messaging_TopicOptions = TopicOptions;
+declare const messaging_jobFlow: typeof jobFlow;
+declare const messaging_jobQueue: typeof jobQueue;
+declare const messaging_subscription: typeof subscription;
+declare const messaging_topic: typeof topic;
+declare const messaging_topicBridge: typeof topicBridge;
+declare namespace messaging {
+  export { type messaging_JobEnvelope as JobEnvelope, messaging_JobFlowGraph as JobFlowGraph, type messaging_JobFlowOptions as JobFlowOptions, messaging_JobQueueGraph as JobQueueGraph, type messaging_JobQueueOptions as JobQueueOptions, type messaging_JobState as JobState, messaging_SubscriptionGraph as SubscriptionGraph, type messaging_SubscriptionOptions as SubscriptionOptions, messaging_TopicBridgeGraph as TopicBridgeGraph, type messaging_TopicBridgeOptions as TopicBridgeOptions, messaging_TopicGraph as TopicGraph, type messaging_TopicOptions as TopicOptions, messaging_jobFlow as jobFlow, messaging_jobQueue as jobQueue, messaging_subscription as subscription, messaging_topic as topic, messaging_topicBridge as topicBridge };
+}
+
+/**
+ * Orchestration patterns (roadmap §4.1).
+ *
+ * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
+ * Exported under the `patterns.orchestration` namespace to avoid collisions with
+ * Phase 2 operator names (for example `gate`, `forEach`).
+ */
+
+type StepRef = string | Node<unknown>;
+type OrchestrationMeta = {
+    orchestration?: true;
+    orchestration_type?: string;
+};
+type OrchestrationStepOptions = Omit<NodeOptions, "describeKind" | "name" | "meta"> & {
+    deps?: ReadonlyArray<StepRef>;
+    meta?: Record<string, unknown> & OrchestrationMeta;
+};
+type BranchResult<T> = {
+    branch: "then" | "else";
+    value: T;
+};
+type SensorControls<T> = {
+    node: Node<T>;
+    push(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    iterations?: number | StepRef;
+};
+type WaitOptions = Omit<OrchestrationStepOptions, "deps">;
+type SubPipelineBuilder = (sub: Graph) => void;
+/**
+ * Creates an orchestration graph container.
+ */
+declare function pipeline(name: string, opts?: GraphOptions): Graph;
+/**
+ * Registers a workflow task node.
+ */
+declare function task<T>(graph: Graph, name: string, run: NodeFn<T>, opts?: OrchestrationStepOptions): Node<T>;
+/**
+ * Emits tagged branch outcomes (`then` / `else`) for each source value.
+ */
+declare function branch<T>(graph: Graph, name: string, source: StepRef, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
+/**
+ * Forwards source values only while `control` is truthy.
+ */
+declare function gate<T>(graph: Graph, name: string, source: StepRef, control: StepRef, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    isApproved?: (value: unknown) => boolean;
+};
+/**
+ * Human/LLM approval gate over a source value.
+ */
+declare function approval<T>(graph: Graph, name: string, source: StepRef, approver: StepRef, opts?: ApprovalOptions): Node<T>;
+/**
+ * Registers a workflow side-effect step. The step remains graph-observable and forwards messages.
+ */
+declare function forEach<T>(graph: Graph, name: string, source: StepRef, run: (value: T, actions: NodeActions) => void, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a join step that emits a tuple of latest dependency values.
+ */
+declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
+    [K in keyof T]: StepRef;
+}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a loop step that applies `iterate` to each source value N times.
+ */
+declare function loop<T>(graph: Graph, name: string, source: StepRef, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
+/**
+ * Mounts and returns a child workflow graph.
+ */
+declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
+/**
+ * Registers a producer-style sensor source and returns imperative controls.
+ */
+declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions, "name" | "describeKind" | "meta"> & {
+    meta?: Record<string, unknown>;
+}): SensorControls<T>;
+/**
+ * Registers a delayed-forwarding step (value-level wait).
+ */
+declare function wait<T>(graph: Graph, name: string, source: StepRef, ms: number, opts?: WaitOptions): Node<T>;
+/**
+ * Registers an error-recovery step for a source.
+ */
+declare function onFailure<T>(graph: Graph, name: string, source: StepRef, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+
+type orchestration_ApprovalOptions = ApprovalOptions;
+type orchestration_BranchResult<T> = BranchResult<T>;
+type orchestration_LoopOptions = LoopOptions;
+type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
+type orchestration_SensorControls<T> = SensorControls<T>;
+type orchestration_StepRef = StepRef;
+type orchestration_SubPipelineBuilder = SubPipelineBuilder;
+type orchestration_WaitOptions = WaitOptions;
+declare const orchestration_approval: typeof approval;
+declare const orchestration_branch: typeof branch;
+declare const orchestration_forEach: typeof forEach;
+declare const orchestration_gate: typeof gate;
+declare const orchestration_join: typeof join;
+declare const orchestration_loop: typeof loop;
+declare const orchestration_onFailure: typeof onFailure;
+declare const orchestration_pipeline: typeof pipeline;
+declare const orchestration_sensor: typeof sensor;
+declare const orchestration_subPipeline: typeof subPipeline;
+declare const orchestration_task: typeof task;
+declare const orchestration_wait: typeof wait;
+declare namespace orchestration {
+  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type orchestration_StepRef as StepRef, type orchestration_SubPipelineBuilder as SubPipelineBuilder, type orchestration_WaitOptions as WaitOptions, orchestration_approval as approval, orchestration_branch as branch, orchestration_forEach as forEach, orchestration_gate as gate, orchestration_join as join, orchestration_loop as loop, orchestration_onFailure as onFailure, orchestration_pipeline as pipeline, orchestration_sensor as sensor, orchestration_subPipeline as subPipeline, orchestration_task as task, orchestration_wait as wait };
+}
+
+/**
+ * Patterns layer: domain/solution helpers (Phase 4+).
+ */
+
+declare const index_ai: typeof ai;
+declare const index_cqrs: typeof cqrs;
+declare const index_memory: typeof memory;
+declare const index_messaging: typeof messaging;
+declare const index_orchestration: typeof orchestration;
+declare namespace index {
+  export { index_ai as ai, index_cqrs as cqrs, index$b as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration };
+}
+
+/**
+ * GraphRefly — public API surface.
+ */
+declare const version = "0.0.0";
+
+export { Actor, AutoCheckpointAdapter, DistillBundle, Extraction, Graph, GraphAutoCheckpointHandle, GraphAutoCheckpointOptions, GraphOptions, Node, NodeActions, NodeFn, NodeInput, NodeOptions, ReactiveListSnapshot, ReactiveLogSnapshot, ReactiveMapSnapshot, ai, index$1 as compat, cqrs, index$9 as jotai, index$b as layout, memory, messaging, index$8 as nanostores, index$a as nestjs, orchestration, index as patterns, index$7 as react, index$6 as signals, index$5 as solid, index$4 as svelte, version, index$3 as vue, index$2 as zustand };