@graphrefly/graphrefly 0.26.0 → 0.27.0

package/dist/index.d.ts

@@ -1,1699 +1,42 @@
-export { i as compat, a as signals } from './index-BjI6ty9z.js';
-import { D as DerivedFn } from './index-CY2TljO4.js';
-export { A as AutoTrackOptions, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as batch, i as core, e as derived, f as downWithBatch, g as dynamicNode, h as effect, j as isBatching, m as monotonicNs, p as pipe, k as producer, s as state, w as wallClockNs } from './index-CY2TljO4.js';
-import { D as DistillBundle, E as Extraction, R as ReactiveMapBundle, S as StatusValue, C as CircuitState, a as RateLimiterOptions, b as CircuitBreakerOptions, c as RetryOptions, F as FallbackInput, N as NS_PER_MS, d as NS_PER_SEC } from './index-DdD5MVDL.js';
-export { A as AckableMessage, e as AdapterHandlers, B as BackoffPreset, f as BackoffStrategy, g as BatchMessage, h as BridgeMessage, i as BufferedSinkHandle, j as BundleTriad, k as CSVRow, l as CacheEvictionPolicy, m as CascadingCache, n as CascadingCacheOptions, o as CheckpointToRedisOptions, p as CheckpointToS3Options, q as CircuitBreaker, r as CircuitOpenError, s as ClickHouseClientLike, t as ClickHouseInsertClientLike, u as ClickHouseRow, v as CronSchedule, w as DistillOptions, x as DrizzleQueryLike, y as EmitTriad, z as ErrorMessage, G as ExponentialBackoffOptions, H as ExternalBundleOptions, I as ExternalRegister, J as FSEvent, K as FSEventType, L as FileWriterLike, M as FromCSVOptions, O as FromClickHouseWatchOptions, P as FromDrizzleOptions, Q as FromFSWatchOptions, T as FromGitHookOptions, U as FromHTTPOptions, V as FromHTTPPollOptions, W as FromHTTPStreamOptions, X as FromKafkaOptions, Y as FromKyselyOptions, Z as FromMCPOptions, _ as FromNATSOptions, $ as FromNDJSONOptions, a0 as FromOTelOptions, a1 as FromPrismaOptions, a2 as FromPrometheusOptions, a3 as FromPulsarOptions, a4 as FromRabbitMQOptions, a5 as FromRedisStreamOptions, a6 as FromSSEOptions, a7 as FromSqliteOptions, a8 as FromStatsDOptions, a9 as FromSyslogOptions, aa as FromWebSocketReconnectOptions, ab as GitEvent, ac as GitHookType, ad as HTTPBundle, ae as IndexBackend, af as IndexRow, ag as InitMessage, ah as JitterMode, ai as KafkaConsumerLike, aj as KafkaMessage, ak as KafkaProducerLike, al as KyselyQueryLike, am as ListBackend, an as LogBackend, ao as LokiClientLike, ap as LokiStream, aq as MCPClientLike, ar as MapBackend, as as MergeMapOptions, at as MongoCollectionLike, au as NATSClientLike, av as NATSMessage, aw as NATSSubscriptionLike, ax as NativeIndexBackend, ay as NativeListBackend, az as NativeLogBackend, aA as NativeMapBackend, aB as NativeMapBackendOptions, aC as NativePubSubBackend, aD as OTelBundle, aE as OTelLog, aF as OTelMetric, aG as OTelRegister, aH as OTelSpan, aI as PostgresClientLike, aJ as PrismaModelLike, aK as PrometheusMetric, aL as PubSubBackend, aM as PubSubHub, aN as PubSubHubOptions, aO as PulsarConsumerLike, aP as PulsarMessage, aQ as PulsarProducerLike, aR as RabbitMQChannelLike, aS as RabbitMQMessage, aT as RateLimiterOverflowError, aU as RateLimiterOverflowPolicy, aV as ReactiveIndexBundle, aW as ReactiveIndexOptions, aX as ReactiveListBundle, aY as ReactiveListOptions, aZ as ReactiveLogBundle, a_ as ReactiveLogOptions, a$ as ReactiveMapOptions, b0 as ReactiveSinkBackpressureOptions, b1 as ReactiveSinkConfig, b2 as ReactiveSinkHandle, b3 as ReactiveSinkOptions, b4 as ReactiveSinkRetryOptions, b5 as ReadyMessage, b6 as RedisCheckpointClientLike, b7 as RedisClientLike, b8 as RedisStreamEntry, b9 as ResettableTimer, ba as RetrySourceOptions, bb as S3ClientLike, bc as SSEEvent, bd as SignalMessage, be as SinkFailure, bf as SinkHandle, bg as SinkTransportError, bh as SqliteDbLike, bi as SqliteIterableDbLike, bj as StatsDMetric, bk as StatsDRegister, bl as SyslogMessage, bm as SyslogRegister, bn as TapObserver, bo as TempoClientLike, bp as ThrottleOptions, bq as TimeoutError, br as ToCSVOptions, bs as ToClickHouseOptions, bt as ToFileOptions, bu as ToHTTPOptions, bv as ToKafkaOptions, bw as ToLokiOptions, bx as ToMongoOptions, by as ToNATSOptions, bz as ToPostgresOptions, bA as ToPulsarOptions, bB as ToRabbitMQOptions, bC as ToRedisStreamOptions, bD as ToS3Options, bE as ToSSEOptions, bF as ToSqliteOptions, bG as ToTempoOptions, bH as ToWebSocketOptions, bI as TokenBucket, bJ as UpsertOptions, bK as ValueMessage, bL as VerifiableBundle, bM as VerifiableOptions, bN as VerifyValue, bO as WatermarkController, bP as WatermarkOptions, bQ as WebSocketLike, bR as WebSocketMessageEventLike, bS as WebSocketRegister, bT as WebhookRegister, bU as WithBreakerBundle, bV as WithStatusBundle, bW as WorkerBridge, bX as WorkerBridgeOptions, bY as WorkerSelfHandle, bZ as WorkerSelfOptions, b_ as WorkerTransport, b$ as audit, c0 as buffer, c1 as bufferCount, c2 as bufferTime, c3 as cascadingCache, c4 as catchError, c5 as checkpointToRedis, c6 as checkpointToS3, c7 as circuitBreaker, c8 as combine, c9 as combineLatest, ca as concat, cb as concatMap, cc as constant, cd as createTransport, ce as createWatermarkController, cf as csvRows, cg as debounce, ch as debounceTime, ci as decorrelatedJitter, cj as delay, ck as deserializeError, cl as distill, cm as distinctUntilChanged, cn as elementAt, co as exhaustMap, cp as exponential, cq as externalBundle, cr as externalProducer, cs as extra, ct as fallback, cu as fibonacci, cv as filter, cw as find, cx as first, cy as flatMap, cz as fromCSV, cA as fromClickHouseWatch, cB as fromDrizzle, cC as fromFSWatch, cD as fromGitHook, cE as fromHTTP, cF as fromHTTPPoll, cG as fromHTTPStream, cH as fromKafka, cI as fromKysely, cJ as fromMCP, cK as fromNATS, cL as fromNDJSON, cM as fromOTel, cN as fromPrisma, cO as fromPrometheus, cP as fromPulsar, cQ as fromRabbitMQ, cR as fromRedisStream, cS as fromSSE, cT as fromSqlite, cU as fromSqliteCursor, cV as fromStatsD, cW as fromSyslog, cX as fromWebSocket, cY as fromWebSocketReconnect, cZ as fromWebhook, c_ as interval, c$ as last, d0 as linear, d1 as lru, d2 as map, d3 as matchesCron, d4 as merge, d5 as mergeMap, d6 as nameToSignal, d7 as ndjsonRows, d8 as pairwise, d9 as parseCron, da as parsePrometheusText, db as parseStatsD, dc as parseSyslog, dd as pausable, de as pubsub, df as race, dg as rateLimiter, dh as reactiveIndex, di as reactiveList, dj as reactiveLog, dk as reactiveMap, dl as reactiveSink, dm as reduce, dn as repeat, dp as rescue, dq as resolveBackoffPreset, dr as retry, ds as retrySource, dt as sample, du as scan, dv as serializeError, dw as signalToName, dx as skip, dy as switchMap, dz as take, dA as takeUntil, dB as takeWhile, dC as tap, dD as throttle, dE as throttleTime, dF as timeout, dG as toCSV, dH as toClickHouse, dI as toFile, dJ as toHTTP, dK as toKafka, dL as toLoki, dM as toMongo, dN as toNATS, dO as toPostgres, dP as toPulsar, dQ as toRabbitMQ, dR as toReadableStream, dS as toRedisStream, dT as toS3, dU as toSSE, dV as toSSEBytes, dW as toSqlite, dX as toTempo, dY as toWebSocket, dZ as tokenBucket, d_ as valve, d$ as verifiable, e0 as window, e1 as windowCount, e2 as windowTime, e3 as withBreaker, e4 as withLatestFrom, e5 as withMaxAttempts, e6 as withStatus, e7 as workerBridge, e8 as workerSelf, e9 as zip } from './index-DdD5MVDL.js';
-import { w as watchTopologyTree } from './index-eJ6T_qGM.js';
-export { E as ENVELOPE_VERSION, a as EvictedSubgraphInfo, b as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, O as SIZEOF_OVERHEAD, S as SIZEOF_SYMBOL, W as WALEntry, c as createDagCborCodec, d as createDagCborZstdCodec, e as decodeEnvelope, f as encodeEnvelope, i as graph, r as registerBuiltinCodecs, g as replayWAL, s as sizeof } from './index-eJ6T_qGM.js';
-import { N as Node, a as NodeOptions, b as NodeActions, A as Actor, P as PolicyRuleData, G as GuardAction } from './node-C_IBuvX2.js';
-export { C as COMPLETE, c as COMPLETE_MSG, d as COMPLETE_ONLY_BATCH, D as DATA, e as DEFAULT_ACTOR, f as DIRTY, g as DIRTY_MSG, h as DIRTY_ONLY_BATCH, i as DepRecord, E as ERROR, F as FnCtx, j as GlobalInspectorEvent, k as GlobalInspectorHook, l as GraphReFlyConfig, m as GuardDenied, n as GuardDeniedDetails, H as HashFn, I as INVALIDATE, o as INVALIDATE_MSG, p as INVALIDATE_ONLY_BATCH, M as Message, q as MessageContext, r as MessageTypeRegistration, s as MessageTypeRegistrationInput, t as Messages, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-C_IBuvX2.js';
-import { NodeInput } from './extra/sources.js';
-export { AsyncSourceOpts, EventTargetLike, FromCronOptions, ReactiveCounterBundle, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
-import { S as StorageHandle, a as StorageTier } from './storage-BMycWEh2.js';
-export { I as IndexedDbStorageSpec, d as dictStorage, f as fileStorage, b as fromIDBRequest, c as fromIDBTransaction, i as indexedDbStorage, m as memoryStorage, s as sqliteStorage } from './storage-BMycWEh2.js';
-import { G as Graph, a as GraphOptions, b as GraphAttachStorageOptions, c as GraphPersistSnapshot, C as CausalChain, d as GraphDescribeOptions, e as GraphDescribeOutput, D as DescribeFilter, f as GraphProfileResult, g as GraphProfileOptions, h as GraphNodeFactory, i as GraphDiffResult } from './graph-DQ69XU0g.js';
-export { j as CausalStep, E as ExplainPathOptions, k as GRAPH_META_SEGMENT, l as GraphActorOptions, m as GraphCheckpointRecord, n as GraphDiagramDirection, o as GraphDiagramOptions, p as GraphDiffChange, q as GraphFactoryContext, r as GraphObserveAll, s as GraphObserveOne, t as GraphVersionChange, u as GraphWALDiff, N as NodeProfile, O as ObserveDetail, v as ObserveEvent, w as ObserveOptions, x as ObserveResult, y as ObserveTheme, z as ObserveThemeName, R as ReachableDirection, A as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, B as TraceEntry, F as diffForWAL, H as explainPath, I as graphProfile, J as reachable } from './graph-DQ69XU0g.js';
-import { c as cqrs } from './index-CuYwdKO-.js';
-export { i as nestjs } from './index-CuYwdKO-.js';
-import { d as demoShell } from './demo-shell-DEp-nMTl.js';
-import { i as index$3 } from './index-BW1z3BN9.js';
-export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-BGqSZ7mt.js';
-export { T as ToObservableOptions, t as toObservable } from './observable-DCk45RH5.js';
-export { i as jotai } from './index-qldRdbQw.js';
-export { i as nanostores } from './index-xdGjv0nO.js';
-export { i as react } from './index-CPgZ5wRl.js';
-export { i as solid } from './index-CDAjUFIv.js';
-export { i as svelte } from './index-DrISNAOm.js';
-export { i as vue } from './index-BYOHF0zP.js';
-export { i as zustand } from './index-CmnuOibw.js';
+export { i as compat, a as signals } from './index-BuEoe-Qu.js';
+export { b as batch, i as core, d as downWithBatch, a as isBatching, m as monotonicNs, w as wallClockNs } from './index-BaSM3aYt.js';
+import { S as StatusValue, C as CircuitState, R as RateLimiterOptions, a as CircuitBreakerOptions, b as RetryOptions, F as FallbackInput, N as NS_PER_MS, c as NS_PER_SEC } from './index-BwfLUNw4.js';
+export { A as AckableMessage, d as AdapterHandlers, B as BackoffPreset, e as BackoffStrategy, f as BatchMessage, g as BridgeMessage, h as BufferedSinkHandle, i as BundleTriad, j as CSVRow, k as CacheEvictionPolicy, l as CascadingCache, m as CascadingCacheOptions, n as CheckpointToRedisOptions, o as CheckpointToS3Options, p as CircuitBreaker, q as CircuitOpenError, r as ClickHouseClientLike, s as ClickHouseInsertClientLike, t as ClickHouseRow, u as CronSchedule, D as DrizzleQueryLike, E as EmitTriad, v as ErrorMessage, w as ExponentialBackoffOptions, x as ExternalBundleOptions, y as ExternalRegister, z as FSEvent, G as FSEventType, H as FileWriterLike, I as FromCSVOptions, J as FromClickHouseWatchOptions, K as FromDrizzleOptions, L as FromFSWatchOptions, M as FromGitHookOptions, O as FromHTTPOptions, P as FromHTTPPollOptions, Q as FromHTTPStreamOptions, T as FromKafkaOptions, U as FromKyselyOptions, V as FromMCPOptions, W as FromNATSOptions, X as FromNDJSONOptions, Y as FromOTelOptions, Z as FromPrismaOptions, _ as FromPrometheusOptions, $ as FromPulsarOptions, a0 as FromRabbitMQOptions, a1 as FromRedisStreamOptions, a2 as FromSSEOptions, a3 as FromSqliteOptions, a4 as FromStatsDOptions, a5 as FromSyslogOptions, a6 as FromWebSocketReconnectOptions, a7 as GitEvent, a8 as GitHookType, a9 as HTTPBundle, aa as IndexBackend, ab as IndexRow, ac as InitMessage, ad as JitterMode, ae as KafkaConsumerLike, af as KafkaMessage, ag as KafkaProducerLike, ah as KyselyQueryLike, ai as ListBackend, aj as LogBackend, ak as LokiClientLike, al as LokiStream, am as MCPClientLike, an as MergeMapOptions, ao as MongoCollectionLike, ap as NATSClientLike, aq as NATSMessage, ar as NATSSubscriptionLike, as as NativeIndexBackend, at as NativeListBackend, au as NativeLogBackend, av as NativePubSubBackend, aw as OTelBundle, ax as OTelLog, ay as OTelMetric, az as OTelRegister, aA as OTelSpan, aB as PostgresClientLike, aC as PrismaModelLike, aD as PrometheusMetric, aE as PubSubBackend, aF as PubSubHub, aG as PubSubHubOptions, aH as PulsarConsumerLike, aI as PulsarMessage, aJ as PulsarProducerLike, aK as RabbitMQChannelLike, aL as RabbitMQMessage, aM as RateLimiterOverflowError, aN as RateLimiterOverflowPolicy, aO as ReactiveIndexBundle, aP as ReactiveIndexOptions, aQ as ReactiveListBundle, aR as ReactiveListOptions, aS as ReactiveLogBundle, aT as ReactiveLogOptions, aU as ReactiveSinkBackpressureOptions, aV as ReactiveSinkConfig, aW as ReactiveSinkHandle, aX as ReactiveSinkOptions, aY as ReactiveSinkRetryOptions, aZ as ReadyMessage, a_ as RedisCheckpointClientLike, a$ as RedisClientLike, b0 as RedisStreamEntry, b1 as ResettableTimer, b2 as RetrySourceOptions, b3 as S3ClientLike, b4 as SSEEvent, b5 as SignalMessage, b6 as SinkFailure, b7 as SinkHandle, b8 as SinkTransportError, b9 as SqliteDbLike, ba as SqliteIterableDbLike, bb as StatsDMetric, bc as StatsDRegister, bd as SyslogMessage, be as SyslogRegister, bf as TapObserver, bg as TempoClientLike, bh as ThrottleOptions, bi as TimeoutError, bj as ToCSVOptions, bk as ToClickHouseOptions, bl as ToFileOptions, bm as ToHTTPOptions, bn as ToKafkaOptions, bo as ToLokiOptions, bp as ToMongoOptions, bq as ToNATSOptions, br as ToPostgresOptions, bs as ToPulsarOptions, bt as ToRabbitMQOptions, bu as ToRedisStreamOptions, bv as ToS3Options, bw as ToSSEOptions, bx as ToSqliteOptions, by as ToTempoOptions, bz as ToWebSocketOptions, bA as TokenBucket, bB as UpsertOptions, bC as ValueMessage, bD as WatermarkController, bE as WatermarkOptions, bF as WebSocketLike, bG as WebSocketMessageEventLike, bH as WebSocketRegister, bI as WebhookRegister, bJ as WithBreakerBundle, bK as WithStatusBundle, bL as WorkerBridge, bM as WorkerBridgeOptions, bN as WorkerSelfHandle, bO as WorkerSelfOptions, bP as WorkerTransport, bQ as audit, bR as buffer, bS as bufferCount, bT as bufferTime, bU as cascadingCache, bV as catchError, bW as checkpointToRedis, bX as checkpointToS3, bY as circuitBreaker, bZ as combine, b_ as combineLatest, b$ as concat, c0 as concatMap, c1 as constant, c2 as createTransport, c3 as createWatermarkController, c4 as csvRows, c5 as debounce, c6 as debounceTime, c7 as decorrelatedJitter, c8 as delay, c9 as deserializeError, ca as distinctUntilChanged, cb as elementAt, cc as exhaustMap, cd as exponential, ce as externalBundle, cf as externalProducer, cg as extra, ch as fallback, ci as fibonacci, cj as filter, ck as find, cl as first, cm as flatMap, cn as fromCSV, co as fromClickHouseWatch, cp as fromDrizzle, cq as fromFSWatch, cr as fromGitHook, cs as fromHTTP, ct as fromHTTPPoll, cu as fromHTTPStream, cv as fromKafka, cw as fromKysely, cx as fromMCP, cy as fromNATS, cz as fromNDJSON, cA as fromOTel, cB as fromPrisma, cC as fromPrometheus, cD as fromPulsar, cE as fromRabbitMQ, cF as fromRedisStream, cG as fromSSE, cH as fromSqlite, cI as fromSqliteCursor, cJ as fromStatsD, cK as fromSyslog, cL as fromWebSocket, cM as fromWebSocketReconnect, cN as fromWebhook, cO as interval, cP as last, cQ as linear, cR as lru, cS as map, cT as matchesCron, cU as merge, cV as mergeMap, cW as nameToSignal, cX as ndjsonRows, cY as pairwise, cZ as parseCron, c_ as parsePrometheusText, c$ as parseStatsD, d0 as parseSyslog, d1 as pausable, d2 as pubsub, d3 as race, d4 as rateLimiter, d5 as reactiveIndex, d6 as reactiveList, d7 as reactiveLog, d8 as reactiveSink, d9 as reduce, da as repeat, db as rescue, dc as resolveBackoffPreset, dd as retry, de as retrySource, df as sample, dg as scan, dh as serializeError, di as signalToName, dj as skip, dk as switchMap, dl as take, dm as takeUntil, dn as takeWhile, dp as tap, dq as throttle, dr as throttleTime, ds as timeout, dt as toCSV, du as toClickHouse, dv as toFile, dw as toHTTP, dx as toKafka, dy as toLoki, dz as toMongo, dA as toNATS, dB as toPostgres, dC as toPulsar, dD as toRabbitMQ, dE as toReadableStream, dF as toRedisStream, dG as toS3, dH as toSSE, dI as toSSEBytes, dJ as toSqlite, dK as toTempo, dL as toWebSocket, dM as tokenBucket, dN as valve, dO as window, dP as windowCount, dQ as windowTime, dR as withBreaker, dS as withLatestFrom, dT as withMaxAttempts, dU as withStatus, dV as workerBridge, dW as workerSelf, dX as zip } from './index-BwfLUNw4.js';
+import { w as watchTopologyTree } from './index-B6D3QNSA.js';
+export { E as ENVELOPE_VERSION, a as EvictedSubgraphInfo, b as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, O as SIZEOF_OVERHEAD, S as SIZEOF_SYMBOL, W as WALEntry, c as createDagCborCodec, d as createDagCborZstdCodec, e as decodeEnvelope, f as encodeEnvelope, i as graph, r as registerBuiltinCodecs, g as replayWAL, s as sizeof } from './index-B6D3QNSA.js';
+import { L as LLMAdapter, G as GateController, a as ai, o as orchestration } from './ai-WlRltJV7.js';
+import { P as PolicyEnforcerGraph, a as PolicyViolation, b as audit } from './audit-DRlSzBu9.js';
+import { c as cqrs } from './index-BPVt8kqc.js';
+export { i as nestjs } from './index-BPVt8kqc.js';
+import { d as demoShell } from './demo-shell-BDkOptd6.js';
+import { N as Node, P as PolicyRuleData, A as Actor, a as NodeOptions } from './node-BmerH3kS.js';
+export { C as COMPLETE, b as COMPLETE_MSG, c as COMPLETE_ONLY_BATCH, D as DATA, d as DEFAULT_ACTOR, e as DIRTY, f as DIRTY_MSG, g as DIRTY_ONLY_BATCH, h as DepRecord, E as ERROR, F as FnCtx, G as GlobalInspectorEvent, i as GlobalInspectorHook, j as GraphReFlyConfig, k as GuardAction, l as GuardDenied, m as GuardDeniedDetails, H as HashFn, I as INVALIDATE, n as INVALIDATE_MSG, o as INVALIDATE_ONLY_BATCH, M as Message, p as MessageContext, q as MessageTypeRegistration, r as MessageTypeRegistrationInput, s as Messages, t as NodeActions, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-BmerH3kS.js';
+import { G as GraphOptions, a as Graph, b as GraphDescribeOptions, c as GraphDescribeOutput, D as DescribeFilter, d as GraphProfileResult, e as GraphProfileOptions, C as CausalChain, f as GraphNodeFactory, g as GraphDiffResult } from './graph-CCwGKLCm.js';
+export { h as CausalStep, E as ExplainPathOptions, i as GRAPH_META_SEGMENT, j as GraphActorOptions, k as GraphAttachStorageOptions, l as GraphCheckpointRecord, m as GraphDiagramDirection, n as GraphDiagramOptions, o as GraphDiffChange, p as GraphFactoryContext, q as GraphObserveAll, r as GraphObserveOne, s as GraphPersistSnapshot, t as GraphVersionChange, u as GraphWALDiff, N as NodeProfile, O as ObserveDetail, v as ObserveEvent, w as ObserveOptions, x as ObserveResult, y as ObserveTheme, z as ObserveThemeName, R as ReachableDirection, A as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, B as TraceEntry, F as diffForWAL, H as explainPath, I as graphProfile, J as reachable } from './graph-CCwGKLCm.js';
+import { T as TopicGraph, m as messaging } from './messaging-XDoYablx.js';
+import { R as ReactiveMapBundle } from './composite-aUCvjZVR.js';
+export { D as DistillBundle, a as DistillOptions, E as Extraction, M as MapBackend, N as NativeMapBackend, b as NativeMapBackendOptions, c as ReactiveMapOptions, V as VerifiableBundle, d as VerifiableOptions, e as VerifyValue, f as distill, r as reactiveMap, v as verifiable } from './composite-aUCvjZVR.js';
+import { m as memory } from './memory-li6FL5RM.js';
+import { i as index$3 } from './index-C8oil6M6.js';
+import { S as StorageTier } from './storage-CMjUUuxn.js';
+export { I as IndexedDbStorageSpec, a as StorageHandle, d as dictStorage, f as fileStorage, b as fromIDBRequest, c as fromIDBTransaction, i as indexedDbStorage, m as memoryStorage, s as sqliteStorage } from './storage-CMjUUuxn.js';
+export { AsyncSourceOpts, EventTargetLike, FromCronOptions, NodeInput, ReactiveCounterBundle, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
+export { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-CCOxXK1e.js';
+export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CbznRPYJ.js';
+export { T as ToObservableOptions, t as toObservable } from './observable-BgGUwcqp.js';
+export { i as jotai } from './index-3lsddbbS.js';
+export { i as nanostores } from './index-C0svESO4.js';
+export { i as react } from './index-Dzk2hrlR.js';
+export { i as solid } from './index-VdHQMPy1.js';
+export { i as svelte } from './index-CxFrXH4m.js';
+export { i as vue } from './index-wEn0eFe8.js';
+export { i as zustand } from './index-B9B7_HEY.js';
 import '@nestjs/common';
 import '@nestjs/core';
-import './reactive-layout-D9gejYXE.js';
+import './reactive-layout-u5Ulnqag.js';
 import 'rxjs';
 import 'vue';
 
-/**
- * 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 };
-}
-
-/**
- * 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;
-    readonly events: Node<readonly T[]>;
-    /**
-     * Most recently published value, or `null` when the topic has no entries
-     * yet. Spec §5.12 reserves `undefined` as the protocol-internal "never
-     * sent DATA" sentinel — `null` is the idiomatic "empty / no value" signal
-     * for domain nodes. F7.
-     *
-     * **Caveat when `T` itself includes `null`** (e.g., `topic<number | null>`):
-     * `latest === null` is ambiguous — it could mean "no publish yet" OR "a
-     * `null` value was published". Use {@link hasLatest} to disambiguate, or
-     * observe {@link events} directly and track length yourself.
-     */
-    readonly latest: Node<T | null>;
-    /**
-     * Reactive `true` once the topic has at least one published entry.
-     * Disambiguates "`null` never published" from "`null` was published" when
-     * `T` includes `null`.
-     */
-    readonly hasLatest: Node<boolean>;
-    constructor(name: string, opts?: TopicOptions);
-    publish(value: T): void;
-    retained(): readonly T[];
-}
-type SubscriptionOptions = {
-    graph?: GraphOptions;
-    cursor?: number;
-};
-declare class SubscriptionGraph<T> extends Graph {
-    readonly source: Node<readonly T[]>;
-    readonly cursor: Node<number>;
-    readonly available: Node<readonly T[]>;
-    /**
-     * Reference to the upstream topic graph. Intentionally NOT mounted
-     * under this subscription: a subscription is a VIEW over an
-     * externally-owned topic. Double-mounting (e.g. hub-owned topic +
-     * sub-mount here) would make either-side teardown leave the other
-     * holding a dead reference. Node-level `derived([topicEvents], …)`
-     * still wires the data dependency across graph boundaries. D1(e).
-     */
-    readonly topic: TopicGraph<T>;
-    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
-    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 _seq;
-    readonly pending: Node<readonly string[]>;
-    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-    readonly depth: Node<number>;
-    constructor(name: string, opts?: JobQueueOptions);
-    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 _completed;
-    readonly completed: Node<readonly JobEnvelope<T>[]>;
-    readonly completedCount: Node<number>;
-    constructor(name: string, opts?: JobFlowOptions);
-    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;
-    readonly bridgedCount: Node<number>;
-    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
-}
-type MessagingHubOptions = {
-    graph?: GraphOptions;
-    /**
-     * Default `TopicOptions` applied to every topic created via `topic(name)`
-     * without explicit options. Per-call opts override. Default: `{}`
-     * (unbounded retention per topic unless `retainedLimit` is set per call).
-     */
-    defaultTopicOptions?: TopicOptions;
-};
-/**
- * Lazy Pulsar-inspired topic registry. Manages a named set of {@link TopicGraph}
- * instances with retention + cursor semantics. Topics are created on first
- * access; `removeTopic(name)` unmounts and tears down via {@link Graph.remove}.
- *
- * **Relationship to `pubsub()` in `src/extra/pubsub.ts`:** `pubsub` is a
- * lightweight last-value state hub (no retention, no cursors). `MessagingHubGraph`
- * is the full messaging hub — retained message logs, cursor-based subscriptions,
- * and pattern-layer lifecycle management.
- *
- * @category patterns
- */
-declare class MessagingHubGraph extends Graph {
-    private readonly _topics;
-    private _version;
-    private readonly _defaultTopicOptions;
-    constructor(name: string, opts?: MessagingHubOptions);
-    /** Monotonic counter advancing on topic create/remove. */
-    get version(): number;
-    /** Number of topics currently in the hub. */
-    get size(): number;
-    /** Checks topic existence without creating. */
-    has(name: string): boolean;
-    /** Iterator over topic names. */
-    topicNames(): IterableIterator<string>;
-    /**
-     * Returns the {@link TopicGraph} for `name`, creating lazily on first call.
-     * Subsequent calls with the same name return the same instance (options on
-     * repeat calls are ignored — the topic is already configured).
-     */
-    topic<T = unknown>(name: string, opts?: TopicOptions): TopicGraph<T>;
-    /**
-     * Publishes a value to the topic, lazily creating it on first publish.
-     *
-     * **Late-subscriber caveat:** the topic is created lazily, so subscribers
-     * that attach AFTER a publish only see the retained window (governed by
-     * `retainedLimit` on `TopicOptions` / `defaultTopicOptions`). If
-     * `retainedLimit === 0` is set explicitly, early publishes are
-     * effectively dropped — prefer an unset `retainedLimit` (unbounded
-     * retention) or subscribe before publishing when late-subscribers matter.
-     */
-    publish<T = unknown>(name: string, value: T): void;
-    /**
-     * Bulk publish — issues all publishes inside one outer batch. New topics
-     * are created on demand. No-op if `entries` yields nothing.
-     *
-     * **Iterable consumption (F6):** `entries` is consumed once (single-pass)
-     * INSIDE the batch frame. If the iterator throws mid-way, the batch is
-     * discarded and NO publishes are visible to subscribers (all-or-nothing).
-     * Pass an array or `Set` for multi-shot callers.
-     */
-    publishMany(entries: Iterable<[string, unknown]>): void;
-    /**
-     * Creates a {@link SubscriptionGraph} over a named topic. The topic is
-     * lazily created if missing. Subscription lifecycle is owned by the caller —
-     * the hub does NOT mount the subscription.
-     *
-     * @param subName - Local name for the subscription graph.
-     * @param topicName - Hub topic to subscribe to.
-     * @param opts - `SubscriptionOptions` (initial cursor, etc.).
-     */
-    subscribe<T = unknown>(subName: string, topicName: string, opts?: SubscriptionOptions): SubscriptionGraph<T>;
-    /**
-     * Unmounts and tears down the topic's graph. Returns `true` if the topic
-     * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
-     */
-    removeTopic(name: string): boolean;
-}
-/**
- * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
- */
-declare function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>;
-/**
- * Creates a lazy Pulsar-inspired messaging hub. Topics are created on first access
- * via `hub.topic(name)`; `hub.publish(name, value)` shortcuts through the registry.
- *
- * @example
- * ```ts
- * import { messagingHub } from "@graphrefly/graphrefly-ts";
- *
- * const hub = messagingHub("main", { defaultTopicOptions: { retainedLimit: 256 } });
- * hub.publish("orders", { id: 1 });
- * hub.publishMany([["shipments", { id: 1 }], ["orders", { id: 2 }]]);
- * const sub = hub.subscribe("orders-worker", "orders", { cursor: 0 });
- * ```
- */
-declare function messagingHub(name: string, opts?: MessagingHubOptions): MessagingHubGraph;
-/**
- * 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_MessagingHubGraph = MessagingHubGraph;
-declare const messaging_MessagingHubGraph: typeof MessagingHubGraph;
-type messaging_MessagingHubOptions = MessagingHubOptions;
-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_messagingHub: typeof messagingHub;
-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_MessagingHubGraph as MessagingHubGraph, type messaging_MessagingHubOptions as MessagingHubOptions, 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_messagingHub as messagingHub, 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$1 = string | Node<unknown>;
-type OrchestrationMeta = {
-    orchestration?: true;
-    orchestration_type?: string;
-};
-type OrchestrationStepOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    deps?: ReadonlyArray<StepRef$1>;
-    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$1;
-};
-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: DerivedFn<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$1, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
-/**
- * Forwards source values only while `control` is truthy.
- */
-declare function valve<T>(graph: Graph, name: string, source: StepRef$1, control: StepRef$1, 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$1, approver: StepRef$1, opts?: ApprovalOptions): Node<T>;
-interface GateOptions {
-    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
-    maxPending?: number;
-    /** Start in open mode (auto-approve). Default: false. */
-    startOpen?: boolean;
-    meta?: Record<string, unknown>;
-}
-/** Control surface returned by {@link gate}. */
-interface GateController<T> {
-    /** The output node registered in the graph (subscribe to receive approved values). */
-    node: Node<T>;
-    /** Reactive queue of values waiting for approval. */
-    pending: Node<T[]>;
-    /** Derived count of pending items. */
-    count: Node<number>;
-    /** Whether the gate is currently open (auto-approving). */
-    isOpen: Node<boolean>;
-    /** Approve and forward the next `count` pending values (default: 1). */
-    approve(count?: number): void;
-    /** Reject (discard) the next `count` pending values (default: 1). */
-    reject(count?: number): void;
-    /**
-     * Transform and forward `count` pending values (default: 1).
-     * `fn` receives `(value, index, pending)` — Array.map-style.
-     */
-    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-    /** Flush all pending values and auto-approve future values. */
-    open(): void;
-    /** Re-enable manual gating (stop auto-approving). */
-    close(): void;
-}
-/**
- * Human-in-the-loop gate: queues incoming values from `source` and lets an external
- * controller {@link GateController.approve approve}, {@link GateController.reject reject},
- * or {@link GateController.modify modify} them before forwarding downstream.
- *
- * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
- * the graph. The gate output node is also registered.
- */
-declare function gate<T>(graph: Graph, name: string, source: StepRef$1, opts?: GateOptions): GateController<T>;
-/**
- * Registers a workflow side-effect step that runs `run` for each upstream
- * DATA value.
- *
- * `run` receives the full `NodeActions` and is the **sole emission point** —
- * call `actions.emit(v)` or `actions.down(msgs)` inside `run` to produce
- * downstream output. If `run` does not emit, this step acts as a pure
- * side-effect sink (graph-observable but no output). Throwing inside `run`
- * terminates the step with ERROR.
- */
-declare function forEach<T>(graph: Graph, name: string, source: StepRef$1, 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$1;
-}, 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$1, 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<unknown>, "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$1, ms: number, opts?: WaitOptions): Node<T>;
-/**
- * Registers an error-recovery step for a source.
- */
-declare function onFailure<T>(graph: Graph, name: string, source: StepRef$1, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-
-type orchestration_ApprovalOptions = ApprovalOptions;
-type orchestration_BranchResult<T> = BranchResult<T>;
-type orchestration_GateController<T> = GateController<T>;
-type orchestration_GateOptions = GateOptions;
-type orchestration_LoopOptions = LoopOptions;
-type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
-type orchestration_SensorControls<T> = SensorControls<T>;
-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_valve: typeof valve;
-declare const orchestration_wait: typeof wait;
-declare namespace orchestration {
-  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_GateController as GateController, type orchestration_GateOptions as GateOptions, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type StepRef$1 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_valve as valve, orchestration_wait as wait };
-}
-
-/**
- * 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";
-/**
- * A single chunk from any streaming source (LLM tokens, WebSocket, SSE, file tail).
- * Generic enough for any streaming source, not just LLM.
- */
-type StreamChunk = {
-    /** Identifier for the stream source (adapter name, URL, etc.). */
-    readonly source: string;
-    /** This chunk's content. */
-    readonly token: string;
-    /** Full accumulated text so far. */
-    readonly accumulated: string;
-    /** 0-based chunk counter. */
-    readonly index: number;
-};
-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 StreamingPromptNodeOptions = {
-    name?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /** Output format — `"json"` attempts JSON.parse on the final accumulated text. Default: `"text"`. */
-    format?: "text" | "json";
-    systemPrompt?: string;
-};
-/**
- * Bundle returned by {@link streamingPromptNode}.
- */
-type StreamingPromptNodeHandle<T> = {
-    /** Final parsed result (emits once per invocation, after stream completes). */
-    output: Node<T | null>;
-    /** Live stream topic — subscribe to `stream.latest` or `stream.events` for chunks. */
-    stream: TopicGraph<StreamChunk>;
-    /** Tear down the keepalive subscription and release resources. */
-    dispose: () => void;
-};
-/**
- * Streaming LLM transform: wraps a prompt template + adapter into a reactive
- * streaming pipeline. Re-invokes the LLM whenever any dep changes; the
- * previous in-flight stream is canceled automatically via `switchMap`.
- *
- * Each token chunk is published to a {@link TopicGraph} as a {@link StreamChunk}.
- * Extractors can mount on the topic independently (see {@link streamExtractor}).
- * Zero overhead if nobody subscribes to the stream topic.
- *
- * The `output` node emits the final parsed result (like {@link promptNode}).
- * The async boundary is handled by `fromAny` (spec §5.10 compliant).
- */
-declare function streamingPromptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: StreamingPromptNodeOptions): StreamingPromptNodeHandle<T>;
-/**
- * Mounts an extractor function on a streaming topic. Returns a derived node
- * that emits extracted values as chunks arrive.
- *
- * `extractFn` receives the accumulated text from the latest chunk and returns
- * the extracted value, or `null` if nothing detected yet. This is the building
- * block for keyword flags, tool call detection, cost metering, etc.
- *
- * @param streamTopic - The stream topic to extract from.
- * @param extractFn - `(accumulated: string) => T | null`.
- * @param opts - Optional name.
- * @returns Derived node emitting extracted values.
- */
-declare function streamExtractor<T>(streamTopic: TopicGraph<StreamChunk>, extractFn: (accumulated: string) => T | null, opts?: {
-    name?: string;
-    /**
-     * Optional structural equals for the extractor output. When two
-     * consecutive chunks produce structurally-equal outputs, the framework
-     * emits `RESOLVED` instead of `DATA`, saving downstream work. Default:
-     * reference equality (`Object.is`). The library cannot know your
-     * output shape — supply this when your `extractFn` returns structured
-     * objects or arrays.
-     */
-    equals?: (a: T | null, b: T | null) => boolean;
-}): Node<T | null>;
-/** A keyword match detected in the stream. */
-type KeywordFlag = {
-    readonly label: string;
-    readonly pattern: RegExp;
-    readonly match: string;
-    readonly position: number;
-};
-type KeywordFlagExtractorOptions = {
-    patterns: readonly {
-        pattern: RegExp;
-        label: string;
-    }[];
-    name?: string;
-    /**
-     * Maximum length of any pattern's literal text. Used as an overlap window
-     * when cursoring through the accumulated stream so matches that span
-     * chunk boundaries aren't missed. Default: 128.
-     */
-    maxPatternLength?: number;
-};
-/**
- * Mounts a keyword-flag extractor on a streaming topic. Scans accumulated text
- * for all configured patterns and emits an array of matches.
- *
- * Use cases: design invariant violations (`setTimeout`, `EventEmitter`), PII
- * detection (SSN, email, phone), toxicity keywords, off-track reasoning.
- *
- * **Streaming optimization.** Maintains a cursor across chunks in `ctx.store`
- * so each chunk scans only the delta region `accumulated.slice(scannedTo -
- * maxPatternLength)` — not the full string. Default structural equals
- * suppresses DATA emission when no new flags were found this chunk.
- */
-declare function keywordFlagExtractor(streamTopic: TopicGraph<StreamChunk>, opts: KeywordFlagExtractorOptions): Node<readonly KeywordFlag[]>;
-/** A tool call detected in the stream. */
-type ExtractedToolCall = {
-    readonly name: string;
-    readonly arguments: Record<string, unknown>;
-    readonly raw: string;
-    readonly startIndex: number;
-};
-/**
- * Mounts a tool-call extractor on a streaming topic. Scans accumulated text
- * for complete JSON objects containing `"name"` and `"arguments"` keys (the
- * standard tool_call shape). Partial JSON is ignored until the closing brace.
- *
- * Feeds into the tool interception chain for reactive tool gating mid-stream.
- *
- * **Streaming optimization.** Maintains a cursor (`scanFrom`) in `ctx.store`
- * so each chunk resumes brace-scanning from the position after the last
- * complete parse (or the last incomplete open brace). Already-parsed objects
- * are not re-parsed. Default structural equals suppresses DATA emission when
- * no new tool call completed this chunk.
- */
-declare function toolCallExtractor(streamTopic: TopicGraph<StreamChunk>, opts?: {
-    name?: string;
-}): Node<readonly ExtractedToolCall[]>;
-/** A cost meter reading from the stream. */
-type CostMeterReading = {
-    readonly chunkCount: number;
-    readonly charCount: number;
-    readonly estimatedTokens: number;
-};
-type CostMeterOptions = {
-    /** Characters per token approximation. Default: 4 (GPT-family). */
-    charsPerToken?: number;
-    name?: string;
-};
-/**
- * Mounts a cost meter on a streaming topic. Counts chunks, characters, and
- * estimates token count. Compose with `budgetGate` for hard-stop when LLM
- * output exceeds budget mid-generation.
- *
- * Default structural equals suppresses DATA emission when two consecutive
- * readings are identical (same chunk count + char count + token estimate).
- */
-declare function costMeterExtractor(streamTopic: TopicGraph<StreamChunk>, opts?: CostMeterOptions): Node<CostMeterReading>;
-/** Options for {@link redactor}. */
-type RedactorOptions = {
-    name?: string;
-};
-/**
- * Stream extractor that replaces matched patterns in the accumulated text.
- *
- * Returns a derived node emitting a sanitized `StreamChunk` on every chunk:
- * `accumulated` and `token` have matched substrings replaced by `replaceFn`.
- * The default `replaceFn` replaces with `"[REDACTED]"`.
- *
- * Compose with `contentGate` for in-flight safety pipelines.
- *
- * @param streamTopic - Streaming topic to monitor.
- * @param patterns    - Array of RegExps to match against accumulated text.
- * @param replaceFn   - Replacement producer (default: always `"[REDACTED]"`).
- */
-declare function redactor(streamTopic: TopicGraph<StreamChunk>, patterns: RegExp[], replaceFn?: (match: string, pattern: RegExp) => string, opts?: RedactorOptions): Node<StreamChunk>;
-/** Content safety decision. */
-type ContentDecision = "allow" | "block" | "review";
-/** Options for {@link contentGate}. */
-type ContentGateOptions = {
-    /**
-     * Hard-block threshold multiplier (default 1.5).
-     * Scores above `threshold * hardMultiplier` emit `"block"`.
-     * Scores between `threshold` and that emit `"review"`.
-     */
-    hardMultiplier?: number;
-    name?: string;
-};
-/**
- * Derived node that classifies accumulated stream text as `"allow"`,
- * `"review"`, or `"block"` based on a classifier score.
- *
- * Emits a three-way decision on every new chunk:
- * - `"allow"` — score below `threshold`
- * - `"review"` — score in `[threshold, threshold × hardMultiplier)`
- * - `"block"` — score at or above `threshold × hardMultiplier`
- *
- * Wire the output into a `valve` (automatic) or `gate` (human approval).
- * This node does not itself control flow — it just classifies.
- *
- * @param streamTopic - Streaming topic to classify.
- * @param classifier  - `(accumulated: string) => number` scoring function, or
- *                      a `Node<number>` for live scores.
- * @param threshold   - Score at which output becomes "review" or "block".
- */
-declare function contentGate(streamTopic: TopicGraph<StreamChunk>, classifier: ((accumulated: string) => number) | Node<number>, threshold: number, opts?: ContentGateOptions): Node<ContentDecision>;
-type GatedStreamOptions = StreamingPromptNodeOptions & {
-    /** Gate options (maxPending, startOpen). */
-    gate?: Omit<GateOptions, "meta">;
-};
-/**
- * Bundle returned by {@link gatedStream}.
- */
-type GatedStreamHandle<T> = {
-    /** Final parsed result (after gate approval). */
-    output: Node<T | null>;
-    /** Live stream topic — subscribe to `stream.latest` for chunks. */
-    stream: TopicGraph<StreamChunk>;
-    /** Gate controller — approve, reject (aborts in-flight stream), modify. */
-    gate: GateController<T | null>;
-    /** Tear down everything. */
-    dispose: () => void;
-};
-/**
- * Streaming LLM transform with human-in-the-loop gate integration.
- *
- * Composes {@link streamingPromptNode} with {@link gate} so that:
- * - `gate.reject()` discards the pending value **and** aborts the in-flight
- *   stream (cancels the `AbortController`).
- * - `gate.modify()` transforms the pending value before forwarding downstream.
- * - `gate.approve()` forwards the final result as normal.
- *
- * The abort-on-reject works by toggling an internal cancel signal that causes
- * the `switchMap` inside `streamingPromptNode` to restart with an empty message
- * list, which triggers the `AbortController.abort()` in the async generator's
- * `finally` block.
- */
-declare function gatedStream<T = string>(graph: Graph, name: string, adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: GatedStreamOptions): GatedStreamHandle<T>;
-type PromptNodeOptions = {
-    name?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /** Output format — `"json"` attempts JSON.parse on the response. Default: `"text"`. */
-    format?: "text" | "json";
-    /** Number of retries on transient errors. Default: 0. */
-    retries?: number;
-    /** Cache LLM responses for identical inputs. Default: false. */
-    cache?: boolean;
-    systemPrompt?: string;
-    meta?: Record<string, unknown>;
-};
-/**
- * Universal LLM transform: wraps a prompt template + model adapter into a reactive derived node.
- * Re-invokes the LLM whenever any dep changes. Suitable for triage, QA, hypothesis, parity, etc.
- *
- * @param adapter - LLM adapter (provider-agnostic).
- * @param deps - Input nodes whose values feed the prompt.
- * @param prompt - Static string or template function receiving dep values.
- * @param opts - Optional configuration.
- * @returns `Node` emitting LLM responses (string or parsed JSON).
- */
-declare function promptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: PromptNodeOptions): Node<T | null>;
-type ChatStreamOptions = {
-    graph?: GraphOptions;
-    maxMessages?: number;
-};
-declare class ChatStreamGraph extends Graph {
-    private readonly _log;
-    readonly messages: Node<readonly ChatMessage[]>;
-    readonly latest: Node<ChatMessage | null>;
-    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[];
-}
-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[]>;
-    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;
-}
-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;
-    /** Storage tier for the archive. Omit to disable archiving. */
-    archiveTier?: StorageTier;
-    /** Options forwarded to `graph.attachStorage` for the archive tier. */
-    archiveStorageOptions?: GraphAttachStorageOptions;
-};
-type MemoryTiersBundle<TMem> = {
-    /** Permanent tier: never evicted. */
-    readonly permanent: LightCollectionBundle<TMem>;
-    /** Active entries node (reactive, holds ReadonlyMap). */
-    readonly activeEntries: Node<unknown>;
-    /** Archive storage handle (null if no tier configured). */
-    readonly archiveHandle: StorageHandle | 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).
-     *
-     * **Synchronous consumer API** — returns the result immediately and batch-writes
-     * `retrieval` and `retrievalTrace` state nodes for observers. Reads the store
-     * snapshot and context value **at call time** (external-boundary read).
-     *
-     * **Do not call from inside a reactive fn body** (derived fn, subscribe callback,
-     * effect body). The cache reads would become transitive protocol violations and
-     * may observe wave-progressive rather than wave-final state.
-     *
-     * **Caller-batch caveat:** if invoked inside a caller's `batch(() => ...)` alongside
-     * upstream store mutations, the store snapshot reflects what has been committed to
-     * `store.entries.cache` at call time. State-backed stores update cache synchronously
-     * so batched inserts are visible; derived-backed store transforms may defer. If you
-     * need fresh state after batched mutations, call `retrieve` after the batch returns.
-     */
-    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_ContentDecision = ContentDecision;
-type ai_ContentGateOptions = ContentGateOptions;
-type ai_CostMeterOptions = CostMeterOptions;
-type ai_CostMeterReading = CostMeterReading;
-type ai_ExtractedToolCall = ExtractedToolCall;
-type ai_FromLLMOptions = FromLLMOptions;
-type ai_GatedStreamHandle<T> = GatedStreamHandle<T>;
-type ai_GatedStreamOptions = GatedStreamOptions;
-type ai_GaugesAsContextOptions = GaugesAsContextOptions;
-type ai_GraphDefValidation = GraphDefValidation;
-type ai_GraphFromSpecOptions = GraphFromSpecOptions;
-type ai_KeywordFlag = KeywordFlag;
-type ai_KeywordFlagExtractorOptions = KeywordFlagExtractorOptions;
-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_McpToolSchema = McpToolSchema;
-type ai_MemoryTier = MemoryTier;
-type ai_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
-type ai_MemoryTiersOptions<TMem> = MemoryTiersOptions<TMem>;
-type ai_OpenAIToolSchema = OpenAIToolSchema;
-type ai_PromptNodeOptions = PromptNodeOptions;
-type ai_RedactorOptions = RedactorOptions;
-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_StreamChunk = StreamChunk;
-type ai_StreamingPromptNodeHandle<T> = StreamingPromptNodeHandle<T>;
-type ai_StreamingPromptNodeOptions = StreamingPromptNodeOptions;
-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_contentGate: typeof contentGate;
-declare const ai_costMeterExtractor: typeof costMeterExtractor;
-declare const ai_fromLLM: typeof fromLLM;
-declare const ai_gatedStream: typeof gatedStream;
-declare const ai_gaugesAsContext: typeof gaugesAsContext;
-declare const ai_graphFromSpec: typeof graphFromSpec;
-declare const ai_keywordFlagExtractor: typeof keywordFlagExtractor;
-declare const ai_knobsAsTools: typeof knobsAsTools;
-declare const ai_llmConsolidator: typeof llmConsolidator;
-declare const ai_llmExtractor: typeof llmExtractor;
-declare const ai_promptNode: typeof promptNode;
-declare const ai_redactor: typeof redactor;
-declare const ai_streamExtractor: typeof streamExtractor;
-declare const ai_streamingPromptNode: typeof streamingPromptNode;
-declare const ai_suggestStrategy: typeof suggestStrategy;
-declare const ai_systemPromptBuilder: typeof systemPromptBuilder;
-declare const ai_toolCallExtractor: typeof toolCallExtractor;
-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_ContentDecision as ContentDecision, type ai_ContentGateOptions as ContentGateOptions, type ai_CostMeterOptions as CostMeterOptions, type ai_CostMeterReading as CostMeterReading, type ai_ExtractedToolCall as ExtractedToolCall, type ai_FromLLMOptions as FromLLMOptions, type ai_GatedStreamHandle as GatedStreamHandle, type ai_GatedStreamOptions as GatedStreamOptions, type ai_GaugesAsContextOptions as GaugesAsContextOptions, type ai_GraphDefValidation as GraphDefValidation, type ai_GraphFromSpecOptions as GraphFromSpecOptions, type ai_KeywordFlag as KeywordFlag, type ai_KeywordFlagExtractorOptions as KeywordFlagExtractorOptions, 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_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_PromptNodeOptions as PromptNodeOptions, type ai_RedactorOptions as RedactorOptions, 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_StreamChunk as StreamChunk, type ai_StreamingPromptNodeHandle as StreamingPromptNodeHandle, type ai_StreamingPromptNodeOptions as StreamingPromptNodeOptions, 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_contentGate as contentGate, ai_costMeterExtractor as costMeterExtractor, ai_fromLLM as fromLLM, ai_gatedStream as gatedStream, ai_gaugesAsContext as gaugesAsContext, ai_graphFromSpec as graphFromSpec, ai_keywordFlagExtractor as keywordFlagExtractor, ai_knobsAsTools as knobsAsTools, ai_llmConsolidator as llmConsolidator, ai_llmExtractor as llmExtractor, ai_promptNode as promptNode, ai_redactor as redactor, ai_streamExtractor as streamExtractor, ai_streamingPromptNode as streamingPromptNode, ai_suggestStrategy as suggestStrategy, ai_systemPromptBuilder as systemPromptBuilder, ai_toolCallExtractor as toolCallExtractor, ai_toolRegistry as toolRegistry, ai_validateGraphDef as validateGraphDef };
-}
-
-/**
- * Audit, policy enforcement, and compliance export (roadmap §9.2).
- *
- * Three composed factories that wrap any {@link Graph} with the harness
- * accountability layer:
- *
- * - {@link auditTrail} — reactive mutation log with by-node/by-actor/by-time
- *   queries.
- * - {@link policyEnforcer} — reactive ABAC enforcement; in `"audit"` mode
- *   records would-be denials, in `"enforce"` mode pushes guards onto target
- *   nodes so subsequent writes throw {@link GuardDenied}.
- * - {@link complianceSnapshot} — point-in-time export of graph state +
- *   audit trail + policies for regulatory archival.
- *
- * @module
- */
-
-/** A single recorded mutation/event in an {@link AuditTrailGraph}. */
-interface AuditEntry {
-    seq: number;
-    timestamp_ns: number;
-    wall_clock_ns: number;
-    path: string;
-    type: "data" | "dirty" | "resolved" | "invalidate" | "pause" | "resume" | "complete" | "error" | "teardown";
-    actor?: Actor;
-    value?: unknown;
-    error?: unknown;
-    reason?: string;
-}
-/** Options for {@link auditTrail}. */
-interface AuditTrailOptions {
-    name?: string;
-    graph?: GraphOptions;
-    /** Ring-buffer cap for the underlying `reactiveLog`. Default: unbounded. */
-    maxSize?: number;
-    /**
-     * Which event types to record. Default: `["data", "error", "complete",
-     * "teardown"]` — the user-meaningful set. Opt in to mid-wave protocol
-     * events (`"dirty"`, `"resolved"`, `"invalidate"`, `"pause"`, `"resume"`)
-     * by listing them explicitly. Note: those tier-1/tier-2 events do not
-     * carry an `actor` (no `lastMutation` populated) — record them only for
-     * protocol-level diagnostics.
-     */
-    includeTypes?: readonly AuditEntry["type"][];
-    /** Per-event filter; return false to skip. */
-    filter?: (entry: AuditEntry) => boolean;
-}
-/**
- * Mounted audit log — `entries` exposes the reactive `AuditEntry[]`; query
- * helpers are sync convenience wrappers over the cached snapshot.
- */
-declare class AuditTrailGraph extends Graph {
-    readonly entries: Node<readonly AuditEntry[]>;
-    readonly count: Node<number>;
-    private readonly _log;
-    private readonly _target;
-    constructor(target: Graph, opts: AuditTrailOptions);
-    /** All entries currently in the ring (snapshot). */
-    all(): readonly AuditEntry[];
-    /** Entries matching `path`. Order preserved. */
-    byNode(path: string): readonly AuditEntry[];
-    /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
-    byActor(actorId: string): readonly AuditEntry[];
-    /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
-    byActorType(type: string): readonly AuditEntry[];
-    /**
-     * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
-     * Omit `end_ns` to query open-ended.
-     */
-    byTimeRange(start_ns: number, end_ns?: number): readonly AuditEntry[];
-    /** Reference to the audited graph (escape hatch for tooling). */
-    get target(): Graph;
-}
-/**
- * Wraps any {@link Graph} with a reactive audit trail recording every event
- * matching `includeTypes` (default: data + error + complete + teardown).
- *
- * Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
- * `path`, `type`, and — when available — `actor`, `value`, `error`, and the
- * `graph.trace()` reasoning annotation for the path.
- *
- * The returned graph mounts an `entries` node + `count` derived. Query
- * helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
- * snapshot synchronously.
- */
-declare function auditTrail(target: Graph, opts?: AuditTrailOptions): AuditTrailGraph;
-/** A single policy denial recorded by {@link PolicyEnforcerGraph}. */
-interface PolicyViolation {
-    timestamp_ns: number;
-    wall_clock_ns: number;
-    path: string;
-    actor: Actor;
-    action: GuardAction;
-    mode: "audit" | "enforce";
-    /** `"observed"` (audit mode after-the-fact) or `"blocked"` (enforce mode pre-write). */
-    result: "observed" | "blocked";
-}
-/** Options for {@link policyEnforcer}. */
-interface PolicyEnforcerOptions {
-    name?: string;
-    graph?: GraphOptions;
-    /**
-     * `"audit"` (default) — observe events and record would-be denials;
-     * does not block writes. Audit mode requires `lastMutation` attribution
-     * on the audited node — anonymous/internal writes (no `actor` passed,
-     * unguarded node) are skipped silently because the policy cannot be
-     * evaluated without an actor.
-     *
-     * `"enforce"` — push guards onto target nodes so disallowed writes
-     * throw {@link GuardDenied}. Reverted on dispose.
-     */
-    mode?: "audit" | "enforce";
-    /**
-     * Restrict enforcement to specific node paths (qualified). When omitted,
-     * applies to every node visible in `target.describe()` at construction
-     * time (subgraphs are walked transitively) AND subscribes to the full
-     * topology tree via {@link watchTopologyTree}, so nodes added to
-     * `target` OR any transitively-mounted subgraph after construction are
-     * guarded automatically (enforce mode only).
-     *
-     * **Cost:** unrestricted mode runs `describe({detail:"minimal"})` once
-     * at construction (O(N) over the graph tree) plus one topology
-     * subscription per graph instance in the mount tree. Restricted mode
-     * skips both and disables dynamic coverage — callers providing
-     * `paths` must re-create on subgraph changes.
-     */
-    paths?: readonly string[];
-    /** Ring-buffer cap for the violations topic. Default: 1000. */
-    violationsLimit?: number;
-}
-/**
- * Reactive ABAC enforcement layer. Policies are reactive — pass a
- * `Node<readonly PolicyRuleData[]>` to allow LLMs (or any reactive source)
- * to update them at runtime; the enforcer rebinds its internal
- * {@link NodeGuard} on every push.
- */
-declare class PolicyEnforcerGraph extends Graph {
-    readonly policies: Node<readonly PolicyRuleData[]>;
-    readonly violations: TopicGraph<PolicyViolation>;
-    readonly violationCount: Node<number>;
-    private readonly _target;
-    private readonly _mode;
-    private _currentGuard;
-    constructor(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts: PolicyEnforcerOptions);
-    private _publishViolation;
-    /** Snapshot of recorded violations. */
-    all(): readonly PolicyViolation[];
-    get mode(): "audit" | "enforce";
-    get target(): Graph;
-}
-/**
- * Wraps a {@link Graph} with reactive policy enforcement. Pass either a
- * static rule list or a {@link Node} of rules (LLM-updatable). Records
- * `PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
- * pushes guards onto target nodes so disallowed writes throw.
- */
-declare function policyEnforcer(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts?: PolicyEnforcerOptions): PolicyEnforcerGraph;
-/**
- * Reactive {@link CausalChain} that recomputes whenever the audited graph
- * changes. Returns a `Node<CausalChain>` suitable for subscription, mounting,
- * or composition (e.g. inside `graphLens.why(node)`).
- *
- * **How it stays live:** an internal `version` state is bumped by an observer
- * attached to `target.observe()`; the derived chain depends on `version`, so
- * each mutation triggers a recompute. To avoid stalling on no-op events, only
- * `data`, `error`, `complete`, and `teardown` bump the version (matching the
- * audit defaults).
- */
-declare function reactiveExplainPath(target: Graph, from: string, to: string, opts?: {
-    maxDepth?: number;
-    name?: string;
-    findCycle?: boolean;
-}): {
-    node: Node<CausalChain>;
-    dispose: () => void;
-};
-/** Options for {@link complianceSnapshot}. */
-interface ComplianceSnapshotOptions {
-    audit?: AuditTrailGraph;
-    policies?: PolicyEnforcerGraph;
-    /** Actor recorded as the snapshot taker. */
-    actor?: Actor;
-}
-/** Output of {@link complianceSnapshot}. JSON-serializable. */
-interface ComplianceSnapshotResult {
-    format_version: 1;
-    timestamp_ns: number;
-    wall_clock_ns: number;
-    actor?: Actor;
-    graph: GraphPersistSnapshot;
-    audit?: {
-        count: number;
-        entries: AuditEntry[];
-    };
-    policies?: {
-        mode: "audit" | "enforce";
-        rules: readonly PolicyRuleData[];
-        violations: readonly PolicyViolation[];
-    };
-    /**
-     * Truncated SHA-256 hex (16 chars / ~64 bits) over a canonical encoding
-     * of every field above (excluding `fingerprint` itself). Deterministic
-     * across runs given identical inputs. Suitable for casual tamper-evidence
-     * and content-addressed dedup; for full cryptographic strength, hash the
-     * canonical JSON externally with Web Crypto / Node `crypto`.
-     */
-    fingerprint: string;
-}
-/**
- * One-shot point-in-time export of a {@link Graph}'s state plus optional
- * audit + policy bundles. Returns a JSON-serializable object with a
- * deterministic truncated-SHA-256 {@link ComplianceSnapshotResult.fingerprint}
- * over the canonical payload for tamper-evidence in regulatory archival.
- *
- * **Cryptographic strength:** the fingerprint is truncated to 64 bits for
- * compact archival. Collision-resistant for casual integrity checks but NOT
- * sufficient for adversarial tamper-evidence — pair with a full SHA-256
- * (or stronger) over the canonical JSON when regulatory requirements demand
- * collision resistance.
- */
-declare function complianceSnapshot(target: Graph, opts?: ComplianceSnapshotOptions): ComplianceSnapshotResult;
-
-type audit_AuditEntry = AuditEntry;
-type audit_AuditTrailGraph = AuditTrailGraph;
-declare const audit_AuditTrailGraph: typeof AuditTrailGraph;
-type audit_AuditTrailOptions = AuditTrailOptions;
-type audit_ComplianceSnapshotOptions = ComplianceSnapshotOptions;
-type audit_ComplianceSnapshotResult = ComplianceSnapshotResult;
-type audit_PolicyEnforcerGraph = PolicyEnforcerGraph;
-declare const audit_PolicyEnforcerGraph: typeof PolicyEnforcerGraph;
-type audit_PolicyEnforcerOptions = PolicyEnforcerOptions;
-type audit_PolicyViolation = PolicyViolation;
-declare const audit_auditTrail: typeof auditTrail;
-declare const audit_complianceSnapshot: typeof complianceSnapshot;
-declare const audit_policyEnforcer: typeof policyEnforcer;
-declare const audit_reactiveExplainPath: typeof reactiveExplainPath;
-declare namespace audit {
-  export { type audit_AuditEntry as AuditEntry, audit_AuditTrailGraph as AuditTrailGraph, type audit_AuditTrailOptions as AuditTrailOptions, type audit_ComplianceSnapshotOptions as ComplianceSnapshotOptions, type audit_ComplianceSnapshotResult as ComplianceSnapshotResult, audit_PolicyEnforcerGraph as PolicyEnforcerGraph, type audit_PolicyEnforcerOptions as PolicyEnforcerOptions, type audit_PolicyViolation as PolicyViolation, audit_auditTrail as auditTrail, audit_complianceSnapshot as complianceSnapshot, audit_policyEnforcer as policyEnforcer, audit_reactiveExplainPath as reactiveExplainPath };
-}
-
 /**
  * Domain templates (roadmap §8.2).
  *
@@ -3779,4 +2122,4 @@ declare namespace index {
  */
 declare const version = "0.0.0";
 
