@graphrefly/graphrefly 0.18.0 → 0.20.0

package/dist/index.d.cts

@@ -1,16 +1,16 @@
-import { N as Node, A as Actor, a as NodeOptions, b as NodeActions, c as NodeFn } from './meta-npl5b97j.cjs';
-export { C as CLEANUP_RESULT, d as COMPLETE, e as CleanupResult, D as DATA, f as DEFAULT_ACTOR, g as DIRTY, h as DescribeDetail, i as DescribeField, j as DescribeNodeOutput, E as ERROR, G as GuardAction, k as GuardDenied, l as GuardDeniedDetails, H as HashFn, I as INVALIDATE, M as Message, m as Messages, n as NodeDescribeKind, o as NodeGuard, p as NodeSink, q as NodeStatus, r as NodeTransportOptions, s as NodeVersionInfo, O as OnMessageHandler, P as PAUSE, t as PolicyAllow, u as PolicyDeny, v as PolicyRuleData, R as RESOLVED, w as RESUME, S as SubscribeHints, T as TEARDOWN, V as V0, x as V1, y as VersioningLevel, z as VersioningOptions, B as accessHintForGuard, F as advanceVersion, J as cleanupResult, K as createVersioning, L as defaultHash, Q as isKnownMessageType, U as isPhase2Message, W as isTerminalMessage, X as isV1, Y as knownMessageTypes, Z as messageTier, _ as node, $ as normalizeActor, a0 as policy, a1 as policyFromRules, a2 as propagatesToMeta, a3 as resolveDescribeFields } from './meta-npl5b97j.cjs';
-import { i as index$b, c as cqrs } from './index-B43mC7uY.cjs';
+import { N as Node, a as NodeOptions, b as NodeActions, A as Actor } from './meta-BnG7XAaE.cjs';
+export { C as CLEANUP_RESULT, c as COMPLETE, d as CleanupResult, D as DATA, e as DEFAULT_ACTOR, f as DIRTY, g as DescribeDetail, h as DescribeField, i as DescribeNodeOutput, E as ERROR, G as GuardAction, j as GuardDenied, k as GuardDeniedDetails, H as HashFn, I as INVALIDATE, M as Message, l as Messages, m as NodeDescribeKind, n as NodeGuard, o as NodeSink, p as NodeStatus, q as NodeTransportOptions, r as NodeVersionInfo, O as OnMessageHandler, P as PAUSE, s as PolicyAllow, t as PolicyDeny, u as PolicyRuleData, R as RESOLVED, v as RESUME, S as START, w as SubscribeHints, T as TEARDOWN, V as V0, x as V1, y as VersioningLevel, z as VersioningOptions, B as accessHintForGuard, F as advanceVersion, J as cleanupResult, K as createVersioning, L as defaultHash, Q as isKnownMessageType, U as isLocalOnly, W as isPhase2Message, X as isTerminalMessage, Y as isV1, Z as knownMessageTypes, _ as messageTier, $ as normalizeActor, a0 as policy, a1 as policyFromRules, a2 as propagatesToMeta, a3 as resolveDescribeFields } from './meta-BnG7XAaE.cjs';
+import { i as index$b, c as cqrs } from './index-BjtlNirP.cjs';
 import { Ref, WatchSource } from 'vue';
