@graphrefly/graphrefly 0.24.0 → 0.26.0

package/dist/index.d.cts

@@ -1,506 +1,36 @@
-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-1z8vRTCt.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 fromRedisStream, d7 as fromSSE, d8 as fromSqlite, d9 as fromSqliteCursor, da as fromStatsD, db as fromSyslog, dc as fromTimer, dd as fromWebSocket, de as fromWebSocketReconnect, df as fromWebhook, dg as globToRegExp, dh as interval, di as keepalive, dj as last, dk as linear, dl as lru, dm as map, dn as matchesAnyPattern, dp as matchesCron, dq as merge, dr as mergeMap, ds as nameToSignal, dt as ndjsonRows, du as never, dv as of, dw as pairwise, dx as parseCron, dy as parsePrometheusText, dz as parseStatsD, dA as parseSyslog, dB as pausable, dC as pubsub, dD as race, dE as rateLimiter, dF as reactiveCounter, dG as reactiveIndex, dH as reactiveList, dI as reactiveLog, dJ as reactiveMap, dK as reactiveSink, dL as reduce, dM as repeat, dN as replay, dO as rescue, dP as resolveBackoffPreset, dQ as retry, dR as retrySource, dS as sample, dT as scan, dU as serializeError, dV as share, dW as shareReplay, dX as signalToName, dY as skip, dZ as switchMap, d_ as take, d$ as takeUntil, e0 as takeWhile, e1 as tap, e2 as throttle, e3 as throttleTime, e4 as throwError, e5 as timeout, e6 as toArray, e7 as toCSV, e8 as toClickHouse, e9 as toFile, ea as toHTTP, eb as toKafka, ec as toLoki, ed as toMongo, ee as toNATS, ef as toPostgres, eg as toPulsar, eh as toRabbitMQ, ei as toReadableStream, ej as toRedisStream, ek as toS3, el as toSSE, em as toSSEBytes, en as toSqlite, eo as toTempo, ep as toWebSocket, eq as tokenBucket, er as valve, es as verifiable, et as window, eu as windowCount, ev as windowTime, ew as withBreaker, ex as withLatestFrom, ey as withMaxAttempts, ez as withStatus, eA as workerBridge, eB as workerSelf, eC as zip } from './index-1z8vRTCt.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-b5BYtczN.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-BEfE8H_G.cjs';
+import { D as DerivedFn } from './index-C0ZXMaXO.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-C0ZXMaXO.cjs';
+import { D as DistillBundle, E as Extraction, R as ReactiveMapBundle, S as StatusValue, C as CircuitState, a as RateLimiterOptions, b as CircuitBreakerOptions, c as RetryOptions, F as FallbackInput, N as NS_PER_MS, d as NS_PER_SEC } from './index-BeIdBfcb.cjs';
+export { A as AckableMessage, e as AdapterHandlers, B as BackoffPreset, f as BackoffStrategy, g as BatchMessage, h as BridgeMessage, i as BufferedSinkHandle, j as BundleTriad, k as CSVRow, l as CacheEvictionPolicy, m as CascadingCache, n as CascadingCacheOptions, o as CheckpointToRedisOptions, p as CheckpointToS3Options, q as CircuitBreaker, r as CircuitOpenError, s as ClickHouseClientLike, t as ClickHouseInsertClientLike, u as ClickHouseRow, v as CronSchedule, w as DistillOptions, x as DrizzleQueryLike, y as EmitTriad, z as ErrorMessage, G as ExponentialBackoffOptions, H as ExternalBundleOptions, I as ExternalRegister, J as FSEvent, K as FSEventType, L as FileWriterLike, M as FromCSVOptions, O as FromClickHouseWatchOptions, P as FromDrizzleOptions, Q as FromFSWatchOptions, T as FromGitHookOptions, U as FromHTTPOptions, V as FromHTTPPollOptions, W as FromHTTPStreamOptions, X as FromKafkaOptions, Y as FromKyselyOptions, Z as FromMCPOptions, _ as FromNATSOptions, $ as FromNDJSONOptions, a0 as FromOTelOptions, a1 as FromPrismaOptions, a2 as FromPrometheusOptions, a3 as FromPulsarOptions, a4 as FromRabbitMQOptions, a5 as FromRedisStreamOptions, a6 as FromSSEOptions, a7 as FromSqliteOptions, a8 as FromStatsDOptions, a9 as FromSyslogOptions, aa as FromWebSocketReconnectOptions, ab as GitEvent, ac as GitHookType, ad as HTTPBundle, ae as IndexBackend, af as IndexRow, ag as InitMessage, ah as JitterMode, ai as KafkaConsumerLike, aj as KafkaMessage, ak as KafkaProducerLike, al as KyselyQueryLike, am as ListBackend, an as LogBackend, ao as LokiClientLike, ap as LokiStream, aq as MCPClientLike, ar as MapBackend, as as MergeMapOptions, at as MongoCollectionLike, au as NATSClientLike, av as NATSMessage, aw as NATSSubscriptionLike, ax as NativeIndexBackend, ay as NativeListBackend, az as NativeLogBackend, aA as NativeMapBackend, aB as NativeMapBackendOptions, aC as NativePubSubBackend, aD as OTelBundle, aE as OTelLog, aF as OTelMetric, aG as OTelRegister, aH as OTelSpan, aI as PostgresClientLike, aJ as PrismaModelLike, aK as PrometheusMetric, aL as PubSubBackend, aM as PubSubHub, aN as PubSubHubOptions, aO as PulsarConsumerLike, aP as PulsarMessage, aQ as PulsarProducerLike, aR as RabbitMQChannelLike, aS as RabbitMQMessage, aT as RateLimiterOverflowError, aU as RateLimiterOverflowPolicy, aV as ReactiveIndexBundle, aW as ReactiveIndexOptions, aX as ReactiveListBundle, aY as ReactiveListOptions, aZ as ReactiveLogBundle, a_ as ReactiveLogOptions, a$ as ReactiveMapOptions, b0 as ReactiveSinkBackpressureOptions, b1 as ReactiveSinkConfig, b2 as ReactiveSinkHandle, b3 as ReactiveSinkOptions, b4 as ReactiveSinkRetryOptions, b5 as ReadyMessage, b6 as RedisCheckpointClientLike, b7 as RedisClientLike, b8 as RedisStreamEntry, b9 as ResettableTimer, ba as RetrySourceOptions, bb as S3ClientLike, bc as SSEEvent, bd as SignalMessage, be as SinkFailure, bf as SinkHandle, bg as SinkTransportError, bh as SqliteDbLike, bi as SqliteIterableDbLike, bj as StatsDMetric, bk as StatsDRegister, bl as SyslogMessage, bm as SyslogRegister, bn as TapObserver, bo as TempoClientLike, bp as ThrottleOptions, bq as TimeoutError, br as ToCSVOptions, bs as ToClickHouseOptions, bt as ToFileOptions, bu as ToHTTPOptions, bv as ToKafkaOptions, bw as ToLokiOptions, bx as ToMongoOptions, by as ToNATSOptions, bz as ToPostgresOptions, bA as ToPulsarOptions, bB as ToRabbitMQOptions, bC as ToRedisStreamOptions, bD as ToS3Options, bE as ToSSEOptions, bF as ToSqliteOptions, bG as ToTempoOptions, bH as ToWebSocketOptions, bI as TokenBucket, bJ as UpsertOptions, bK as ValueMessage, bL as VerifiableBundle, bM as VerifiableOptions, bN as VerifyValue, bO as WatermarkController, bP as WatermarkOptions, bQ as WebSocketLike, bR as WebSocketMessageEventLike, bS as WebSocketRegister, bT as WebhookRegister, bU as WithBreakerBundle, bV as WithStatusBundle, bW as WorkerBridge, bX as WorkerBridgeOptions, bY as WorkerSelfHandle, bZ as WorkerSelfOptions, b_ as WorkerTransport, b$ as audit, c0 as buffer, c1 as bufferCount, c2 as bufferTime, c3 as cascadingCache, c4 as catchError, c5 as checkpointToRedis, c6 as checkpointToS3, c7 as circuitBreaker, c8 as combine, c9 as combineLatest, ca as concat, cb as concatMap, cc as constant, cd as createTransport, ce as createWatermarkController, cf as csvRows, cg as debounce, ch as debounceTime, ci as decorrelatedJitter, cj as delay, ck as deserializeError, cl as distill, cm as distinctUntilChanged, cn as elementAt, co as exhaustMap, cp as exponential, cq as externalBundle, cr as externalProducer, cs as extra, ct as fallback, cu as fibonacci, cv as filter, cw as find, cx as first, cy as flatMap, cz as fromCSV, cA as fromClickHouseWatch, cB as fromDrizzle, cC as fromFSWatch, cD as fromGitHook, cE as fromHTTP, cF as fromHTTPPoll, cG as fromHTTPStream, cH as fromKafka, cI as fromKysely, cJ as fromMCP, cK as fromNATS, cL as fromNDJSON, cM as fromOTel, cN as fromPrisma, cO as fromPrometheus, cP as fromPulsar, cQ as fromRabbitMQ, cR as fromRedisStream, cS as fromSSE, cT as fromSqlite, cU as fromSqliteCursor, cV as fromStatsD, cW as fromSyslog, cX as fromWebSocket, cY as fromWebSocketReconnect, cZ as fromWebhook, c_ as interval, c$ as last, d0 as linear, d1 as lru, d2 as map, d3 as matchesCron, d4 as merge, d5 as mergeMap, d6 as nameToSignal, d7 as ndjsonRows, d8 as pairwise, d9 as parseCron, da as parsePrometheusText, db as parseStatsD, dc as parseSyslog, dd as pausable, de as pubsub, df as race, dg as rateLimiter, dh as reactiveIndex, di as reactiveList, dj as reactiveLog, dk as reactiveMap, dl as reactiveSink, dm as reduce, dn as repeat, dp as rescue, dq as resolveBackoffPreset, dr as retry, ds as retrySource, dt as sample, du as scan, dv as serializeError, dw as signalToName, dx as skip, dy as switchMap, dz as take, dA as takeUntil, dB as takeWhile, dC as tap, dD as throttle, dE as throttleTime, dF as timeout, dG as toCSV, dH as toClickHouse, dI as toFile, dJ as toHTTP, dK as toKafka, dL as toLoki, dM as toMongo, dN as toNATS, dO as toPostgres, dP as toPulsar, dQ as toRabbitMQ, dR as toReadableStream, dS as toRedisStream, dT as toS3, dU as toSSE, dV as toSSEBytes, dW as toSqlite, dX as toTempo, dY as toWebSocket, dZ as tokenBucket, d_ as valve, d$ as verifiable, e0 as window, e1 as windowCount, e2 as windowTime, e3 as withBreaker, e4 as withLatestFrom, e5 as withMaxAttempts, e6 as withStatus, e7 as workerBridge, e8 as workerSelf, e9 as zip } from './index-BeIdBfcb.cjs';
+import { w as watchTopologyTree } from './index-CUwyr1Kk.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-CUwyr1Kk.cjs';
+import { N as Node, a as NodeOptions, b as NodeActions, A as Actor, P as PolicyRuleData, G as GuardAction } from './node-C_IBuvX2.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, j as GlobalInspectorEvent, k as GlobalInspectorHook, l as GraphReFlyConfig, m as GuardDenied, n as GuardDeniedDetails, H as HashFn, I as INVALIDATE, o as INVALIDATE_MSG, p as INVALIDATE_ONLY_BATCH, M as Message, q as MessageContext, r as MessageTypeRegistration, s as MessageTypeRegistrationInput, t as Messages, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-C_IBuvX2.cjs';
+import { NodeInput } from './extra/sources.cjs';
+export { AsyncSourceOpts, EventTargetLike, FromCronOptions, ReactiveCounterBundle, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.cjs';
+import { S as StorageHandle, a as StorageTier } from './storage-DiqWHzVI.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-DiqWHzVI.cjs';
+import { G as Graph, a as GraphOptions, b as GraphAttachStorageOptions, c as GraphPersistSnapshot, C as CausalChain, d as GraphDescribeOptions, e as GraphDescribeOutput, D as DescribeFilter, f as GraphProfileResult, g as GraphProfileOptions, h as GraphNodeFactory, i as GraphDiffResult } from './graph-6tZ5jEzr.cjs';
+export { j as CausalStep, E as ExplainPathOptions, k as GRAPH_META_SEGMENT, l as GraphActorOptions, m as GraphCheckpointRecord, n as GraphDiagramDirection, o as GraphDiagramOptions, p as GraphDiffChange, q as GraphFactoryContext, r as GraphObserveAll, s as GraphObserveOne, t as GraphVersionChange, u as GraphWALDiff, N as NodeProfile, O as ObserveDetail, v as ObserveEvent, w as ObserveOptions, x as ObserveResult, y as ObserveTheme, z as ObserveThemeName, R as ReachableDirection, A as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, B as TraceEntry, F as diffForWAL, H as explainPath, I as graphProfile, J as reachable } from './graph-6tZ5jEzr.cjs';
+import { c as cqrs } from './index-_oMEWlDq.cjs';
+export { i as nestjs } from './index-_oMEWlDq.cjs';
+import { d as demoShell } from './demo-shell-26p5fVxn.cjs';
+import { i as index$3 } from './index-C8mdwMXc.cjs';
+export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-C0-8XW6Q.cjs';
+export { T as ToObservableOptions, t as toObservable } from './observable-Crr1jgzx.cjs';
+export { i as jotai } from './index-QBpffFW-.cjs';
+export { i as nanostores } from './index-CUyrtuOf.cjs';
+export { i as react } from './index-DFhjO4Gg.cjs';
+export { i as solid } from './index-B_IP40nB.cjs';
+export { i as svelte } from './index-Bd_fwmLf.cjs';
+export { i as vue } from './index-Bxb5ZYc9.cjs';
+export { i as zustand } from './index-B4MP_8V_.cjs';
 import '@nestjs/common';
 import '@nestjs/core';
+import './reactive-layout-BaOQefHu.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 };
-}
+import 'vue';
 
 /**
  * Memory patterns (roadmap §4.3).
@@ -1925,101 +1455,243 @@ declare namespace ai {
 }
 
 /**
- * Three-pane demo shell (roadmap §7.2).
+ * Audit, policy enforcement, and compliance export (roadmap §9.2).
+ *
+ * Three composed factories that wrap any {@link Graph} with the harness
+ * accountability layer:
  *
- * A `Graph("demo-shell")` that dogfoods reactive coordination for the
- * main/side split layout with synchronized cross-highlighting.
+ * - {@link auditTrail} — reactive mutation log with by-node/by-actor/by-time
+ *   queries.
+ * - {@link policyEnforcer} — reactive ABAC enforcement; in `"audit"` mode
+ *   records would-be denials, in `"enforce"` mode pushes guards onto target
+ *   nodes so subsequent writes throw {@link GuardDenied}.
+ * - {@link complianceSnapshot} — point-in-time export of graph state +
+ *   audit trail + policies for regulatory archival.
  *
- * **Zero framework dependency** — framework bindings wrap pane components only.
- * The shell graph is headless and fully testable.
+ * @module
  */
 
