@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/index.d.cts

@@ -1,2026 +1,41 @@
-import { N as Node, a as NodeOptions, b as NodeActions, A as Actor } from './node-B-f-Lu-k.cjs';
-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, G as GlobalInspectorEvent, j as GlobalInspectorHook, k as GraphReFlyConfig, l as GuardAction, 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, P as NodeVersionInfo, Q as OnMessageHandler, R as OnSubscribeHandler, S as PAUSE, T as PolicyAllow, U as PolicyDeny, V as PolicyRuleData, 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-B-f-Lu-k.cjs';
-import { i as index$b, c as cqrs } from './index-J7Kc0oIQ.cjs';
-import { Ref, WatchSource } from 'vue';
-import { G as Graph, a as GraphOptions, b as GraphAttachStorageOptions, c as GraphProfileResult, d as GraphProfileOptions } from './graph-D-3JIQme.cjs';
-export { D as DescribeFilter, e as GRAPH_META_SEGMENT, f as GraphActorOptions, g as GraphCheckpointRecord, h as GraphDescribeOptions, i as GraphDescribeOutput, j as GraphDiagramDirection, k as GraphDiagramOptions, l as GraphDiffChange, m as GraphDiffResult, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q as GraphObserveOne, r as GraphPersistSnapshot, s as GraphVersionChange, t as GraphWALDiff, N as NodeProfile, O as ObserveDetail, u as ObserveEvent, v as ObserveOptions, w as ObserveResult, x as ObserveTheme, y as ObserveThemeName, R as ReachableDirection, z as ReachableOptions, T as TraceEntry, A as diffForWAL, B as graphProfile, C as reachable } from './graph-D-3JIQme.cjs';
-import { D as DerivedFn } from './index-BJB7t9gg.cjs';
-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-BJB7t9gg.cjs';
-import { N as NodeInput, D as DistillBundle, E as Extraction } from './index-Ch0IpIO0.cjs';
-export { A as AckableMessage, a as AdapterHandlers, b as AsyncSourceOpts, B as BackoffPreset, c as BackoffStrategy, d as BatchMessage, e as BridgeMessage, f as BufferedSinkHandle, g as BundleTriad, C as CSVRow, h as CacheEvictionPolicy, i as CascadingCache, j as CascadingCacheOptions, k as CheckpointToRedisOptions, l as CheckpointToS3Options, m as CircuitBreaker, n as CircuitBreakerOptions, o as CircuitOpenError, p as CircuitState, q as ClickHouseClientLike, r as ClickHouseInsertClientLike, s as ClickHouseRow, t as CronSchedule, u as DistillOptions, v as DrizzleQueryLike, w as EmitTriad, x as ErrorMessage, y as EventTargetLike, z as ExponentialBackoffOptions, F as ExternalBundleOptions, G as ExternalRegister, H as FSEvent, I as FSEventType, J as FallbackInput, K as FileWriterLike, L as FromCSVOptions, M as FromClickHouseWatchOptions, O as FromCronOptions, P as FromDrizzleOptions, Q as FromFSWatchOptions, R as FromGitHookOptions, S as FromHTTPOptions, T as FromHTTPPollOptions, U as FromHTTPStreamOptions, V as FromKafkaOptions, W as FromKyselyOptions, X as FromMCPOptions, Y as FromNATSOptions, Z as FromNDJSONOptions, _ as FromOTelOptions, $ as FromPrismaOptions, a0 as FromPrometheusOptions, a1 as FromPulsarOptions, a2 as FromRabbitMQOptions, a3 as FromRedisStreamOptions, a4 as FromSSEOptions, a5 as FromSqliteOptions, a6 as FromStatsDOptions, a7 as FromSyslogOptions, a8 as FromWebSocketReconnectOptions, a9 as GitEvent, aa as GitHookType, ab as HTTPBundle, ac as IndexBackend, ad as IndexRow, ae as InitMessage, af as JitterMode, ag as KafkaConsumerLike, ah as KafkaMessage, ai as KafkaProducerLike, aj as KyselyQueryLike, ak as ListBackend, al as LogBackend, am as LokiClientLike, an as LokiStream, ao as MCPClientLike, ap as MapBackend, aq as MergeMapOptions, ar as MongoCollectionLike, as as NATSClientLike, at as NATSMessage, au as NATSSubscriptionLike, av as NS_PER_MS, aw as NS_PER_SEC, 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 RateLimiterOptions, aU as RateLimiterOverflowError, aV as RateLimiterOverflowPolicy, aW as ReactiveCounterBundle, aX as ReactiveIndexBundle, aY as ReactiveIndexOptions, aZ as ReactiveListBundle, a_ as ReactiveListOptions, a$ as ReactiveLogBundle, b0 as ReactiveLogOptions, b1 as ReactiveMapBundle, b2 as ReactiveMapOptions, b3 as ReactiveSinkBackpressureOptions, b4 as ReactiveSinkConfig, b5 as ReactiveSinkHandle, b6 as ReactiveSinkOptions, b7 as ReactiveSinkRetryOptions, b8 as ReadyMessage, b9 as RedisCheckpointClientLike, ba as RedisClientLike, bb as RedisStreamEntry, bc as ResettableTimer, bd as RetryOptions, be as RetrySourceOptions, bf as S3ClientLike, bg as SSEEvent, bh as SignalMessage, bi as SinkFailure, bj as SinkHandle, bk as SinkTransportError, bl as SqliteDbLike, bm as SqliteIterableDbLike, bn as StatsDMetric, bo as StatsDRegister, bp as StatusValue, bq as SyslogMessage, br as SyslogRegister, bs as TapObserver, bt as TempoClientLike, bu as ThrottleOptions, bv as TimeoutError, bw as ToCSVOptions, bx as ToClickHouseOptions, by as ToFileOptions, bz as ToHTTPOptions, bA as ToKafkaOptions, bB as ToLokiOptions, bC as ToMongoOptions, bD as ToNATSOptions, bE as ToPostgresOptions, bF as ToPulsarOptions, bG as ToRabbitMQOptions, bH as ToRedisStreamOptions, bI as ToS3Options, bJ as ToSSEOptions, bK as ToSqliteOptions, bL as ToTempoOptions, bM as ToWebSocketOptions, bN as TokenBucket, bO as UpsertOptions, bP as ValueMessage, bQ as VerifiableBundle, bR as VerifiableOptions, bS as VerifyValue, bT as WatermarkController, bU as WatermarkOptions, bV as WebSocketLike, bW as WebSocketMessageEventLike, bX as WebSocketRegister, bY as WebhookRegister, bZ as WithBreakerBundle, b_ as WithStatusBundle, b$ as WorkerBridge, c0 as WorkerBridgeOptions, c1 as WorkerSelfHandle, c2 as WorkerSelfOptions, c3 as WorkerTransport, c4 as audit, c5 as buffer, c6 as bufferCount, c7 as bufferTime, c8 as cached, c9 as cascadingCache, ca as catchError, cb as checkpointToRedis, cc as checkpointToS3, cd as circuitBreaker, ce as combine, cf as combineLatest, cg as concat, ch as concatMap, ci as constant, cj as createTransport, ck as createWatermarkController, cl as csvRows, cm as debounce, cn as debounceTime, co as decorrelatedJitter, cp as delay, cq as deserializeError, cr as distill, cs as distinctUntilChanged, ct as elementAt, cu as empty, cv as escapeRegexChar, cw as exhaustMap, cx as exponential, cy as externalBundle, cz as externalProducer, cA as extra, cB as fallback, cC as fibonacci, cD as filter, cE as find, cF as first, cG as firstValueFrom, cH as firstWhere, cI as flatMap, cJ as forEach, cK as fromAny, cL as fromAsyncIter, cM as fromCSV, cN as fromClickHouseWatch, cO as fromCron, cP as fromDrizzle, cQ as fromEvent, cR as fromFSWatch, cS as fromGitHook, cT as fromHTTP, cU as fromHTTPPoll, cV as fromHTTPStream, cW as fromIter, cX as fromKafka, cY as fromKysely, cZ as fromMCP, c_ as fromNATS, c$ as fromNDJSON, d0 as fromOTel, d1 as fromPrisma, d2 as fromPrometheus, d3 as fromPromise, d4 as fromPulsar, d5 as fromRabbitMQ, d6 as fromRaf, d7 as fromRedisStream, d8 as fromSSE, d9 as fromSqlite, da as fromSqliteCursor, db as fromStatsD, dc as fromSyslog, dd as fromTimer, de as fromWebSocket, df as fromWebSocketReconnect, dg as fromWebhook, dh as globToRegExp, di as interval, dj as keepalive, dk as last, dl as linear, dm as lru, dn as map, dp as matchesAnyPattern, dq as matchesCron, dr as merge, ds as mergeMap, dt as nameToSignal, du as ndjsonRows, dv as never, dw as of, dx as pairwise, dy as parseCron, dz as parsePrometheusText, dA as parseStatsD, dB as parseSyslog, dC as pausable, dD as pubsub, dE as race, dF as rateLimiter, dG as reactiveCounter, dH as reactiveIndex, dI as reactiveList, dJ as reactiveLog, dK as reactiveMap, dL as reactiveSink, dM as reduce, dN as repeat, dO as replay, dP as rescue, dQ as resolveBackoffPreset, dR as retry, dS as retrySource, dT as sample, dU as scan, dV as serializeError, dW as share, dX as shareReplay, dY as signalToName, dZ as skip, d_ as switchMap, d$ as take, e0 as takeUntil, e1 as takeWhile, e2 as tap, e3 as throttle, e4 as throttleTime, e5 as throwError, e6 as timeout, e7 as toArray, e8 as toCSV, e9 as toClickHouse, ea as toFile, eb as toHTTP, ec as toKafka, ed as toLoki, ee as toMongo, ef as toNATS, eg as toPostgres, eh as toPulsar, ei as toRabbitMQ, ej as toReadableStream, ek as toRedisStream, el as toS3, em as toSSE, en as toSSEBytes, eo as toSqlite, ep as toTempo, eq as toWebSocket, er as tokenBucket, es as valve, et as verifiable, eu as window, ev as windowCount, ew as windowTime, ex as withBreaker, ey as withLatestFrom, ez as withMaxAttempts, eA as withStatus, eB as workerBridge, eC as workerSelf, eD as zip } from './index-Ch0IpIO0.cjs';
-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-AMWewNDe.cjs';
-import { S as StorageHandle, a as StorageTier } from './storage-BuTdpCI1.cjs';
-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-BuTdpCI1.cjs';
-import { M as MeasurementAdapter, i as index$c } from './index-DKE1EATr.cjs';
-export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-DWbkoq1s.cjs';
-export { T as ToObservableOptions, t as toObservable } from './observable-DBnrwcar.cjs';
+export { i as compat, a as signals } from './index-D8wS_PeY.cjs';
+export { b as batch, i as core, d as downWithBatch, a as isBatching, m as monotonicNs, w as wallClockNs } from './index-DVGiGFGT.cjs';
+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-BHlKbUwO.cjs';
+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-BHlKbUwO.cjs';
+import { w as watchTopologyTree } from './index-CO8uBlUh.cjs';
+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-CO8uBlUh.cjs';
+import { L as LLMAdapter, G as GateController, a as ai, o as orchestration } from './ai-CaR_912Q.cjs';
+import { P as PolicyEnforcerGraph, a as PolicyViolation, b as audit } from './audit-ClmqGOCx.cjs';
+import { c as cqrs } from './index-DlLp-2Xn.cjs';
+export { i as nestjs } from './index-DlLp-2Xn.cjs';
+import { d as demoShell } from './demo-shell-Crid1WdR.cjs';
+import { N as Node, P as PolicyRuleData, A as Actor, a as NodeOptions } from './node-BmerH3kS.cjs';
+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.cjs';
+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-DNCrvZSn.cjs';
+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-DNCrvZSn.cjs';
+import { T as TopicGraph, m as messaging } from './messaging-Gt4LPbyA.cjs';
+import { R as ReactiveMapBundle } from './composite-C7PcQvcs.cjs';
+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-C7PcQvcs.cjs';
+import { m as memory } from './memory-C6Z2tGpC.cjs';
+import { i as index$3 } from './index-CI3DprxP.cjs';
+import { S as StorageTier } from './storage-DdWlZo6U.cjs';
+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-DdWlZo6U.cjs';
+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.cjs';
+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-D02n5JjF.cjs';
+export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-BxCA7rcr.cjs';
+export { T as ToObservableOptions, t as toObservable } from './observable-DJt_AxzQ.cjs';
+export { i as jotai } from './index-ByQxazQJ.cjs';
+export { i as nanostores } from './index-DO_6JN9Z.cjs';
+export { i as react } from './index-DYme44FM.cjs';
+export { i as solid } from './index-Xi3u0HCQ.cjs';
+export { i as svelte } from './index-VHqptjhu.cjs';
+export { i as vue } from './index-B1tloyhO.cjs';
+export { i as zustand } from './index-B6EhDnjH.cjs';
 import '@nestjs/common';
 import '@nestjs/core';