-import { G as Graph, a as GraphOptions, b as GraphAutoCheckpointHandle, A as AutoCheckpointAdapter, c as GraphAutoCheckpointOptions } from './graph-BYFlyNpX.cjs';
-export { D as DescribeFilter, d as GRAPH_META_SEGMENT, e as GraphActorOptions, f as GraphCheckpointRecord, g as GraphDescribeOptions, h as GraphDescribeOutput, i as GraphDiagramDirection, j as GraphDiagramOptions, k as GraphDiffChange, l as GraphDiffResult, m as GraphDumpOptions, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q as GraphObserveOne, r as GraphPersistSnapshot, O as ObserveDetail, s as ObserveEvent, t as ObserveOptions, u as ObserveResult, v as ObserveTheme, w as ObserveThemeName, R as ReachableDirection, x as ReachableOptions, T as TraceEntry, y as reachable } from './graph-BYFlyNpX.cjs';
-export { B as BridgeOptions, D as DEFAULT_DOWN, a as DownStrategy, b as DynGet, c as DynamicNodeFn, d as DynamicNodeImpl, e as DynamicNodeOptions, P as PipeOperator, R as ResettableTimer, f as batch, g as bridge, i as core, h as derived, j as downWithBatch, k as dynamicNode, l as effect, m as isBatching, n as monotonicNs, p as partitionForBatch, o as pipe, q as producer, s as state, w as wallClockNs } from './index-EmzYk-TG.cjs';
-import { N as NodeInput, D as DistillBundle, E as Extraction } from './index-D_tUMcpz.cjs';
-export { A as AdapterHandlers, a as AsyncSourceOpts, B as BackoffPreset, b as BackoffStrategy, c as BatchMessage, d as BridgeMessage, e as BufferedSinkHandle, C as CSVRow, f as CacheEvictionPolicy, g as CacheTier, h as CascadingCache, i as CascadingCacheOptions, j as CheckpointAdapter, k as CheckpointToRedisOptions, l as CheckpointToS3Options, m as CircuitBreaker, n as CircuitBreakerOptions, o as CircuitOpenError, p as CircuitState, q as ClickHouseClientLike, r as ClickHouseInsertClientLike, s as ClickHouseRow, t as CronSchedule, u as DictCheckpointAdapter, v as DistillOptions, w as DrizzleQueryLike, x as ErrorMessage, y as EventTargetLike, z as ExponentialBackoffOptions, F as FSEvent, G as FSEventType, H as FileCheckpointAdapter, I as FileWriterLike, J as FromCSVOptions, K as FromClickHouseWatchOptions, L as FromCronOptions, M as FromDrizzleOptions, O as FromFSWatchOptions, P as FromGitHookOptions, Q as FromHTTPOptions, R as FromKafkaOptions, S as FromKyselyOptions, T as FromMCPOptions, U as FromNATSOptions, V as FromNDJSONOptions, W as FromOTelOptions, X as FromPrismaOptions, Y as FromPrometheusOptions, Z as FromPulsarOptions, _ as FromRabbitMQOptions, $ as FromRedisStreamOptions, a0 as FromSqliteOptions, a1 as FromStatsDOptions, a2 as FromSyslogOptions, a3 as GitEvent, a4 as GitHookType, a5 as HTTPBundle, a6 as IndexRow, a7 as IndexedDbCheckpointSpec, a8 as InitMessage, a9 as JitterMode, aa as KafkaConsumerLike, ab as KafkaMessage, ac as KafkaProducerLike, ad as KyselyQueryLike, ae as LokiClientLike, af as LokiStream, ag as MCPClientLike, ah as MemoryCheckpointAdapter, ai as MergeMapOptions, aj as MongoCollectionLike, ak as NATSClientLike, al as NATSMessage, am as NATSSubscriptionLike, an as NS_PER_MS, ao as NS_PER_SEC, ap as OTelBundle, aq as OTelLog, ar as OTelMetric, as as OTelRegister, at as OTelSpan, au as PostgresClientLike, av as PrismaModelLike, aw as PrometheusMetric, ax as PubSubHub, ay as PulsarConsumerLike, az as PulsarMessage, aA as PulsarProducerLike, aB as RabbitMQChannelLike, aC as RabbitMQMessage, aD as ReactiveIndexBundle, aE as ReactiveIndexOptions, aF as ReactiveListBundle, aG as ReactiveListOptions, aH as ReactiveLogBundle, aI as ReactiveLogOptions, aJ as ReactiveMapBundle, aK as ReactiveMapOptions, aL as ReadyMessage, aM as RedisCheckpointClientLike, aN as RedisClientLike, aO as RedisStreamEntry, aP as RetryOptions, aQ as S3ClientLike, aR as SignalMessage, aS as SinkHandle, aT as SinkTransportError, aU as SqliteCheckpointAdapter, aV as SqliteDbLike, aW as StatsDMetric, aX as StatsDRegister, aY as StatusValue, aZ as SyslogMessage, a_ as SyslogRegister, a$ as TapObserver, b0 as TempoClientLike, b1 as ThrottleOptions, b2 as TieredStorage, b3 as TieredStorageOptions, b4 as TimeoutError, b5 as ToCSVOptions, b6 as ToClickHouseOptions, b7 as ToFileOptions, b8 as ToKafkaOptions, b9 as ToLokiOptions, ba as ToMongoOptions, bb as ToNATSOptions, bc as ToPostgresOptions, bd as ToPulsarOptions, be as ToRabbitMQOptions, bf as ToRedisStreamOptions, bg as ToS3Options, bh as ToSSEOptions, bi as ToSqliteOptions, bj as ToTempoOptions, bk as ToWebSocketOptions, bl as ToWebSocketTransportError, bm as TokenBucket, bn as ValueMessage, bo as VerifiableBundle, bp as VerifiableOptions, bq as VerifyValue, br as WatermarkController, bs as WatermarkOptions, bt as WebSocketLike, bu as WebSocketMessageEventLike, bv as WebSocketRegister, bw as WebhookRegister, bx as WithBreakerBundle, by as WithStatusBundle, bz as WorkerBridge, bA as WorkerBridgeOptions, bB as WorkerSelfHandle, bC as WorkerSelfOptions, bD as WorkerTransport, bE as audit, bF as buffer, bG as bufferCount, bH as bufferTime, bI as cache, bJ as cached, bK as cascadingCache, bL as catchError, bM as checkpointNodeValue, bN as checkpointToRedis, bO as checkpointToS3, bP as circuitBreaker, bQ as combine, bR as combineLatest, bS as concat, bT as concatMap, bU as constant, bV as createTransport, bW as createWatermarkController, bX as debounce, bY as debounceTime, bZ as decorrelatedJitter, b_ as delay, b$ as deserializeError, c0 as distill, c1 as distinctUntilChanged, c2 as elementAt, c3 as empty, c4 as escapeRegexChar, c5 as exhaustMap, c6 as exponential, c7 as extra, c8 as fallback, c9 as fibonacci, ca as filter, cb as find, cc as first, cd as firstValueFrom, ce as flatMap, cf as forEach, cg as fromAny, ch as fromAsyncIter, ci as fromCSV, cj as fromClickHouseWatch, ck as fromCron, cl as fromDrizzle, cm as fromEvent, cn as fromFSWatch, co as fromGitHook, cp as fromHTTP, cq as fromIDBRequest, cr as fromIDBTransaction, cs as fromIter, ct as fromKafka, cu as fromKysely, cv as fromMCP, cw as fromNATS, cx as fromNDJSON, cy as fromOTel, cz as fromPrisma, cA as fromPrometheus, cB as fromPromise, cC as fromPulsar, cD as fromRabbitMQ, cE as fromRedisStream, cF as fromSqlite, cG as fromStatsD, cH as fromSyslog, cI as fromTimer, cJ as fromWebSocket, cK as fromWebhook, cL as globToRegExp, cM as interval, cN as last, cO as linear, cP as logSlice, cQ as lru, cR as map, cS as matchesAnyPattern, cT as matchesCron, cU as merge, cV as mergeMap, cW as nameToSignal, cX as never, cY as of, cZ as pairwise, c_ as parseCron, c$ as parsePrometheusText, d0 as parseStatsD, d1 as parseSyslog, d2 as pausable, d3 as pubsub, d4 as race, d5 as rateLimiter, d6 as reactiveIndex, d7 as reactiveList, d8 as reactiveLog, d9 as reactiveMap, da as reduce, db as repeat, dc as replay, dd as rescue, de as resolveBackoffPreset, df as restoreGraphCheckpoint, dg as restoreGraphCheckpointIndexedDb, dh as retry, di as sample, dj as saveGraphCheckpoint, dk as saveGraphCheckpointIndexedDb, dl as scan, dm as serializeError, dn as share, dp as shareReplay, dq as signalToName, dr as skip, ds as startWith, dt as switchMap, du as take, dv as takeUntil, dw as takeWhile, dx as tap, dy as throttle, dz as throttleTime, dA as throwError, dB as tieredStorage, dC as timeout, dD as toArray, dE as toCSV, dF as toClickHouse, dG as toFile, dH as toKafka, dI as toLoki, dJ as toMongo, dK as toNATS, dL as toPostgres, dM as toPulsar, dN as toRabbitMQ, dO as toRedisStream, dP as toS3, dQ as toSSE, dR as toSqlite, dS as toTempo, dT as toWebSocket, dU as tokenBucket, dV as tokenTracker, dW as valve, dX as verifiable, dY as window, dZ as windowCount, d_ as windowTime, d$ as withBreaker, e0 as withLatestFrom, e1 as withMaxAttempts, e2 as withStatus, e3 as workerBridge, e4 as workerSelf, e5 as zip } from './index-D_tUMcpz.cjs';
-import { G as GraphProfileResult, a as GraphProfileOptions } from './index-Ci_vPaVm.cjs';
-export { D as DeltaCheckpoint, E as EvictedSubgraphInfo, b as EvictionPolicy, c as GraphCodec, J as JsonCodec, L as LazyGraphCodec, N as NodeProfile, W as WALEntry, d as createDagCborCodec, e as createDagCborZstdCodec, i as graph, g as graphProfile, n as negotiateCodec, r as replayWAL, s as sizeof } from './index-Ci_vPaVm.cjs';
-import { M as MeasurementAdapter, i as index$c } from './index-BqOWSFhr.cjs';
-export { T as ToObservableOptions, t as toObservable } from './observable-DFBCBELR.cjs';
+import { G as Graph, a as GraphOptions, b as GraphAutoCheckpointHandle, A as AutoCheckpointAdapter, c as GraphAutoCheckpointOptions, d as GraphProfileResult, e as GraphProfileOptions } from './graph-KsTe57nI.cjs';
+export { D as DescribeFilter, f as GRAPH_META_SEGMENT, g as GraphActorOptions, h as GraphCheckpointRecord, i as GraphDescribeOptions, j as GraphDescribeOutput, k as GraphDiagramDirection, l as GraphDiagramOptions, m as GraphDiffChange, n as GraphDiffResult, o as GraphDumpOptions, p as GraphFactoryContext, q as GraphNodeFactory, r as GraphObserveAll, s as GraphObserveOne, t as GraphPersistSnapshot, N as NodeProfile, O as ObserveDetail, u as ObserveEvent, v as ObserveOptions, w as ObserveResult, x as ObserveTheme, y as ObserveThemeName, R as ReachableDirection, z as ReachableOptions, T as TraceEntry, B as graphProfile, C as reachable } from './graph-KsTe57nI.cjs';
+import { N as NodeFn } from './index-Bc_diYYJ.cjs';
+export { B as BridgeOptions, D as DEFAULT_DOWN, a as DownStrategy, b as DynGet, c as DynamicNodeFn, d as DynamicNodeImpl, e as DynamicNodeOptions, P as PipeOperator, R as ResettableTimer, f as batch, g as bridge, i as core, h as derived, j as downWithBatch, k as dynamicNode, l as effect, m as isBatching, n as monotonicNs, o as node, p as partitionForBatch, q as pipe, r as producer, s as state, w as wallClockNs } from './index-Bc_diYYJ.cjs';
+import { N as NodeInput, D as DistillBundle, E as Extraction } from './index-SFzE_KTa.cjs';
+export { A as AdapterHandlers, a as AsyncSourceOpts, B as BackoffPreset, b as BackoffStrategy, c as BatchMessage, d as BridgeMessage, e as BufferedSinkHandle, C as CSVRow, f as CacheEvictionPolicy, g as CacheTier, h as CascadingCache, i as CascadingCacheOptions, j as CheckpointAdapter, k as CheckpointToRedisOptions, l as CheckpointToS3Options, m as CircuitBreaker, n as CircuitBreakerOptions, o as CircuitOpenError, p as CircuitState, q as ClickHouseClientLike, r as ClickHouseInsertClientLike, s as ClickHouseRow, t as CronSchedule, u as DictCheckpointAdapter, v as DistillOptions, w as DrizzleQueryLike, x as ErrorMessage, y as EventTargetLike, z as ExponentialBackoffOptions, F as FSEvent, G as FSEventType, H as FileCheckpointAdapter, I as FileWriterLike, J as FromCSVOptions, K as FromClickHouseWatchOptions, L as FromCronOptions, M as FromDrizzleOptions, O as FromFSWatchOptions, P as FromGitHookOptions, Q as FromHTTPOptions, R as FromKafkaOptions, S as FromKyselyOptions, T as FromMCPOptions, U as FromNATSOptions, V as FromNDJSONOptions, W as FromOTelOptions, X as FromPrismaOptions, Y as FromPrometheusOptions, Z as FromPulsarOptions, _ as FromRabbitMQOptions, $ as FromRedisStreamOptions, a0 as FromSqliteOptions, a1 as FromStatsDOptions, a2 as FromSyslogOptions, a3 as GitEvent, a4 as GitHookType, a5 as HTTPBundle, a6 as IndexRow, a7 as IndexedDbCheckpointSpec, a8 as InitMessage, a9 as JitterMode, aa as KafkaConsumerLike, ab as KafkaMessage, ac as KafkaProducerLike, ad as KyselyQueryLike, ae as LokiClientLike, af as LokiStream, ag as MCPClientLike, ah as MemoryCheckpointAdapter, ai as MergeMapOptions, aj as MongoCollectionLike, ak as NATSClientLike, al as NATSMessage, am as NATSSubscriptionLike, an as NS_PER_MS, ao as NS_PER_SEC, ap as OTelBundle, aq as OTelLog, ar as OTelMetric, as as OTelRegister, at as OTelSpan, au as PostgresClientLike, av as PrismaModelLike, aw as PrometheusMetric, ax as PubSubHub, ay as PulsarConsumerLike, az as PulsarMessage, aA as PulsarProducerLike, aB as RabbitMQChannelLike, aC as RabbitMQMessage, aD as ReactiveCounterBundle, aE as ReactiveIndexBundle, aF as ReactiveIndexOptions, aG as ReactiveListBundle, aH as ReactiveListOptions, aI as ReactiveLogBundle, aJ as ReactiveLogOptions, aK as ReactiveMapBundle, aL as ReactiveMapOptions, aM as ReadyMessage, aN as RedisCheckpointClientLike, aO as RedisClientLike, aP as RedisStreamEntry, aQ as RetryOptions, aR as S3ClientLike, aS as SignalMessage, aT as SinkHandle, aU as SinkTransportError, aV as SqliteCheckpointAdapter, aW as SqliteDbLike, aX as StatsDMetric, aY as StatsDRegister, aZ as StatusValue, a_ as SyslogMessage, a$ as SyslogRegister, b0 as TapObserver, b1 as TempoClientLike, b2 as ThrottleOptions, b3 as TieredStorage, b4 as TieredStorageOptions, b5 as TimeoutError, b6 as ToCSVOptions, b7 as ToClickHouseOptions, b8 as ToFileOptions, b9 as ToKafkaOptions, ba as ToLokiOptions, bb as ToMongoOptions, bc as ToNATSOptions, bd as ToPostgresOptions, be as ToPulsarOptions, bf as ToRabbitMQOptions, bg as ToRedisStreamOptions, bh as ToS3Options, bi as ToSSEOptions, bj as ToSqliteOptions, bk as ToTempoOptions, bl as ToWebSocketOptions, bm as ToWebSocketTransportError, bn as TokenBucket, bo as ValueMessage, bp as VerifiableBundle, bq as VerifiableOptions, br as VerifyValue, bs as WatermarkController, bt as WatermarkOptions, bu as WebSocketLike, bv as WebSocketMessageEventLike, bw as WebSocketRegister, bx as WebhookRegister, by as WithBreakerBundle, bz as WithStatusBundle, bA as WorkerBridge, bB as WorkerBridgeOptions, bC as WorkerSelfHandle, bD as WorkerSelfOptions, bE as WorkerTransport, bF as audit, bG as buffer, bH as bufferCount, bI as bufferTime, bJ as cache, bK as cached, bL as cascadingCache, bM as catchError, bN as checkpointNodeValue, bO as checkpointToRedis, bP as checkpointToS3, bQ as circuitBreaker, bR as combine, bS as combineLatest, bT as concat, bU as concatMap, bV as constant, bW as createTransport, bX as createWatermarkController, bY as debounce, bZ as debounceTime, b_ as decorrelatedJitter, b$ as delay, c0 as deserializeError, c1 as distill, c2 as distinctUntilChanged, c3 as elementAt, c4 as empty, c5 as escapeRegexChar, c6 as exhaustMap, c7 as exponential, c8 as extra, c9 as fallback, ca as fibonacci, cb as filter, cc as find, cd as first, ce as firstValueFrom, cf as firstWhere, cg as flatMap, ch as forEach, ci as fromAny, cj as fromAsyncIter, ck as fromCSV, cl as fromClickHouseWatch, cm as fromCron, cn as fromDrizzle, co as fromEvent, cp as fromFSWatch, cq as fromGitHook, cr as fromHTTP, cs as fromIDBRequest, ct as fromIDBTransaction, cu as fromIter, 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 fromPromise, cE as fromPulsar, cF as fromRabbitMQ, cG as fromRedisStream, cH as fromSqlite, cI as fromStatsD, cJ as fromSyslog, cK as fromTimer, cL as fromWebSocket, cM as fromWebhook, cN as globToRegExp, cO as interval, cP as keepalive, cQ as last, cR as linear, cS as logSlice, cT as lru, cU as map, cV as matchesAnyPattern, cW as matchesCron, cX as merge, cY as mergeMap, cZ as nameToSignal, c_ as never, c$ as of, d0 as pairwise, d1 as parseCron, d2 as parsePrometheusText, d3 as parseStatsD, d4 as parseSyslog, d5 as pausable, d6 as pubsub, d7 as race, d8 as rateLimiter, d9 as reactiveCounter, da as reactiveIndex, db as reactiveList, dc as reactiveLog, dd as reactiveMap, de as reduce, df as repeat, dg as replay, dh as rescue, di as resolveBackoffPreset, dj as restoreGraphCheckpoint, dk as restoreGraphCheckpointIndexedDb, dl as retry, dm as sample, dn as saveGraphCheckpoint, dp as saveGraphCheckpointIndexedDb, dq as scan, dr as serializeError, ds as share, dt as shareReplay, du as signalToName, dv as skip, dw as switchMap, dx as take, dy as takeUntil, dz as takeWhile, dA as tap, dB as throttle, dC as throttleTime, dD as throwError, dE as tieredStorage, dF as timeout, dG as toArray, dH as toCSV, dI as toClickHouse, dJ as toFile, dK as toKafka, dL as toLoki, dM as toMongo, dN as toNATS, dO as toPostgres, dP as toPulsar, dQ as toRabbitMQ, dR as toRedisStream, dS as toS3, dT as toSSE, dU as toSqlite, dV as toTempo, dW as toWebSocket, dX as tokenBucket, dY as tokenTracker, dZ as valve, d_ as verifiable, d$ as window, e0 as windowCount, e1 as windowTime, e2 as withBreaker, e3 as withLatestFrom, e4 as withMaxAttempts, e5 as withStatus, e6 as workerBridge, e7 as workerSelf, e8 as zip } from './index-SFzE_KTa.cjs';
+export { D as DeltaCheckpoint, E as EvictedSubgraphInfo, a as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, W as WALEntry, c as createDagCborCodec, b as createDagCborZstdCodec, i as graph, n as negotiateCodec, r as replayWAL, s as sizeof } from './index-UudxGnzc.cjs';
+import { M as MeasurementAdapter, i as index$c } from './index-VHA43cGP.cjs';
+export { T as ToObservableOptions, t as toObservable } from './observable-C8Kx_O6k.cjs';
 import '@nestjs/common';
 import '@nestjs/core';
 import 'rxjs';