-/** 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;
+/** A single recorded mutation/event in an {@link AuditTrailGraph}. */
+interface AuditEntry {
+    seq: number;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    type: "data" | "dirty" | "resolved" | "invalidate" | "pause" | "resume" | "complete" | "error" | "teardown";
+    actor?: Actor;
+    value?: unknown;
+    error?: unknown;
+    reason?: string;
+}
+/** Options for {@link auditTrail}. */
+interface AuditTrailOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /** Ring-buffer cap for the underlying `reactiveLog`. Default: unbounded. */
+    maxSize?: number;
+    /**
+     * Which event types to record. Default: `["data", "error", "complete",
+     * "teardown"]` — the user-meaningful set. Opt in to mid-wave protocol
+     * events (`"dirty"`, `"resolved"`, `"invalidate"`, `"pause"`, `"resume"`)
+     * by listing them explicitly. Note: those tier-1/tier-2 events do not
+     * carry an `actor` (no `lastMutation` populated) — record them only for
+     * protocol-level diagnostics.
+     */
+    includeTypes?: readonly AuditEntry["type"][];
+    /** Per-event filter; return false to skip. */
+    filter?: (entry: AuditEntry) => boolean;
+}
+/**
+ * Mounted audit log — `entries` exposes the reactive `AuditEntry[]`; query
+ * helpers are sync convenience wrappers over the cached snapshot.
+ */
+declare class AuditTrailGraph extends Graph {
+    readonly entries: Node<readonly AuditEntry[]>;
+    readonly count: Node<number>;
+    private readonly _log;
+    private readonly _target;
+    constructor(target: Graph, opts: AuditTrailOptions);
+    /** All entries currently in the ring (snapshot). */
+    all(): readonly AuditEntry[];
+    /** Entries matching `path`. Order preserved. */
+    byNode(path: string): readonly AuditEntry[];
+    /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
+    byActor(actorId: string): readonly AuditEntry[];
+    /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
+    byActorType(type: string): readonly AuditEntry[];
+    /**
+     * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
+     * Omit `end_ns` to query open-ended.
+     */
+    byTimeRange(start_ns: number, end_ns?: number): readonly AuditEntry[];
+    /** Reference to the audited graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wraps any {@link Graph} with a reactive audit trail recording every event
+ * matching `includeTypes` (default: data + error + complete + teardown).
+ *
+ * Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
+ * `path`, `type`, and — when available — `actor`, `value`, `error`, and the
+ * `graph.trace()` reasoning annotation for the path.
+ *
+ * The returned graph mounts an `entries` node + `count` derived. Query
+ * helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
+ * snapshot synchronously.
+ */
+declare function auditTrail(target: Graph, opts?: AuditTrailOptions): AuditTrailGraph;
+/** A single policy denial recorded by {@link PolicyEnforcerGraph}. */
+interface PolicyViolation {
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    actor: Actor;
+    action: GuardAction;
+    mode: "audit" | "enforce";
+    /** `"observed"` (audit mode after-the-fact) or `"blocked"` (enforce mode pre-write). */
+    result: "observed" | "blocked";
+}
+/** Options for {@link policyEnforcer}. */
+interface PolicyEnforcerOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /**
+     * `"audit"` (default) — observe events and record would-be denials;
+     * does not block writes. Audit mode requires `lastMutation` attribution
+     * on the audited node — anonymous/internal writes (no `actor` passed,
+     * unguarded node) are skipped silently because the policy cannot be
+     * evaluated without an actor.
+     *
+     * `"enforce"` — push guards onto target nodes so disallowed writes
+     * throw {@link GuardDenied}. Reverted on dispose.
+     */
+    mode?: "audit" | "enforce";
+    /**
+     * Restrict enforcement to specific node paths (qualified). When omitted,
+     * applies to every node visible in `target.describe()` at construction
+     * time (subgraphs are walked transitively) AND subscribes to the full
+     * topology tree via {@link watchTopologyTree}, so nodes added to
+     * `target` OR any transitively-mounted subgraph after construction are
+     * guarded automatically (enforce mode only).
+     *
+     * **Cost:** unrestricted mode runs `describe({detail:"minimal"})` once
+     * at construction (O(N) over the graph tree) plus one topology
+     * subscription per graph instance in the mount tree. Restricted mode
+     * skips both and disables dynamic coverage — callers providing
+     * `paths` must re-create on subgraph changes.
+     */
+    paths?: readonly string[];
+    /** Ring-buffer cap for the violations topic. Default: 1000. */
+    violationsLimit?: number;
+}
+/**
+ * Reactive ABAC enforcement layer. Policies are reactive — pass a
+ * `Node<readonly PolicyRuleData[]>` to allow LLMs (or any reactive source)
+ * to update them at runtime; the enforcer rebinds its internal
+ * {@link NodeGuard} on every push.
+ */
+declare class PolicyEnforcerGraph extends Graph {
+    readonly policies: Node<readonly PolicyRuleData[]>;
+    readonly violations: TopicGraph<PolicyViolation>;
+    readonly violationCount: Node<number>;
+    private readonly _target;
+    private readonly _mode;
+    private _currentGuard;
+    constructor(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts: PolicyEnforcerOptions);
+    private _publishViolation;
+    /** Snapshot of recorded violations. */
+    all(): readonly PolicyViolation[];
+    get mode(): "audit" | "enforce";
+    get target(): Graph;
+}
+/**
+ * Wraps a {@link Graph} with reactive policy enforcement. Pass either a
+ * static rule list or a {@link Node} of rules (LLM-updatable). Records
+ * `PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
+ * pushes guards onto target nodes so disallowed writes throw.
+ */
+declare function policyEnforcer(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts?: PolicyEnforcerOptions): PolicyEnforcerGraph;
+/**
+ * Reactive {@link CausalChain} that recomputes whenever the audited graph
+ * changes. Returns a `Node<CausalChain>` suitable for subscription, mounting,
+ * or composition (e.g. inside `graphLens.why(node)`).
+ *
+ * **How it stays live:** an internal `version` state is bumped by an observer
+ * attached to `target.observe()`; the derived chain depends on `version`, so
+ * each mutation triggers a recompute. To avoid stalling on no-op events, only
+ * `data`, `error`, `complete`, and `teardown` bump the version (matching the
+ * audit defaults).
+ */
+declare function reactiveExplainPath(target: Graph, from: string, to: string, opts?: {
+    maxDepth?: number;
+    name?: string;
+    findCycle?: boolean;
+}): {
+    node: Node<CausalChain>;
+    dispose: () => void;
 };