+import './reactive-layout-MQP--J3F.cjs';
 import 'rxjs';
-
-/**
- * Options for creating an atom.
- *
- * @category compat
- */
-interface AtomOptions {
-    /** Optional identifier for the underlying node. */
-    name?: string;
-    /** Optional companion meta nodes. */
-    meta?: Record<string, unknown>;
-}
-/**
- * A read-only Jotai-compatible atom.
- *
- * @category compat
- */
-interface ReadableAtom<T> {
-    /** Returns the current cached value. */
-    get(): T;
-    /** Subscribes to value changes. Returns an unsubscribe function. */
-    subscribe(callback: (value: T) => void): () => void;
-    /** Access to companion meta nodes. */
-    readonly meta: Record<string, Node>;
-    /** @internal The underlying GraphReFly node. */
-    _node: Node<T>;
-}
-/**
- * A writable Jotai-compatible atom.
- *
- * @category compat
- */
-interface WritableAtom<T> extends ReadableAtom<T> {
-    /** Sets a new value. */
-    set(value: T): void;
-    /** Updates the value using a transformation function. */
-    update(fn: (current: T) => T): void;
-}
-/** Function type for reading other atoms inside a derived atom. */
-type GetFn = <V>(a: ReadableAtom<V>) => V;
-/** Function type for writing to other atoms inside a writable derived atom. */
-type SetFn = <V>(a: WritableAtom<V>, value: V) => void;
-/** Function that computes the atom's value. */
-type ReadFn<T> = (get: GetFn) => T;
-/** Function that handles writes to the atom. */
-type WriteFn<T> = (get: GetFn, set: SetFn, value: T) => void;
-/**
- * Creates a Jotai-compatible atom built on GraphReFly primitives.
- *
- * Supports three overloads:
- * 1. `atom(initial)` — Writable primitive atom (wraps `state()`).
- * 2. `atom(read)` — Read-only derived atom (wraps `dynamicNode()`).
- * 3. `atom(read, write)` — Writable derived atom.
- *
- * @param initialOrRead - Initial value or a read function.
- * @param writeOrOptions - Write function or options object.
- * @param options - Optional configuration.
- * @returns WritableAtom or ReadableAtom.
- *
- * @example
- * ```ts
- * const count = atom(0);
- * count.set(1);
- * const doubled = atom((get) => get(count)! * 2);
- * ```
- *
- * @category compat
- */
-declare function atom$1<T>(initial: T, options?: AtomOptions): WritableAtom<T>;
-declare function atom$1<T>(read: ReadFn<T>, options?: AtomOptions): ReadableAtom<T>;
-declare function atom$1<T>(read: ReadFn<T>, write: WriteFn<T>, options?: AtomOptions): WritableAtom<T>;
-
-type index$a_AtomOptions = AtomOptions;
-type index$a_GetFn = GetFn;
-type index$a_ReadFn<T> = ReadFn<T>;
-type index$a_ReadableAtom<T> = ReadableAtom<T>;
-type index$a_SetFn = SetFn;
-type index$a_WritableAtom<T> = WritableAtom<T>;
-type index$a_WriteFn<T> = WriteFn<T>;
-declare namespace index$a {
-  export { type index$a_AtomOptions as AtomOptions, type index$a_GetFn as GetFn, type index$a_ReadFn as ReadFn, type index$a_ReadableAtom as ReadableAtom, type index$a_SetFn as SetFn, type index$a_WritableAtom as WritableAtom, type index$a_WriteFn as WriteFn, atom$1 as atom };
-}
-
-/**
- * A Nanostores-compatible atom.
- *
- * @category compat
- */
-interface NanoAtom<T> {
-    /** Get current value. */
-    get(): T;
-    /** Set a new value (writable atoms only). */
-    set(value: T): void;
-    /** Subscribe to value changes. Callback receives the new value.
-     * Returns unsubscribe function. Called immediately with current value. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible computed store.
- *
- * @category compat
- */
-interface NanoComputed<T> {
-    /** Get current value. */
-    get(): T;
-    /** Subscribe to value changes. Called immediately with current value.
-     * Returns unsubscribe function. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible map.
- *
- * @category compat
- */
-interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
-    /** Set a single key. */
-    setKey<K extends keyof T>(key: K, value: T[K]): void;
-}
-/**
- * Creates a nanostores-compatible atom.
- *
- * @param initial - Initial value.
- * @returns `NanoAtom<T>`
- *
- * @category compat
- */
-declare function atom<T>(initial: T): NanoAtom<T>;
-/**
- * Creates a nanostores-compatible computed store.
- *
- * @param stores - One or more atoms/computed stores.
- * @param fn - Compute function.
- * @returns `NanoComputed<T>`
- *
- * @category compat
- */
-declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
-declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
-declare function computed<T, A, B, C>(stores: [
-    NanoAtom<A> | NanoComputed<A>,
-    NanoAtom<B> | NanoComputed<B>,
-    NanoAtom<C> | NanoComputed<C>
-], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
-/**
- * Creates a nanostores-compatible map.
- *
- * @param initial - Initial object value.
- * @returns `NanoMap<T>`
- *
- * @category compat
- */
-declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
-/**
- * Returns the current value of the store.
- *
- * @category compat
- */
-declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
-/**
- * Adds a listener for the store start (first listener connected).
- *
- * @category compat
- */
-declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store stop (last listener disconnected).
- *
- * @category compat
- */
-declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store mount (first listener connected).
- *
- * @returns A cleanup function called when the last listener is removed.
- * @category compat
- */
-declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
-/**
- * Batches multiple store updates.
- *
- * @category compat
- */
-declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
-
-type index$9_NanoAtom<T> = NanoAtom<T>;
-type index$9_NanoComputed<T> = NanoComputed<T>;
-type index$9_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
-declare const index$9_action: typeof action;
-declare const index$9_atom: typeof atom;
-declare const index$9_computed: typeof computed;
-declare const index$9_getValue: typeof getValue;
-declare const index$9_map: typeof map;
-declare const index$9_onMount: typeof onMount;
-declare const index$9_onStart: typeof onStart;
-declare const index$9_onStop: typeof onStop;
-declare namespace index$9 {
-  export { type index$9_NanoAtom as NanoAtom, type index$9_NanoComputed as NanoComputed, type index$9_NanoMap as NanoMap, index$9_action as action, index$9_atom as atom, index$9_computed as computed, index$9_getValue as getValue, index$9_map as map, index$9_onMount as onMount, index$9_onStart as onStart, index$9_onStop as onStop };
-}
-
-/**
- * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - Any `Node<T>`.
- * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
- */
-declare function useSubscribe$3<T>(node: Node<T>): T | undefined | null;
-/**
- * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
- * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - A `Node<T>` (e.g. state node).
- * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
- */
-declare function useStore$3<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory$3<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic set of keyed node records.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
- *
- * @param keysNode - Node of current keys (e.g. node IDs)
- * @param factory - Function returning `{ [field]: Node<V> }` for each key.
- * @returns `Record<K, R>` — snapshot of resolved values for all keys.
- */
-declare function useSubscribeRecord$3<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$3<K, R>): Record<K, R>;
-
-declare namespace index$8 {
-  export { type NodeFactory$3 as NodeFactory, useStore$3 as useStore, useSubscribe$3 as useSubscribe, useSubscribeRecord$3 as useSubscribeRecord };
-}
-
-/**
- * Options for creating signals.
- *
- * @category compat
- */
-interface SignalOptions {
-    /** Optional identifier for the underlying node. */
-    name?: string;
-    /** Custom equality function for change detection. */
-    equals?: (a: any, b: any) => boolean;
-}
-/**
- * Common interface for all reactive signals.
- *
- * @category compat
- */
-interface AnySignal<T> {
-    /** Returns the current value of the signal. */
-    get(): T;
-    /** @internal The underlying GraphReFly node. */
-    _node: Node<T>;
-}
-/**
- * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
- * Automatically registers itself as a dependency if read inside a `Computed`.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * count.get(); // 0
- * count.set(1);
- * count.get(); // 1
- * ```
- */
-declare class SignalState<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    private readonly _equals;
-    constructor(initial: T, opts?: SignalOptions);
-    get(): T;
-    set(value: T): void;
-}
-/**
- * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
- * Automatically tracks dependencies when `get()` is called on other signals
- * during its computation.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * const doubled = new Signal.Computed(() => count.get() * 2);
- * ```
- */
-declare class SignalComputed<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    constructor(computation: () => T, opts?: SignalOptions);
-    get(): T;
-}
-/**
- * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
- * Provides auto-tracking conforming to the TS39 signals proposal.
- *
- * @category compat
- */
-declare const Signal: {
-    readonly State: typeof SignalState;
-    readonly Computed: typeof SignalComputed;
-    /**
-     * Subscribes to changes on a signal.
-     * Returns an unsubscribe callback.
-     *
-     * @example
-     * ```ts
-     * const count = new Signal.State(0);
-     * const unsub = Signal.sub(count, v => console.log(v));
-     * ```
-     */
-    readonly sub: <T>(signal: AnySignal<T>, callback: ((value: T) => void) | {
-        data?: (value: T) => void;
-        error?: (err: unknown) => void;
-        complete?: () => void;
-    }) => (() => void);
-};
-
-type index$7_AnySignal<T> = AnySignal<T>;
-declare const index$7_Signal: typeof Signal;
-type index$7_SignalComputed<T> = SignalComputed<T>;
-declare const index$7_SignalComputed: typeof SignalComputed;
-type index$7_SignalOptions = SignalOptions;
-type index$7_SignalState<T> = SignalState<T>;
-declare const index$7_SignalState: typeof SignalState;
-declare namespace index$7 {
-  export { type index$7_AnySignal as AnySignal, index$7_Signal as Signal, index$7_SignalComputed as SignalComputed, type index$7_SignalOptions as SignalOptions, index$7_SignalState as SignalState };
-}
-
-/** Solid accessor function — returns current value when called. */
-type Accessor<T> = () => T;
-/**
- * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-declare function useSubscribe$2<T>(node: Node<T>): Accessor<T | undefined | null>;
-/**
- * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
- * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-declare function useStore$2<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory$2<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic set of keyed node records as a Solid accessor.
- * Re-subscribes all per-key fields whenever `keys` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-declare function useSubscribeRecord$2<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$2<K, R>): Accessor<Record<K, R>>;
-
-type index$6_Accessor<T> = Accessor<T>;
-declare namespace index$6 {
-  export { type index$6_Accessor as Accessor, type NodeFactory$2 as NodeFactory, useStore$2 as useStore, useSubscribe$2 as useSubscribe, useSubscribeRecord$2 as useSubscribeRecord };
-}
-
-/** Svelte store contract — implements the minimal `subscribe` method. */
-interface SvelteReadable<T> {
-    subscribe(run: (value: T) => void): () => void;
-}
-/** Svelte writable store contract. */
-interface SvelteWritable<T> extends SvelteReadable<T> {
-    set(value: T): void;
-    update(updater: (value: T) => T): void;
-}
-/**
- * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-declare function useSubscribe$1<T>(node: Node<T>): SvelteReadable<T | undefined | null>;
-/**
- * Bind a writable `Node<T>` as a Svelte writable store.
- * Reads and writes adapt seamlessly.
- * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-declare function useStore$1<T>(node: Node<T>): SvelteWritable<T | undefined | null>;
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory$1<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-declare function useSubscribeRecord$1<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$1<K, R>): SvelteReadable<Record<K, R>>;
-
-type index$5_SvelteReadable<T> = SvelteReadable<T>;
-type index$5_SvelteWritable<T> = SvelteWritable<T>;
-declare namespace index$5 {
-  export { type NodeFactory$1 as NodeFactory, type index$5_SvelteReadable as SvelteReadable, type index$5_SvelteWritable as SvelteWritable, useStore$1 as useStore, useSubscribe$1 as useSubscribe, useSubscribeRecord$1 as useSubscribeRecord };
-}
-
-/**
- * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-declare function useSubscribe<T>(node: Node<T>): Readonly<Ref<T | undefined | null>>;
-/**
- * Bind a writable `Node<T>` as a Vue `Ref<T>`. Reads and writes are bidirectional.
- * Value sets always dispatch `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-declare function useStore<T>(node: Node<T>): Ref<T | undefined | null>;
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord` factory. */
-type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic set of keyed node records. When keys change,
- * old subscriptions are torn down and new ones created automatically.
- * Must be called during Vue `setup()`.
- */
-declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keys: WatchSource<K[] | undefined>, factory: NodeFactory<K, R>): Readonly<Ref<Record<K, R>>>;
-
-type index$4_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
-declare const index$4_useStore: typeof useStore;
-declare const index$4_useSubscribe: typeof useSubscribe;
-declare const index$4_useSubscribeRecord: typeof useSubscribeRecord;
-declare namespace index$4 {
-  export { type index$4_NodeFactory as NodeFactory, index$4_useStore as useStore, index$4_useSubscribe as useSubscribe, index$4_useSubscribeRecord as useSubscribeRecord };
-}
-
-/** Zustand-compatible Store API. */
-interface StoreApi<T> {
-    getState: () => T;
-    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
-    getInitialState: () => T;
-    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
-    destroy: () => void;
-}
-/** Function type for initializing the store. */
-type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
-/**
- * Creates a Zustand-compatible store backed by a GraphReFly state node.
- * returns an object that is both a Graph and a StoreApi.
- *
- * @example
- * ```ts
- * const store = create((set) => ({
- *   count: 0,
- *   inc: () => set((s) => ({ count: s.count + 1 }))
- * }));
- * store.getState().inc();
- * ```
- *
- * @category compat
- */
-declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
-
-type index$3_StateCreator<T> = StateCreator<T>;
-type index$3_StoreApi<T> = StoreApi<T>;
-declare const index$3_create: typeof create;
-declare namespace index$3 {
-  export { type index$3_StateCreator as StateCreator, type index$3_StoreApi as StoreApi, index$3_create as create };
-}
-
-/**
- * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
- *
- * Framework adapters are optional peers. Install only what you use:
- * - `@graphrefly/graphrefly-ts/compat/react` -> `react`, `react-dom`
- * - `@graphrefly/graphrefly-ts/compat/vue` -> `vue`
- * - `@graphrefly/graphrefly-ts/compat/svelte` -> `svelte`
- * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
- */
-
-declare namespace index$2 {
-  export { index$a as jotai, index$9 as nanostores, index$b as nestjs, index$8 as react, index$7 as signals, index$6 as solid, index$5 as svelte, index$4 as vue, index$3 as zustand };
-}
-
-/**
- * Memory patterns (roadmap §4.3).
- *
- * Domain-layer helpers composed from GraphRefly primitives. `vectorIndex` uses
- * an exact-search backend by default; an HNSW adapter can be injected as an
- * optional dependency.
- */
-
-type CollectionPolicy = "fifo" | "lru";
-type VectorBackend = "flat" | "hnsw";
-type LightCollectionEntry<T> = {
-    readonly id: string;
-    readonly value: T;
-    readonly createdAtNs: number;
-    readonly lastAccessNs: number;
-};
-type LightCollectionOptions = {
-    name?: string;
-    maxSize?: number;
-    policy?: CollectionPolicy;
-};
-type LightCollectionBundle<T> = {
-    readonly entries: Node<ReadonlyMap<string, LightCollectionEntry<T>>>;
-    upsert: (id: string, value: T) => void;
-    remove: (id: string) => void;
-    clear: () => void;
-    get: (id: string) => T | undefined;
-    has: (id: string) => boolean;
-};
-type CollectionEntry<T> = LightCollectionEntry<T> & {
-    readonly baseScore: number;
-};
-type RankedCollectionEntry<T> = CollectionEntry<T> & {
-    readonly score: number;
-};
-type CollectionOptions<T> = {
-    maxSize?: number;
-    policy?: CollectionPolicy;
-    /**
-     * Produces a base score at insert/update time.
-     */
-    score?: (value: T) => number;
-    /**
-     * Exponential decay rate per second. 0 disables decay.
-     */
-    decayRate?: number;
-    /**
-     * Minimum score floor after decay.
-     */
-    minScore?: number;
-};
-type CollectionGraph<T> = Graph & {
-    upsert: (id: string, value: T, opts?: {
-        score?: number;
-    }) => void;
-    remove: (id: string) => void;
-    clear: () => void;
-    getItem: (id: string) => CollectionEntry<T> | undefined;
-};
-type VectorRecord<TMeta> = {
-    readonly id: string;
-    readonly vector: readonly number[];
-    readonly meta?: TMeta;
-};
-type VectorSearchResult<TMeta> = {
-    readonly id: string;
-    readonly score: number;
-    readonly meta?: TMeta;
-};
-type HnswAdapter<TMeta> = {
-    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
-    remove: (id: string) => void;
-    clear: () => void;
-    search: (query: readonly number[], k: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
-};
-type VectorIndexOptions<TMeta> = {
-    backend?: VectorBackend;
-    dimension?: number;
-    /**
-     * Optional dependency seam for HNSW.
-     */
-    hnswFactory?: () => HnswAdapter<TMeta>;
-};
-type VectorIndexBundle<TMeta> = {
-    readonly backend: VectorBackend;
-    readonly entries: Node<ReadonlyMap<string, VectorRecord<TMeta>>>;
-    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
-    remove: (id: string) => void;
-    clear: () => void;
-    search: (query: readonly number[], k?: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
-};
-type KnowledgeEdge<TRelation extends string = string> = {
-    readonly from: string;
-    readonly to: string;
-    readonly relation: TRelation;
-    readonly weight: number;
-};
-type KnowledgeGraphGraph<TEntity, TRelation extends string = string> = Graph & {
-    upsertEntity: (id: string, value: TEntity) => void;
-    removeEntity: (id: string) => void;
-    link: (from: string, to: string, relation: TRelation, weight?: number) => void;
-    unlink: (from: string, to: string, relation?: TRelation) => void;
-    related: (id: string, relation?: TRelation) => ReadonlyArray<KnowledgeEdge<TRelation>>;
-};
-declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: number, minScore?: number): number;
-declare function lightCollection<T>(opts?: LightCollectionOptions): LightCollectionBundle<T>;
-declare function collection<T>(name: string, opts?: CollectionOptions<T>): CollectionGraph<T>;
-declare function vectorIndex<TMeta>(opts?: VectorIndexOptions<TMeta>): VectorIndexBundle<TMeta>;
-declare function knowledgeGraph<TEntity, TRelation extends string = string>(name: string): KnowledgeGraphGraph<TEntity, TRelation>;
-
-type memory_CollectionEntry<T> = CollectionEntry<T>;
-type memory_CollectionGraph<T> = CollectionGraph<T>;
-type memory_CollectionOptions<T> = CollectionOptions<T>;
-type memory_CollectionPolicy = CollectionPolicy;
-type memory_HnswAdapter<TMeta> = HnswAdapter<TMeta>;
-type memory_KnowledgeEdge<TRelation extends string = string> = KnowledgeEdge<TRelation>;
-type memory_KnowledgeGraphGraph<TEntity, TRelation extends string = string> = KnowledgeGraphGraph<TEntity, TRelation>;
-type memory_LightCollectionBundle<T> = LightCollectionBundle<T>;
-type memory_LightCollectionEntry<T> = LightCollectionEntry<T>;
-type memory_LightCollectionOptions = LightCollectionOptions;
-type memory_RankedCollectionEntry<T> = RankedCollectionEntry<T>;
-type memory_VectorBackend = VectorBackend;
-type memory_VectorIndexBundle<TMeta> = VectorIndexBundle<TMeta>;
-type memory_VectorIndexOptions<TMeta> = VectorIndexOptions<TMeta>;
-type memory_VectorRecord<TMeta> = VectorRecord<TMeta>;
-type memory_VectorSearchResult<TMeta> = VectorSearchResult<TMeta>;
-declare const memory_collection: typeof collection;
-declare const memory_decay: typeof decay;
-declare const memory_knowledgeGraph: typeof knowledgeGraph;
-declare const memory_lightCollection: typeof lightCollection;
-declare const memory_vectorIndex: typeof vectorIndex;
-declare namespace memory {
-  export { type memory_CollectionEntry as CollectionEntry, type memory_CollectionGraph as CollectionGraph, type memory_CollectionOptions as CollectionOptions, type memory_CollectionPolicy as CollectionPolicy, type memory_HnswAdapter as HnswAdapter, type memory_KnowledgeEdge as KnowledgeEdge, type memory_KnowledgeGraphGraph as KnowledgeGraphGraph, type memory_LightCollectionBundle as LightCollectionBundle, type memory_LightCollectionEntry as LightCollectionEntry, type memory_LightCollectionOptions as LightCollectionOptions, type memory_RankedCollectionEntry as RankedCollectionEntry, type memory_VectorBackend as VectorBackend, type memory_VectorIndexBundle as VectorIndexBundle, type memory_VectorIndexOptions as VectorIndexOptions, type memory_VectorRecord as VectorRecord, type memory_VectorSearchResult as VectorSearchResult, memory_collection as collection, memory_decay as decay, memory_knowledgeGraph as knowledgeGraph, memory_lightCollection as lightCollection, memory_vectorIndex as vectorIndex };
-}
-
-/**
- * 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 };
-}
-
-/**
- * Three-pane demo shell (roadmap §7.2).
- *
- * A `Graph("demo-shell")` that dogfoods reactive coordination for the
- * main/side split layout with synchronized cross-highlighting.
- *
- * **Zero framework dependency** — framework bindings wrap pane components only.
- * The shell graph is headless and fully testable.
- */
-
-/** Identifies which pane is the source of a hover event. */
-type HoverPaneType = "visual" | "graph" | "code";
-/** Cross-highlighting hover target. `null` means nothing hovered. */
-type HoverTarget = {
-    pane: HoverPaneType;
-    id: string;
-} | null;
-/** Which pane is full-screened (null = normal layout). */
-type FullscreenPane = "main" | "graph" | "code" | null;
-/**
- * Cross-referencing registry: maps node paths to code line numbers and
- * visual element selectors. Provided by each demo's `store.ts`.
- */
-type NodeRegistry = Map<string, {
-    codeLine: number;
-    visualSelector: string;
-}>;
-/** Callbacks for cross-highlighting effect nodes. */
-type HighlightCallbacks = {
-    /** Called when code-scroll highlight target changes. */
-    codeScroll?: (line: number | null) => void;
-    /** Called when visual highlight target changes. */
-    visual?: (selector: string | null) => void;
-    /** Called when graph highlight target changes. */
-    graph?: (nodeId: string | null) => void;
-};
-/** Label dimensions for graph node sizing. */
-type GraphLabelSize = {
-    width: number;
-    height: number;
-};
-/** Options for {@link demoShell}. */
-type DemoShellOptions = {
-    /** Initial main/side split ratio (0–1). Default: `0.65`. */
-    mainRatio?: number;
-    /** Initial graph/code vertical split in the side pane (0–1). Default: `0.5`. */
-    sideSplit?: number;
-    /** Initial viewport width in pixels. Default: `1280`. */
-    viewportWidth?: number;
-    /** Cross-referencing registry for hover→code/visual/graph mapping. */
-    nodeRegistry?: NodeRegistry;
-    /** Measurement adapter for layout engine integration. When provided, enables layout/* derived nodes. */
-    adapter?: MeasurementAdapter;
-    /** Font string for layout measurement. Default: `"14px monospace"`. */
-    layoutFont?: string;
-    /** Callbacks for cross-highlighting effect nodes. When provided, creates effect nodes visible in describe(). */
-    onHighlight?: HighlightCallbacks;
-};
-/** Return type of {@link demoShell}. */
-type DemoShellHandle = {
-    /** The demo-shell graph. */
-    graph: Graph;
-    setMainRatio(ratio: number): void;
-    setSideSplit(ratio: number): void;
-    setFullscreen(pane: FullscreenPane): void;
-    setViewportWidth(width: number): void;
-    setHoverTarget(target: HoverTarget): void;
-    setDemoGraph(g: Graph | null): void;
-    bumpGraphTick(): void;
-    selectNode(path: string | null): void;
-    setMetaDebug(on: boolean): void;
-    /** Set code text for layout/code-lines measurement (requires adapter). */
-    setCodeText(text: string): void;
-    /** Atomic multi-set — wraps core `batch()` for glitch-free updates. */
-    batch(fn: () => void): void;
-    destroy(): void;
-};
-/**
- * Creates the three-pane demo shell graph (roadmap §7.2).
- *
- * All coordination is reactive — no polling, no imperative triggers.
- * Framework bindings subscribe to named nodes and drive `state` inputs.
- */
-declare function demoShell(opts?: DemoShellOptions): DemoShellHandle;
-
-type demoShell$1_DemoShellHandle = DemoShellHandle;
-type demoShell$1_DemoShellOptions = DemoShellOptions;
-type demoShell$1_FullscreenPane = FullscreenPane;
-type demoShell$1_GraphLabelSize = GraphLabelSize;
-type demoShell$1_HighlightCallbacks = HighlightCallbacks;
-type demoShell$1_HoverPaneType = HoverPaneType;
-type demoShell$1_HoverTarget = HoverTarget;
-type demoShell$1_NodeRegistry = NodeRegistry;
-declare const demoShell$1_demoShell: typeof demoShell;
-declare namespace demoShell$1 {
-  export { type demoShell$1_DemoShellHandle as DemoShellHandle, type demoShell$1_DemoShellOptions as DemoShellOptions, type demoShell$1_FullscreenPane as FullscreenPane, type demoShell$1_GraphLabelSize as GraphLabelSize, type demoShell$1_HighlightCallbacks as HighlightCallbacks, type demoShell$1_HoverPaneType as HoverPaneType, type demoShell$1_HoverTarget as HoverTarget, type demoShell$1_NodeRegistry as NodeRegistry, demoShell$1_demoShell as demoShell };
-}
+import 'vue';
 
 /**
  * Domain templates (roadmap §8.2).
@@ -2565,6 +580,135 @@ declare namespace graphspec {
   export { type graphspec_CatalogFnEntry as CatalogFnEntry, type graphspec_CatalogSourceEntry as CatalogSourceEntry, type graphspec_CompileSpecOptions as CompileSpecOptions, type graphspec_ConfigFieldSchema as ConfigFieldSchema, type graphspec_FnFactory as FnFactory, type graphspec_GraphSpec as GraphSpec, type graphspec_GraphSpecCatalog as GraphSpecCatalog, type graphspec_GraphSpecFeedbackEdge as GraphSpecFeedbackEdge, type graphspec_GraphSpecNode as GraphSpecNode, type graphspec_GraphSpecTemplate as GraphSpecTemplate, type graphspec_GraphSpecTemplateRef as GraphSpecTemplateRef, type graphspec_GraphSpecValidation as GraphSpecValidation, type graphspec_LLMComposeOptions as LLMComposeOptions, type graphspec_LLMRefineOptions as LLMRefineOptions, type graphspec_SourceFactory as SourceFactory, type graphspec_SpecDiffEntry as SpecDiffEntry, type graphspec_SpecDiffResult as SpecDiffResult, graphspec_compileSpec as compileSpec, graphspec_decompileGraph as decompileGraph, graphspec_extractFnFactory as extractFnFactory, graphspec_extractSourceFactory as extractSourceFactory, graphspec_generateCatalogPrompt as generateCatalogPrompt, graphspec_isRichFnEntry as isRichFnEntry, graphspec_isRichSourceEntry as isRichSourceEntry, graphspec_llmCompose as llmCompose, graphspec_llmRefine as llmRefine, graphspec_specDiff as specDiff, graphspec_validateSpec as validateSpec, graphspec_validateSpecAgainstCatalog as validateSpecAgainstCatalog };
 }
 
+/**
+ * Composable safety layer (roadmap §9.0b).
+ *
+ * {@link guardedExecution} wraps any {@link Graph} with:
+ *
+ * - {@link policyEnforcer} — reactive ABAC, policies stored as a `Node` so
+ *   LLMs / humans can update them at runtime. Now with full transitive
+ *   dynamic coverage via `watchTopologyTree`.
+ * - Scoped {@link GuardedExecutionGraph.scopedDescribe} — delegates to
+ *   `target.describe({actor})` so callers see only what the actor is
+ *   allowed to see.
+ * - The enforcer's `violations` topic is republished as `violations` on
+ *   the wrapper, composable with {@link graphLens}.`health` alerts.
+ *
+ * V1 scope: policies + actor + scoped describe. Budget-as-option is NOT
+ * in V1 — it requires a cost-tracking design that hasn't landed yet.
+ * Callers who need a budget limit today append a budget-aware
+ * {@link PolicyRuleData} to the policies list (check current cost and
+ * `deny` when exhausted).
+ *
+ * @module
+ */
+
+/** Options for {@link guardedExecution}. */
+interface GuardedExecutionOptions {
+    /**
+     * Policies enforced against every guarded write. Static list or a live
+     * `Node<readonly PolicyRuleData[]>` (LLM-updatable).
+     *
+     * **Deny-by-default gotcha:** the underlying `policyFromRules()` denies any
+     * action that matches no rule. An empty policies list in `mode: "enforce"`
+     * therefore blocks EVERY write AND every `observe` through the stacked
+     * guard — including `scopedDescribe()`. If you want a permissive base, add
+     * at least `{ effect: "allow", action: "*" }` and layer deny rules on top.
+     * In `mode: "audit"` no guards are stacked, so empty policies are safe.
+     */
+    policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>;
+    /**
+     * Actor whose perspective drives {@link GuardedExecutionGraph.scopedDescribe}
+     * and {@link GuardedExecutionGraph.describe} — when omitted, callers must
+     * pass `{actor}` explicitly or they get the target's raw describe.
+     */
+    actor?: Actor;
+    /**
+     * `"enforce"` (default) — push guards onto target nodes so disallowed
+     * writes throw {@link GuardDenied}.
+     * `"audit"` — record would-be denials to the `violations` topic without
+     * blocking writes.
+     */
+    mode?: "audit" | "enforce";
+    /** Ring-buffer cap for the `violations` topic. Default 1000 (inherited from policyEnforcer). */
+    violationsLimit?: number;
+    /** Wrapper graph name. Default `${target.name}_guarded`. */
+    name?: string;
+    /** Wrapper graph options. */
+    graph?: GraphOptions;
+}
+/**
+ * Wrapper over a target {@link Graph} providing reactive ABAC + scoped
+ * describe. Mounts a {@link PolicyEnforcerGraph} under `enforcer`.
+ *
+ * @category patterns
+ */
+declare class GuardedExecutionGraph extends Graph {
+    readonly enforcer: PolicyEnforcerGraph;
+    readonly violations: TopicGraph<PolicyViolation>;
+    private readonly _target;
+    private readonly _defaultActor;
+    constructor(target: Graph, opts: GuardedExecutionOptions);
+    /**
+     * Describe the **target** graph scoped to the configured actor. Returns
+     * only nodes the actor is permitted to see (via the target's node guards
+     * filtering `describe()` via `actor`).
+     *
+     * Pass `{actor}` in opts to override the configured actor for this call.
+     * Pass any standard {@link GraphDescribeOptions} fields (`detail`,
+     * `fields`, `filter`) — they apply to the target's describe.
+     *
+     * **Mode interaction:**
+     * - In `mode: "enforce"` (default), the enforcer stacks a policy-derived
+     *   guard on every target node. `scopedDescribe({actor})` then filters by
+     *   the AND of per-node guards AND the stacked policy guard.
+     * - In `mode: "audit"`, NO guards are stacked — `scopedDescribe` filters
+     *   purely by the target's pre-existing per-node guards. If a target has
+     *   no node-level guards, the policy rules you pass have no effect on
+     *   visibility (they only populate the `violations` topic on writes).
+     */
+    scopedDescribe(opts?: Omit<GraphDescribeOptions, "actor"> & {
+        actor?: Actor;
+    }): GraphDescribeOutput;
+    /** The wrapped graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wrap a {@link Graph} with {@link policyEnforcer} plus a scoped describe
+ * lens. Returns a {@link GuardedExecutionGraph} that can be mounted, diffed,
+ * or composed with {@link graphLens}.
+ *
+ * @param target - The graph to guard.
+ * @param opts - See {@link GuardedExecutionOptions}.
+ *
+ * @example
+ * ```ts
+ * const guarded = guardedExecution(app, {
+ *   actor: { type: "human", id: "alice" },
+ *   policies: [
+ *     { effect: "allow", action: "read", actorType: "human" },
+ *     { effect: "deny", action: "write", pathPattern: "system::*" },
+ *   ],
+ *   mode: "enforce",
+ * });
+ *
+ * const view = guarded.scopedDescribe({ detail: "standard" });
+ * guarded.violations.events.subscribe(msgs => console.log("violations:", msgs));
+ * ```
+ *
+ * @category patterns
+ */
+declare function guardedExecution(target: Graph, opts: GuardedExecutionOptions): GuardedExecutionGraph;
+
+declare const guardedExecution$1_DescribeFilter: typeof DescribeFilter;
+type guardedExecution$1_GuardedExecutionGraph = GuardedExecutionGraph;
+declare const guardedExecution$1_GuardedExecutionGraph: typeof GuardedExecutionGraph;
+type guardedExecution$1_GuardedExecutionOptions = GuardedExecutionOptions;
+declare const guardedExecution$1_guardedExecution: typeof guardedExecution;
+declare namespace guardedExecution$1 {
+  export { guardedExecution$1_DescribeFilter as DescribeFilter, guardedExecution$1_GuardedExecutionGraph as GuardedExecutionGraph, type guardedExecution$1_GuardedExecutionOptions as GuardedExecutionOptions, guardedExecution$1_guardedExecution as guardedExecution };
+}
+
 /**
  * Harness wiring types (roadmap §9.0).
  *
@@ -3118,66 +1262,223 @@ declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions)
  * @module
  */
 
-type index$1_CodeChange = CodeChange;
-type index$1_CodeChangeBridgeOptions = CodeChangeBridgeOptions;
-declare const index$1_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
-declare const index$1_DEFAULT_QUEUE_CONFIGS: typeof DEFAULT_QUEUE_CONFIGS;
-declare const index$1_DEFAULT_SEVERITY_WEIGHTS: typeof DEFAULT_SEVERITY_WEIGHTS;
-type index$1_ErrorClass = ErrorClass;
-type index$1_ErrorClassifier = ErrorClassifier;
-type index$1_EvalDelta = EvalDelta;
-type index$1_EvalIntakeBridgeOptions = EvalIntakeBridgeOptions;
-type index$1_EvalJudgeScore = EvalJudgeScore;
-type index$1_EvalResult = EvalResult;
-type index$1_EvalTaskDelta = EvalTaskDelta;
-type index$1_EvalTaskResult = EvalTaskResult;
-type index$1_ExecuteOutput = ExecuteOutput;
-type index$1_ExecutionResult = ExecutionResult;
-type index$1_HarnessGraph = HarnessGraph;
-declare const index$1_HarnessGraph: typeof HarnessGraph;
-type index$1_HarnessLoopOptions = HarnessLoopOptions;
-type index$1_HarnessProfileResult = HarnessProfileResult;
-type index$1_HarnessTraceHandle = HarnessTraceHandle;
-type index$1_HarnessTraceOptions = HarnessTraceOptions;
-type index$1_IntakeBridgeOptions = IntakeBridgeOptions;
-type index$1_IntakeItem = IntakeItem;
-type index$1_IntakeSource = IntakeSource;
-type index$1_Intervention = Intervention;
-type index$1_LintError = LintError;
-type index$1_NotifyEffectOptions = NotifyEffectOptions;
-type index$1_NotifyTransport<T> = NotifyTransport<T>;
-type index$1_PrioritySignals = PrioritySignals;
-declare const index$1_QUEUE_NAMES: typeof QUEUE_NAMES;
-type index$1_QueueConfig = QueueConfig;
-type index$1_QueueRoute = QueueRoute;
-type index$1_RootCause = RootCause;
-type index$1_Severity = Severity;
-type index$1_StrategyEntry = StrategyEntry;
-type index$1_StrategyKey = StrategyKey;
-type index$1_StrategyModelBundle = StrategyModelBundle;
-type index$1_StrategySnapshot = StrategySnapshot;
-type index$1_TestFailure = TestFailure;
-type index$1_TraceDetail = TraceDetail;
-type index$1_TraceEvent = TraceEvent;
-type index$1_TraceEventType = TraceEventType;
-type index$1_TriagedItem = TriagedItem;
-type index$1_VerifyResult = VerifyResult;
-declare const index$1_affectedTaskFilter: typeof affectedTaskFilter;
-declare const index$1_beforeAfterCompare: typeof beforeAfterCompare;
-declare const index$1_codeChangeBridge: typeof codeChangeBridge;
-declare const index$1_createIntakeBridge: typeof createIntakeBridge;
-declare const index$1_defaultErrorClassifier: typeof defaultErrorClassifier;
-declare const index$1_evalIntakeBridge: typeof evalIntakeBridge;
-declare const index$1_evalSource: typeof evalSource;
-declare const index$1_harnessLoop: typeof harnessLoop;
-declare const index$1_harnessProfile: typeof harnessProfile;
-declare const index$1_harnessTrace: typeof harnessTrace;
-declare const index$1_notifyEffect: typeof notifyEffect;
-declare const index$1_priorityScore: typeof priorityScore;
-declare const index$1_strategyKey: typeof strategyKey;
-declare const index$1_strategyModel: typeof strategyModel;
-declare namespace index$1 {
-  export { type index$1_CodeChange as CodeChange, type index$1_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index$1_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index$1_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index$1_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index$1_ErrorClass as ErrorClass, type index$1_ErrorClassifier as ErrorClassifier, type index$1_EvalDelta as EvalDelta, type index$1_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index$1_EvalJudgeScore as EvalJudgeScore, type index$1_EvalResult as EvalResult, type index$1_EvalTaskDelta as EvalTaskDelta, type index$1_EvalTaskResult as EvalTaskResult, type index$1_ExecuteOutput as ExecuteOutput, type index$1_ExecutionResult as ExecutionResult, index$1_HarnessGraph as HarnessGraph, type index$1_HarnessLoopOptions as HarnessLoopOptions, type index$1_HarnessProfileResult as HarnessProfileResult, type index$1_HarnessTraceHandle as HarnessTraceHandle, type index$1_HarnessTraceOptions as HarnessTraceOptions, type index$1_IntakeBridgeOptions as IntakeBridgeOptions, type index$1_IntakeItem as IntakeItem, type index$1_IntakeSource as IntakeSource, type index$1_Intervention as Intervention, type index$1_LintError as LintError, type index$1_NotifyEffectOptions as NotifyEffectOptions, type index$1_NotifyTransport as NotifyTransport, type index$1_PrioritySignals as PrioritySignals, index$1_QUEUE_NAMES as QUEUE_NAMES, type index$1_QueueConfig as QueueConfig, type index$1_QueueRoute as QueueRoute, type index$1_RootCause as RootCause, type index$1_Severity as Severity, type index$1_StrategyEntry as StrategyEntry, type index$1_StrategyKey as StrategyKey, type index$1_StrategyModelBundle as StrategyModelBundle, type index$1_StrategySnapshot as StrategySnapshot, type index$1_TestFailure as TestFailure, type index$1_TraceDetail as TraceDetail, type index$1_TraceEvent as TraceEvent, type index$1_TraceEventType as TraceEventType, type index$1_TriagedItem as TriagedItem, type index$1_VerifyResult as VerifyResult, index$1_affectedTaskFilter as affectedTaskFilter, index$1_beforeAfterCompare as beforeAfterCompare, index$1_codeChangeBridge as codeChangeBridge, index$1_createIntakeBridge as createIntakeBridge, index$1_defaultErrorClassifier as defaultErrorClassifier, index$1_evalIntakeBridge as evalIntakeBridge, index$1_evalSource as evalSource, index$1_harnessLoop as harnessLoop, index$1_harnessProfile as harnessProfile, index$1_harnessTrace as harnessTrace, index$1_notifyEffect as notifyEffect, index$1_priorityScore as priorityScore, index$1_strategyKey as strategyKey, index$1_strategyModel as strategyModel };
+type index$2_CodeChange = CodeChange;
+type index$2_CodeChangeBridgeOptions = CodeChangeBridgeOptions;
+declare const index$2_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
+declare const index$2_DEFAULT_QUEUE_CONFIGS: typeof DEFAULT_QUEUE_CONFIGS;
+declare const index$2_DEFAULT_SEVERITY_WEIGHTS: typeof DEFAULT_SEVERITY_WEIGHTS;
+type index$2_ErrorClass = ErrorClass;
+type index$2_ErrorClassifier = ErrorClassifier;
+type index$2_EvalDelta = EvalDelta;
+type index$2_EvalIntakeBridgeOptions = EvalIntakeBridgeOptions;
+type index$2_EvalJudgeScore = EvalJudgeScore;
+type index$2_EvalResult = EvalResult;
+type index$2_EvalTaskDelta = EvalTaskDelta;
+type index$2_EvalTaskResult = EvalTaskResult;
+type index$2_ExecuteOutput = ExecuteOutput;
+type index$2_ExecutionResult = ExecutionResult;
+type index$2_HarnessGraph = HarnessGraph;
+declare const index$2_HarnessGraph: typeof HarnessGraph;
+type index$2_HarnessLoopOptions = HarnessLoopOptions;
+type index$2_HarnessProfileResult = HarnessProfileResult;
+type index$2_HarnessTraceHandle = HarnessTraceHandle;
+type index$2_HarnessTraceOptions = HarnessTraceOptions;
+type index$2_IntakeBridgeOptions = IntakeBridgeOptions;
+type index$2_IntakeItem = IntakeItem;
+type index$2_IntakeSource = IntakeSource;
+type index$2_Intervention = Intervention;
+type index$2_LintError = LintError;
+type index$2_NotifyEffectOptions = NotifyEffectOptions;
+type index$2_NotifyTransport<T> = NotifyTransport<T>;
+type index$2_PrioritySignals = PrioritySignals;
+declare const index$2_QUEUE_NAMES: typeof QUEUE_NAMES;
+type index$2_QueueConfig = QueueConfig;
+type index$2_QueueRoute = QueueRoute;
+type index$2_RootCause = RootCause;
+type index$2_Severity = Severity;
+type index$2_StrategyEntry = StrategyEntry;
+type index$2_StrategyKey = StrategyKey;
+type index$2_StrategyModelBundle = StrategyModelBundle;
+type index$2_StrategySnapshot = StrategySnapshot;
+type index$2_TestFailure = TestFailure;
+type index$2_TraceDetail = TraceDetail;
+type index$2_TraceEvent = TraceEvent;
+type index$2_TraceEventType = TraceEventType;
+type index$2_TriagedItem = TriagedItem;
+type index$2_VerifyResult = VerifyResult;
+declare const index$2_affectedTaskFilter: typeof affectedTaskFilter;
+declare const index$2_beforeAfterCompare: typeof beforeAfterCompare;
+declare const index$2_codeChangeBridge: typeof codeChangeBridge;
+declare const index$2_createIntakeBridge: typeof createIntakeBridge;
+declare const index$2_defaultErrorClassifier: typeof defaultErrorClassifier;
+declare const index$2_evalIntakeBridge: typeof evalIntakeBridge;
+declare const index$2_evalSource: typeof evalSource;
+declare const index$2_harnessLoop: typeof harnessLoop;
+declare const index$2_harnessProfile: typeof harnessProfile;
+declare const index$2_harnessTrace: typeof harnessTrace;
+declare const index$2_notifyEffect: typeof notifyEffect;
+declare const index$2_priorityScore: typeof priorityScore;
+declare const index$2_strategyKey: typeof strategyKey;
+declare const index$2_strategyModel: typeof strategyModel;
+declare namespace index$2 {
+  export { type index$2_CodeChange as CodeChange, type index$2_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index$2_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index$2_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index$2_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index$2_ErrorClass as ErrorClass, type index$2_ErrorClassifier as ErrorClassifier, type index$2_EvalDelta as EvalDelta, type index$2_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index$2_EvalJudgeScore as EvalJudgeScore, type index$2_EvalResult as EvalResult, type index$2_EvalTaskDelta as EvalTaskDelta, type index$2_EvalTaskResult as EvalTaskResult, type index$2_ExecuteOutput as ExecuteOutput, type index$2_ExecutionResult as ExecutionResult, index$2_HarnessGraph as HarnessGraph, type index$2_HarnessLoopOptions as HarnessLoopOptions, type index$2_HarnessProfileResult as HarnessProfileResult, type index$2_HarnessTraceHandle as HarnessTraceHandle, type index$2_HarnessTraceOptions as HarnessTraceOptions, type index$2_IntakeBridgeOptions as IntakeBridgeOptions, type index$2_IntakeItem as IntakeItem, type index$2_IntakeSource as IntakeSource, type index$2_Intervention as Intervention, type index$2_LintError as LintError, type index$2_NotifyEffectOptions as NotifyEffectOptions, type index$2_NotifyTransport as NotifyTransport, type index$2_PrioritySignals as PrioritySignals, index$2_QUEUE_NAMES as QUEUE_NAMES, type index$2_QueueConfig as QueueConfig, type index$2_QueueRoute as QueueRoute, type index$2_RootCause as RootCause, type index$2_Severity as Severity, type index$2_StrategyEntry as StrategyEntry, type index$2_StrategyKey as StrategyKey, type index$2_StrategyModelBundle as StrategyModelBundle, type index$2_StrategySnapshot as StrategySnapshot, type index$2_TestFailure as TestFailure, type index$2_TraceDetail as TraceDetail, type index$2_TraceEvent as TraceEvent, type index$2_TraceEventType as TraceEventType, type index$2_TriagedItem as TriagedItem, type index$2_VerifyResult as VerifyResult, index$2_affectedTaskFilter as affectedTaskFilter, index$2_beforeAfterCompare as beforeAfterCompare, index$2_codeChangeBridge as codeChangeBridge, index$2_createIntakeBridge as createIntakeBridge, index$2_defaultErrorClassifier as defaultErrorClassifier, index$2_evalIntakeBridge as evalIntakeBridge, index$2_evalSource as evalSource, index$2_harnessLoop as harnessLoop, index$2_harnessProfile as harnessProfile, index$2_harnessTrace as harnessTrace, index$2_notifyEffect as notifyEffect, index$2_priorityScore as priorityScore, index$2_strategyKey as strategyKey, index$2_strategyModel as strategyModel };
+}
+
+/** Aggregate topology stats emitted by {@link LensGraph.stats}. */
+interface TopologyStats {
+    /** Total primary nodes across this graph and all transitively mounted subgraphs. */
+    nodeCount: number;
+    /** Total directed edges (derived from deps; no duplicates). */
+    edgeCount: number;
+    /** Count of mounted subgraphs (transitive). */
+    subgraphCount: number;
+    /** Qualified paths with no upstream deps (source nodes). Sorted. */
+    sources: readonly string[];
+    /** Qualified paths with no downstream consumers in-graph (sink nodes). Sorted. */
+    sinks: readonly string[];
+    /** Longest path from any source to any sink (in edges). `0` for empty graphs. */
+    depth: number;
+    /** `true` if the dep DAG contains a cycle (feedback edge). */
+    hasCycles: boolean;
+}
+/** A single health problem entry. */
+interface HealthProblem {
+    path: string;
+    /** V1 only reports `"errored"`. Future versions may add `"completed"`, `"disconnected"`. */
+    status: "errored";
+    /** First errored upstream ancestor along the dep chain, when one exists and is distinct from `path`. */
+    upstreamCause?: string;
+}
+/** Aggregate health snapshot. `ok=true` iff `problems.length === 0`. */
+interface HealthReport {
+    ok: boolean;
+    problems: readonly HealthProblem[];
+}
+/** One per-path flow entry stored in {@link LensGraph.flow}. */
+interface FlowEntry {
+    path: string;
+    /** Cumulative DATA emissions observed since the lens activated. */
+    count: number;
+    /** `monotonicNs()` at the most recent DATA emission, or `null` if none yet. */
+    lastUpdate_ns: number | null;
+}
+/** Options for {@link graphLens}. */
+interface GraphLensOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /**
+     * Limit which node paths `flow` tracks. When omitted, every path in
+     * `target.describe()` is observed. Recommended for graphs with hundreds
+     * of nodes since each tracked path adds one observe-event dispatch per
+     * DATA emission.
+     */
+    pathFilter?: (path: string) => boolean;
+    /**
+     * LRU cap on the {@link LensGraph.flow} map. When set, the flow tracker
+     * evicts least-recently-used paths (by insertion / set order) once the
+     * entry count exceeds this bound. Omit for unbounded (not recommended
+     * for long-running graphs with churning paths). Passed through to the
+     * underlying {@link reactiveMap}'s `maxSize`.
+     */
+    maxFlowPaths?: number;
+}
+/**
+ * Reactive observability surface for a target {@link Graph}.
+ * See {@link graphLens}.
+ *
+ * @category observability
+ */
+declare class LensGraph extends Graph {
+    /**
+     * Aggregate structural stats — `nodeCount`, `edgeCount`, `sources`,
+     * `sinks`, `depth`, `hasCycles`, `subgraphCount`. Recomputes on every
+     * structural change via {@link watchTopologyTree} (transitive).
+     *
+     * Named `stats` (not `topology`) because `Graph.topology` already names
+     * the raw `TopologyEvent` stream on every graph including `LensGraph`;
+     * giving the lens its own `topology` accessor with an incompatible
+     * `Node<TopologyStats>` type would break Liskov substitutability.
+     */
+    readonly stats: Node<TopologyStats>;
+    readonly health: Node<HealthReport>;
+    /**
+     * Per-path flow tracker — a live {@link ReactiveMapBundle} keyed by
+     * qualified path. Use `.get(path)` / `.has(path)` / `.size` for O(1)
+     * sync queries; subscribe to `.entries` for a reactive snapshot of the
+     * whole map. Lazy — the snapshot is materialized only while `.entries`
+     * has subscribers.
+     *
+     * Shape intentionally differs from `stats` / `health` (which are plain
+     * `Node<Report>`) because `flow` is a keyed collection, not a single
+     * aggregate value. The map shape exposes cheaper queries than any
+     * snapshot-based design.
+     */
+    readonly flow: ReactiveMapBundle<string, FlowEntry>;
+    private readonly _target;
+    constructor(target: Graph, opts?: GraphLensOptions);
+    /**
+     * Live causal chain from `from` to `to`. Recomputes whenever the target
+     * mutates. Disposed automatically when the lens is destroyed.
+     *
+     * **Lifetime note:** every call to `why()` registers a lens-owned disposer
+     * that runs on `lens.destroy()`. The returned `dispose` function releases
+     * the internal subscription but does NOT remove the lens-owned disposer —
+     * so heavy calling (e.g. per render frame) accumulates no-op disposers
+     * until lens teardown. Cache the returned handle for long-lived queries.
+     *
+     * @param from - Qualified path of the upstream endpoint.
+     * @param to - Qualified path of the downstream endpoint.
+     * @param opts - See {@link reactiveExplainPath}.
+     */
+    why(from: string, to: string, opts?: {
+        maxDepth?: number;
+        name?: string;
+        findCycle?: boolean;
+    }): {
+        node: Node<CausalChain>;
+        dispose: () => void;
+    };
+    /** Reference to the lensed graph. */
+    get target(): Graph;
+}
+/**
+ * Create a reactive observability lens over a {@link Graph}. Returns a
+ * {@link LensGraph} with three reactive surfaces (`stats`, `health`, `flow`)
+ * plus the `why(from, to)` method.
+ *
+ * The returned graph is detached. Mount it via `target.mount("lens", lens)`
+ * if you want it to appear in the target's `describe()`, or keep it standalone.
+ *
+ * @param target - The graph to observe.
+ * @param opts - See {@link GraphLensOptions}.
+ *
+ * @example
+ * ```ts
+ * const g = new Graph("app");
+ * g.add("counter", state(0));
+ * const lens = graphLens(g);
+ * lens.stats.subscribe((msgs) => console.log(msgs[0]?.[1])); // TopologyStats
+ * // Flow queries — O(1) without subscribing to snapshots:
+ * lens.flow.get("counter");        // FlowEntry | undefined
+ * lens.flow.size;                  // number
+ * lens.flow.entries.subscribe(...); // reactive snapshot, lazy-materialized
+ * ```
+ *
+ * @category observability
+ */
+declare function graphLens(target: Graph, opts?: GraphLensOptions): LensGraph;
+
+type lens_FlowEntry = FlowEntry;
+type lens_GraphLensOptions = GraphLensOptions;
+type lens_HealthProblem = HealthProblem;
+type lens_HealthReport = HealthReport;
+type lens_LensGraph = LensGraph;
+declare const lens_LensGraph: typeof LensGraph;
+type lens_TopologyStats = TopologyStats;
+declare const lens_graphLens: typeof graphLens;
+declare const lens_watchTopologyTree: typeof watchTopologyTree;
+declare namespace lens {
+  export { type lens_FlowEntry as FlowEntry, type lens_GraphLensOptions as GraphLensOptions, type lens_HealthProblem as HealthProblem, type lens_HealthReport as HealthReport, lens_LensGraph as LensGraph, type lens_TopologyStats as TopologyStats, lens_graphLens as graphLens, lens_watchTopologyTree as watchTopologyTree };
 }
 
 /**
@@ -3399,20 +1700,421 @@ declare namespace reduction {
   export { type reduction_BudgetConstraint as BudgetConstraint, type reduction_BudgetGateOptions as BudgetGateOptions, type reduction_EffectivenessEntry as EffectivenessEntry, type reduction_EffectivenessSnapshot as EffectivenessSnapshot, type reduction_EffectivenessTrackerBundle as EffectivenessTrackerBundle, type reduction_EffectivenessTrackerOptions as EffectivenessTrackerOptions, type reduction_FeedbackOptions as FeedbackOptions, type reduction_FunnelOptions as FunnelOptions, type reduction_FunnelStage as FunnelStage, type reduction_ScoredItem as ScoredItem, type reduction_ScorerOptions as ScorerOptions, type reduction_StepRef as StepRef, type reduction_StratifyOptions as StratifyOptions, type reduction_StratifyRule as StratifyRule, reduction_budgetGate as budgetGate, reduction_effectivenessTracker as effectivenessTracker, reduction_feedback as feedback, reduction_funnel as funnel, reduction_scorer as scorer, reduction_stratify as stratify };
 }
 
+/**
+ * Resilience composition with correct nesting order (roadmap §9.0b).
+ *
+ * {@link resilientPipeline} composes the resilience primitives from
+ * `extra/resilience.ts` in the order discovered during the §9.1 eval runs:
+ *
+ * ```text
+ *   rateLimit → budget → breaker → timeout → retry → fallback → status
+ * ```
+ *
+ * Note on retry/timeout ordering: `timeout` is applied BEFORE `retry` so each
+ * retry attempt resubscribes to a fresh deadline (per-attempt semantics). If
+ * `timeout` wrapped `retry`, a single deadline would apply to the entire
+ * retry chain — not what callers expect.
+ *
+ * Every step is optional — omit the option and that layer is skipped. The
+ * returned bundle exposes the final `Node<T>` plus the status/error/breaker
+ * companions so callers can wire them into dashboards, alerts, or
+ * {@link graphLens}.
+ *
+ * Subsumes the pre-1.0 `resilientFetch` template — that template becomes a
+ * preconfigured instance of this factory for the HTTP fetch case.
+ *
+ * @module
+ */
+
+/** Options for {@link resilientPipeline}. Every field is optional — omit to skip that layer. */
+interface ResilientPipelineOptions<T> {
+    /** Admission control — at most `maxEvents` DATA per `windowNs`. See {@link rateLimiter}. */
+    rateLimit?: RateLimiterOptions;
+    /** Cost/constraint gate. See {@link budgetGate}. */
+    budget?: ReadonlyArray<BudgetConstraint>;
+    /** Circuit breaker — fail-fast when the downstream resource is unhealthy. See {@link circuitBreaker}. */
+    breaker?: CircuitBreakerOptions;
+    /**
+     * Behavior when the breaker is open:
+     * - `"skip"` — emit RESOLVED (default, lets downstream drop the beat)
+     * - `"error"` — emit a `CircuitOpenError` so `retry`/`fallback` can react
+     *
+     * Only used when `breaker` is provided.
+     */
+    breakerOnOpen?: "skip" | "error";
+    /** Retry policy on terminal ERROR. See {@link retry}. */
+    retry?: RetryOptions;
+    /**
+     * Per-attempt deadline in milliseconds. Converted to ns internally. Omit to skip the timeout wrap.
+     *
+     * Specified in ms (not ns) because callers consistently think in millisecond deadlines;
+     * retry/breaker/ratelimit options take ns to match their primitives exactly.
+     */
+    timeoutMs?: number;
+    /** Final fallback value emitted on terminal ERROR after retry exhausts. See {@link fallback}. */
+    fallback?: FallbackInput<T>;
+    /** Initial status reported by the status node. Default `"pending"`. */
+    initialStatus?: StatusValue;
+}
+/** Output bundle of {@link resilientPipeline}. */
+interface ResilientPipelineBundle<T> {
+    /** The final resilient node. Subscribe to this for DATA emissions. */
+    node: Node<T>;
+    /** Live status: `"pending" | "active" | "completed" | "errored"`. */
+    status: Node<StatusValue>;
+    /** Last error payload, or `null` when not errored. */
+    error: Node<unknown | null>;
+    /** Breaker state when `opts.breaker` was provided; `undefined` otherwise. */
+    breakerState: Node<CircuitState> | undefined;
+}
+/**
+ * Compose a resilient pipeline around `source` in the canonical nesting
+ * order — `rateLimit → budget → breaker → timeout → retry → fallback → status`.
+ * Omit any option to skip that layer.
+ *
+ * @param source - Upstream node to wrap.
+ * @param opts - See {@link ResilientPipelineOptions}. All fields optional.
+ *
+ * @example
+ * ```ts
+ * const safeFetch = resilientPipeline(fetchNode, {
+ *   rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC },
+ *   breaker: { failureThreshold: 5 },
+ *   retry: { count: 3, backoff: "exponential" },
+ *   timeoutMs: 10_000,
+ *   fallback: null,
+ * });
+ * safeFetch.status.subscribe(msgs => console.log(msgs));
+ * ```
+ *
+ * @category patterns
+ */
+declare function resilientPipeline<T>(source: Node<T>, opts?: ResilientPipelineOptions<T>): ResilientPipelineBundle<T>;
+
+declare const resilientPipeline$1_NS_PER_MS: typeof NS_PER_MS;
+declare const resilientPipeline$1_NS_PER_SEC: typeof NS_PER_SEC;
+type resilientPipeline$1_ResilientPipelineBundle<T> = ResilientPipelineBundle<T>;
+type resilientPipeline$1_ResilientPipelineOptions<T> = ResilientPipelineOptions<T>;
+declare const resilientPipeline$1_resilientPipeline: typeof resilientPipeline;
+declare namespace resilientPipeline$1 {
+  export { resilientPipeline$1_NS_PER_MS as NS_PER_MS, resilientPipeline$1_NS_PER_SEC as NS_PER_SEC, type resilientPipeline$1_ResilientPipelineBundle as ResilientPipelineBundle, type resilientPipeline$1_ResilientPipelineOptions as ResilientPipelineOptions, resilientPipeline$1_resilientPipeline as resilientPipeline };
+}
+
+/**
+ * Surface: create a graph from a {@link GraphSpec} (§9.3-core).
+ *
+ * Thin wrapper over {@link compileSpec} that converts the two failure modes
+ * ({@link validateSpec} structural errors, and catalog-aware validation
+ * errors) into typed {@link SurfaceError} throws. Consumers are MCP/CLI
+ * wrappers, not end-user graph code — those should import `compileSpec`
+ * directly.
+ *
+ * @module
+ */
+
+/** Options for {@link createGraph}. Same shape as {@link CompileSpecOptions}. */
+type CreateGraphOptions = CompileSpecOptions;
+/**
+ * Build a {@link Graph} from a parsed {@link GraphSpec} with surface-layer
+ * error typing.
+ *
+ * @throws {SurfaceError} `invalid-spec` for structural errors;
+ *   `catalog-error` when fn/source names or config don't match the catalog.
+ */
+declare function createGraph(spec: GraphSpec, opts?: CreateGraphOptions): Graph;
+
+/**
+ * Typed errors for the surface layer (§9.3-core).
+ *
+ * The surface layer is consumed by `@graphrefly/mcp-server` and
+ * `@graphrefly/cli`. Both have native error channels (MCP's `isError` flag,
+ * CLI's exit codes), so surface functions throw a {@link SurfaceError}
+ * carrying a structured code + details payload that wrappers can map to
+ * their native shape. No `Result` envelope — keep the callsite idiom
+ * `try/catch` and let each wrapper surface the error its own way.
+ *
+ * @module
+ */
+/** Structured error codes emitted by the surface layer. JSON-safe. */
+type SurfaceErrorCode = "invalid-spec" | "graph-not-found" | "graph-exists" | "snapshot-not-found" | "node-not-found" | "reduce-timeout" | "catalog-error" | "restore-failed" | "snapshot-failed" | "tier-no-list" | "internal-error";
+/** JSON-safe shape surfaces should echo back through the wrapper. */
+interface SurfaceErrorPayload {
+    code: SurfaceErrorCode;
+    message: string;
+    /** Optional structured detail; must be JSON-safe. */
+    details?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Thrown by surface layer functions on failure. `code` is the stable
+ * machine-readable identifier; `details` carries structured context
+ * (e.g. `validateSpec` errors, missing path name). Both fields round-trip
+ * through `toJSON()` for wrappers that serialize errors over the wire.
+ */
+declare class SurfaceError extends Error {
+    readonly code: SurfaceErrorCode;
+    readonly details?: Readonly<Record<string, unknown>>;
+    constructor(code: SurfaceErrorCode, message: string, details?: Readonly<Record<string, unknown>>);
+    /**
+     * JSON-safe payload for wire serialization. Defensively validates
+     * `details` — if it can't be round-tripped through `JSON.stringify`
+     * (cyclic refs, `BigInt`, `Error` instance not pre-toJSON'd), the
+     * payload falls back to `{code, message}` only rather than crashing
+     * the MCP/CLI wrapper when it serializes this error onto the wire.
+     */
+    toJSON(): SurfaceErrorPayload;
+}
+/** Wrap any thrown value as a SurfaceError. Idempotent on existing SurfaceError. */
+declare function asSurfaceError(err: unknown, fallbackCode?: SurfaceErrorCode): SurfaceError;
+
+/**
+ * Surface: one-shot `input → pipeline → output` (§9.3-core).
+ *
+ * `runReduction` compiles a {@link GraphSpec}, pushes an input value to a
+ * named state node, awaits the first post-push DATA emission on a named
+ * output, then disposes the graph. Stateless per call — no graphId, no
+ * registry.
+ *
+ * Named `runReduction` (not `reduce`) to avoid collision with the
+ * reactive {@link reduce} operator in `extra/operators.ts`. The MCP tool
+ * name (`graphrefly_reduce`) and CLI subcommand (`graphrefly reduce`) use
+ * the short form; the library export carries the verb.
+ *
+ * The subscribe-before-push ordering is deliberate. `graph.set` propagates
+ * synchronously for sync derived/operator chains; for async sources
+ * (`fromPromise`, `fromAsyncIter`, LLM adapters) the first post-push DATA
+ * arrives on a later tick. Subscribing before the push catches both, and
+ * skipping the priming push-on-subscribe emission avoids resolving with the
+ * stale pre-push cache (spec §2.2).
+ *
+ * @module
+ */
+
+/** Options for {@link reduce}. */
+interface ReduceOptions {
+    /** Fn/source catalog for {@link createGraph}. */
+    catalog?: GraphSpecCatalog;
+    /** Path of the state node that receives the input. Default `"input"`. */
+    inputPath?: string;
+    /** Path of the node whose first post-push DATA is the result. Default `"output"`. */
+    outputPath?: string;
+    /** Hard deadline in milliseconds. Default `30_000`. */
+    timeoutMs?: number;
+}
+/**
+ * Run a spec as a one-shot reduction: `input → graph → output`.
+ *
+ * Resolves on the first `[DATA, v]` **or** `[RESOLVED]` emitted by
+ * `outputPath` after the input push. The RESOLVED path handles spec
+ * §1.3.3 equals-substitution (output recomputed to a value equal to its
+ * cache, so the graph skips the DATA push) by returning `outputNode.cache`
+ * — the caller always gets the settled value, never hangs on idempotent
+ * inputs.
+ *
+ * @throws {SurfaceError} `invalid-spec` / `catalog-error` (propagated from
+ *   {@link createGraph}), `node-not-found` when `inputPath`/`outputPath`
+ *   can't be resolved, `reduce-timeout` when `timeoutMs` elapses without
+ *   a post-push emission, or the ERROR payload from the graph re-thrown
+ *   as `internal-error`.
+ */
+declare function runReduction(spec: GraphSpec, input: unknown, opts?: ReduceOptions): Promise<unknown>;
+
+/**
+ * Surface: snapshot save/restore/diff/list over {@link StorageTier} (§9.3-core).
+ *
+ * One-shot snapshot management for stateless callers (MCP tools, CLI
+ * commands) layered on the existing multi-tier auto-checkpoint substrate.
+ * A saved snapshot is a `mode: "full"` {@link GraphCheckpointRecord} with
+ * `seq: 0` — byte-identical to the baseline anchor
+ * {@link Graph.attachStorage} writes on its first flush. An
+ * auto-checkpointed graph can therefore be restored through this surface,
+ * and a surface-saved snapshot can be picked up by `attachStorage({
+ * autoRestore: true })`.
+ *
+ * The wire envelope stays at {@link SNAPSHOT_WIRE_VERSION}; no new format.
+ *
+ * @module
+ */
+
+/**
+ * Current envelope version. Re-exported from `graph.ts` so the one-shot
+ * surface path and `Graph.attachStorage` write byte-identical
+ * `format_version` fields — no silent wire drift.
+ */
+declare const SNAPSHOT_WIRE_VERSION = 1;
+/** Shape returned by {@link saveSnapshot}. */
+interface SaveSnapshotResult {
+    snapshotId: string;
+    timestamp_ns: number;
+}
+/** Options for {@link restoreSnapshot}. */
+interface RestoreSnapshotOptions {
+    /** Passthrough to `Graph.fromSnapshot`. First matching pattern wins. */
+    factories?: Record<string, GraphNodeFactory>;
+}
+/**
+ * Write a graph's current state as a one-shot `mode: "full"` record.
+ *
+ * Uses the same {@link GraphCheckpointRecord} envelope as
+ * {@link Graph.attachStorage} so the two persistence paths interoperate.
+ *
+ * @throws {SurfaceError} `snapshot-failed` when the tier's `save` throws.
+ */
+declare function saveSnapshot(graph: Graph, snapshotId: string, tier: StorageTier): Promise<SaveSnapshotResult>;
+/**
+ * Load a snapshot from a tier and materialize it as a new {@link Graph}.
+ *
+ * Uses {@link Graph.fromSnapshot} to reconstruct topology; pass
+ * `factories` when the graph includes non-state nodes that the default
+ * hydrator can't rebuild on its own.
+ *
+ * **Requires a `mode: "full"` record.** Surface-written snapshots from
+ * {@link saveSnapshot} always qualify. Records written by
+ * {@link Graph.attachStorage} with `compactEvery > 1` may be
+ * `mode: "diff"` between compacts — those throw `restore-failed` until
+ * the tier's next compact flush (or until Phase 8.7 WAL replay lands).
+ * If you need interop during development, either call
+ * {@link saveSnapshot} explicitly (always full) or configure
+ * `attachStorage({compactEvery: 1})`.
+ *
+ * @throws {SurfaceError} `snapshot-not-found` on miss; `restore-failed`
+ *   when the payload shape doesn't match, when the record is
+ *   `mode: "diff"`, or when `Graph.fromSnapshot` rejects.
+ */
+declare function restoreSnapshot(snapshotId: string, tier: StorageTier, opts?: RestoreSnapshotOptions): Promise<Graph>;
+/**
+ * Load two snapshots and compute a {@link GraphDiffResult} via static
+ * {@link Graph.diff}. Returns the audit shape (structural + value diff,
+ * no payload); use {@link diffForWAL} directly for WAL-oriented diffs.
+ *
+ * @throws {SurfaceError} `snapshot-not-found` on either miss.
+ */
+declare function diffSnapshots(snapshotIdA: string, snapshotIdB: string, tier: StorageTier): Promise<GraphDiffResult>;
+/**
+ * Enumerate snapshot ids on a tier.
+ *
+ * **Scope caveat:** returns every key on the tier, not just those
+ * written by {@link saveSnapshot}. When the same tier also backs
+ * {@link Graph.attachStorage} (for auto-checkpoints keyed by
+ * `graph.name`), those names appear in this list too. Wrappers that
+ * want a namespaced snapshot store should use a dedicated tier or
+ * encode an id prefix on write. Tracked in `docs/optimizations.md`
+ * under "surface `listSnapshots` namespacing".
+ *
+ * @throws {SurfaceError} `tier-no-list` when the tier does not implement
+ *   the optional `list()` method. Check `typeof tier.list === "function"`
+ *   before calling if you want to branch on capability.
+ */
+declare function listSnapshots(tier: StorageTier): Promise<readonly string[]>;
+/**
+ * Delete a snapshot from a tier.
+ *
+ * Silent on miss (clear semantics). `tier.clear` is optional — throws
+ * `snapshot-failed` when the tier is append-only.
+ *
+ * @throws {SurfaceError} `snapshot-failed` when `clear` is unsupported
+ *   or throws.
+ */
+declare function deleteSnapshot(snapshotId: string, tier: StorageTier): Promise<void>;
+
+/**
+ * Surface layer (§9.3-core) — shared, JSON-safe operations consumed by
+ * `@graphrefly/mcp-server` and `@graphrefly/cli`.
+ *
+ * The surface is a thin projection of existing Graph APIs (`describe`,
+ * `observe`, `explain`, `snapshot`, `restore`, static `diff`), plus two
+ * genuinely new operations:
+ *
+ * 1. {@link createGraph} — `compileSpec` wrapped with typed surface errors.
+ * 2. {@link reduce} — one-shot `input → pipeline → output`.
+ *
+ * Snapshot persistence reuses the {@link StorageTier} substrate introduced
+ * for `Graph.attachStorage`, so one-shot snapshots and auto-checkpoints
+ * share the {@link GraphCheckpointRecord} envelope. No new wire format.
+ *
+ * Errors throw as {@link SurfaceError} — wrappers map to their native
+ * error channel (MCP `isError`, CLI exit code). No `Result<T, E>` wrapper.
+ *
+ * @module
+ */
+
+type index$1_CatalogFnEntry = CatalogFnEntry;
+type index$1_CatalogSourceEntry = CatalogSourceEntry;
+type index$1_ConfigFieldSchema = ConfigFieldSchema;
+type index$1_CreateGraphOptions = CreateGraphOptions;
+type index$1_FnFactory = FnFactory;
+type index$1_GraphSpec = GraphSpec;
+type index$1_GraphSpecCatalog = GraphSpecCatalog;
+type index$1_GraphSpecFeedbackEdge = GraphSpecFeedbackEdge;
+type index$1_GraphSpecNode = GraphSpecNode;
+type index$1_GraphSpecTemplate = GraphSpecTemplate;
+type index$1_GraphSpecTemplateRef = GraphSpecTemplateRef;
+type index$1_GraphSpecValidation = GraphSpecValidation;
+type index$1_ReduceOptions = ReduceOptions;
+type index$1_RestoreSnapshotOptions = RestoreSnapshotOptions;
+declare const index$1_SNAPSHOT_WIRE_VERSION: typeof SNAPSHOT_WIRE_VERSION;
+type index$1_SaveSnapshotResult = SaveSnapshotResult;
+type index$1_SourceFactory = SourceFactory;
+type index$1_SurfaceError = SurfaceError;
+declare const index$1_SurfaceError: typeof SurfaceError;
+type index$1_SurfaceErrorCode = SurfaceErrorCode;
+type index$1_SurfaceErrorPayload = SurfaceErrorPayload;
+declare const index$1_asSurfaceError: typeof asSurfaceError;
+declare const index$1_createGraph: typeof createGraph;
+declare const index$1_deleteSnapshot: typeof deleteSnapshot;
+declare const index$1_diffSnapshots: typeof diffSnapshots;
+declare const index$1_listSnapshots: typeof listSnapshots;
+declare const index$1_restoreSnapshot: typeof restoreSnapshot;
+declare const index$1_runReduction: typeof runReduction;
+declare const index$1_saveSnapshot: typeof saveSnapshot;
+declare namespace index$1 {
+  export { type index$1_CatalogFnEntry as CatalogFnEntry, type index$1_CatalogSourceEntry as CatalogSourceEntry, type index$1_ConfigFieldSchema as ConfigFieldSchema, type index$1_CreateGraphOptions as CreateGraphOptions, type index$1_FnFactory as FnFactory, type index$1_GraphSpec as GraphSpec, type index$1_GraphSpecCatalog as GraphSpecCatalog, type index$1_GraphSpecFeedbackEdge as GraphSpecFeedbackEdge, type index$1_GraphSpecNode as GraphSpecNode, type index$1_GraphSpecTemplate as GraphSpecTemplate, type index$1_GraphSpecTemplateRef as GraphSpecTemplateRef, type index$1_GraphSpecValidation as GraphSpecValidation, type index$1_ReduceOptions as ReduceOptions, type index$1_RestoreSnapshotOptions as RestoreSnapshotOptions, index$1_SNAPSHOT_WIRE_VERSION as SNAPSHOT_WIRE_VERSION, type index$1_SaveSnapshotResult as SaveSnapshotResult, type index$1_SourceFactory as SourceFactory, index$1_SurfaceError as SurfaceError, type index$1_SurfaceErrorCode as SurfaceErrorCode, type index$1_SurfaceErrorPayload as SurfaceErrorPayload, index$1_asSurfaceError as asSurfaceError, index$1_createGraph as createGraph, index$1_deleteSnapshot as deleteSnapshot, index$1_diffSnapshots as diffSnapshots, index$1_listSnapshots as listSnapshots, index$1_restoreSnapshot as restoreSnapshot, index$1_runReduction as runReduction, index$1_saveSnapshot as saveSnapshot };
+}
+
 /**
  * Patterns layer: domain/solution helpers (Phase 4+).
  */
 
+type index_CatalogFnEntry = CatalogFnEntry;
+type index_CatalogSourceEntry = CatalogSourceEntry;
+type index_ConfigFieldSchema = ConfigFieldSchema;
+type index_CreateGraphOptions = CreateGraphOptions;
+type index_FnFactory = FnFactory;
+type index_GraphSpec = GraphSpec;
+type index_GraphSpecCatalog = GraphSpecCatalog;
+type index_GraphSpecFeedbackEdge = GraphSpecFeedbackEdge;
+type index_GraphSpecNode = GraphSpecNode;
+type index_GraphSpecTemplate = GraphSpecTemplate;
+type index_GraphSpecTemplateRef = GraphSpecTemplateRef;
+type index_GraphSpecValidation = GraphSpecValidation;
+type index_ReduceOptions = ReduceOptions;
+type index_RestoreSnapshotOptions = RestoreSnapshotOptions;
+declare const index_SNAPSHOT_WIRE_VERSION: typeof SNAPSHOT_WIRE_VERSION;
+type index_SaveSnapshotResult = SaveSnapshotResult;
+type index_SourceFactory = SourceFactory;
+type index_SurfaceError = SurfaceError;
+declare const index_SurfaceError: typeof SurfaceError;
+type index_SurfaceErrorCode = SurfaceErrorCode;
+type index_SurfaceErrorPayload = SurfaceErrorPayload;
 declare const index_ai: typeof ai;
+declare const index_asSurfaceError: typeof asSurfaceError;
 declare const index_cqrs: typeof cqrs;
+declare const index_createGraph: typeof createGraph;
+declare const index_deleteSnapshot: typeof deleteSnapshot;
+declare const index_demoShell: typeof demoShell;
+declare const index_diffSnapshots: typeof diffSnapshots;
 declare const index_domainTemplates: typeof domainTemplates;
 declare const index_graphspec: typeof graphspec;
+declare const index_lens: typeof lens;
+declare const index_listSnapshots: typeof listSnapshots;
 declare const index_memory: typeof memory;
 declare const index_messaging: typeof messaging;
 declare const index_orchestration: typeof orchestration;
 declare const index_reduction: typeof reduction;
+declare const index_restoreSnapshot: typeof restoreSnapshot;
+declare const index_runReduction: typeof runReduction;
+declare const index_saveSnapshot: typeof saveSnapshot;
 declare namespace index {
-  export { index_ai as ai, index_cqrs as cqrs, demoShell$1 as demoShell, index_domainTemplates as domainTemplates, index_graphspec as graphspec, index$1 as harness, index$c as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration, index_reduction as reduction };
+  export { type index_CatalogFnEntry as CatalogFnEntry, type index_CatalogSourceEntry as CatalogSourceEntry, type index_ConfigFieldSchema as ConfigFieldSchema, type index_CreateGraphOptions as CreateGraphOptions, type index_FnFactory as FnFactory, type index_GraphSpec as GraphSpec, type index_GraphSpecCatalog as GraphSpecCatalog, type index_GraphSpecFeedbackEdge as GraphSpecFeedbackEdge, type index_GraphSpecNode as GraphSpecNode, type index_GraphSpecTemplate as GraphSpecTemplate, type index_GraphSpecTemplateRef as GraphSpecTemplateRef, type index_GraphSpecValidation as GraphSpecValidation, type index_ReduceOptions as ReduceOptions, type index_RestoreSnapshotOptions as RestoreSnapshotOptions, index_SNAPSHOT_WIRE_VERSION as SNAPSHOT_WIRE_VERSION, type index_SaveSnapshotResult as SaveSnapshotResult, type index_SourceFactory as SourceFactory, index_SurfaceError as SurfaceError, type index_SurfaceErrorCode as SurfaceErrorCode, type index_SurfaceErrorPayload as SurfaceErrorPayload, audit as accountability, index_ai as ai, index_asSurfaceError as asSurfaceError, index_cqrs as cqrs, index_createGraph as createGraph, index_deleteSnapshot as deleteSnapshot, index_demoShell as demoShell, index_diffSnapshots as diffSnapshots, index_domainTemplates as domainTemplates, index_graphspec as graphspec, guardedExecution$1 as guarded, index$2 as harness, index$3 as layout, index_lens as lens, index_listSnapshots as listSnapshots, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration, index_reduction as reduction, resilientPipeline$1 as resilientPipeline, index_restoreSnapshot as restoreSnapshot, index_runReduction as runReduction, index_saveSnapshot as saveSnapshot, index$1 as surface };
 }
 
 /**
@@ -3420,4 +2122,4 @@ declare namespace index {
  */
 declare const version = "0.0.0";
 
-export { Actor, DerivedFn, DistillBundle, Extraction, Graph, GraphAttachStorageOptions, GraphOptions, GraphProfileOptions, GraphProfileResult, Node, NodeActions, NodeInput, NodeOptions, StorageHandle, StorageTier, ai, index$2 as compat, cqrs, demoShell$1 as demoShell, domainTemplates, graphspec, index$1 as harness, index$a as jotai, index$c as layout, memory, messaging, index$9 as nanostores, index$b as nestjs, orchestration, index as patterns, index$8 as react, reduction, index$7 as signals, index$6 as solid, index$5 as svelte, version, index$4 as vue, index$3 as zustand };
+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 };