@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/index.d.ts

@@ -1,2120 +1,90 @@
-export { i as compat, a as signals } from './index-BuEoe-Qu.js';
-export { b as batch, i as core, d as downWithBatch, a as isBatching, m as monotonicNs, w as wallClockNs } from './index-BaSM3aYt.js';
-import { S as StatusValue, C as CircuitState, R as RateLimiterOptions, a as CircuitBreakerOptions, b as RetryOptions, F as FallbackInput, N as NS_PER_MS, c as NS_PER_SEC } from './index-BwfLUNw4.js';
-export { A as AckableMessage, d as AdapterHandlers, B as BackoffPreset, e as BackoffStrategy, f as BatchMessage, g as BridgeMessage, h as BufferedSinkHandle, i as BundleTriad, j as CSVRow, k as CacheEvictionPolicy, l as CascadingCache, m as CascadingCacheOptions, n as CheckpointToRedisOptions, o as CheckpointToS3Options, p as CircuitBreaker, q as CircuitOpenError, r as ClickHouseClientLike, s as ClickHouseInsertClientLike, t as ClickHouseRow, u as CronSchedule, D as DrizzleQueryLike, E as EmitTriad, v as ErrorMessage, w as ExponentialBackoffOptions, x as ExternalBundleOptions, y as ExternalRegister, z as FSEvent, G as FSEventType, H as FileWriterLike, I as FromCSVOptions, J as FromClickHouseWatchOptions, K as FromDrizzleOptions, L as FromFSWatchOptions, M as FromGitHookOptions, O as FromHTTPOptions, P as FromHTTPPollOptions, Q as FromHTTPStreamOptions, T as FromKafkaOptions, U as FromKyselyOptions, V as FromMCPOptions, W as FromNATSOptions, X as FromNDJSONOptions, Y as FromOTelOptions, Z as FromPrismaOptions, _ as FromPrometheusOptions, $ as FromPulsarOptions, a0 as FromRabbitMQOptions, a1 as FromRedisStreamOptions, a2 as FromSSEOptions, a3 as FromSqliteOptions, a4 as FromStatsDOptions, a5 as FromSyslogOptions, a6 as FromWebSocketReconnectOptions, a7 as GitEvent, a8 as GitHookType, a9 as HTTPBundle, aa as IndexBackend, ab as IndexRow, ac as InitMessage, ad as JitterMode, ae as KafkaConsumerLike, af as KafkaMessage, ag as KafkaProducerLike, ah as KyselyQueryLike, ai as ListBackend, aj as LogBackend, ak as LokiClientLike, al as LokiStream, am as MCPClientLike, an as MergeMapOptions, ao as MongoCollectionLike, ap as NATSClientLike, aq as NATSMessage, ar as NATSSubscriptionLike, as as NativeIndexBackend, at as NativeListBackend, au as NativeLogBackend, av as NativePubSubBackend, aw as OTelBundle, ax as OTelLog, ay as OTelMetric, az as OTelRegister, aA as OTelSpan, aB as PostgresClientLike, aC as PrismaModelLike, aD as PrometheusMetric, aE as PubSubBackend, aF as PubSubHub, aG as PubSubHubOptions, aH as PulsarConsumerLike, aI as PulsarMessage, aJ as PulsarProducerLike, aK as RabbitMQChannelLike, aL as RabbitMQMessage, aM as RateLimiterOverflowError, aN as RateLimiterOverflowPolicy, aO as ReactiveIndexBundle, aP as ReactiveIndexOptions, aQ as ReactiveListBundle, aR as ReactiveListOptions, aS as ReactiveLogBundle, aT as ReactiveLogOptions, aU as ReactiveSinkBackpressureOptions, aV as ReactiveSinkConfig, aW as ReactiveSinkHandle, aX as ReactiveSinkOptions, aY as ReactiveSinkRetryOptions, aZ as ReadyMessage, a_ as RedisCheckpointClientLike, a$ as RedisClientLike, b0 as RedisStreamEntry, b1 as ResettableTimer, b2 as RetrySourceOptions, b3 as S3ClientLike, b4 as SSEEvent, b5 as SignalMessage, b6 as SinkFailure, b7 as SinkHandle, b8 as SinkTransportError, b9 as SqliteDbLike, ba as SqliteIterableDbLike, bb as StatsDMetric, bc as StatsDRegister, bd as SyslogMessage, be as SyslogRegister, bf as TapObserver, bg as TempoClientLike, bh as ThrottleOptions, bi as TimeoutError, bj as ToCSVOptions, bk as ToClickHouseOptions, bl as ToFileOptions, bm as ToHTTPOptions, bn as ToKafkaOptions, bo as ToLokiOptions, bp as ToMongoOptions, bq as ToNATSOptions, br as ToPostgresOptions, bs as ToPulsarOptions, bt as ToRabbitMQOptions, bu as ToRedisStreamOptions, bv as ToS3Options, bw as ToSSEOptions, bx as ToSqliteOptions, by as ToTempoOptions, bz as ToWebSocketOptions, bA as TokenBucket, bB as UpsertOptions, bC as ValueMessage, bD as WatermarkController, bE as WatermarkOptions, bF as WebSocketLike, bG as WebSocketMessageEventLike, bH as WebSocketRegister, bI as WebhookRegister, bJ as WithBreakerBundle, bK as WithStatusBundle, bL as WorkerBridge, bM as WorkerBridgeOptions, bN as WorkerSelfHandle, bO as WorkerSelfOptions, bP as WorkerTransport, bQ as audit, bR as buffer, bS as bufferCount, bT as bufferTime, bU as cascadingCache, bV as catchError, bW as checkpointToRedis, bX as checkpointToS3, bY as circuitBreaker, bZ as combine, b_ as combineLatest, b$ as concat, c0 as concatMap, c1 as constant, c2 as createTransport, c3 as createWatermarkController, c4 as csvRows, c5 as debounce, c6 as debounceTime, c7 as decorrelatedJitter, c8 as delay, c9 as deserializeError, ca as distinctUntilChanged, cb as elementAt, cc as exhaustMap, cd as exponential, ce as externalBundle, cf as externalProducer, cg as extra, ch as fallback, ci as fibonacci, cj as filter, ck as find, cl as first, cm as flatMap, cn as fromCSV, co as fromClickHouseWatch, cp as fromDrizzle, cq as fromFSWatch, cr as fromGitHook, cs as fromHTTP, ct as fromHTTPPoll, cu as fromHTTPStream, cv as fromKafka, cw as fromKysely, cx as fromMCP, cy as fromNATS, cz as fromNDJSON, cA as fromOTel, cB as fromPrisma, cC as fromPrometheus, cD as fromPulsar, cE as fromRabbitMQ, cF as fromRedisStream, cG as fromSSE, cH as fromSqlite, cI as fromSqliteCursor, cJ as fromStatsD, cK as fromSyslog, cL as fromWebSocket, cM as fromWebSocketReconnect, cN as fromWebhook, cO as interval, cP as last, cQ as linear, cR as lru, cS as map, cT as matchesCron, cU as merge, cV as mergeMap, cW as nameToSignal, cX as ndjsonRows, cY as pairwise, cZ as parseCron, c_ as parsePrometheusText, c$ as parseStatsD, d0 as parseSyslog, d1 as pausable, d2 as pubsub, d3 as race, d4 as rateLimiter, d5 as reactiveIndex, d6 as reactiveList, d7 as reactiveLog, d8 as reactiveSink, d9 as reduce, da as repeat, db as rescue, dc as resolveBackoffPreset, dd as retry, de as retrySource, df as sample, dg as scan, dh as serializeError, di as signalToName, dj as skip, dk as switchMap, dl as take, dm as takeUntil, dn as takeWhile, dp as tap, dq as throttle, dr as throttleTime, ds as timeout, dt as toCSV, du as toClickHouse, dv as toFile, dw as toHTTP, dx as toKafka, dy as toLoki, dz as toMongo, dA as toNATS, dB as toPostgres, dC as toPulsar, dD as toRabbitMQ, dE as toReadableStream, dF as toRedisStream, dG as toS3, dH as toSSE, dI as toSSEBytes, dJ as toSqlite, dK as toTempo, dL as toWebSocket, dM as tokenBucket, dN as valve, dO as window, dP as windowCount, dQ as windowTime, dR as withBreaker, dS as withLatestFrom, dT as withMaxAttempts, dU as withStatus, dV as workerBridge, dW as workerSelf, dX as zip } from './index-BwfLUNw4.js';
-import { w as watchTopologyTree } from './index-B6D3QNSA.js';
-export { E as ENVELOPE_VERSION, a as EvictedSubgraphInfo, b as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, O as SIZEOF_OVERHEAD, S as SIZEOF_SYMBOL, W as WALEntry, c as createDagCborCodec, d as createDagCborZstdCodec, e as decodeEnvelope, f as encodeEnvelope, i as graph, r as registerBuiltinCodecs, g as replayWAL, s as sizeof } from './index-B6D3QNSA.js';
-import { L as LLMAdapter, G as GateController, a as ai, o as orchestration } from './ai-WlRltJV7.js';
-import { P as PolicyEnforcerGraph, a as PolicyViolation, b as audit } from './audit-DRlSzBu9.js';
-import { c as cqrs } from './index-BPVt8kqc.js';
-export { i as nestjs } from './index-BPVt8kqc.js';
-import { d as demoShell } from './demo-shell-BDkOptd6.js';
-import { N as Node, P as PolicyRuleData, A as Actor, a as NodeOptions } from './node-BmerH3kS.js';
-export { C as COMPLETE, b as COMPLETE_MSG, c as COMPLETE_ONLY_BATCH, D as DATA, d as DEFAULT_ACTOR, e as DIRTY, f as DIRTY_MSG, g as DIRTY_ONLY_BATCH, h as DepRecord, E as ERROR, F as FnCtx, G as GlobalInspectorEvent, i as GlobalInspectorHook, j as GraphReFlyConfig, k as GuardAction, l as GuardDenied, m as GuardDeniedDetails, H as HashFn, I as INVALIDATE, n as INVALIDATE_MSG, o as INVALIDATE_ONLY_BATCH, M as Message, p as MessageContext, q as MessageTypeRegistration, r as MessageTypeRegistrationInput, s as Messages, t as NodeActions, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-BmerH3kS.js';
-import { G as GraphOptions, a as Graph, b as GraphDescribeOptions, c as GraphDescribeOutput, D as DescribeFilter, d as GraphProfileResult, e as GraphProfileOptions, C as CausalChain, f as GraphNodeFactory, g as GraphDiffResult } from './graph-CCwGKLCm.js';
-export { h as CausalStep, E as ExplainPathOptions, i as GRAPH_META_SEGMENT, j as GraphActorOptions, k as GraphAttachStorageOptions, l as GraphCheckpointRecord, m as GraphDiagramDirection, n as GraphDiagramOptions, o as GraphDiffChange, p as GraphFactoryContext, q as GraphObserveAll, r as GraphObserveOne, s as GraphPersistSnapshot, t as GraphVersionChange, u as GraphWALDiff, N as NodeProfile, O as ObserveDetail, v as ObserveEvent, w as ObserveOptions, x as ObserveResult, y as ObserveTheme, z as ObserveThemeName, R as ReachableDirection, A as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, B as TraceEntry, F as diffForWAL, H as explainPath, I as graphProfile, J as reachable } from './graph-CCwGKLCm.js';
-import { T as TopicGraph, m as messaging } from './messaging-XDoYablx.js';
-import { R as ReactiveMapBundle } from './composite-aUCvjZVR.js';
-export { D as DistillBundle, a as DistillOptions, E as Extraction, M as MapBackend, N as NativeMapBackend, b as NativeMapBackendOptions, c as ReactiveMapOptions, V as VerifiableBundle, d as VerifiableOptions, e as VerifyValue, f as distill, r as reactiveMap, v as verifiable } from './composite-aUCvjZVR.js';
-import { m as memory } from './memory-li6FL5RM.js';
-import { i as index$3 } from './index-C8oil6M6.js';
-import { S as StorageTier } from './storage-CMjUUuxn.js';
-export { I as IndexedDbStorageSpec, a as StorageHandle, d as dictStorage, f as fileStorage, b as fromIDBRequest, c as fromIDBTransaction, i as indexedDbStorage, m as memoryStorage, s as sqliteStorage } from './storage-CMjUUuxn.js';
-export { AsyncSourceOpts, EventTargetLike, FromCronOptions, NodeInput, ReactiveCounterBundle, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
-export { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-CCOxXK1e.js';
-export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CbznRPYJ.js';
-export { T as ToObservableOptions, t as toObservable } from './observable-BgGUwcqp.js';
-export { i as jotai } from './index-3lsddbbS.js';
-export { i as nanostores } from './index-C0svESO4.js';
-export { i as react } from './index-Dzk2hrlR.js';
-export { i as solid } from './index-VdHQMPy1.js';
-export { i as svelte } from './index-CxFrXH4m.js';
-export { i as vue } from './index-wEn0eFe8.js';
-export { i as zustand } from './index-B9B7_HEY.js';
+export { i as compat, a as signals } from './index-CI0yDnLp.js';
+export { b as batch, i as core, d as downWithBatch, a as isBatching, m as monotonicNs, w as wallClockNs } from './index-CcWOJ6F0.js';
+export { A as AckableMessage, a as AdapterHandlers, B as BatchMessage, b as BridgeMessage, c as BufferedSinkHandle, d as BundleTriad, C as CSVRow, e as CacheEvictionPolicy, f as CascadingCache, g as CascadingCacheOptions, h as CheckpointToRedisOptions, i as CheckpointToS3Options, j as ClickHouseClientLike, k as ClickHouseInsertClientLike, l as ClickHouseRow, m as CronSchedule, D as DrizzleQueryLike, E as EmitTriad, n as ErrorMessage, o as ExternalBundleOptions, p as ExternalRegister, F as FileWriterLike, q as FromCSVOptions, r as FromClickHouseWatchOptions, s as FromDrizzleOptions, t as FromHTTPOptions, u as FromHTTPPollOptions, v as FromHTTPStreamOptions, w as FromKafkaOptions, x as FromKyselyOptions, y as FromMCPOptions, z as FromNATSOptions, G as FromNDJSONOptions, H as FromOTelOptions, I as FromPrismaOptions, J as FromPrometheusOptions, K as FromPulsarOptions, L as FromRabbitMQOptions, M as FromRedisStreamOptions, N as FromSSEOptions, O as FromSqliteOptions, P as FromStatsDOptions, Q as FromSyslogOptions, R as FromWebSocketReconnectOptions, S as HTTPBundle, T as InitMessage, U as KafkaConsumerLike, V as KafkaMessage, W as KafkaProducerLike, X as KyselyQueryLike, Y as LokiClientLike, Z as LokiStream, _ as MCPClientLike, $ as MongoCollectionLike, a0 as NATSClientLike, a1 as NATSMessage, a2 as NATSSubscriptionLike, a3 as NativePubSubBackend, a4 as OTelBundle, a5 as OTelLog, a6 as OTelMetric, a7 as OTelRegister, a8 as OTelSpan, a9 as PostgresClientLike, aa as PrismaModelLike, ab as PrometheusMetric, ac as PubSubBackend, ad as PubSubHub, ae as PubSubHubOptions, af as PulsarConsumerLike, ag as PulsarMessage, ah as PulsarProducerLike, ai as RabbitMQChannelLike, aj as RabbitMQMessage, ak as ReactiveSinkBackpressureOptions, al as ReactiveSinkConfig, am as ReactiveSinkHandle, an as ReactiveSinkOptions, ao as ReactiveSinkRetryOptions, ap as ReadyMessage, aq as RedisCheckpointClientLike, ar as RedisClientLike, as as RedisStreamEntry, at as ResettableTimer, au as S3ClientLike, av as SSEEvent, aw as SignalMessage, ax as SingleFromAnyOptions, ay as SinkFailure, az as SinkHandle, aA as SinkTransportError, aB as SqliteDbLike, aC as SqliteIterableDbLike, aD as StatsDMetric, aE as StatsDRegister, aF as StratifyOptions, aG as StratifyRule, aH as SyslogMessage, aI as SyslogRegister, aJ as TempoClientLike, aK as ToCSVOptions, aL as ToClickHouseOptions, aM as ToFileOptions, aN as ToHTTPOptions, aO as ToKafkaOptions, aP as ToLokiOptions, aQ as ToMongoOptions, aR as ToNATSOptions, aS as ToPostgresOptions, aT as ToPulsarOptions, aU as ToRabbitMQOptions, aV as ToRedisStreamOptions, aW as ToS3Options, aX as ToSSEOptions, aY as ToSqliteOptions, aZ as ToTempoOptions, a_ as ToWebSocketOptions, a$ as ValueMessage, b0 as WatermarkController, b1 as WatermarkOptions, b2 as WebSocketLike, b3 as WebSocketMessageEventLike, b4 as WebSocketRegister, b5 as WebhookRegister, b6 as WorkerBridge, b7 as WorkerBridgeOptions, b8 as WorkerSelfHandle, b9 as WorkerSelfOptions, ba as WorkerTransport, bb as cascadingCache, bc as checkpointToRedis, bd as checkpointToS3, be as createTransport, bf as createWatermarkController, bg as csvRows, bh as deserializeError, bi as externalBundle, bj as externalProducer, bk as extra, bl as fromCSV, bm as fromClickHouseWatch, bn as fromDrizzle, bo as fromHTTP, bp as fromHTTPPoll, bq as fromHTTPStream, br as fromKafka, bs as fromKysely, bt as fromMCP, bu as fromNATS, bv as fromNDJSON, bw as fromOTel, bx as fromPrisma, by as fromPrometheus, bz as fromPulsar, bA as fromRabbitMQ, bB as fromRedisStream, bC as fromSSE, bD as fromSqlite, bE as fromSqliteCursor, bF as fromStatsD, bG as fromSyslog, bH as fromWebSocket, bI as fromWebSocketReconnect, bJ as fromWebhook, bK as lru, bL as matchesCron, bM as nameToSignal, bN as ndjsonRows, bO as parseCron, bP as parsePrometheusText, bQ as parseStatsD, bR as parseSyslog, bS as pubsub, bT as reactiveSink, bU as serializeError, bV as signalToName, bW as singleFromAny, bX as singleNodeFromAny, bY as stratify, bZ as toCSV, b_ as toClickHouse, b$ as toFile, c0 as toHTTP, c1 as toKafka, c2 as toLoki, c3 as toMongo, c4 as toNATS, c5 as toPostgres, c6 as toPulsar, c7 as toRabbitMQ, c8 as toReadableStream, c9 as toRedisStream, ca as toS3, cb as toSSE, cc as toSSEBytes, cd as toSqlite, ce as toTempo, cf as toWebSocket, cg as workerBridge, ch as workerSelf } from './index-2BVuRCI4.js';
+export { E as ENVELOPE_VERSION, a as EvictedSubgraphInfo, b as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, O as ObservabilityCheck, c as ObservabilityDescribeFormat, d as SIZEOF_OVERHEAD, S as SIZEOF_SYMBOL, V as ValidateObservabilityOptions, e as ValidateObservabilityResult, W as WALEntry, f as createDagCborCodec, g as createDagCborZstdCodec, h as decodeEnvelope, i as encodeEnvelope, j as graph, r as registerBuiltinCodecs, k as replayWAL, s as sizeof, v as validateGraphObservability } from './index-BiyjsZ0m.js';
+export { C as ChatMessage, L as LLMAdapter, a as LLMInvokeOptions, b as LLMResponse, S as StreamDelta, T as TokenUsage, c as ToolCall, d as ToolDefinition } from './types-u64Ose53.js';
+import { i as index$2 } from './index-BqZ6vB2A.js';
+import { i as index$1 } from './index-CiaVoZGo.js';
+import { i as index$3 } from './index-BSfwiy5B.js';
+import { i as index$4 } from './index-C66RJiX8.js';
+import { i as index$5 } from './index-BJqt9EwW.js';
+import { C as CatalogFnEntry, a as CatalogSourceEntry, b as ConfigFieldSchema, F as FnFactory, G as GraphSpec, c as GraphSpecCatalog, d as GraphSpecFeedbackEdge, e as GraphSpecNode, f as GraphSpecTemplate, g as GraphSpecTemplateRef, h as GraphSpecValidation, S as SourceFactory, i as index$6 } from './index-DDy8eeXS.js';
+import { i as index$7 } from './index-B-gqvYel.js';
+import { i as index$8 } from './index-CA1Cu7Ud.js';
+import { i as index$9 } from './index-Vg7tORgk.js';
+import { i as index$b } from './index-BUi57v_p.js';
+import { i as index$c } from './index-DCeTyFlB.js';
+import { i as index$d } from './index-DuB5aO4-.js';
+import { i as index$e } from './index-DJ5oNBc8.js';
+import { i as index$a } from './index-D5XJ2tSx.js';
+import { i as index$f } from './index-A65LZhoM.js';
+import { i as index$g } from './index-DwjJGKxV.js';
+import { i as index$h } from './index-Byh-xTyp.js';
+import { C as CreateGraphOptions, R as ReduceOptions, a as RestoreSnapshotOptions, S as SNAPSHOT_WIRE_VERSION, b as SaveSnapshotResult, c as SurfaceError, d as SurfaceErrorCode, e as SurfaceErrorPayload, f as asSurfaceError, g as createGraph, h as deleteSnapshot, i as diffSnapshots, l as listSnapshots, r as restoreSnapshot, j as runReduction, s as saveSnapshot, k as index$i } from './index-C8RfjffH.js';
+export { A as Actor, C as COMPLETE, f as COMPLETE_MSG, g as COMPLETE_ONLY_BATCH, D as DATA, h as DEFAULT_ACTOR, i as DIRTY, j as DIRTY_MSG, k as DIRTY_ONLY_BATCH, l as DepRecord, E as ERROR, F as FnCtx, m as GlobalInspectorEvent, n as GlobalInspectorHook, o as GraphReFlyConfig, G as GuardAction, p as GuardDenied, q as GuardDeniedDetails, H as HashFn, I as INVALIDATE, r as INVALIDATE_MSG, s as INVALIDATE_ONLY_BATCH, M as Message, t as MessageContext, u as MessageTypeRegistration, v as MessageTypeRegistrationInput, b as Messages, a as Node, c as NodeActions, w as NodeCtx, e as NodeDescribeKind, x as NodeFn, d as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, N as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, W as PolicyDeny, P as PolicyRuleData, X as RESOLVED, Y as RESOLVED_MSG, Z as RESOLVED_ONLY_BATCH, _ as RESUME, $ as START, a0 as START_MSG, a1 as SubscribeContext, a2 as TEARDOWN, a3 as TEARDOWN_MSG, a4 as TEARDOWN_ONLY_BATCH, a5 as V0, a6 as V1, V 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-Dd6wHSib.js';
+export { AsyncSourceOpts, EventTargetLike, FromCronOptions, NodeInput, ReactiveCounterBundle, awaitSettled, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
+export { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-CY-MCfZ9.js';
+export { B as BackoffPreset, d as BackoffStrategy, e as CircuitBreaker, a as CircuitBreakerOptions, f as CircuitOpenError, C as CircuitState, E as ExponentialBackoffOptions, F as FallbackInput, J as JitterMode, N as NS_PER_MS, c as NS_PER_SEC, R as RateLimiterOptions, g as RateLimiterOverflowError, h as RateLimiterOverflowPolicy, b as RetryOptions, i as RetrySourceOptions, S as StatusValue, T as TimeoutError, j as TokenBucket, W as WithBreakerBundle, k as WithStatusBundle, l as circuitBreaker, m as constant, n as decorrelatedJitter, o as exponential, p as fallback, q as fibonacci, r as linear, s as rateLimiter, t as resolveBackoffPreset, u as retry, v as retrySource, w as timeout, x as tokenBucket, y as withBreaker, z as withMaxAttempts, A as withStatus } from './resilience-CBfYJW5C.js';
+export { C as CausalChain, e as CausalStep, D as DescribeFilter, E as ExplainPathOptions, f as GRAPH_META_SEGMENT, G as Graph, g as GraphActorOptions, h as GraphAttachStorageOptions, i as GraphCheckpointRecord, b as GraphDescribeOptions, c 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, a as GraphOptions, d as GraphPersistSnapshot, r as GraphProfileOptions, s as GraphProfileResult, 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 mermaidLiveUrl, K as reachable } from './graph-Qjg9gWHI.js';
+export { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CckhhFRd.js';
+export { D as DistillBundle, a as DistillOptions, E as Extraction, V as VerifiableBundle, b as VerifiableOptions, c as VerifyValue, d as distill, v as verifiable } from './composite-BL-llbnE.js';
+export { IndexBackend, IndexRow, ListBackend, NativeIndexBackend, NativeListBackend, ReactiveIndexBundle, ReactiveIndexOptions, ReactiveListBundle, ReactiveListOptions, UpsertOptions, reactiveIndex, reactiveList } from './extra/reactive.js';
+export { L as LogBackend, N as NativeLogBackend, R as ReactiveLogBundle, a as ReactiveLogOptions, r as reactiveLog } from './reactive-log-1QTyx10a.js';
+export { M as MapBackend, N as NativeMapBackend, b as NativeMapBackendOptions, R as ReactiveMapBundle, a as ReactiveMapOptions, r as reactiveMap } from './reactive-map-FeuTVAJb.js';
+export { MergeMapOptions, TapObserver, ThrottleOptions, audit, buffer, bufferCount, bufferTime, catchError, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, distinctUntilChanged, elementAt, exhaustMap, filter, find, first, flatMap, interval, last, map, merge, mergeMap, pairwise, pausable, race, reduce, repeat, rescue, sample, scan, skip, switchMap, take, takeUntil, takeWhile, tap, throttle, throttleTime, valve, window, windowCount, windowTime, withLatestFrom, zip } from './extra/operators.js';
+export { StorageHandle, StorageTier, dictStorage, memoryStorage, sortJsonValue, stableJsonString } from './extra/storage-core.js';
+export { T as ToObservableOptions, t as toObservable } from './observable-BZJgo616.js';
+export { i as jotai } from './index-IMAHq-ia.js';
+export { i as nanostores } from './index-BM8BU4q6.js';
+export { i as nestjs } from './index-2NvguqQA.js';
+export { i as react } from './index-Ct5CWc4E.js';
+export { i as solid } from './index-BQaEnxBf.js';
+export { i as svelte } from './index-gsT79Xu9.js';
+export { i as vue } from './index-CX2tFJL1.js';
+export { w as watchTopologyTree } from './topology-tree-one6oSKY.js';
+export { i as zustand } from './index-CJ45TW-h.js';
+import './cascading-Bp99ckMJ.js';
+import './fallback-eOm3LNxP.js';
+import './reactive-layout-BkBwVvwm.js';
+import 'rxjs';
 import '@nestjs/common';
 import '@nestjs/core';
-import './reactive-layout-u5Ulnqag.js';
-import 'rxjs';
 import 'vue';
 
-/**
- * Domain templates (roadmap §8.2).
- *
- * Opinionated Graph factories for common "info → action" domains.
- * Each template wires up §8.1 reduction primitives (stratify, funnel, feedback,
- * budgetGate, scorer) with domain-specific stages. Users fork/extend by
- * accessing named nodes and swapping stages.
- *
- * **Source injection (option B):** templates accept a `source` node, not a
- * hardcoded adapter. Pass `fromOTel(...)`, `fromGitHook(...)`, or a test
- * `state()` — the topology is the same.
- *
- * @module
- */
-
-/** Stratification branch config for observability signals. */
-type ObservabilityBranch = {
-    name: string;
-    classify: (value: unknown) => boolean;
-};
-/** Options for {@link observabilityGraph}. */
-type ObservabilityGraphOptions = GraphOptions & {
-    /** Ingested signal source (e.g. fromOTel(...) or test state). */
-    source: Node<unknown>;
-    /**
-     * Classification rules for signal stratification.
-     * Default: errors / traces / metrics branches.
-     */
-    branches?: ObservabilityBranch[];
-    /**
-     * Correlation function: receives stratified branch values and produces
-     * correlated insights. Default: identity pass-through.
-     */
-    correlate?: (values: unknown[]) => unknown;
-    /**
-     * SLO verification function: returns a verification result for a
-     * correlated insight. Default: always passes.
-     */
-    sloCheck?: (value: unknown) => unknown;
-    /**
-     * Scorer weights for alert prioritization. One per branch.
-     * Default: equal weights [1, 1, 1].
-     */
-    weights?: number[];
-    /** Max feedback iterations for false-positive learning. Default: 5. */
-    maxFeedbackIterations?: number;
-};
-/**
- * OTel ingest → stratified reduction → correlation → SLO verification →
- * alert prioritization → output.
- *
- * Well-known node names:
- * - `"source"` — injected signal source
- * - `"stratify::branch/<name>"` — per-branch classification
- * - `"correlate"` — cross-branch correlation
- * - `"slo_value"`, `"slo_verified"` — SLO verification pair
- * - `"alerts"` — scored, prioritized output
- * - `"output"` — final output (alias for alerts)
- *
- * @category patterns
- */
-declare function observabilityGraph(name: string, opts: ObservabilityGraphOptions): Graph;
-/** A structured issue extracted from raw findings. */
-type ExtractedIssue = {
-    id: string;
-    title: string;
-    severity: number;
-    source: string;
-    raw: unknown;
-};
-/** Options for {@link issueTrackerGraph}. */
-type IssueTrackerGraphOptions = GraphOptions & {
-    /** Findings source (e.g. fromGitHook(...), fromFSWatch(...)). */
-    source: Node<unknown>;
-    /**
-     * Extract structured issues from raw findings.
-     * Default: wraps raw value as a single issue.
-     */
-    extract?: (raw: unknown) => ExtractedIssue;
-    /**
-     * Verify an extracted issue (assertion check).
-     * Default: always valid.
-     */
-    verify?: (issue: ExtractedIssue) => unknown;
-    /**
-     * Detect regression by comparing against known patterns.
-     * Receives (current issue, known patterns).
-     * Default: no regression detected.
-     */
-    detectRegression?: (issue: ExtractedIssue, known: unknown) => unknown;
-    /** Max feedback iterations for re-scanning. Default: 3. */
-    maxFeedbackIterations?: number;
-};
-/**
- * Findings ingest → extraction → verification → regression detection →
- * distillation → prioritized queue.
- *
- * Well-known node names:
- * - `"source"` — injected findings source
- * - `"extract"` — structured issue extraction
- * - `"verify"` — issue verification
- * - `"known_patterns"` — accumulated known issue patterns (state)
- * - `"regression"` — regression detection
- * - `"priority"` — severity-based prioritization
- * - `"output"` — final prioritized output
- *
- * @category patterns
- */
-declare function issueTrackerGraph(name: string, opts: IssueTrackerGraphOptions): Graph;
-/** Classification result from LLM moderation. */
-type ModerationResult = {
-    label: "safe" | "review" | "block";
-    confidence: number;
-    reason?: string;
-    original: unknown;
-};
-/** Options for {@link contentModerationGraph}. */
-type ContentModerationGraphOptions = GraphOptions & {
-    /** Content source (text/multimedia ingest). */
-    source: Node<unknown>;
-    /**
-     * Classification function: returns a ModerationResult.
-     * Default: labels everything "review" with confidence 0.5.
-     */
-    classify?: (content: unknown) => ModerationResult;
-    /** System prompt for LLM classification. */
-    systemPrompt?: string;
-    /** Scorer weights: [safe, review, block]. Default: [0.1, 1, 2]. */
-    weights?: [number, number, number];
-    /** Max feedback iterations for policy refinement. Default: 5. */
-    maxFeedbackIterations?: number;
-    /** Max review queue size. When set, oldest entries are trimmed on overflow. */
-    maxQueueSize?: number;
-};
-/**
- * Content ingest → LLM/rule classification → stratified routing (safe/review/block) →
- * human review queue → scorer → feedback (false positives → policy refinement) → output.
- *
- * Well-known node names:
- * - `"source"` — content ingest
- * - `"classify"` — LLM or rule-based classification
- * - `"stratify::branch/safe"`, `"stratify::branch/review"`, `"stratify::branch/block"` — routed branches
- * - `"review_queue"` — state node for human review items
- * - `"priority"` — scored priority output
- * - `"policy"` — writable state for policy refinement
- * - `"output"` — final moderation output
- *
- * @category patterns
- */
-declare function contentModerationGraph(name: string, opts: ContentModerationGraphOptions): Graph;
-/** Schema validation result. */
-type ValidationResult = {
-    valid: boolean;
-    errors: string[];
-    record: unknown;
-};
-/** Anomaly detection result. */
-type AnomalyResult = {
-    anomaly: boolean;
-    score: number;
-    detail?: string;
-    record: unknown;
-};
-/** Options for {@link dataQualityGraph}. */
-type DataQualityGraphOptions = GraphOptions & {
-    /** Data source (e.g. fromPrisma(...), fromKysely(...)). */
-    source: Node<unknown>;
-    /**
-     * Schema validation function.
-     * Default: always valid.
-     */
-    validate?: (record: unknown) => ValidationResult;
-    /**
-     * Anomaly detection function.
-     * Default: no anomaly.
-     */
-    detectAnomaly?: (record: unknown) => AnomalyResult;
-    /**
-     * Drift detection: compares current record against baseline.
-     * Default: no drift.
-     */
-    detectDrift?: (record: unknown, baseline: unknown) => unknown;
-    /**
-     * Remediation suggestion function.
-     * Default: no suggestion.
-     */
-    suggest?: (result: {
-        validation: ValidationResult;
-        anomaly: AnomalyResult;
-    }) => unknown;
-    /** Max feedback iterations for rule refinement. Default: 3. */
-    maxFeedbackIterations?: number;
-};
-/**
- * Data ingest → schema validation → anomaly detection → drift alerting →
- * auto-remediation suggestions → output.
- *
- * Well-known node names:
- * - `"source"` — data ingest
- * - `"validate"` — schema validation
- * - `"anomaly"` — anomaly detection
- * - `"baseline"` — rolling baseline state
- * - `"drift"` — drift detection
- * - `"remediate"` — auto-remediation suggestions
- * - `"output"` — combined quality report
- *
- * @category patterns
- */
-declare function dataQualityGraph(name: string, opts: DataQualityGraphOptions): Graph;
-
-type domainTemplates_AnomalyResult = AnomalyResult;
-type domainTemplates_ContentModerationGraphOptions = ContentModerationGraphOptions;
-type domainTemplates_DataQualityGraphOptions = DataQualityGraphOptions;
-type domainTemplates_ExtractedIssue = ExtractedIssue;
-type domainTemplates_IssueTrackerGraphOptions = IssueTrackerGraphOptions;
-type domainTemplates_ModerationResult = ModerationResult;
-type domainTemplates_ObservabilityBranch = ObservabilityBranch;
-type domainTemplates_ObservabilityGraphOptions = ObservabilityGraphOptions;
-type domainTemplates_ValidationResult = ValidationResult;
-declare const domainTemplates_contentModerationGraph: typeof contentModerationGraph;
-declare const domainTemplates_dataQualityGraph: typeof dataQualityGraph;
-declare const domainTemplates_issueTrackerGraph: typeof issueTrackerGraph;
-declare const domainTemplates_observabilityGraph: typeof observabilityGraph;
-declare namespace domainTemplates {
-  export { type domainTemplates_AnomalyResult as AnomalyResult, type domainTemplates_ContentModerationGraphOptions as ContentModerationGraphOptions, type domainTemplates_DataQualityGraphOptions as DataQualityGraphOptions, type domainTemplates_ExtractedIssue as ExtractedIssue, type domainTemplates_IssueTrackerGraphOptions as IssueTrackerGraphOptions, type domainTemplates_ModerationResult as ModerationResult, type domainTemplates_ObservabilityBranch as ObservabilityBranch, type domainTemplates_ObservabilityGraphOptions as ObservabilityGraphOptions, type domainTemplates_ValidationResult as ValidationResult, domainTemplates_contentModerationGraph as contentModerationGraph, domainTemplates_dataQualityGraph as dataQualityGraph, domainTemplates_issueTrackerGraph as issueTrackerGraph, domainTemplates_observabilityGraph as observabilityGraph };
-}
-
-/**
- * LLM graph composition (roadmap §8.3).
- *
- * Declarative GraphSpec schema + compiler/decompiler for graph topology.
- * The LLM designs graphs as JSON; compileSpec instantiates them; decompileGraph
- * extracts them back. Templates support reusable subgraph patterns. Feedback
- * edges express bounded cycles via §8.1 feedback().
- *
- * @module
- */
-
-/** A single node declaration in a GraphSpec. */
-type GraphSpecNode = {
-    /** Node kind: state, producer, derived, effect, operator. */
-    type: "state" | "producer" | "derived" | "effect" | "operator";
-    /** Dependency node names (for derived/effect/operator). */
-    deps?: string[];
-    /** Named function from the catalog (for derived/effect/operator/producer). */
-    fn?: string;
-    /** Named source from the catalog (for producer). */
-    source?: string;
-    /** Freeform config passed to the catalog fn/source factory. */
-    config?: Record<string, unknown>;
-    /** Initial value (for state nodes). */
-    initial?: unknown;
-    /** Human/LLM-readable metadata. */
-    meta?: Record<string, unknown>;
-};
-/** Template instantiation node — expanded at compile time. */
-type GraphSpecTemplateRef = {
-    type: "template";
-    /** Name of the template to instantiate. */
-    template: string;
-    /** Parameter bindings: template param name → node name. */
-    bind: Record<string, string>;
-};
-/** A reusable subgraph pattern with parameter substitution. */
-type GraphSpecTemplate = {
-    /** Parameter names (prefixed with $ in node refs). */
-    params: string[];
-    /** Node declarations within the template. */
-    nodes: Record<string, GraphSpecNode>;
-    /** Which node's output is the template's output. */
-    output: string;
-};
-/** A feedback edge: bounded cycle from condition to reentry. */
-type GraphSpecFeedbackEdge = {
-    /** Node whose DATA triggers the feedback. */
-    from: string;
-    /** State node that receives the feedback value. */
-    to: string;
-    /** Max iterations before stopping (default: 10). */
-    maxIterations?: number;
-};
-/** Declarative graph topology for LLM composition (§8.3). */
-type GraphSpec = {
-    /** Graph name. */
-    name: string;
-    /** Node declarations (keyed by node name). */
-    nodes: Record<string, GraphSpecNode | GraphSpecTemplateRef>;
-    /** Reusable subgraph templates. */
-    templates?: Record<string, GraphSpecTemplate>;
-    /** Feedback edges (bounded cycles). */
-    feedback?: GraphSpecFeedbackEdge[];
-};
-/**
- * Factory for creating a derived/effect/operator node from catalog.
- * Receives resolved dep nodes and the config from the spec.
- */
-type FnFactory = (deps: Node<unknown>[], config: Record<string, unknown>) => Node<unknown>;
-/**
- * Factory for creating a producer node from catalog.
- * Receives the config from the spec.
- */
-type SourceFactory = (config: Record<string, unknown>) => Node<unknown>;
-/** Simple config field descriptor for LLM prompt generation and validation. */
-type ConfigFieldSchema = {
-    /** Human-readable type: "string", "number", "boolean", "string[]", etc. */
-    type: string;
-    /** Whether this field is required (default: true). */
-    required?: boolean;
-    /** Allowed values (enum constraint). */
-    enum?: readonly (string | number | boolean)[];
-    /** Human-readable description for LLM context. */
-    description?: string;
-    /** Default value if omitted. */
-    default?: unknown;
-};
-/**
- * Rich catalog entry: bundles a runtime factory with LLM-facing metadata.
- *
- * The metadata is used to:
- * 1. Auto-generate prompt text for {@link llmCompose} (replaces manual `catalogDescription`)
- * 2. Validate LLM output in {@link validateSpec} (catch wrong fn names, invalid config)
- * 3. Provide actionable error messages for {@link llmRefine} feedback loops
- *
- * Developers register ONE object; the library handles prompt generation and validation.
- */
-type CatalogFnEntry = {
-    /** Runtime factory. */
-    factory: FnFactory;
-    /** One-line description for LLM prompt (what it does, not how). */
-    description: string;
-    /** Config field schemas. Keys are config field names. */
-    configSchema?: Record<string, ConfigFieldSchema>;
-    /** Example config objects (shown in prompt for complex fns). */
-    examples?: Record<string, unknown>[];
-    /** Category tags for grouping in prompt (e.g., "resilience", "reduction", "ai"). */
-    tags?: string[];
-};
-/** Rich catalog entry for producer sources. */
-type CatalogSourceEntry = {
-    /** Runtime factory. */
-    factory: SourceFactory;
-    /** One-line description for LLM prompt. */
-    description: string;
-    /** Config field schemas. */
-    configSchema?: Record<string, ConfigFieldSchema>;
-    /** Example config objects. */
-    examples?: Record<string, unknown>[];
-    /** Category tags. */
-    tags?: string[];
-};
-/**
- * Fn/source lookup table passed to compileSpec and llmCompose.
- *
- * Accepts both bare factories (backward-compatible) and rich {@link CatalogFnEntry}
- * / {@link CatalogSourceEntry} objects. When rich entries are provided, the library
- * auto-generates LLM prompts and validates LLM output against the catalog.
- */
-type GraphSpecCatalog = {
-    fns?: Record<string, FnFactory | CatalogFnEntry>;
-    sources?: Record<string, SourceFactory | CatalogSourceEntry>;
-};
-/** Type guard: is this a rich catalog fn entry (vs bare factory)? */
-declare function isRichFnEntry(entry: FnFactory | CatalogFnEntry): entry is CatalogFnEntry;
-/** Type guard: is this a rich catalog source entry (vs bare factory)? */
-declare function isRichSourceEntry(entry: SourceFactory | CatalogSourceEntry): entry is CatalogSourceEntry;
-/** Extract the runtime factory from a catalog entry (rich or bare). */
-declare function extractFnFactory(entry: FnFactory | CatalogFnEntry): FnFactory;
-/** Extract the runtime factory from a catalog source entry (rich or bare). */
-declare function extractSourceFactory(entry: SourceFactory | CatalogSourceEntry): SourceFactory;
-/**
- * Auto-generate catalog prompt text from rich catalog entries.
- *
- * Groups fns by tag, formats each as `- name: description. Config: { ... }`.
- * Falls back to listing names only for bare factories.
- */
-declare function generateCatalogPrompt(catalog: GraphSpecCatalog): string;
-/**
- * Validate a GraphSpec against a catalog.
- *
- * Checks that fn/source names reference actual catalog entries, and validates
- * config fields against configSchema when rich entries are available.
- * Returns additional errors beyond structural {@link validateSpec} checks.
- */
-declare function validateSpecAgainstCatalog(spec: GraphSpec, catalog: GraphSpecCatalog): GraphSpecValidation;
-/** Validation result from {@link validateSpec}. */
-type GraphSpecValidation = {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Validate a GraphSpec JSON object.
- *
- * Checks structural validity: required fields, node types, dep references,
- * template references, feedback edge targets, self-cycles, and bind completeness.
- */
-declare function validateSpec(spec: unknown): GraphSpecValidation;
-/** Options for {@link compileSpec}. */
-type CompileSpecOptions = {
-    /** Fn/source catalog for resolving named factories. */
-    catalog?: GraphSpecCatalog;
-};
-/**
- * Instantiate a Graph from a GraphSpec.
- *
- * Handles template expansion (mounted subgraphs), feedback wiring via §8.1
- * feedback(), node factory lookup from the catalog, and topology validation.
- *
- * @param spec - Declarative graph topology.
- * @param opts - Catalog and compile options.
- * @returns A running Graph.
- * @throws On validation failure, missing catalog entries, or unresolvable deps.
- *
- * @category patterns
- */
-declare function compileSpec(spec: GraphSpec, opts?: CompileSpecOptions): Graph;
-/**
- * Extract a GraphSpec from a running graph.
- *
- * Uses `describe({ detail: "standard" })` as a starting point, then enriches:
- * - Feedback edges recovered from counter node meta (`feedbackFrom`/`feedbackTo`)
- * - Template refs recovered from output node meta (`_templateName`/`_templateBind`)
- * - Structural fingerprinting as fallback for 2+ identical mounted subgraphs
- *
- * @param graph - Running graph to decompile.
- * @returns A GraphSpec representation.
- *
- * @category patterns
- */
-declare function decompileGraph(graph: Graph): GraphSpec;
-/** A single change in a spec diff. */
-type SpecDiffEntry = {
-    type: "added" | "removed" | "changed";
-    path: string;
-    detail?: string;
-};
-/** Structural diff between two GraphSpecs. */
-type SpecDiffResult = {
-    entries: SpecDiffEntry[];
-    summary: string;
-};
-/**
- * Compute a structural diff between two GraphSpecs.
- *
- * Template-aware: reports "changed template definition" vs "changed
- * instantiation bindings." No runtime needed — pure JSON comparison.
- *
- * @param specA - The "before" spec.
- * @param specB - The "after" spec.
- * @returns Diff entries and a human-readable summary.
- *
- * @category patterns
- */
-declare function specDiff(specA: GraphSpec, specB: GraphSpec): SpecDiffResult;
-/** Options for {@link llmCompose}. */
-type LLMComposeOptions = {
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /** Extra instructions appended to the system prompt. */
-    systemPromptExtra?: string;
-    /**
-     * Available fn/source catalog names for the LLM to reference.
-     * When omitted and `catalog` contains rich {@link CatalogFnEntry} entries,
-     * the prompt is auto-generated via {@link generateCatalogPrompt}.
-     */
-    catalogDescription?: string;
-    /**
-     * Catalog for auto-prompt generation and catalog-aware validation.
-     * When rich entries are provided, the catalog prompt is auto-generated
-     * and LLM output is validated against fn/source names and config schemas.
-     */
-    catalog?: GraphSpecCatalog;
-    /**
-     * Max auto-refine attempts when the LLM output fails catalog validation.
-     * Each attempt feeds the validation errors back to the LLM via llmRefine.
-     * Default: 0 (no auto-refine). Set to 2-3 for production use.
-     */
-    maxAutoRefine?: number;
-};
-/**
- * Ask an LLM to compose a GraphSpec from a natural-language problem description.
- *
- * The LLM generates a GraphSpec (with templates + feedback), validated before
- * returning. The spec is for human review before compilation via compileSpec().
- *
- * @param problem - Natural language problem description.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and catalog description.
- * @returns A validated GraphSpec.
- * @throws On invalid LLM output or validation failure.
- *
- * @category patterns
- */
-declare function llmCompose(problem: string, adapter: LLMAdapter, opts?: LLMComposeOptions): Promise<GraphSpec>;
-/** Options for {@link llmRefine}. */
-type LLMRefineOptions = LLMComposeOptions;
-/**
- * Ask an LLM to modify an existing GraphSpec based on feedback or changed requirements.
- *
- * @param currentSpec - The current GraphSpec to modify.
- * @param feedback - Natural language feedback or changed requirements.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options.
- * @returns A new GraphSpec incorporating the feedback.
- * @throws On invalid LLM output or validation failure.
- *
- * @category patterns
- */
-declare function llmRefine(currentSpec: GraphSpec, feedback: string, adapter: LLMAdapter, opts?: LLMRefineOptions): Promise<GraphSpec>;
-
-type graphspec_CatalogFnEntry = CatalogFnEntry;
-type graphspec_CatalogSourceEntry = CatalogSourceEntry;
-type graphspec_CompileSpecOptions = CompileSpecOptions;
-type graphspec_ConfigFieldSchema = ConfigFieldSchema;
-type graphspec_FnFactory = FnFactory;
-type graphspec_GraphSpec = GraphSpec;
-type graphspec_GraphSpecCatalog = GraphSpecCatalog;
-type graphspec_GraphSpecFeedbackEdge = GraphSpecFeedbackEdge;
-type graphspec_GraphSpecNode = GraphSpecNode;
-type graphspec_GraphSpecTemplate = GraphSpecTemplate;
-type graphspec_GraphSpecTemplateRef = GraphSpecTemplateRef;
-type graphspec_GraphSpecValidation = GraphSpecValidation;
-type graphspec_LLMComposeOptions = LLMComposeOptions;
-type graphspec_LLMRefineOptions = LLMRefineOptions;
-type graphspec_SourceFactory = SourceFactory;
-type graphspec_SpecDiffEntry = SpecDiffEntry;
-type graphspec_SpecDiffResult = SpecDiffResult;
-declare const graphspec_compileSpec: typeof compileSpec;
-declare const graphspec_decompileGraph: typeof decompileGraph;
-declare const graphspec_extractFnFactory: typeof extractFnFactory;
-declare const graphspec_extractSourceFactory: typeof extractSourceFactory;
-declare const graphspec_generateCatalogPrompt: typeof generateCatalogPrompt;
-declare const graphspec_isRichFnEntry: typeof isRichFnEntry;
-declare const graphspec_isRichSourceEntry: typeof isRichSourceEntry;
-declare const graphspec_llmCompose: typeof llmCompose;
-declare const graphspec_llmRefine: typeof llmRefine;
-declare const graphspec_specDiff: typeof specDiff;
-declare const graphspec_validateSpec: typeof validateSpec;
-declare const graphspec_validateSpecAgainstCatalog: typeof validateSpecAgainstCatalog;
-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).
- *
- * Shared types for the reactive collaboration loop: intake, triage, queue,
- * gate, execute, verify, reflect. These types are intentionally domain-agnostic
- * — the harness loop is not specific to eval workflows.
- *
- * @module
- */
-/** Sources that can produce intake items. */
-type IntakeSource = "eval" | "test" | "human" | "code-change" | "hypothesis" | "parity";
-/** Severity levels for intake items. */
-type Severity = "critical" | "high" | "medium" | "low";
-/** Root cause categories for triage classification. */
-type RootCause = "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown";
-/** Intervention types that address root causes. */
-type Intervention = "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate";
-/** Routing destinations after triage. */
-type QueueRoute = "auto-fix" | "needs-decision" | "investigation" | "backlog";
-/** Ordered queue route names for iteration. */
-declare const QUEUE_NAMES: readonly QueueRoute[];
-/**
- * An item entering the harness loop via the INTAKE stage.
- *
- * All intake sources produce this uniform shape — the intake topic
- * doesn't care where items came from.
- */
-interface IntakeItem {
-    source: IntakeSource;
-    summary: string;
-    evidence: string;
-    affectsAreas: string[];
-    affectsEvalTasks?: string[];
-    severity?: Severity;
-    relatedTo?: string[];
-    /** Item-carried reingestion count. Incremented on each full-loop reingestion. */
-    _reingestions?: number;
-}
-/** Output of the TRIAGE stage — enriched intake item with classification. */
-interface TriagedItem extends IntakeItem {
-    rootCause: RootCause;
-    intervention: Intervention;
-    route: QueueRoute;
-    priority: number;
-    triageReasoning?: string;
-    /** Item-carried retry count. Incremented on each fast-retry pass. */
-    _retries?: number;
-}
-/** Effectiveness record for a rootCause→intervention pair. */
-interface StrategyEntry {
-    rootCause: RootCause;
-    intervention: Intervention;
-    attempts: number;
-    successes: number;
-    successRate: number;
-}
-/** Key format: `${rootCause}→${intervention}`. */
-type StrategyKey = `${RootCause}→${Intervention}`;
-declare function strategyKey(rootCause: RootCause, intervention: Intervention): StrategyKey;
-/** LLM output shape from the EXECUTE stage (partial — lacks `item`). */
-type ExecuteOutput = {
-    outcome: "success" | "failure" | "partial";
-    detail: string;
-};
-/** Full execution result assembled downstream (LLM output + context). */
-interface ExecutionResult {
-    item: TriagedItem;
-    outcome: "success" | "failure" | "partial";
-    detail: string;
-}
-/** Whether an error is self-correctable (fast-retry) or structural (full loop). */
-type ErrorClass = "self-correctable" | "structural";
-/** Classifier for fast-retry path. */
-type ErrorClassifier = (result: ExecutionResult) => ErrorClass;
-/** Default error classifier: parse/config errors are self-correctable. */
-declare function defaultErrorClassifier(result: ExecutionResult): ErrorClass;
-/** Result of the VERIFY stage. */
-interface VerifyResult {
-    item: TriagedItem;
-    execution: ExecutionResult;
-    verified: boolean;
-    findings: string[];
-    errorClass?: ErrorClass;
-}
-/** Configurable signals for priority scoring. */
-interface PrioritySignals {
-    /** Per-severity base weight (default: critical=100, high=70, medium=40, low=10). */
-    severityWeights?: Partial<Record<Severity, number>>;
-    /** Decay rate per second for attention decay (default ~1.15e-6 ≈ 7-day half-life). */
-    decayRate?: number;
-    /** Strategy model effectiveness boost threshold (default 0.7). */
-    effectivenessThreshold?: number;
-    /** Strategy model effectiveness boost amount (default 15). */
-    effectivenessBoost?: number;
-}
-/** Default severity weights. */
-declare const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number>;
-/** Default decay rate: ~7-day half-life. */
-declare const DEFAULT_DECAY_RATE: number;
-/** Per-queue configuration in the harness loop. */
-interface QueueConfig {
-    /** Whether this queue is gated (requires human approval). */
-    gated: boolean;
-    /** Maximum pending items in the gate (default Infinity). */
-    maxPending?: number;
-    /** Start the gate in open (auto-approve) mode? */
-    startOpen?: boolean;
-}
-/** Default queue configurations. */
-declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
-/** Options for {@link harnessLoop}. */
-interface HarnessLoopOptions {
-    /** LLM adapter for promptNode-based stages (triage, execute, verify, reflect). */
-    adapter: unknown;
-    /** Custom triage prompt (receives IntakeItem + strategy model as context). */
-    triagePrompt?: string | ((...args: unknown[]) => string);
-    /** Custom execute prompt. */
-    executePrompt?: string | ((...args: unknown[]) => string);
-    /** Custom verify prompt. */
-    verifyPrompt?: string | ((...args: unknown[]) => string);
-    /** Per-queue configuration overrides. */
-    queues?: Partial<Record<QueueRoute, QueueConfig>>;
-    /** Priority scoring signals. */
-    priority?: PrioritySignals;
-    /** Error classifier for fast-retry path. */
-    errorClassifier?: ErrorClassifier;
-    /** Max fast-retries per item before routing to full intake (default 2). */
-    maxRetries?: number;
-    /** Global retry cap across all items — circuit breaker (default maxRetries × 10). */
-    maxTotalRetries?: number;
-    /** Max re-ingestions from verify→intake before giving up (default 1). */
-    maxReingestions?: number;
-    /** Global reingestion cap across all items — circuit breaker (default maxReingestions × 10). */
-    maxTotalReingestions?: number;
-    /** Retained limit for topic logs (default 1000). */
-    retainedLimit?: number;
-}
-
-/**
- * Harness bridge factories (roadmap §9.0).
- *
- * Intake bridges, eval source wrapper, before/after comparison,
- * affected-task filter, code-change bridge, and notification effect.
- * All are compositions of existing primitives — no new abstractions.
- *
- * @module
- */
-
-/** Options for {@link createIntakeBridge}. */
-interface IntakeBridgeOptions {
-    /** Name for the effect node (default "intake-bridge"). */
-    name?: string;
-}
-/**
- * Generic source→intake bridge factory.
- *
- * Watches a source node for new values, passes each through a user-supplied
- * `parser` that produces zero or more `IntakeItem`s, and publishes them to
- * the given intake topic.
- *
- * This is the generalized pattern behind {@link evalIntakeBridge}. Use it for
- * CI results, test failures, Slack messages, monitoring alerts, or any domain
- * where structured results should flow into a harness loop.
- *
- * @param source - Reactive node emitting domain-specific data.
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param parser - Converts source data into IntakeItem[]. Return empty array to skip.
- * @param opts - Optional configuration.
- * @returns The effect node (for lifecycle management).
- */
-declare function createIntakeBridge<T>(source: Node<T>, intakeTopic: TopicGraph<IntakeItem>, parser: (value: T) => IntakeItem[], opts?: IntakeBridgeOptions): Node<unknown>;
-/**
- * Minimal eval result shape accepted by the bridge.
- *
- * TS eval runner uses `EvalRun` from `evals/lib/types.ts` which is a superset
- * of this shape. The bridge only reads what it needs.
- */
-interface EvalResult {
-    run_id: string;
-    model: string;
-    tasks: EvalTaskResult[];
-}
-interface EvalTaskResult {
-    task_id: string;
-    valid: boolean;
-    judge_scores?: EvalJudgeScore[];
-}
-interface EvalJudgeScore {
-    claim: string;
-    pass: boolean;
-    reasoning: string;
-}
-interface EvalIntakeBridgeOptions {
-    /** Name for the effect node (default "eval-intake-bridge"). */
-    name?: string;
-    /** Minimum severity for eval-sourced items (default "medium"). */
-    defaultSeverity?: Severity;
-}
-/**
- * Create an effect node that watches an eval results source and publishes
- * per-criterion findings to an intake topic.
- *
- * Each failing judge criterion produces a separate IntakeItem — not one
- * item per task. This gives the triage stage granular findings to classify.
- *
- * @param evalSource - Node emitting EvalResult (or EvalResult[]).
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param opts - Optional configuration.
- * @returns The effect node (for lifecycle management).
- */
-declare function evalIntakeBridge(evalSource: Node<EvalResult | EvalResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
-/**
- * Wrap any eval runner as a reactive producer node.
- *
- * When `trigger` emits, calls `runner()` and emits the result downstream.
- * Uses `switchMap` + `fromAny` — the async boundary stays in the source
- * layer (spec §5.10). A new trigger cancels any in-flight run.
- *
- * ```ts
- * const trigger = state(0);         // bump to trigger a new run
- * const results = evalSource(trigger, () => runEvals(config));
- * results.subscribe(msgs => { ... });
- * trigger.down([[DATA, 1]]);         // fires the runner
- * ```
- *
- * @param trigger - Any node; each new DATA emission fires the runner.
- * @param runner  - Returns an EvalResult (or promise of one).
- */
-declare function evalSource<T extends EvalResult>(trigger: Node<unknown>, runner: () => T | Promise<T>): Node<T>;
-/** Per-task delta produced by {@link beforeAfterCompare}. */
-interface EvalTaskDelta {
-    taskId: string;
-    before: boolean;
-    after: boolean;
-    /** Score-level diff (after − before), undefined if no scores present. */
-    scoreDiff?: number;
-}
-/** Output of {@link beforeAfterCompare}. */
-interface EvalDelta {
-    /** Task IDs that newly fail in `after` (were passing in `before`). */
-    newFailures: string[];
-    /** Task IDs that now pass in `after` (were failing in `before`). */
-    resolved: string[];
-    /** Full per-task breakdown. */
-    taskDeltas: EvalTaskDelta[];
-    /** True when net resolutions > net failures. */
-    overallImproved: boolean;
-}
-/**
- * Derived node that computes before/after eval deltas.
- *
- * Pure computation: no LLM, no async. Compares per-task validity and
- * pass counts between two `EvalResult` snapshots.
- *
- * @param before - Node holding the baseline eval result.
- * @param after  - Node holding the new eval result.
- */
-declare function beforeAfterCompare(before: Node<EvalResult>, after: Node<EvalResult>): Node<EvalDelta>;
-/**
- * Derived node that selects which eval task IDs to re-run.
- *
- * Collects `affectsEvalTasks` from all triaged items, deduplicates, then
- * optionally intersects with `fullTaskSet`. Returns a sorted array of IDs.
- *
- * Use this to avoid re-running the full eval suite after each fix: only the
- * tasks that the triaged items claim to affect are returned.
- *
- * @param issues      - Node holding the current list of triaged items.
- * @param fullTaskSet - Optional node (or plain array) of all known task IDs.
- *                      When provided, output is the intersection.
- */
-declare function affectedTaskFilter(issues: Node<readonly TriagedItem[]>, fullTaskSet?: Node<readonly string[]> | readonly string[]): Node<string[]>;
-/** A single lint error emitted by a CI tool. */
-interface LintError {
-    file: string;
-    line: number;
-    col: number;
-    rule: string;
-    message: string;
-}
-/** A single test failure emitted by a test runner. */
-interface TestFailure {
-    testId: string;
-    file: string;
-    message: string;
-}
-/** Structured code-change / CI event. */
-interface CodeChange {
-    /** Files touched by the change. */
-    files: string[];
-    lintErrors?: LintError[];
-    testFailures?: TestFailure[];
-}
-/** Options for {@link codeChangeBridge}. */
-interface CodeChangeBridgeOptions {
-    /** Name for the effect node (default "code-change-bridge"). */
-    name?: string;
-    /** Default severity for generated IntakeItems (default "high"). */
-    defaultSeverity?: Severity;
-}
-/**
- * Intake bridge for code-change / CI events.
- *
- * Watches a source node for `CodeChange` events and publishes one
- * `IntakeItem` per lint error and per test failure to the intake topic.
- * Pass a custom `parser` to override the default mapping.
- *
- * @param source      - Node emitting CodeChange events.
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param parser      - Optional custom parser (overrides default).
- * @param opts        - Optional configuration.
- */
-declare function codeChangeBridge(source: Node<CodeChange>, intakeTopic: TopicGraph<IntakeItem>, parser?: (change: CodeChange) => IntakeItem[], opts?: CodeChangeBridgeOptions): Node<unknown>;
-/** Transport function for {@link notifyEffect}. Sync or async. */
-type NotifyTransport<T> = (item: T) => void | Promise<void>;
-/** Options for {@link notifyEffect}. */
-interface NotifyEffectOptions {
-    /** Name for the effect node (default "notify-effect"). */
-    name?: string;
-}
-/**
- * Effect node that sends each new topic entry to an external channel.
- *
- * The `transport` function is called for every item published to `topic`.
- * Async transports are bridged via `fromAny` (spec §5.10 compliant).
- *
- * Typical use: Slack webhook, GitHub PR comment, email notification, etc.
- * The factory provides reactive wiring; the transport supplies domain logic.
- *
- * ```ts
- * notifyEffect(alertQueue, async (item) => {
- *   await fetch(SLACK_WEBHOOK, { method: 'POST', body: JSON.stringify({ text: item.summary }) });
- * });
- * ```
- *
- * @param topic     - TopicGraph whose latest entry triggers the notification.
- * @param transport - Called with each new item. May return a Promise.
- * @param opts      - Optional configuration.
- */
-declare function notifyEffect<T>(topic: TopicGraph<T>, transport: NotifyTransport<T>, opts?: NotifyEffectOptions): Node<unknown>;
-
-/**
- * Strategy model and priority scoring (roadmap §9.0).
- *
- * Pure-computation derived nodes — no LLM, no async.
- *
- * @module
- */
-
-/** Snapshot shape for the strategy model node. */
-type StrategySnapshot = ReadonlyMap<StrategyKey, StrategyEntry>;
-/** Bundle returned by {@link strategyModel}. */
-interface StrategyModelBundle {
-    /** Reactive node — current strategy map. */
-    readonly node: Node<StrategySnapshot>;
-    /** Record a completed issue (success or failure). */
-    record(rootCause: RootCause, intervention: Intervention, success: boolean): void;
-    /** Look up effectiveness for a specific pair. */
-    lookup(rootCause: RootCause, intervention: Intervention): StrategyEntry | undefined;
-    /** Tear down internal keepalive subscriptions. */
-    dispose(): void;
-}
-/**
- * Create a strategy model that tracks `rootCause × intervention → successRate`
- * over completed issues. Pure derived computation — no LLM.
- *
- * The model feeds back into TRIAGE for routing hints.
- */
-declare function strategyModel(): StrategyModelBundle;
-/**
- * Create a priority scoring derived node for a single triaged item.
- *
- * Combines severity weight, attention decay, strategy model effectiveness,
- * and an optional external urgency signal.
- *
- * @param item - Node holding the triaged item.
- * @param strategy - Strategy model node.
- * @param lastInteractionNs - Node holding the monotonic timestamp (ns) of last human interaction.
- * @param urgency - Optional external urgency signal node (0–1 scale).
- * @param signals - Configurable scoring parameters.
- */
-declare function priorityScore(item: Node<TriagedItem>, strategy: Node<StrategySnapshot>, lastInteractionNs: Node<number>, urgency?: Node<number>, signals?: PrioritySignals): Node<number>;
-
-/**
- * harnessLoop() factory (roadmap §9.0).
- *
- * Wires the static 7-stage topology: INTAKE → TRIAGE → QUEUE → GATE →
- * EXECUTE → VERIFY → REFLECT. Static topology, flowing data — the Kafka
- * insight applied to human+LLM collaboration.
- *
- * @module
- */
-
-/** The graph returned by {@link harnessLoop}. */
-declare class HarnessGraph extends Graph {
-    /** Intake topic — publish items here to enter the loop. */
-    readonly intake: TopicGraph<IntakeItem>;
-    /** Per-route queue topics. */
-    readonly queues: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
-    /** Per-route gate controllers (only for gated queues). */
-    readonly gates: ReadonlyMap<QueueRoute, GateController<TriagedItem>>;
-    /** Strategy model bundle — record outcomes, lookup effectiveness. */
-    readonly strategy: StrategyModelBundle;
-    /** Verify results topic — subscribe to see verification outcomes. */
-    readonly verifyResults: TopicGraph<VerifyResult>;
-    /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
-    readonly totalRetries: Node<number>;
-    /** Global reingestion count across all items (circuit breaker). Reactive — subscribable. */
-    readonly totalReingestions: Node<number>;
-    constructor(name: string, intake: TopicGraph<IntakeItem>, queues: Map<QueueRoute, TopicGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, verifyResults: TopicGraph<VerifyResult>, totalRetries: Node<number>, totalReingestions: Node<number>);
-}
-/**
- * Wire the reactive collaboration loop as a static-topology graph.
- *
- * The loop has 7 stages:
- * 1. **INTAKE** — items arrive from multiple sources via `intake.publish()`
- * 2. **TRIAGE** — promptNode classifies, routes, and prioritizes
- * 3. **QUEUE** — 4 priority-ordered TopicGraphs (auto-fix, needs-decision, investigation, backlog)
- * 4. **GATE** — human approval on configurable queues
- * 5. **EXECUTE** — promptNode or human implements the fix
- * 6. **VERIFY** — promptNode reviews + optional fast-retry
- * 7. **REFLECT** — strategy model records outcomes
- *
- * @param name - Graph name.
- * @param opts - Configuration.
- * @returns HarnessGraph with controller accessors.
- */
-declare function harnessLoop(name: string, opts: HarnessLoopOptions): HarnessGraph;
-
-/**
- * Harness-specific graph profiling (roadmap §9.0).
- *
- * Extends {@link graphProfile} with harness domain counters:
- * queue depths, strategy entries, retry/reingestion tracker sizes.
- *
- * @module
- */
-
-/** Harness-specific profile extending the base graph profile. */
-interface HarnessProfileResult extends GraphProfileResult {
-    /** Per-queue retained item counts. */
-    queueDepths: Record<QueueRoute, number>;
-    /** Number of rootCause→intervention entries in the strategy model. */
-    strategyEntries: number;
-    /** Global retry count across all items. */
-    totalRetries: number;
-    /** Global reingestion count across all items. */
-    totalReingestions: number;
-}
-/**
- * Profile a harness graph with domain-specific counters.
- *
- * @param harness - The HarnessGraph to profile.
- * @param opts - Optional base profile options.
- * @returns Harness profile with queue depths, strategy stats, and tracker sizes.
- */
-declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOptions): HarnessProfileResult;
-
-/**
- * Harness pipeline trace (roadmap §9.0 — Inspection Tool Consolidation).
- *
- * Attaches reactive observers (via `observe()`) to all harness stages.
- * One call gives full pipeline visibility with stage labels and elapsed
- * timestamps relative to the `harnessTrace()` invocation time.
- *
- * Supports two output modes:
- * - **String logger** (default): rendered lines to `console.log` or a custom sink.
- * - **Structured events**: programmatic `TraceEvent[]` list for test assertions
- *   and tooling. Access via `handle.events`.
- *
- * Supports configurable detail levels (`"summary"`, `"standard"`, `"full"`)
- * to control output verbosity without composing different tool calls.
- *
- * @module
- */
-
-/** Event type captured by structured trace. */
-type TraceEventType = "data" | "error" | "complete";
-/** A single structured trace event. */
-interface TraceEvent {
-    /** Elapsed seconds since trace was created. */
-    elapsed: number;
-    /** Pipeline stage label (INTAKE, TRIAGE, QUEUE, GATE, EXECUTE, VERIFY, STRATEGY). */
-    stage: string;
-    /** Event type. */
-    type: TraceEventType;
-    /** Data payload (present for "data" and "error" events). Omitted at "summary" detail. */
-    data?: unknown;
-    /** Human-readable summary of the data. Present at "standard" and "full" detail. */
-    summary?: string;
-}
-/** Detail level for trace output. */
-type TraceDetail = 
-/** Stage + elapsed only. No data preview. Lowest overhead. */
-"summary"
-/** Stage + elapsed + truncated data preview. Default. */
- | "standard"
-/** Stage + elapsed + full raw data. Use for debugging, not production. */
- | "full";
-/** Handle returned by {@link harnessTrace}. Call `dispose()` to stop tracing. */
-interface HarnessTraceHandle {
-    /** Stop tracing and detach all observers. Safe to call multiple times. */
-    dispose(): void;
-    /**
-     * Structured trace events collected since creation. Plain array — no
-     * subscription needed (COMPOSITION-GUIDE §1: avoid lazy-activation
-     * friction for inspection tools). Populated reactively via observe().
-     */
-    readonly events: readonly TraceEvent[];
-}
-/** Options for {@link harnessTrace}. */
-interface HarnessTraceOptions {
-    /** Sink for rendered trace lines. Default: `console.log`. */
-    logger?: (line: string) => void;
-    /** Detail level for both string and structured output. Default: `"summary"`. */
-    detail?: TraceDetail;
-}
-/**
- * Attach reactive trace observers to all harness pipeline stages.
- *
- * Wires `graph.observe(path, { format: "json" })` to each stage node,
- * intercepting the logger callback to emit stage-labeled lines with
- * elapsed timestamps. Surfaces DATA, ERROR, and COMPLETE events.
- *
- * **Structured events:** Every trace event is also pushed to
- * `handle.events` — a plain array (not a reactive node) that tests and
- * tooling can inspect programmatically. To use structured events alone
- * without string output, pass `{ logger: null }`.
- *
- * **Detail levels:**
- * - `"summary"` — stage + elapsed only. Minimal overhead.
- * - `"standard"` (default) — stage + elapsed + truncated data preview.
- * - `"full"` — stage + elapsed + full raw data object in events.
- *
- * Elapsed timestamps are relative to the `harnessTrace()` invocation time,
- * not the first event.
- *
- * @param harness - The HarnessGraph to trace.
- * @param opts - Optional configuration.
- * @returns Handle with `dispose()` to stop tracing and `events` for structured access.
- */
-declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions): HarnessTraceHandle;
-
-/**
- * Harness wiring (roadmap §9.0).
- *
- * Reactive collaboration loop: static-topology, flowing data.
- * Composes orchestration (gate), AI (promptNode), reduction (scorer/stratify),
- * and messaging (TopicGraph/bridge) into a 7-stage loop.
- *
- * @module
- */
-
-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 };
-}
-
-/**
- * Reduction primitives (roadmap §8.1).
- *
- * Composable building blocks for taking heterogeneous massive inputs and producing
- * prioritized, auditable, human-actionable output. Each primitive is either a Graph
- * factory or a Node factory, built on top of core + extra primitives.
- *
- * @module
- */
-
-type StepRef = string | Node<unknown>;
-/** A single routing rule for {@link stratify}. */
-type StratifyRule<T> = {
-    /** Branch name (used as node name under `branch/<name>`). */
-    name: string;
-    /** Classifier: returns `true` if the value belongs to this branch. */
-    classify: (value: T) => boolean;
-    /** Optional operator chain applied to the branch after classification. */
-    ops?: (n: Node<T>) => Node;
-};
-/** Options for {@link stratify}. */
-type StratifyOptions = GraphOptions & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Route input to different reduction branches based on classifier functions.
- *
- * Each branch gets an independent operator chain. Rules are reactive — update
- * the `"rules"` state node to rewrite classification at runtime. Rule updates
- * affect **future items only** (streaming classification, not retroactive).
- *
- * Branch nodes are structural — created at construction time and persist for
- * the graph's lifetime. If a rule name is removed from the rules array, the
- * corresponding branch silently drops items (classifier not found). To tear
- * down a dead branch, call `graph.remove("branch/<name>")`.
- *
- * @param name - Graph name.
- * @param source - Input node (registered externally or will be added as `"source"`).
- * @param rules - Initial routing rules.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"source"`, `"rules"`, and `"branch/<name>"` nodes.
- *
- * @category patterns
- */
-declare function stratify<T>(name: string, source: Node<T>, rules: ReadonlyArray<StratifyRule<T>>, opts?: StratifyOptions): Graph;
-/** A named stage for {@link funnel}. */
-type FunnelStage = {
-    /** Stage name (mounted as subgraph). */
-    name: string;
-    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
-    build: (sub: Graph) => void;
-};
-/** Options for {@link funnel}. */
-type FunnelOptions = GraphOptions & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Multi-source merge with sequential reduction stages.
- *
- * Sources are merged into a single stream. Each stage is a named subgraph
- * (mounted via `graph.mount()`). Stages connect linearly:
- * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
- *
- * @param name - Graph name.
- * @param sources - Input nodes to merge.
- * @param stages - Sequential reduction stages.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"merged"` and mounted stage subgraphs.
- *
- * @category patterns
- */
-declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
-/** Options for {@link feedback}. */
-type FeedbackOptions = {
-    /** Maximum feedback iterations before stopping (default: 10). */
-    maxIterations?: number;
-    /** Optional budget gate node path for cost-bounded iteration. */
-    budgetNode?: StepRef;
-    meta?: Record<string, unknown>;
-};
-/**
- * Introduce a bounded reactive cycle into an existing graph.
- *
- * When `condition` emits a non-null DATA value, the feedback effect routes it
- * back to the `reentry` state node — creating a cycle. Bounded by
- * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
- * is the source of truth — reset it to 0 to allow more iterations.
- *
- * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
- *
- * @param graph - Existing graph to augment with a feedback cycle.
- * @param condition - Path to a node whose DATA triggers feedback.
- * @param reentry - Path to a state node that receives the feedback value.
- * @param opts - Iteration bounds and metadata.
- * @returns The same graph (mutated with feedback nodes added).
- *
- * @category patterns
- */
-declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
-/** A reactive constraint for {@link budgetGate}. */
-type BudgetConstraint<T = unknown> = {
-    /** Constraint node whose value is checked. */
-    node: Node<T>;
-    /** Returns `true` when the constraint is satisfied (budget available). */
-    check: (value: T) => boolean;
-};
-/** Options for {@link budgetGate}. */
-type BudgetGateOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Pass-through that respects reactive constraint nodes.
- *
- * DATA flows through when all constraints are satisfied. When any constraint
- * is exceeded, PAUSE is sent upstream and DATA is buffered. When constraints
- * relax, RESUME is sent and buffered DATA flushes.
- *
- * @param source - Input node.
- * @param constraints - Reactive constraint checks.
- * @param opts - Optional node options.
- * @returns Gated node.
- *
- * @category patterns
- */
-declare function budgetGate<T>(source: Node<T>, constraints: ReadonlyArray<BudgetConstraint>, opts?: BudgetGateOptions): Node<T>;
-/** A scored item with full breakdown. */
-type ScoredItem<T = unknown> = {
-    /** Original value. */
-    value: T;
-    /** Final weighted score. */
-    score: number;
-    /** Per-signal breakdown: signal index → weighted contribution. */
-    breakdown: number[];
-};
-/** Options for {@link scorer}. */
-type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    meta?: Record<string, unknown>;
-    /** Custom scoring function per signal. Default: identity (signal value IS the score). */
-    scoreFns?: ReadonlyArray<(value: unknown) => number>;
-};
-/**
- * Reactive multi-signal scoring with live weights.
- *
- * Each source emits items to score. Weights are reactive state nodes that
- * LLM or human can adjust live. Output is sorted scored items with full
- * breakdown.
- *
- * @param sources - Signal nodes (each emits a numeric score dimension).
- * @param weights - Reactive weight nodes (one per source).
- * @param opts - Optional node/meta options.
- * @returns Node emitting scored output.
- *
- * @category patterns
- */
-declare function scorer(sources: ReadonlyArray<Node<number>>, weights: ReadonlyArray<Node<number>>, opts?: ScorerOptions): Node<ScoredItem<number[]>>;
-/** A single effectiveness record for an action×context pair. */
-type EffectivenessEntry = {
-    readonly key: string;
-    readonly attempts: number;
-    readonly successes: number;
-    readonly successRate: number;
-};
-/** Snapshot shape for the effectiveness tracker node. */
-type EffectivenessSnapshot = ReadonlyMap<string, EffectivenessEntry>;
-/** Bundle returned by {@link effectivenessTracker}. */
-interface EffectivenessTrackerBundle {
-    /** Reactive node — current effectiveness map snapshot. */
-    readonly node: Node<EffectivenessSnapshot>;
-    /** Record a completed action (success or failure). */
-    record(key: string, success: boolean): void;
-    /** Look up effectiveness for a specific key. */
-    lookup(key: string): EffectivenessEntry | undefined;
-    /** Tear down internal keepalive subscriptions. */
-    dispose(): void;
-}
-/** Options for {@link effectivenessTracker}. */
-type EffectivenessTrackerOptions = {
-    /** Name for the reactive map (default "effectiveness-entries"). */
-    name?: string;
-};
-/**
- * Generic action×context → success rate tracker.
- *
- * Generalized from the harness `strategyModel` pattern. Tracks attempts and
- * successes per string key, exposes a reactive snapshot node, and provides
- * `record()` / `lookup()` methods.
- *
- * Use cases: A/B testing, routing optimization, cache policy tuning, retry
- * strategy selection — any domain that tracks effectiveness per action.
- *
- * @param opts - Optional configuration.
- * @returns Bundle with reactive node, record(), lookup(), dispose().
- */
-declare function effectivenessTracker(opts?: EffectivenessTrackerOptions): EffectivenessTrackerBundle;
-
-type reduction_BudgetConstraint<T = unknown> = BudgetConstraint<T>;
-type reduction_BudgetGateOptions = BudgetGateOptions;
-type reduction_EffectivenessEntry = EffectivenessEntry;
-type reduction_EffectivenessSnapshot = EffectivenessSnapshot;
-type reduction_EffectivenessTrackerBundle = EffectivenessTrackerBundle;
-type reduction_EffectivenessTrackerOptions = EffectivenessTrackerOptions;
-type reduction_FeedbackOptions = FeedbackOptions;
-type reduction_FunnelOptions = FunnelOptions;
-type reduction_FunnelStage = FunnelStage;
-type reduction_ScoredItem<T = unknown> = ScoredItem<T>;
-type reduction_ScorerOptions = ScorerOptions;
-type reduction_StepRef = StepRef;
-type reduction_StratifyOptions = StratifyOptions;
-type reduction_StratifyRule<T> = StratifyRule<T>;
-declare const reduction_budgetGate: typeof budgetGate;
-declare const reduction_effectivenessTracker: typeof effectivenessTracker;
-declare const reduction_feedback: typeof feedback;
-declare const reduction_funnel: typeof funnel;
-declare const reduction_scorer: typeof scorer;
-declare const reduction_stratify: typeof stratify;
-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_CatalogFnEntry: typeof CatalogFnEntry;
+declare const index_CatalogSourceEntry: typeof CatalogSourceEntry;
+declare const index_ConfigFieldSchema: typeof ConfigFieldSchema;
+declare const index_CreateGraphOptions: typeof CreateGraphOptions;
+declare const index_FnFactory: typeof FnFactory;
+declare const index_GraphSpec: typeof GraphSpec;
+declare const index_GraphSpecCatalog: typeof GraphSpecCatalog;
+declare const index_GraphSpecFeedbackEdge: typeof GraphSpecFeedbackEdge;
+declare const index_GraphSpecNode: typeof GraphSpecNode;
+declare const index_GraphSpecTemplate: typeof GraphSpecTemplate;
+declare const index_GraphSpecTemplateRef: typeof GraphSpecTemplateRef;
+declare const index_GraphSpecValidation: typeof GraphSpecValidation;
+declare const index_ReduceOptions: typeof ReduceOptions;
+declare const index_RestoreSnapshotOptions: typeof 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_SaveSnapshotResult: typeof SaveSnapshotResult;
+declare const index_SourceFactory: typeof SourceFactory;
 declare const index_SurfaceError: typeof SurfaceError;
-type index_SurfaceErrorCode = SurfaceErrorCode;
-type index_SurfaceErrorPayload = SurfaceErrorPayload;
-declare const index_ai: typeof ai;
+declare const index_SurfaceErrorCode: typeof SurfaceErrorCode;
+declare const index_SurfaceErrorPayload: typeof SurfaceErrorPayload;
 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 { 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 };
+  export { index_CatalogFnEntry as CatalogFnEntry, index_CatalogSourceEntry as CatalogSourceEntry, index_ConfigFieldSchema as ConfigFieldSchema, index_CreateGraphOptions as CreateGraphOptions, index_FnFactory as FnFactory, index_GraphSpec as GraphSpec, index_GraphSpecCatalog as GraphSpecCatalog, index_GraphSpecFeedbackEdge as GraphSpecFeedbackEdge, index_GraphSpecNode as GraphSpecNode, index_GraphSpecTemplate as GraphSpecTemplate, index_GraphSpecTemplateRef as GraphSpecTemplateRef, index_GraphSpecValidation as GraphSpecValidation, index_ReduceOptions as ReduceOptions, index_RestoreSnapshotOptions as RestoreSnapshotOptions, index_SNAPSHOT_WIRE_VERSION as SNAPSHOT_WIRE_VERSION, index_SaveSnapshotResult as SaveSnapshotResult, index_SourceFactory as SourceFactory, index_SurfaceError as SurfaceError, index_SurfaceErrorCode as SurfaceErrorCode, index_SurfaceErrorPayload as SurfaceErrorPayload, index$1 as accountability, index$2 as ai, index_asSurfaceError as asSurfaceError, index$3 as cqrs, index_createGraph as createGraph, index_deleteSnapshot as deleteSnapshot, index$4 as demoShell, index_diffSnapshots as diffSnapshots, index$5 as domainTemplates, index$6 as graphspec, index$7 as guarded, index$8 as harness, index$9 as jobQueue, index$a as layout, index$b as lens, index_listSnapshots as listSnapshots, index$c as memory, index$d as messaging, index$e as orchestration, index$f as reduction, index$g as refine, index$h as resilientPipeline, index_restoreSnapshot as restoreSnapshot, index_runReduction as runReduction, index_saveSnapshot as saveSnapshot, index$i as surface };
 }
 
 /**
@@ -2122,4 +92,4 @@ declare namespace index {
  */
 declare const version = "0.0.0";
 
-export { Actor, type CatalogFnEntry, type CatalogSourceEntry, CausalChain, CircuitBreakerOptions, CircuitState, type ConfigFieldSchema, type CreateGraphOptions, DescribeFilter, FallbackInput, type FnFactory, Graph, GraphDescribeOptions, GraphDescribeOutput, GraphDiffResult, GraphNodeFactory, GraphOptions, GraphProfileOptions, GraphProfileResult, type GraphSpec, type GraphSpecCatalog, type GraphSpecFeedbackEdge, type GraphSpecNode, type GraphSpecTemplate, type GraphSpecTemplateRef, type GraphSpecValidation, NS_PER_MS, NS_PER_SEC, Node, NodeOptions, PolicyRuleData, RateLimiterOptions, ReactiveMapBundle, type ReduceOptions, type RestoreSnapshotOptions, RetryOptions, SNAPSHOT_WIRE_VERSION, type SaveSnapshotResult, type SourceFactory, StatusValue, StorageTier, SurfaceError, type SurfaceErrorCode, type SurfaceErrorPayload, audit as accountability, ai, asSurfaceError, cqrs, createGraph, deleteSnapshot, demoShell, diffSnapshots, domainTemplates, graphspec, guardedExecution$1 as guarded, index$2 as harness, index$3 as layout, lens, listSnapshots, memory, messaging, orchestration, index as patterns, reduction, resilientPipeline$1 as resilientPipeline, restoreSnapshot, runReduction, saveSnapshot, index$1 as surface, version, watchTopologyTree };
+export { CatalogFnEntry, CatalogSourceEntry, ConfigFieldSchema, CreateGraphOptions, FnFactory, GraphSpec, GraphSpecCatalog, GraphSpecFeedbackEdge, GraphSpecNode, GraphSpecTemplate, GraphSpecTemplateRef, GraphSpecValidation, ReduceOptions, RestoreSnapshotOptions, SNAPSHOT_WIRE_VERSION, SaveSnapshotResult, SourceFactory, SurfaceError, SurfaceErrorCode, SurfaceErrorPayload, index$1 as accountability, index$2 as ai, asSurfaceError, index$3 as cqrs, createGraph, deleteSnapshot, index$4 as demoShell, diffSnapshots, index$5 as domainTemplates, index$6 as graphspec, index$7 as guarded, index$8 as harness, index$9 as jobQueue, index$a as layout, index$b as lens, listSnapshots, index$c as memory, index$d as messaging, index$e as orchestration, index as patterns, index$f as reduction, index$g as refine, index$h as resilientPipeline, restoreSnapshot, runReduction, saveSnapshot, index$i as surface, version };