+/** Options for {@link complianceSnapshot}. */
+interface ComplianceSnapshotOptions {
+    audit?: AuditTrailGraph;
+    policies?: PolicyEnforcerGraph;
+    /** Actor recorded as the snapshot taker. */
+    actor?: Actor;
+}
+/** Output of {@link complianceSnapshot}. JSON-serializable. */
+interface ComplianceSnapshotResult {
+    format_version: 1;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    actor?: Actor;
+    graph: GraphPersistSnapshot;
+    audit?: {
+        count: number;
+        entries: AuditEntry[];
+    };
+    policies?: {
+        mode: "audit" | "enforce";
+        rules: readonly PolicyRuleData[];
+        violations: readonly PolicyViolation[];
+    };
+    /**
+     * Truncated SHA-256 hex (16 chars / ~64 bits) over a canonical encoding
+     * of every field above (excluding `fingerprint` itself). Deterministic
+     * across runs given identical inputs. Suitable for casual tamper-evidence
+     * and content-addressed dedup; for full cryptographic strength, hash the
+     * canonical JSON externally with Web Crypto / Node `crypto`.
+     */
+    fingerprint: string;
+}
 /**
- * Creates the three-pane demo shell graph (roadmap §7.2).
+ * One-shot point-in-time export of a {@link Graph}'s state plus optional
+ * audit + policy bundles. Returns a JSON-serializable object with a
+ * deterministic truncated-SHA-256 {@link ComplianceSnapshotResult.fingerprint}
+ * over the canonical payload for tamper-evidence in regulatory archival.
  *
- * All coordination is reactive — no polling, no imperative triggers.
- * Framework bindings subscribe to named nodes and drive `state` inputs.
+ * **Cryptographic strength:** the fingerprint is truncated to 64 bits for
+ * compact archival. Collision-resistant for casual integrity checks but NOT
+ * sufficient for adversarial tamper-evidence — pair with a full SHA-256
+ * (or stronger) over the canonical JSON when regulatory requirements demand
+ * collision resistance.
  */