@@ -245,7 +245,7 @@ type NodeFactory$3<K, R extends Record<string, any>> = (key: K) => {
 /**
  * Subscribe to a dynamic set of keyed node records.
  * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
  * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
  *
  * @param keysNode - Node of current keys (e.g. node IDs)
@@ -374,7 +374,7 @@ type NodeFactory$2<K, R extends Record<string, any>> = (key: K) => {
 /**
  * Subscribe to a dynamic set of keyed node records as a Solid accessor.
  * Re-subscribes all per-key fields whenever `keys` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
  */
 declare function useSubscribeRecord$2<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$2<K, R>): Accessor<Record<K, R>>;
 
@@ -411,7 +411,7 @@ type NodeFactory$1<K, R extends Record<string, any>> = (key: K) => {
 /**
  * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
  * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 2`) to avoid DIRTY-phase churn.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
  */
 declare function useSubscribeRecord$1<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$1<K, R>): SvelteReadable<Record<K, R>>;
 
@@ -634,6 +634,303 @@ declare namespace memory {
   export { type memory_CollectionEntry as CollectionEntry, type memory_CollectionGraph as CollectionGraph, type memory_CollectionOptions as CollectionOptions, type memory_CollectionPolicy as CollectionPolicy, type memory_HnswAdapter as HnswAdapter, type memory_KnowledgeEdge as KnowledgeEdge, type memory_KnowledgeGraphGraph as KnowledgeGraphGraph, type memory_LightCollectionBundle as LightCollectionBundle, type memory_LightCollectionEntry as LightCollectionEntry, type memory_LightCollectionOptions as LightCollectionOptions, type memory_RankedCollectionEntry as RankedCollectionEntry, type memory_VectorBackend as VectorBackend, type memory_VectorIndexBundle as VectorIndexBundle, type memory_VectorIndexOptions as VectorIndexOptions, type memory_VectorRecord as VectorRecord, type memory_VectorSearchResult as VectorSearchResult, memory_collection as collection, memory_decay as decay, memory_knowledgeGraph as knowledgeGraph, memory_lightCollection as lightCollection, memory_vectorIndex as vectorIndex };
 }
 