-export { Actor, type CatalogFnEntry, type CatalogSourceEntry, CausalChain, CircuitBreakerOptions, CircuitState, type ConfigFieldSchema, type CreateGraphOptions, DerivedFn, DescribeFilter, DistillBundle, Extraction, FallbackInput, type FnFactory, Graph, GraphAttachStorageOptions, GraphDescribeOptions, GraphDescribeOutput, GraphDiffResult, GraphNodeFactory, GraphOptions, GraphPersistSnapshot, GraphProfileOptions, GraphProfileResult, type GraphSpec, type GraphSpecCatalog, type GraphSpecFeedbackEdge, type GraphSpecNode, type GraphSpecTemplate, type GraphSpecTemplateRef, type GraphSpecValidation, GuardAction, NS_PER_MS, NS_PER_SEC, Node, NodeActions, NodeInput, NodeOptions, PolicyRuleData, RateLimiterOptions, ReactiveMapBundle, type ReduceOptions, type RestoreSnapshotOptions, RetryOptions, SNAPSHOT_WIRE_VERSION, type SaveSnapshotResult, type SourceFactory, StatusValue, StorageHandle, StorageTier, SurfaceError, type SurfaceErrorCode, type SurfaceErrorPayload, audit as accountability, ai, asSurfaceError, cqrs, createGraph, deleteSnapshot, demoShell, diffSnapshots, domainTemplates, graphspec, guardedExecution$1 as guarded, index$2 as harness, index$3 as layout, lens, listSnapshots, memory, messaging, orchestration, index as patterns, reduction, resilientPipeline$1 as resilientPipeline, restoreSnapshot, runReduction, saveSnapshot, index$1 as surface, version, watchTopologyTree };
+export { Actor, type CatalogFnEntry, type CatalogSourceEntry, CausalChain, CircuitBreakerOptions, CircuitState, type ConfigFieldSchema, type CreateGraphOptions, DescribeFilter, FallbackInput, type FnFactory, Graph, GraphDescribeOptions, GraphDescribeOutput, GraphDiffResult, GraphNodeFactory, GraphOptions, GraphProfileOptions, GraphProfileResult, type GraphSpec, type GraphSpecCatalog, type GraphSpecFeedbackEdge, type GraphSpecNode, type GraphSpecTemplate, type GraphSpecTemplateRef, type GraphSpecValidation, NS_PER_MS, NS_PER_SEC, Node, NodeOptions, PolicyRuleData, RateLimiterOptions, ReactiveMapBundle, type ReduceOptions, type RestoreSnapshotOptions, RetryOptions, SNAPSHOT_WIRE_VERSION, type SaveSnapshotResult, type SourceFactory, StatusValue, StorageTier, SurfaceError, type SurfaceErrorCode, type SurfaceErrorPayload, audit as accountability, ai, asSurfaceError, cqrs, createGraph, deleteSnapshot, demoShell, diffSnapshots, domainTemplates, graphspec, guardedExecution$1 as guarded, index$2 as harness, index$3 as layout, lens, listSnapshots, memory, messaging, orchestration, index as patterns, reduction, resilientPipeline$1 as resilientPipeline, restoreSnapshot, runReduction, saveSnapshot, index$1 as surface, version, watchTopologyTree };