-declare function demoShell(opts?: DemoShellOptions): DemoShellHandle;
+declare function complianceSnapshot(target: Graph, opts?: ComplianceSnapshotOptions): ComplianceSnapshotResult;
 
-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 };
+type audit_AuditEntry = AuditEntry;
+type audit_AuditTrailGraph = AuditTrailGraph;
+declare const audit_AuditTrailGraph: typeof AuditTrailGraph;
+type audit_AuditTrailOptions = AuditTrailOptions;
+type audit_ComplianceSnapshotOptions = ComplianceSnapshotOptions;
+type audit_ComplianceSnapshotResult = ComplianceSnapshotResult;
+type audit_PolicyEnforcerGraph = PolicyEnforcerGraph;
+declare const audit_PolicyEnforcerGraph: typeof PolicyEnforcerGraph;
+type audit_PolicyEnforcerOptions = PolicyEnforcerOptions;
+type audit_PolicyViolation = PolicyViolation;
+declare const audit_auditTrail: typeof auditTrail;
+declare const audit_complianceSnapshot: typeof complianceSnapshot;
+declare const audit_policyEnforcer: typeof policyEnforcer;
+declare const audit_reactiveExplainPath: typeof reactiveExplainPath;
+declare namespace audit {
+  export { type audit_AuditEntry as AuditEntry, audit_AuditTrailGraph as AuditTrailGraph, type audit_AuditTrailOptions as AuditTrailOptions, type audit_ComplianceSnapshotOptions as ComplianceSnapshotOptions, type audit_ComplianceSnapshotResult as ComplianceSnapshotResult, audit_PolicyEnforcerGraph as PolicyEnforcerGraph, type audit_PolicyEnforcerOptions as PolicyEnforcerOptions, type audit_PolicyViolation as PolicyViolation, audit_auditTrail as auditTrail, audit_complianceSnapshot as complianceSnapshot, audit_policyEnforcer as policyEnforcer, audit_reactiveExplainPath as reactiveExplainPath };
 }
 
 /**
@@ -2565,6 +2237,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 +2919,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 +3357,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 +3779,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, DerivedFn, DescribeFilter, DistillBundle, Extraction, FallbackInput, type FnFactory, Graph, GraphAttachStorageOptions, GraphDescribeOptions, GraphDescribeOutput, GraphDiffResult, GraphNodeFactory, GraphOptions, GraphPersistSnapshot, GraphProfileOptions, GraphProfileResult, type GraphSpec, type GraphSpecCatalog, type GraphSpecFeedbackEdge, type GraphSpecNode, type GraphSpecTemplate, type GraphSpecTemplateRef, type GraphSpecValidation, GuardAction, NS_PER_MS, NS_PER_SEC, Node, NodeActions, NodeInput, NodeOptions, PolicyRuleData, RateLimiterOptions, ReactiveMapBundle, type ReduceOptions, type RestoreSnapshotOptions, RetryOptions, SNAPSHOT_WIRE_VERSION, type SaveSnapshotResult, type SourceFactory, StatusValue, StorageHandle, StorageTier, SurfaceError, type SurfaceErrorCode, type SurfaceErrorPayload, audit as accountability, ai, asSurfaceError, cqrs, createGraph, deleteSnapshot, demoShell, diffSnapshots, domainTemplates, graphspec, guardedExecution$1 as guarded, index$2 as harness, index$3 as layout, lens, listSnapshots, memory, messaging, orchestration, index as patterns, reduction, resilientPipeline$1 as resilientPipeline, restoreSnapshot, runReduction, saveSnapshot, index$1 as surface, version, watchTopologyTree };