+/**
+ * Messaging patterns (roadmap §4.2).
+ *
+ * Pulsar-inspired messaging features modeled as graph factories:
+ * - `topic()` for append-only topic streams
+ * - `subscription()` for cursor-based consumers
+ * - `jobQueue()` for queue claim/ack flow
+ */
+
+type TopicOptions = {
+    graph?: GraphOptions;
+    retainedLimit?: number;
+};
+declare class TopicGraph<T> extends Graph {
+    private readonly _log;
+    readonly events: Node<readonly T[]>;
+    readonly latest: Node<T | undefined>;
+    constructor(name: string, opts?: TopicOptions);
+    publish(value: T): void;
+    retained(): readonly T[];
+}
+type SubscriptionOptions = {
+    graph?: GraphOptions;
+    cursor?: number;
+};
+declare class SubscriptionGraph<T> extends Graph {
+    readonly source: Node<readonly T[]>;
+    readonly cursor: Node<number>;
+    readonly available: Node<readonly T[]>;
+    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
+    ack(count?: number): number;
+    pull(limit?: number, opts?: {
+        ack?: boolean;
+    }): readonly T[];
+}
+type JobState = "queued" | "inflight";
+type JobEnvelope<T> = {
+    id: string;
+    payload: T;
+    attempts: number;
+    metadata: Readonly<Record<string, unknown>>;
+    state: JobState;
+};
+type JobQueueOptions = {
+    graph?: GraphOptions;
+};
+declare class JobQueueGraph<T> extends Graph {
+    private readonly _pending;
+    private readonly _jobs;
+    private _seq;
+    readonly pending: Node<readonly string[]>;
+    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
+    readonly depth: Node<number>;
+    constructor(name: string, opts?: JobQueueOptions);
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    claim(limit?: number): readonly JobEnvelope<T>[];
+    ack(id: string): boolean;
+    nack(id: string, opts?: {
+        requeue?: boolean;
+    }): boolean;
+}
+type JobFlowOptions = {
+    graph?: GraphOptions;
+    stages?: readonly string[];
+    maxPerPump?: number;
+};
+declare class JobFlowGraph<T> extends Graph {
+    private readonly _stageNames;
+    private readonly _queues;
+    private readonly _completed;
+    readonly completed: Node<readonly JobEnvelope<T>[]>;
+    readonly completedCount: Node<number>;
+    constructor(name: string, opts?: JobFlowOptions);
+    stages(): readonly string[];
+    queue(stage: string): JobQueueGraph<T>;
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    retainedCompleted(): readonly JobEnvelope<T>[];
+}
+type TopicBridgeOptions<TIn, TOut> = {
+    graph?: GraphOptions;
+    cursor?: number;
+    maxPerPump?: number;
+    map?: (value: TIn) => TOut | undefined;
+};
+declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
+    private readonly _sourceSub;
+    private readonly _target;
+    readonly bridgedCount: Node<number>;
+    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
+}
+/**
+ * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
+ */
+declare function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>;
+/**
+ * Creates a cursor-based subscription graph over a topic.
+ */
+declare function subscription<T>(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions): SubscriptionGraph<T>;
+/**
+ * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
+ */
+declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
+/**
+ * Creates an autonomous multi-stage queue chain graph.
+ */
+declare function jobFlow<T>(name: string, opts?: JobFlowOptions): JobFlowGraph<T>;
+/**
+ * Creates an autonomous cursor-based topic relay graph.
+ */
+declare function topicBridge<TIn, TOut = TIn>(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>): TopicBridgeGraph<TIn, TOut>;
+
+type messaging_JobEnvelope<T> = JobEnvelope<T>;
+type messaging_JobFlowGraph<T> = JobFlowGraph<T>;
+declare const messaging_JobFlowGraph: typeof JobFlowGraph;
+type messaging_JobFlowOptions = JobFlowOptions;
+type messaging_JobQueueGraph<T> = JobQueueGraph<T>;
+declare const messaging_JobQueueGraph: typeof JobQueueGraph;
+type messaging_JobQueueOptions = JobQueueOptions;
+type messaging_JobState = JobState;
+type messaging_SubscriptionGraph<T> = SubscriptionGraph<T>;
+declare const messaging_SubscriptionGraph: typeof SubscriptionGraph;
+type messaging_SubscriptionOptions = SubscriptionOptions;
+type messaging_TopicBridgeGraph<TIn, TOut = TIn> = TopicBridgeGraph<TIn, TOut>;
+declare const messaging_TopicBridgeGraph: typeof TopicBridgeGraph;
+type messaging_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
+type messaging_TopicGraph<T> = TopicGraph<T>;
+declare const messaging_TopicGraph: typeof TopicGraph;
+type messaging_TopicOptions = TopicOptions;
+declare const messaging_jobFlow: typeof jobFlow;
+declare const messaging_jobQueue: typeof jobQueue;
+declare const messaging_subscription: typeof subscription;
+declare const messaging_topic: typeof topic;
+declare const messaging_topicBridge: typeof topicBridge;
+declare namespace messaging {
+  export { type messaging_JobEnvelope as JobEnvelope, messaging_JobFlowGraph as JobFlowGraph, type messaging_JobFlowOptions as JobFlowOptions, messaging_JobQueueGraph as JobQueueGraph, type messaging_JobQueueOptions as JobQueueOptions, type messaging_JobState as JobState, messaging_SubscriptionGraph as SubscriptionGraph, type messaging_SubscriptionOptions as SubscriptionOptions, messaging_TopicBridgeGraph as TopicBridgeGraph, type messaging_TopicBridgeOptions as TopicBridgeOptions, messaging_TopicGraph as TopicGraph, type messaging_TopicOptions as TopicOptions, messaging_jobFlow as jobFlow, messaging_jobQueue as jobQueue, messaging_subscription as subscription, messaging_topic as topic, messaging_topicBridge as topicBridge };
+}
+
+/**
+ * Orchestration patterns (roadmap §4.1).
+ *
+ * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
+ * Exported under the `patterns.orchestration` namespace to avoid collisions with
+ * Phase 2 operator names (for example `gate`, `forEach`).
+ */
+
+type StepRef$1 = string | Node<unknown>;
+type OrchestrationMeta = {
+    orchestration?: true;
+    orchestration_type?: string;
+};
+type OrchestrationStepOptions = Omit<NodeOptions, "describeKind" | "name" | "meta"> & {
+    deps?: ReadonlyArray<StepRef$1>;
+    meta?: Record<string, unknown> & OrchestrationMeta;
+};
+type BranchResult<T> = {
+    branch: "then" | "else";
+    value: T;
+};
+type SensorControls<T> = {
+    node: Node<T>;
+    push(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    iterations?: number | StepRef$1;
+};
+type WaitOptions = Omit<OrchestrationStepOptions, "deps">;
+type SubPipelineBuilder = (sub: Graph) => void;
+/**
+ * Creates an orchestration graph container.
+ */
+declare function pipeline(name: string, opts?: GraphOptions): Graph;
+/**
+ * Registers a workflow task node.
+ */
+declare function task<T>(graph: Graph, name: string, run: NodeFn<T>, opts?: OrchestrationStepOptions): Node<T>;
+/**
+ * Emits tagged branch outcomes (`then` / `else`) for each source value.
+ */
+declare function branch<T>(graph: Graph, name: string, source: StepRef$1, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
+/**
+ * Forwards source values only while `control` is truthy.
+ */
+declare function valve<T>(graph: Graph, name: string, source: StepRef$1, control: StepRef$1, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    isApproved?: (value: unknown) => boolean;
+};
+/**
+ * Human/LLM approval gate over a source value.
+ */
+declare function approval<T>(graph: Graph, name: string, source: StepRef$1, approver: StepRef$1, opts?: ApprovalOptions): Node<T>;
+interface GateOptions {
+    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
+    maxPending?: number;
+    /** Start in open mode (auto-approve). Default: false. */
+    startOpen?: boolean;
+    meta?: Record<string, unknown>;
+}
+/** Control surface returned by {@link gate}. */
+interface GateController<T> {
+    /** The output node registered in the graph (subscribe to receive approved values). */
+    node: Node<T>;
+    /** Reactive queue of values waiting for approval. */
+    pending: Node<T[]>;
+    /** Derived count of pending items. */
+    count: Node<number>;
+    /** Whether the gate is currently open (auto-approving). */
+    isOpen: Node<boolean>;
+    /** Approve and forward the next `count` pending values (default: 1). */
+    approve(count?: number): void;
+    /** Reject (discard) the next `count` pending values (default: 1). */
+    reject(count?: number): void;
+    /**
+     * Transform and forward `count` pending values (default: 1).
+     * `fn` receives `(value, index, pending)` — Array.map-style.
+     */
+    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
+    /** Flush all pending values and auto-approve future values. */
+    open(): void;
+    /** Re-enable manual gating (stop auto-approving). */
+    close(): void;
+}
+/**
+ * Human-in-the-loop gate: queues incoming values from `source` and lets an external
+ * controller {@link GateController.approve approve}, {@link GateController.reject reject},
+ * or {@link GateController.modify modify} them before forwarding downstream.
+ *
+ * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
+ * the graph. The gate output node is also registered.
+ */
+declare function gate<T>(graph: Graph, name: string, source: StepRef$1, opts?: GateOptions): GateController<T>;
+/**
+ * Registers a workflow side-effect step. The step remains graph-observable and forwards messages.
+ */
+declare function forEach<T>(graph: Graph, name: string, source: StepRef$1, run: (value: T, actions: NodeActions) => void, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a join step that emits a tuple of latest dependency values.
+ */
+declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
+    [K in keyof T]: StepRef$1;
+}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a loop step that applies `iterate` to each source value N times.
+ */
+declare function loop<T>(graph: Graph, name: string, source: StepRef$1, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
+/**
+ * Mounts and returns a child workflow graph.
+ */
+declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
+/**
+ * Registers a producer-style sensor source and returns imperative controls.
+ */
+declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions, "name" | "describeKind" | "meta"> & {
+    meta?: Record<string, unknown>;
+}): SensorControls<T>;
+/**
+ * Registers a delayed-forwarding step (value-level wait).
+ */
+declare function wait<T>(graph: Graph, name: string, source: StepRef$1, ms: number, opts?: WaitOptions): Node<T>;
+/**
+ * Registers an error-recovery step for a source.
+ */
+declare function onFailure<T>(graph: Graph, name: string, source: StepRef$1, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+
+type orchestration_ApprovalOptions = ApprovalOptions;
+type orchestration_BranchResult<T> = BranchResult<T>;
+type orchestration_GateController<T> = GateController<T>;
+type orchestration_GateOptions = GateOptions;
+type orchestration_LoopOptions = LoopOptions;
+type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
+type orchestration_SensorControls<T> = SensorControls<T>;
+type orchestration_SubPipelineBuilder = SubPipelineBuilder;
+type orchestration_WaitOptions = WaitOptions;
+declare const orchestration_approval: typeof approval;
+declare const orchestration_branch: typeof branch;
+declare const orchestration_forEach: typeof forEach;
+declare const orchestration_gate: typeof gate;
+declare const orchestration_join: typeof join;
+declare const orchestration_loop: typeof loop;
+declare const orchestration_onFailure: typeof onFailure;
+declare const orchestration_pipeline: typeof pipeline;
+declare const orchestration_sensor: typeof sensor;
+declare const orchestration_subPipeline: typeof subPipeline;
+declare const orchestration_task: typeof task;
+declare const orchestration_valve: typeof valve;
+declare const orchestration_wait: typeof wait;
+declare namespace orchestration {
+  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_GateController as GateController, type orchestration_GateOptions as GateOptions, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type StepRef$1 as StepRef, type orchestration_SubPipelineBuilder as SubPipelineBuilder, type orchestration_WaitOptions as WaitOptions, orchestration_approval as approval, orchestration_branch as branch, orchestration_forEach as forEach, orchestration_gate as gate, orchestration_join as join, orchestration_loop as loop, orchestration_onFailure as onFailure, orchestration_pipeline as pipeline, orchestration_sensor as sensor, orchestration_subPipeline as subPipeline, orchestration_task as task, orchestration_valve as valve, orchestration_wait as wait };
+}
+
 /**
  * AI surface patterns (roadmap §4.4).
  *
@@ -696,6 +993,20 @@ type ToolDefinition = {
     };
 };
 type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
+/**
+ * A single chunk from any streaming source (LLM tokens, WebSocket, SSE, file tail).
+ * Generic enough for any streaming source, not just LLM.
+ */
+type StreamChunk = {
+    /** Identifier for the stream source (adapter name, URL, etc.). */
+    readonly source: string;
+    /** This chunk's content. */
+    readonly token: string;
+    /** Full accumulated text so far. */
+    readonly accumulated: string;
+    /** 0-based chunk counter. */
+    readonly index: number;
+};
 type FromLLMOptions = {
     name?: string;
     model?: string;
@@ -711,27 +1022,143 @@ type FromLLMOptions = {
  * Uses `switchMap` internally — new invocations cancel stale in-flight ones.
  */
 declare function fromLLM(adapter: LLMAdapter, messages: NodeInput<readonly ChatMessage[]>, opts?: FromLLMOptions): Node<LLMResponse | null>;
-type FromLLMStreamOptions = FromLLMOptions;
+type StreamingPromptNodeOptions = {
+    name?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Output format — `"json"` attempts JSON.parse on the final accumulated text. Default: `"text"`. */
+    format?: "text" | "json";
+    systemPrompt?: string;
+};
 /**
- * Bundle returned by {@link fromLLMStream}. `node` is the reactive log of
- * token chunks; `dispose` tears down the internal effect and log.
+ * Bundle returned by {@link streamingPromptNode}.
  */
-type LLMStreamHandle = {
-    /** Reactive log node accumulating token chunks. */
-    node: Node<readonly string[]>;
-    /** Tear down the internal effect, abort any in-flight stream, and release resources. */
+type StreamingPromptNodeHandle<T> = {
+    /** Final parsed result (emits once per invocation, after stream completes). */
+    output: Node<T | null>;
+    /** Live stream topic — subscribe to `stream.latest` or `stream.events` for chunks. */
+    stream: TopicGraph<StreamChunk>;
+    /** Tear down the keepalive subscription and release resources. */
     dispose: () => void;
 };
 /**
- * Streaming LLM invocation. Returns a `{ node, dispose }` bundle where
- * `node` is a `reactiveLog`-backed node that accumulates token chunks as
- * they arrive from `adapter.stream()`.
+ * Streaming LLM transform: wraps a prompt template + adapter into a reactive
+ * streaming pipeline. Re-invokes the LLM whenever any dep changes; the
+ * previous in-flight stream is canceled automatically via `switchMap`.
+ *
+ * Each token chunk is published to a {@link TopicGraph} as a {@link StreamChunk}.
+ * Extractors can mount on the topic independently (see {@link streamExtractor}).
+ * Zero overhead if nobody subscribes to the stream topic.
  *
- * An `effect` watches the messages input; new values abort the in-flight
- * stream and clear the log before starting a new one. Call `dispose()` to
- * tear down the effect and release resources.
+ * The `output` node emits the final parsed result (like {@link promptNode}).
+ * The async boundary is handled by `fromAny` (spec §5.10 compliant).
  */
-declare function fromLLMStream(adapter: LLMAdapter, messages: NodeInput<readonly ChatMessage[]>, opts?: FromLLMStreamOptions): LLMStreamHandle;
+declare function streamingPromptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: StreamingPromptNodeOptions): StreamingPromptNodeHandle<T>;
+/**
+ * Mounts an extractor function on a streaming topic. Returns a derived node
+ * that emits extracted values as chunks arrive.
+ *
+ * `extractFn` receives the accumulated text from the latest chunk and returns
+ * the extracted value, or `null` if nothing detected yet. This is the building
+ * block for keyword flags, tool call detection, cost metering, etc.
+ *
+ * @param streamTopic - The stream topic to extract from.
+ * @param extractFn - `(accumulated: string) => T | null`.
+ * @param opts - Optional name.
+ * @returns Derived node emitting extracted values.
+ */
+declare function streamExtractor<T>(streamTopic: TopicGraph<StreamChunk>, extractFn: (accumulated: string) => T | null, opts?: {
+    name?: string;
+}): Node<T | null>;
+/** A keyword match detected in the stream. */
+type KeywordFlag = {
+    readonly label: string;
+    readonly pattern: RegExp;
+    readonly match: string;
+    readonly position: number;
+};
+type KeywordFlagExtractorOptions = {
+    patterns: readonly {
+        pattern: RegExp;
+        label: string;
+    }[];
+    name?: string;
+};
+/**
+ * Mounts a keyword-flag extractor on a streaming topic. Scans accumulated text
+ * for all configured patterns and emits an array of matches.
+ *
+ * Use cases: design invariant violations (`setTimeout`, `EventEmitter`), PII
+ * detection (SSN, email, phone), toxicity keywords, off-track reasoning.
+ */
+declare function keywordFlagExtractor(streamTopic: TopicGraph<StreamChunk>, opts: KeywordFlagExtractorOptions): Node<readonly KeywordFlag[]>;
+/** A tool call detected in the stream. */
+type ExtractedToolCall = {
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+    readonly raw: string;
+    readonly startIndex: number;
+};
+/**
+ * Mounts a tool-call extractor on a streaming topic. Scans accumulated text
+ * for complete JSON objects containing `"name"` and `"arguments"` keys (the
+ * standard tool_call shape). Partial JSON is ignored until the closing brace.
+ *
+ * Feeds into the tool interception chain for reactive tool gating mid-stream.
+ */
+declare function toolCallExtractor(streamTopic: TopicGraph<StreamChunk>, opts?: {
+    name?: string;
+}): Node<readonly ExtractedToolCall[]>;
+/** A cost meter reading from the stream. */
+type CostMeterReading = {
+    readonly chunkCount: number;
+    readonly charCount: number;
+    readonly estimatedTokens: number;
+};
+type CostMeterOptions = {
+    /** Characters per token approximation. Default: 4 (GPT-family). */
+    charsPerToken?: number;
+    name?: string;
+};
+/**
+ * Mounts a cost meter on a streaming topic. Counts chunks, characters, and
+ * estimates token count. Compose with `budgetGate` for hard-stop when LLM
+ * output exceeds budget mid-generation.
+ */
+declare function costMeterExtractor(streamTopic: TopicGraph<StreamChunk>, opts?: CostMeterOptions): Node<CostMeterReading>;
+type GatedStreamOptions = StreamingPromptNodeOptions & {
+    /** Gate options (maxPending, startOpen). */
+    gate?: Omit<GateOptions, "meta">;
+};
+/**
+ * Bundle returned by {@link gatedStream}.
+ */
+type GatedStreamHandle<T> = {
+    /** Final parsed result (after gate approval). */
+    output: Node<T | null>;
+    /** Live stream topic — subscribe to `stream.latest` for chunks. */
+    stream: TopicGraph<StreamChunk>;
+    /** Gate controller — approve, reject (aborts in-flight stream), modify. */
+    gate: GateController<T | null>;
+    /** Tear down everything. */
+    dispose: () => void;
+};
+/**
+ * Streaming LLM transform with human-in-the-loop gate integration.
+ *
+ * Composes {@link streamingPromptNode} with {@link gate} so that:
+ * - `gate.reject()` discards the pending value **and** aborts the in-flight
+ *   stream (cancels the `AbortController`).
+ * - `gate.modify()` transforms the pending value before forwarding downstream.
+ * - `gate.approve()` forwards the final result as normal.
+ *
+ * The abort-on-reject works by toggling an internal cancel signal that causes
+ * the `switchMap` inside `streamingPromptNode` to restart with an empty message
+ * list, which triggers the `AbortController.abort()` in the async generator's
+ * `finally` block.
+ */
+declare function gatedStream<T = string>(graph: Graph, name: string, adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: GatedStreamOptions): GatedStreamHandle<T>;
 type PromptNodeOptions = {
     name?: string;
     model?: string;
@@ -1203,18 +1630,23 @@ type ai_ChatMessage = ChatMessage;
 type ai_ChatStreamGraph = ChatStreamGraph;
 declare const ai_ChatStreamGraph: typeof ChatStreamGraph;
 type ai_ChatStreamOptions = ChatStreamOptions;
+type ai_CostMeterOptions = CostMeterOptions;
+type ai_CostMeterReading = CostMeterReading;
+type ai_ExtractedToolCall = ExtractedToolCall;
 type ai_FromLLMOptions = FromLLMOptions;
-type ai_FromLLMStreamOptions = FromLLMStreamOptions;
+type ai_GatedStreamHandle<T> = GatedStreamHandle<T>;
+type ai_GatedStreamOptions = GatedStreamOptions;
 type ai_GaugesAsContextOptions = GaugesAsContextOptions;
 type ai_GraphDefValidation = GraphDefValidation;
 type ai_GraphFromSpecOptions = GraphFromSpecOptions;
+type ai_KeywordFlag = KeywordFlag;
+type ai_KeywordFlagExtractorOptions = KeywordFlagExtractorOptions;
 type ai_KnobsAsToolsResult = KnobsAsToolsResult;
 type ai_LLMAdapter = LLMAdapter;
 type ai_LLMConsolidatorOptions = LLMConsolidatorOptions;
 type ai_LLMExtractorOptions = LLMExtractorOptions;
 type ai_LLMInvokeOptions = LLMInvokeOptions;
 type ai_LLMResponse = LLMResponse;
-type ai_LLMStreamHandle = LLMStreamHandle;
 type ai_McpToolSchema = McpToolSchema;
 type ai_MemoryTier = MemoryTier;
 type ai_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
@@ -1227,6 +1659,9 @@ type ai_RetrievalQuery = RetrievalQuery;
 type ai_RetrievalTrace<TMem> = RetrievalTrace<TMem>;
 type ai_StrategyOperation = StrategyOperation;
 type ai_StrategyPlan = StrategyPlan;
+type ai_StreamChunk = StreamChunk;
+type ai_StreamingPromptNodeHandle<T> = StreamingPromptNodeHandle<T>;
+type ai_StreamingPromptNodeOptions = StreamingPromptNodeOptions;
 type ai_SuggestStrategyOptions = SuggestStrategyOptions;
 type ai_SystemPromptHandle = SystemPromptHandle;
 type ai_ToolCall = ToolCall;
@@ -1238,20 +1673,25 @@ declare const ai_admissionFilter3D: typeof admissionFilter3D;
 declare const ai_agentLoop: typeof agentLoop;
 declare const ai_agentMemory: typeof agentMemory;
 declare const ai_chatStream: typeof chatStream;
+declare const ai_costMeterExtractor: typeof costMeterExtractor;
 declare const ai_fromLLM: typeof fromLLM;
-declare const ai_fromLLMStream: typeof fromLLMStream;
+declare const ai_gatedStream: typeof gatedStream;
 declare const ai_gaugesAsContext: typeof gaugesAsContext;
 declare const ai_graphFromSpec: typeof graphFromSpec;
+declare const ai_keywordFlagExtractor: typeof keywordFlagExtractor;
 declare const ai_knobsAsTools: typeof knobsAsTools;
 declare const ai_llmConsolidator: typeof llmConsolidator;
 declare const ai_llmExtractor: typeof llmExtractor;
 declare const ai_promptNode: typeof promptNode;
+declare const ai_streamExtractor: typeof streamExtractor;
+declare const ai_streamingPromptNode: typeof streamingPromptNode;
 declare const ai_suggestStrategy: typeof suggestStrategy;
 declare const ai_systemPromptBuilder: typeof systemPromptBuilder;
+declare const ai_toolCallExtractor: typeof toolCallExtractor;
 declare const ai_toolRegistry: typeof toolRegistry;
 declare const ai_validateGraphDef: typeof validateGraphDef;
 declare namespace ai {
-  export { type ai_AdmissionScore3DOptions as AdmissionScore3DOptions, type ai_AdmissionScores as AdmissionScores, ai_AgentLoopGraph as AgentLoopGraph, type ai_AgentLoopOptions as AgentLoopOptions, type ai_AgentLoopStatus as AgentLoopStatus, type ai_AgentMemoryGraph as AgentMemoryGraph, type ai_AgentMemoryOptions as AgentMemoryOptions, type ai_ChatMessage as ChatMessage, ai_ChatStreamGraph as ChatStreamGraph, type ai_ChatStreamOptions as ChatStreamOptions, type ai_FromLLMOptions as FromLLMOptions, type ai_FromLLMStreamOptions as FromLLMStreamOptions, type ai_GaugesAsContextOptions as GaugesAsContextOptions, type ai_GraphDefValidation as GraphDefValidation, type ai_GraphFromSpecOptions as GraphFromSpecOptions, type ai_KnobsAsToolsResult as KnobsAsToolsResult, type ai_LLMAdapter as LLMAdapter, type ai_LLMConsolidatorOptions as LLMConsolidatorOptions, type ai_LLMExtractorOptions as LLMExtractorOptions, type ai_LLMInvokeOptions as LLMInvokeOptions, type ai_LLMResponse as LLMResponse, type ai_LLMStreamHandle as LLMStreamHandle, type ai_McpToolSchema as McpToolSchema, type ai_MemoryTier as MemoryTier, type ai_MemoryTiersBundle as MemoryTiersBundle, type ai_MemoryTiersOptions as MemoryTiersOptions, type ai_OpenAIToolSchema as OpenAIToolSchema, type ai_PromptNodeOptions as PromptNodeOptions, type ai_RetrievalEntry as RetrievalEntry, type ai_RetrievalPipelineOptions as RetrievalPipelineOptions, type ai_RetrievalQuery as RetrievalQuery, type ai_RetrievalTrace as RetrievalTrace, type ai_StrategyOperation as StrategyOperation, type ai_StrategyPlan as StrategyPlan, type ai_SuggestStrategyOptions as SuggestStrategyOptions, type ai_SystemPromptHandle as SystemPromptHandle, type ai_ToolCall as ToolCall, type ai_ToolDefinition as ToolDefinition, ai_ToolRegistryGraph as ToolRegistryGraph, type ai_ToolRegistryOptions as ToolRegistryOptions, ai_admissionFilter3D as admissionFilter3D, ai_agentLoop as agentLoop, ai_agentMemory as agentMemory, ai_chatStream as chatStream, ai_fromLLM as fromLLM, ai_fromLLMStream as fromLLMStream, ai_gaugesAsContext as gaugesAsContext, ai_graphFromSpec as graphFromSpec, ai_knobsAsTools as knobsAsTools, ai_llmConsolidator as llmConsolidator, ai_llmExtractor as llmExtractor, ai_promptNode as promptNode, ai_suggestStrategy as suggestStrategy, ai_systemPromptBuilder as systemPromptBuilder, ai_toolRegistry as toolRegistry, ai_validateGraphDef as validateGraphDef };
+  export { type ai_AdmissionScore3DOptions as AdmissionScore3DOptions, type ai_AdmissionScores as AdmissionScores, ai_AgentLoopGraph as AgentLoopGraph, type ai_AgentLoopOptions as AgentLoopOptions, type ai_AgentLoopStatus as AgentLoopStatus, type ai_AgentMemoryGraph as AgentMemoryGraph, type ai_AgentMemoryOptions as AgentMemoryOptions, type ai_ChatMessage as ChatMessage, ai_ChatStreamGraph as ChatStreamGraph, type ai_ChatStreamOptions as ChatStreamOptions, type ai_CostMeterOptions as CostMeterOptions, type ai_CostMeterReading as CostMeterReading, type ai_ExtractedToolCall as ExtractedToolCall, type ai_FromLLMOptions as FromLLMOptions, type ai_GatedStreamHandle as GatedStreamHandle, type ai_GatedStreamOptions as GatedStreamOptions, type ai_GaugesAsContextOptions as GaugesAsContextOptions, type ai_GraphDefValidation as GraphDefValidation, type ai_GraphFromSpecOptions as GraphFromSpecOptions, type ai_KeywordFlag as KeywordFlag, type ai_KeywordFlagExtractorOptions as KeywordFlagExtractorOptions, type ai_KnobsAsToolsResult as KnobsAsToolsResult, type ai_LLMAdapter as LLMAdapter, type ai_LLMConsolidatorOptions as LLMConsolidatorOptions, type ai_LLMExtractorOptions as LLMExtractorOptions, type ai_LLMInvokeOptions as LLMInvokeOptions, type ai_LLMResponse as LLMResponse, type ai_McpToolSchema as McpToolSchema, type ai_MemoryTier as MemoryTier, type ai_MemoryTiersBundle as MemoryTiersBundle, type ai_MemoryTiersOptions as MemoryTiersOptions, type ai_OpenAIToolSchema as OpenAIToolSchema, type ai_PromptNodeOptions as PromptNodeOptions, type ai_RetrievalEntry as RetrievalEntry, type ai_RetrievalPipelineOptions as RetrievalPipelineOptions, type ai_RetrievalQuery as RetrievalQuery, type ai_RetrievalTrace as RetrievalTrace, type ai_StrategyOperation as StrategyOperation, type ai_StrategyPlan as StrategyPlan, type ai_StreamChunk as StreamChunk, type ai_StreamingPromptNodeHandle as StreamingPromptNodeHandle, type ai_StreamingPromptNodeOptions as StreamingPromptNodeOptions, type ai_SuggestStrategyOptions as SuggestStrategyOptions, type ai_SystemPromptHandle as SystemPromptHandle, type ai_ToolCall as ToolCall, type ai_ToolDefinition as ToolDefinition, ai_ToolRegistryGraph as ToolRegistryGraph, type ai_ToolRegistryOptions as ToolRegistryOptions, ai_admissionFilter3D as admissionFilter3D, ai_agentLoop as agentLoop, ai_agentMemory as agentMemory, ai_chatStream as chatStream, ai_costMeterExtractor as costMeterExtractor, ai_fromLLM as fromLLM, ai_gatedStream as gatedStream, ai_gaugesAsContext as gaugesAsContext, ai_graphFromSpec as graphFromSpec, ai_keywordFlagExtractor as keywordFlagExtractor, ai_knobsAsTools as knobsAsTools, ai_llmConsolidator as llmConsolidator, ai_llmExtractor as llmExtractor, ai_promptNode as promptNode, ai_streamExtractor as streamExtractor, ai_streamingPromptNode as streamingPromptNode, ai_suggestStrategy as suggestStrategy, ai_systemPromptBuilder as systemPromptBuilder, ai_toolCallExtractor as toolCallExtractor, ai_toolRegistry as toolRegistry, ai_validateGraphDef as validateGraphDef };
 }
 
 /**
@@ -1843,199 +2283,56 @@ type LLMComposeOptions = {
  * @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 };
-}
-
-/**
- * Messaging patterns (roadmap §4.2).
- *
- * Pulsar-inspired messaging features modeled as graph factories:
- * - `topic()` for append-only topic streams
- * - `subscription()` for cursor-based consumers
- * - `jobQueue()` for queue claim/ack flow
- */
-
-type TopicOptions = {
-    graph?: GraphOptions;
-    retainedLimit?: number;
-};
-declare class TopicGraph<T> extends Graph {
-    private readonly _log;
-    readonly events: Node<readonly T[]>;
-    readonly latest: Node<T | undefined>;
-    constructor(name: string, opts?: TopicOptions);
-    publish(value: T): void;
-    retained(): readonly T[];
-}
-type SubscriptionOptions = {
-    graph?: GraphOptions;
-    cursor?: number;
-};
-declare class SubscriptionGraph<T> extends Graph {
-    readonly source: Node<readonly T[]>;
-    readonly cursor: Node<number>;
-    readonly available: Node<readonly T[]>;
-    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
-    ack(count?: number): number;
-    pull(limit?: number, opts?: {
-        ack?: boolean;
-    }): readonly T[];
-}
-type JobState = "queued" | "inflight";
-type JobEnvelope<T> = {
-    id: string;
-    payload: T;
-    attempts: number;
-    metadata: Readonly<Record<string, unknown>>;
-    state: JobState;
-};
-type JobQueueOptions = {
-    graph?: GraphOptions;
-};
-declare class JobQueueGraph<T> extends Graph {
-    private readonly _pending;
-    private readonly _jobs;
-    private _seq;
-    readonly pending: Node<readonly string[]>;
-    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-    readonly depth: Node<number>;
-    constructor(name: string, opts?: JobQueueOptions);
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    claim(limit?: number): readonly JobEnvelope<T>[];
-    ack(id: string): boolean;
-    nack(id: string, opts?: {
-        requeue?: boolean;
-    }): boolean;
-}
-type JobFlowOptions = {
-    graph?: GraphOptions;
-    stages?: readonly string[];
-    maxPerPump?: number;
-};
-declare class JobFlowGraph<T> extends Graph {
-    private readonly _stageNames;
-    private readonly _queues;
-    private readonly _completed;
-    readonly completed: Node<readonly JobEnvelope<T>[]>;
-    readonly completedCount: Node<number>;
-    constructor(name: string, opts?: JobFlowOptions);
-    stages(): readonly string[];
-    queue(stage: string): JobQueueGraph<T>;
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    retainedCompleted(): readonly JobEnvelope<T>[];
-}
-type TopicBridgeOptions<TIn, TOut> = {
-    graph?: GraphOptions;
-    cursor?: number;
-    maxPerPump?: number;
-    map?: (value: TIn) => TOut | undefined;
-};
-declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
-    private readonly _sourceSub;
-    private readonly _target;
-    readonly bridgedCount: Node<number>;
-    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
-}
-/**
- * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
- */
-declare function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>;
-/**
- * Creates a cursor-based subscription graph over a topic.
- */
-declare function subscription<T>(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions): SubscriptionGraph<T>;
-/**
- * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
- */
-declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
-/**
- * Creates an autonomous multi-stage queue chain graph.
+ * @category patterns
  */
-declare function jobFlow<T>(name: string, opts?: JobFlowOptions): JobFlowGraph<T>;
+declare function llmCompose(problem: string, adapter: LLMAdapter, opts?: LLMComposeOptions): Promise<GraphSpec>;
+/** Options for {@link llmRefine}. */
+type LLMRefineOptions = LLMComposeOptions;
 /**
- * Creates an autonomous cursor-based topic relay graph.
+ * 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 topicBridge<TIn, TOut = TIn>(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>): TopicBridgeGraph<TIn, TOut>;
+declare function llmRefine(currentSpec: GraphSpec, feedback: string, adapter: LLMAdapter, opts?: LLMRefineOptions): Promise<GraphSpec>;
 
-type messaging_JobEnvelope<T> = JobEnvelope<T>;
-type messaging_JobFlowGraph<T> = JobFlowGraph<T>;
-declare const messaging_JobFlowGraph: typeof JobFlowGraph;
-type messaging_JobFlowOptions = JobFlowOptions;
-type messaging_JobQueueGraph<T> = JobQueueGraph<T>;
-declare const messaging_JobQueueGraph: typeof JobQueueGraph;
-type messaging_JobQueueOptions = JobQueueOptions;
-type messaging_JobState = JobState;
-type messaging_SubscriptionGraph<T> = SubscriptionGraph<T>;
-declare const messaging_SubscriptionGraph: typeof SubscriptionGraph;
-type messaging_SubscriptionOptions = SubscriptionOptions;
-type messaging_TopicBridgeGraph<TIn, TOut = TIn> = TopicBridgeGraph<TIn, TOut>;
-declare const messaging_TopicBridgeGraph: typeof TopicBridgeGraph;
-type messaging_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
-type messaging_TopicGraph<T> = TopicGraph<T>;
-declare const messaging_TopicGraph: typeof TopicGraph;
-type messaging_TopicOptions = TopicOptions;
-declare const messaging_jobFlow: typeof jobFlow;
-declare const messaging_jobQueue: typeof jobQueue;
-declare const messaging_subscription: typeof subscription;
-declare const messaging_topic: typeof topic;
-declare const messaging_topicBridge: typeof topicBridge;
-declare namespace messaging {
-  export { type messaging_JobEnvelope as JobEnvelope, messaging_JobFlowGraph as JobFlowGraph, type messaging_JobFlowOptions as JobFlowOptions, messaging_JobQueueGraph as JobQueueGraph, type messaging_JobQueueOptions as JobQueueOptions, type messaging_JobState as JobState, messaging_SubscriptionGraph as SubscriptionGraph, type messaging_SubscriptionOptions as SubscriptionOptions, messaging_TopicBridgeGraph as TopicBridgeGraph, type messaging_TopicBridgeOptions as TopicBridgeOptions, messaging_TopicGraph as TopicGraph, type messaging_TopicOptions as TopicOptions, messaging_jobFlow as jobFlow, messaging_jobQueue as jobQueue, messaging_subscription as subscription, messaging_topic as topic, messaging_topicBridge as topicBridge };
+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 };
 }
 
 /**
@@ -2185,6 +2482,29 @@ interface HarnessLoopOptions {
  * @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.
  *
@@ -2226,160 +2546,6 @@ interface EvalIntakeBridgeOptions {
  */
 declare function evalIntakeBridge(evalSource: Node<EvalResult | EvalResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
 
-/**
- * Orchestration patterns (roadmap §4.1).
- *
- * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
- * Exported under the `patterns.orchestration` namespace to avoid collisions with
- * Phase 2 operator names (for example `gate`, `forEach`).
- */
-
-type StepRef$1 = string | Node<unknown>;
-type OrchestrationMeta = {
-    orchestration?: true;
-    orchestration_type?: string;
-};
-type OrchestrationStepOptions = Omit<NodeOptions, "describeKind" | "name" | "meta"> & {
-    deps?: ReadonlyArray<StepRef$1>;
-    meta?: Record<string, unknown> & OrchestrationMeta;
-};
-type BranchResult<T> = {
-    branch: "then" | "else";
-    value: T;
-};
-type SensorControls<T> = {
-    node: Node<T>;
-    push(value: T): void;
-    error(err: unknown): void;
-    complete(): void;
-};
-type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
-    iterations?: number | StepRef$1;
-};
-type WaitOptions = Omit<OrchestrationStepOptions, "deps">;
-type SubPipelineBuilder = (sub: Graph) => void;
-/**
- * Creates an orchestration graph container.
- */
-declare function pipeline(name: string, opts?: GraphOptions): Graph;
-/**
- * Registers a workflow task node.
- */
-declare function task<T>(graph: Graph, name: string, run: NodeFn<T>, opts?: OrchestrationStepOptions): Node<T>;
-/**
- * Emits tagged branch outcomes (`then` / `else`) for each source value.
- */
-declare function branch<T>(graph: Graph, name: string, source: StepRef$1, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
-/**
- * Forwards source values only while `control` is truthy.
- */
-declare function valve<T>(graph: Graph, name: string, source: StepRef$1, control: StepRef$1, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
-    isApproved?: (value: unknown) => boolean;
-};
-/**
- * Human/LLM approval gate over a source value.
- */
-declare function approval<T>(graph: Graph, name: string, source: StepRef$1, approver: StepRef$1, opts?: ApprovalOptions): Node<T>;
-interface GateOptions {
-    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
-    maxPending?: number;
-    /** Start in open mode (auto-approve). Default: false. */
-    startOpen?: boolean;
-    meta?: Record<string, unknown>;
-}
-/** Control surface returned by {@link gate}. */
-interface GateController<T> {
-    /** The output node registered in the graph (subscribe to receive approved values). */
-    node: Node<T>;
-    /** Reactive queue of values waiting for approval. */
-    pending: Node<T[]>;
-    /** Derived count of pending items. */
-    count: Node<number>;
-    /** Whether the gate is currently open (auto-approving). */
-    isOpen: Node<boolean>;
-    /** Approve and forward the next `count` pending values (default: 1). */
-    approve(count?: number): void;
-    /** Reject (discard) the next `count` pending values (default: 1). */
-    reject(count?: number): void;
-    /**
-     * Transform and forward `count` pending values (default: 1).
-     * `fn` receives `(value, index, pending)` — Array.map-style.
-     */
-    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-    /** Flush all pending values and auto-approve future values. */
-    open(): void;
-    /** Re-enable manual gating (stop auto-approving). */
-    close(): void;
-}
-/**
- * Human-in-the-loop gate: queues incoming values from `source` and lets an external
- * controller {@link GateController.approve approve}, {@link GateController.reject reject},
- * or {@link GateController.modify modify} them before forwarding downstream.
- *
- * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
- * the graph. The gate output node is also registered.
- */
-declare function gate<T>(graph: Graph, name: string, source: StepRef$1, opts?: GateOptions): GateController<T>;
-/**
- * Registers a workflow side-effect step. The step remains graph-observable and forwards messages.
- */
-declare function forEach<T>(graph: Graph, name: string, source: StepRef$1, run: (value: T, actions: NodeActions) => void, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-/**
- * Registers a join step that emits a tuple of latest dependency values.
- */
-declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
-    [K in keyof T]: StepRef$1;
-}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-/**
- * Registers a loop step that applies `iterate` to each source value N times.
- */
-declare function loop<T>(graph: Graph, name: string, source: StepRef$1, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
-/**
- * Mounts and returns a child workflow graph.
- */
-declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
-/**
- * Registers a producer-style sensor source and returns imperative controls.
- */
-declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions, "name" | "describeKind" | "meta"> & {
-    meta?: Record<string, unknown>;
-}): SensorControls<T>;
-/**
- * Registers a delayed-forwarding step (value-level wait).
- */
-declare function wait<T>(graph: Graph, name: string, source: StepRef$1, ms: number, opts?: WaitOptions): Node<T>;
-/**
- * Registers an error-recovery step for a source.
- */
-declare function onFailure<T>(graph: Graph, name: string, source: StepRef$1, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-
-type orchestration_ApprovalOptions = ApprovalOptions;
-type orchestration_BranchResult<T> = BranchResult<T>;
-type orchestration_GateController<T> = GateController<T>;
-type orchestration_GateOptions = GateOptions;
-type orchestration_LoopOptions = LoopOptions;
-type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
-type orchestration_SensorControls<T> = SensorControls<T>;
-type orchestration_SubPipelineBuilder = SubPipelineBuilder;
-type orchestration_WaitOptions = WaitOptions;
-declare const orchestration_approval: typeof approval;
-declare const orchestration_branch: typeof branch;
-declare const orchestration_forEach: typeof forEach;
-declare const orchestration_gate: typeof gate;
-declare const orchestration_join: typeof join;
-declare const orchestration_loop: typeof loop;
-declare const orchestration_onFailure: typeof onFailure;
-declare const orchestration_pipeline: typeof pipeline;
-declare const orchestration_sensor: typeof sensor;
-declare const orchestration_subPipeline: typeof subPipeline;
-declare const orchestration_task: typeof task;
-declare const orchestration_valve: typeof valve;
-declare const orchestration_wait: typeof wait;
-declare namespace orchestration {
-  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_GateController as GateController, type orchestration_GateOptions as GateOptions, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type StepRef$1 as StepRef, type orchestration_SubPipelineBuilder as SubPipelineBuilder, type orchestration_WaitOptions as WaitOptions, orchestration_approval as approval, orchestration_branch as branch, orchestration_forEach as forEach, orchestration_gate as gate, orchestration_join as join, orchestration_loop as loop, orchestration_onFailure as onFailure, orchestration_pipeline as pipeline, orchestration_sensor as sensor, orchestration_subPipeline as subPipeline, orchestration_task as task, orchestration_valve as valve, orchestration_wait as wait };
-}
-
 /**
  * Strategy model and priority scoring (roadmap §9.0).
  *
@@ -2504,17 +2670,57 @@ declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOption
  * 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.
@@ -2523,12 +2729,22 @@ interface HarnessTraceOptions {
  * 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.
+ * @returns Handle with `dispose()` to stop tracing and `events` for structured access.
  */
 declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions): HarnessTraceHandle;
 
@@ -2559,6 +2775,7 @@ type index$1_HarnessLoopOptions = HarnessLoopOptions;
 type index$1_HarnessProfileResult = HarnessProfileResult;
 type index$1_HarnessTraceHandle = HarnessTraceHandle;
 type index$1_HarnessTraceOptions = HarnessTraceOptions;
+type index$1_IntakeBridgeOptions = IntakeBridgeOptions;
 type index$1_IntakeItem = IntakeItem;
 type index$1_IntakeSource = IntakeSource;
 type index$1_Intervention = Intervention;
@@ -2572,8 +2789,12 @@ type index$1_StrategyEntry = StrategyEntry;
 type index$1_StrategyKey = StrategyKey;
 type index$1_StrategyModelBundle = StrategyModelBundle;
 type index$1_StrategySnapshot = StrategySnapshot;
+type index$1_TraceDetail = TraceDetail;
+type index$1_TraceEvent = TraceEvent;
+type index$1_TraceEventType = TraceEventType;
 type index$1_TriagedItem = TriagedItem;
 type index$1_VerifyResult = VerifyResult;
+declare const index$1_createIntakeBridge: typeof createIntakeBridge;
 declare const index$1_defaultErrorClassifier: typeof defaultErrorClassifier;
 declare const index$1_evalIntakeBridge: typeof evalIntakeBridge;
 declare const index$1_harnessLoop: typeof harnessLoop;
@@ -2583,7 +2804,7 @@ declare const index$1_priorityScore: typeof priorityScore;
 declare const index$1_strategyKey: typeof strategyKey;
 declare const index$1_strategyModel: typeof strategyModel;
 declare namespace index$1 {
-  export { index$1_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index$1_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index$1_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index$1_ErrorClass as ErrorClass, type index$1_ErrorClassifier as ErrorClassifier, type index$1_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index$1_EvalJudgeScore as EvalJudgeScore, type index$1_EvalResult as EvalResult, type index$1_EvalTaskResult as EvalTaskResult, type index$1_ExecuteOutput as ExecuteOutput, type index$1_ExecutionResult as ExecutionResult, index$1_HarnessGraph as HarnessGraph, type index$1_HarnessLoopOptions as HarnessLoopOptions, type index$1_HarnessProfileResult as HarnessProfileResult, type index$1_HarnessTraceHandle as HarnessTraceHandle, type index$1_HarnessTraceOptions as HarnessTraceOptions, type index$1_IntakeItem as IntakeItem, type index$1_IntakeSource as IntakeSource, type index$1_Intervention as Intervention, type index$1_PrioritySignals as PrioritySignals, index$1_QUEUE_NAMES as QUEUE_NAMES, type index$1_QueueConfig as QueueConfig, type index$1_QueueRoute as QueueRoute, type index$1_RootCause as RootCause, type index$1_Severity as Severity, type index$1_StrategyEntry as StrategyEntry, type index$1_StrategyKey as StrategyKey, type index$1_StrategyModelBundle as StrategyModelBundle, type index$1_StrategySnapshot as StrategySnapshot, type index$1_TriagedItem as TriagedItem, type index$1_VerifyResult as VerifyResult, index$1_defaultErrorClassifier as defaultErrorClassifier, index$1_evalIntakeBridge as evalIntakeBridge, index$1_harnessLoop as harnessLoop, index$1_harnessProfile as harnessProfile, index$1_harnessTrace as harnessTrace, index$1_priorityScore as priorityScore, index$1_strategyKey as strategyKey, index$1_strategyModel as strategyModel };
+  export { index$1_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index$1_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index$1_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index$1_ErrorClass as ErrorClass, type index$1_ErrorClassifier as ErrorClassifier, type index$1_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index$1_EvalJudgeScore as EvalJudgeScore, type index$1_EvalResult as EvalResult, type index$1_EvalTaskResult as EvalTaskResult, type index$1_ExecuteOutput as ExecuteOutput, type index$1_ExecutionResult as ExecutionResult, index$1_HarnessGraph as HarnessGraph, type index$1_HarnessLoopOptions as HarnessLoopOptions, type index$1_HarnessProfileResult as HarnessProfileResult, type index$1_HarnessTraceHandle as HarnessTraceHandle, type index$1_HarnessTraceOptions as HarnessTraceOptions, type index$1_IntakeBridgeOptions as IntakeBridgeOptions, type index$1_IntakeItem as IntakeItem, type index$1_IntakeSource as IntakeSource, type index$1_Intervention as Intervention, type index$1_PrioritySignals as PrioritySignals, index$1_QUEUE_NAMES as QUEUE_NAMES, type index$1_QueueConfig as QueueConfig, type index$1_QueueRoute as QueueRoute, type index$1_RootCause as RootCause, type index$1_Severity as Severity, type index$1_StrategyEntry as StrategyEntry, type index$1_StrategyKey as StrategyKey, type index$1_StrategyModelBundle as StrategyModelBundle, type index$1_StrategySnapshot as StrategySnapshot, type index$1_TraceDetail as TraceDetail, type index$1_TraceEvent as TraceEvent, type index$1_TraceEventType as TraceEventType, type index$1_TriagedItem as TriagedItem, type index$1_VerifyResult as VerifyResult, index$1_createIntakeBridge as createIntakeBridge, index$1_defaultErrorClassifier as defaultErrorClassifier, index$1_evalIntakeBridge as evalIntakeBridge, index$1_harnessLoop as harnessLoop, index$1_harnessProfile as harnessProfile, index$1_harnessTrace as harnessTrace, index$1_priorityScore as priorityScore, index$1_strategyKey as strategyKey, index$1_strategyModel as strategyModel };
 }
 
 /**
@@ -2741,9 +2962,52 @@ type ScorerOptions = Omit<NodeOptions, "describeKind" | "name" | "meta"> & {
  * @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;
@@ -2753,12 +3017,13 @@ 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_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_feedback as feedback, reduction_funnel as funnel, reduction_scorer as scorer, reduction_stratify as stratify };
+  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 };
 }
 
 /**