@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/{index-BPVt8kqc.d.ts → index-2NvguqQA.d.ts}

@@ -1,8 +1,9 @@
-import { T as ToObservableOptions, t as toObservable } from './observable-BgGUwcqp.js';
+import { T as ToObservableOptions, t as toObservable } from './observable-BZJgo616.js';
 import { OnModuleInit, OnModuleDestroy, ExecutionContext, CanActivate, DynamicModule } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { a as Graph, G as GraphOptions, s as GraphPersistSnapshot } from './graph-CCwGKLCm.js';
-import { A as Actor, N as Node } from './node-BmerH3kS.js';
+import { G as Graph, d as GraphPersistSnapshot } from './graph-Qjg9gWHI.js';
+import { A as Actor } from './node-Dd6wHSib.js';
+import { C as CqrsOptions, a as CqrsGraph, E as EventStoreAdapter } from './index-BSfwiy5B.js';
 
 /** Class constructor key for decorator registries and Nest `ModuleRef.get()`. */
 type DecoratorHostConstructor = abstract new (...args: unknown[]) => unknown;
@@ -192,7 +193,7 @@ declare function GraphCron(expr: string): (value: DecoratorBoundMethod, context:
  * }
  * ```
  */
-declare function CommandHandler$1(cqrsName: string, commandName: string): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void;
+declare function CommandHandler(cqrsName: string, commandName: string): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void;
 /**
  * Subscribe a method to CQRS event stream DATA — replaces `@EventsHandler()` from `@nestjs/cqrs`.
  *
@@ -256,7 +257,7 @@ declare function QueryHandler(cqrsName: string, projectionName: string): (value:
  * }
  * ```
  */
-declare function SagaHandler$1(cqrsName: string, sagaName: string, eventNames: readonly string[]): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void;
+declare function SagaHandler(cqrsName: string, sagaName: string, eventNames: readonly string[]): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void;
 
 declare class GraphReflyEventExplorer implements OnModuleInit, OnModuleDestroy {
     private readonly graph;
@@ -579,194 +580,6 @@ declare class GraphReflyGuardImpl implements CanActivate {
  */
 declare function GraphReflyGuard(extractor?: ActorExtractor): GraphReflyGuardImpl;
 
-/**
- * CQRS patterns (roadmap §4.5).
- *
- * Composition layer over reactiveLog (3.2), pipeline/sagas (4.1), event bus (4.2),
- * projections (4.3). Guards (1.5) enforce command/query boundary.
- *
- * - `cqrs(name, opts?)` → `CqrsGraph` — top-level factory
- * - `CqrsGraph.command(name, handler)` — write-only node; guard rejects `observe`
- * - `CqrsGraph.event(name)` — backed by `reactiveLog`; append-only
- * - `CqrsGraph.projection(name, events, reducer, initial)` — read-only derived; guard rejects `write`
- * - `CqrsGraph.saga(name, events, handler)` — event-driven side effects
- */
-
-/**
- * Immutable envelope for events emitted by command handlers.
- *
- * `seq` is a per-graph monotonic counter that provides stable ordering when
- * multiple events share the same `timestampNs` (same wall-clock tick).
- */
-type CqrsEvent<T = unknown> = {
-    type: string;
-    payload: T;
-    /** Wall-clock nanoseconds (via `wallClockNs()`). */
-    timestampNs: number;
-    /** Monotonic sequence within this CqrsGraph instance. */
-    seq: number;
-    /** V0 identity of the event log node at append time (§6.0b). */
-    v0?: {
-        id: string;
-        version: number;
-    };
-};
-/**
- * Opaque replay cursor returned by `loadEvents`. Pass it back to
- * `loadEvents` to resume from the last position.
- */
-type EventStoreCursor = {
-    readonly __brand?: "EventStoreCursor";
-    [key: string]: unknown;
-};
-/**
- * Result of `loadEvents` — events plus an opaque cursor for resumption.
- */
-type LoadEventsResult = {
-    events: CqrsEvent[];
-    cursor: EventStoreCursor | undefined;
-};
-/**
- * Pluggable persistence for CQRS events.
- *
- * **`persist`:** Must be synchronous. Called from the dispatch path inside
- * `batch()`. Adapters that need async I/O should buffer internally and
- * expose a `flush()` method for explicit drain.
- */
-interface EventStoreAdapter {
-    persist(event: CqrsEvent): void;
-    /**
-     * Load persisted events. When `cursor` is provided, returns only events
-     * after that position. The returned `cursor` should be passed to the next
-     * `loadEvents` call for incremental replay.
-     */
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult | Promise<LoadEventsResult>;
-    /** Optional explicit flush for adapters with async I/O. */
-    flush?(): Promise<void>;
-}
-declare class MemoryEventStore implements EventStoreAdapter {
-    private readonly _store;
-    persist(event: CqrsEvent): void;
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult;
-    clear(): void;
-}
-type CommandActions = {
-    /** Append an event to a named event log (bypasses event guard). */
-    emit: (eventName: string, payload: unknown) => void;
-};
-/**
- * Command handler receives the dispatch payload and actions to emit events.
- *
- * **Purity:** Handlers should not mutate the payload. Event emission via
- * `actions.emit()` is the only sanctioned side effect.
- */
-type CommandHandler<T = unknown> = (payload: T, actions: CommandActions) => void;
-/**
- * Projection reducer folds events into a read model.
- *
- * **Purity contract:** Reducers MUST be pure — return a new state value
- * without mutating `state` or any event. The `state` parameter is the
- * original `initial` value on every invocation (full event-sourcing replay),
- * so mutation would corrupt future recomputations.
- */
-type ProjectionReducer<TState = unknown, TEvent = unknown> = (state: TState, events: readonly CqrsEvent<TEvent>[]) => TState;
-type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
-type CqrsOptions = {
-    graph?: GraphOptions;
-};
-declare class CqrsGraph extends Graph {
-    private readonly _eventLogs;
-    private readonly _commandHandlers;
-    private readonly _projections;
-    private readonly _sagas;
-    private readonly _keepaliveDisposers;
-    private _eventStore;
-    private _seq;
-    constructor(name: string, opts?: CqrsOptions);
-    destroy(): void;
-    /**
-     * Register a named event stream backed by `reactiveLog`.
-     * Guard denies external `write` — only commands append internally.
-     */
-    event(name: string): Node<readonly CqrsEvent[]>;
-    /** Internal: append to an event log, auto-registering if needed. */
-    private _appendEvent;
-    /**
-     * Register a command with its handler. Guard denies `observe` (write-only).
-     * Use `dispatch(name, payload)` to execute.
-     *
-     * The command node carries dynamic `meta.error` — a reactive companion
-     * that holds the last handler error (or `null` on success).
-     */
-    command<T = unknown>(name: string, handler: CommandHandler<T>): Node<T>;
-    /**
-     * Execute a registered command. Wraps the entire dispatch in `batch()` so
-     * the command node DATA and all emitted events settle atomically.
-     *
-     * If the handler throws, `meta.error` on the command node is set to the
-     * error and the exception is re-thrown.
-     */
-    dispatch<T = unknown>(commandName: string, payload: T): void;
-    /**
-     * Register a read-only projection derived from event streams.
-     * Guard denies `write` — value is computed from events only.
-     *
-     * **Purity contract:** The `reducer` must be a pure function — it receives
-     * the original `initial` on every invocation (full event-sourcing replay).
-     * Never mutate `initial`; always return a new value.
-     */
-    projection<TState>(name: string, eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Node<TState>;
-    /**
-     * Register an event-driven side effect. Runs handler for each **new** event
-     * from the specified streams (tracks last-processed entry count per stream).
-     *
-     * The saga node carries dynamic `meta.error` — a reactive companion that
-     * holds the last handler error (or `null` on success). Handler errors do
-     * not propagate out of the saga run (the event cursor still advances so
-     * the same entry is not delivered twice).
-     */
-    saga<T = unknown>(name: string, eventNames: readonly string[], handler: SagaHandler<T>): Node<unknown>;
-    useEventStore(adapter: EventStoreAdapter): void;
-    /**
-     * Replay persisted events through a reducer to rebuild a read model.
-     * Requires an event store adapter wired via `useEventStore()`.
-     */
-    rebuildProjection<TState>(eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Promise<TState>;
-}
-/**
- * Create a CQRS graph container.
- *
- * @example
- * ```ts
- * const app = cqrs("orders");
- * app.event("orderPlaced");
- * app.command("placeOrder", (payload, { emit }) => {
- *   emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
- * });
- * app.projection("orderCount", ["orderPlaced"], (_s, events) => events.length, 0);
- * app.dispatch("placeOrder", { id: "1", amount: 100 });
- * ```
- */
-declare function cqrs(name: string, opts?: CqrsOptions): CqrsGraph;
-
-type cqrs$1_CommandActions = CommandActions;
-type cqrs$1_CommandHandler<T = unknown> = CommandHandler<T>;
-type cqrs$1_CqrsEvent<T = unknown> = CqrsEvent<T>;
-type cqrs$1_CqrsGraph = CqrsGraph;
-declare const cqrs$1_CqrsGraph: typeof CqrsGraph;
-type cqrs$1_CqrsOptions = CqrsOptions;
-type cqrs$1_EventStoreAdapter = EventStoreAdapter;
-type cqrs$1_EventStoreCursor = EventStoreCursor;
-type cqrs$1_LoadEventsResult = LoadEventsResult;
-type cqrs$1_MemoryEventStore = MemoryEventStore;
-declare const cqrs$1_MemoryEventStore: typeof MemoryEventStore;
-type cqrs$1_ProjectionReducer<TState = unknown, TEvent = unknown> = ProjectionReducer<TState, TEvent>;
-type cqrs$1_SagaHandler<T = unknown> = SagaHandler<T>;
-declare const cqrs$1_cqrs: typeof cqrs;
-declare namespace cqrs$1 {
-  export { type cqrs$1_CommandActions as CommandActions, type cqrs$1_CommandHandler as CommandHandler, type cqrs$1_CqrsEvent as CqrsEvent, cqrs$1_CqrsGraph as CqrsGraph, type cqrs$1_CqrsOptions as CqrsOptions, type cqrs$1_EventStoreAdapter as EventStoreAdapter, type cqrs$1_EventStoreCursor as EventStoreCursor, type cqrs$1_LoadEventsResult as LoadEventsResult, cqrs$1_MemoryEventStore as MemoryEventStore, type cqrs$1_ProjectionReducer as ProjectionReducer, type cqrs$1_SagaHandler as SagaHandler, cqrs$1_cqrs as cqrs };
-}
-
 interface GraphReflyRootOptions {
     /** Root graph name (default: `"root"`). */
     name?: string;
@@ -884,6 +697,7 @@ type index_ActorExtractor = ActorExtractor;
 declare const index_COMMAND_HANDLERS: typeof COMMAND_HANDLERS;
 declare const index_CQRS_EVENT_HANDLERS: typeof CQRS_EVENT_HANDLERS;
 declare const index_CRON_HANDLERS: typeof CRON_HANDLERS;
+declare const index_CommandHandler: typeof CommandHandler;
 type index_CommandHandlerMeta = CommandHandlerMeta;
 declare const index_EVENT_HANDLERS: typeof EVENT_HANDLERS;
 declare const index_EventHandler: typeof EventHandler;
@@ -921,6 +735,7 @@ declare const index_QUERY_HANDLERS: typeof QUERY_HANDLERS;
 declare const index_QueryHandler: typeof QueryHandler;
 type index_QueryHandlerMeta = QueryHandlerMeta;
 declare const index_SAGA_HANDLERS: typeof SAGA_HANDLERS;
+declare const index_SagaHandler: typeof SagaHandler;
 type index_SagaHandlerMeta = SagaHandlerMeta;
 declare const index_ToObservableOptions: typeof ToObservableOptions;
 declare const index_fromHeader: typeof fromHeader;
@@ -932,7 +747,7 @@ declare const index_observeSSE: typeof observeSSE;
 declare const index_observeSubscription: typeof observeSubscription;
 declare const index_toObservable: typeof toObservable;
 declare namespace index {
-  export { index_ACTOR_KEY as ACTOR_KEY, type index_ActorExtractor as ActorExtractor, index_COMMAND_HANDLERS as COMMAND_HANDLERS, index_CQRS_EVENT_HANDLERS as CQRS_EVENT_HANDLERS, index_CRON_HANDLERS as CRON_HANDLERS, CommandHandler$1 as CommandHandler, type index_CommandHandlerMeta as CommandHandlerMeta, index_EVENT_HANDLERS as EVENT_HANDLERS, index_EventHandler as EventHandler, type index_EventHandlerMeta as EventHandlerMeta, index_GRAPHREFLY_REQUEST_GRAPH as GRAPHREFLY_REQUEST_GRAPH, index_GRAPHREFLY_ROOT_GRAPH as GRAPHREFLY_ROOT_GRAPH, index_GraphCron as GraphCron, type index_GraphCronMeta as GraphCronMeta, index_GraphInterval as GraphInterval, type index_GraphIntervalMeta as GraphIntervalMeta, type index_GraphReflyCqrsOptions as GraphReflyCqrsOptions, index_GraphReflyEventExplorer as GraphReflyEventExplorer, type index_GraphReflyFeatureOptions as GraphReflyFeatureOptions, index_GraphReflyGuard as GraphReflyGuard, index_GraphReflyGuardImpl as GraphReflyGuardImpl, index_GraphReflyModule as GraphReflyModule, type index_GraphReflyRootOptions as GraphReflyRootOptions, index_INTERVAL_HANDLERS as INTERVAL_HANDLERS, index_InjectCqrsGraph as InjectCqrsGraph, index_InjectGraph as InjectGraph, index_InjectNode as InjectNode, index_ObserveGateway as ObserveGateway, type index_ObserveGatewayOptions as ObserveGatewayOptions, type index_ObserveSSEOptions as ObserveSSEOptions, type index_ObserveSubscriptionOptions as ObserveSubscriptionOptions, type index_ObserveWsCommand as ObserveWsCommand, type index_ObserveWsMessage as ObserveWsMessage, index_OnGraphEvent as OnGraphEvent, type index_OnGraphEventMeta as OnGraphEventMeta, index_QUERY_HANDLERS as QUERY_HANDLERS, index_QueryHandler as QueryHandler, type index_QueryHandlerMeta as QueryHandlerMeta, index_SAGA_HANDLERS as SAGA_HANDLERS, SagaHandler$1 as SagaHandler, type index_SagaHandlerMeta as SagaHandlerMeta, index_ToObservableOptions as ToObservableOptions, index_fromHeader as fromHeader, index_fromJwtPayload as fromJwtPayload, index_getActor as getActor, index_getGraphToken as getGraphToken, index_getNodeToken as getNodeToken, index_observeSSE as observeSSE, index_observeSubscription as observeSubscription, index_toObservable as toObservable };
+  export { index_ACTOR_KEY as ACTOR_KEY, type index_ActorExtractor as ActorExtractor, index_COMMAND_HANDLERS as COMMAND_HANDLERS, index_CQRS_EVENT_HANDLERS as CQRS_EVENT_HANDLERS, index_CRON_HANDLERS as CRON_HANDLERS, index_CommandHandler as CommandHandler, type index_CommandHandlerMeta as CommandHandlerMeta, index_EVENT_HANDLERS as EVENT_HANDLERS, index_EventHandler as EventHandler, type index_EventHandlerMeta as EventHandlerMeta, index_GRAPHREFLY_REQUEST_GRAPH as GRAPHREFLY_REQUEST_GRAPH, index_GRAPHREFLY_ROOT_GRAPH as GRAPHREFLY_ROOT_GRAPH, index_GraphCron as GraphCron, type index_GraphCronMeta as GraphCronMeta, index_GraphInterval as GraphInterval, type index_GraphIntervalMeta as GraphIntervalMeta, type index_GraphReflyCqrsOptions as GraphReflyCqrsOptions, index_GraphReflyEventExplorer as GraphReflyEventExplorer, type index_GraphReflyFeatureOptions as GraphReflyFeatureOptions, index_GraphReflyGuard as GraphReflyGuard, index_GraphReflyGuardImpl as GraphReflyGuardImpl, index_GraphReflyModule as GraphReflyModule, type index_GraphReflyRootOptions as GraphReflyRootOptions, index_INTERVAL_HANDLERS as INTERVAL_HANDLERS, index_InjectCqrsGraph as InjectCqrsGraph, index_InjectGraph as InjectGraph, index_InjectNode as InjectNode, index_ObserveGateway as ObserveGateway, type index_ObserveGatewayOptions as ObserveGatewayOptions, type index_ObserveSSEOptions as ObserveSSEOptions, type index_ObserveSubscriptionOptions as ObserveSubscriptionOptions, type index_ObserveWsCommand as ObserveWsCommand, type index_ObserveWsMessage as ObserveWsMessage, index_OnGraphEvent as OnGraphEvent, type index_OnGraphEventMeta as OnGraphEventMeta, index_QUERY_HANDLERS as QUERY_HANDLERS, index_QueryHandler as QueryHandler, type index_QueryHandlerMeta as QueryHandlerMeta, index_SAGA_HANDLERS as SAGA_HANDLERS, index_SagaHandler as SagaHandler, type index_SagaHandlerMeta as SagaHandlerMeta, index_ToObservableOptions as ToObservableOptions, index_fromHeader as fromHeader, index_fromJwtPayload as fromJwtPayload, index_getActor as getActor, index_getGraphToken as getGraphToken, index_getNodeToken as getNodeToken, index_observeSSE as observeSSE, index_observeSubscription as observeSubscription, index_toObservable as toObservable };
 }
 
-export { ACTOR_KEY as A, type ObserveSubscriptionOptions as B, COMMAND_HANDLERS as C, type ObserveWsCommand as D, EVENT_HANDLERS as E, type ObserveWsMessage as F, GRAPHREFLY_REQUEST_GRAPH as G, OnGraphEvent as H, INTERVAL_HANDLERS as I, type OnGraphEventMeta as J, QueryHandler as K, type QueryHandlerMeta as L, SagaHandler$1 as M, type SagaHandlerMeta as N, ObserveGateway as O, fromHeader as P, QUERY_HANDLERS as Q, fromJwtPayload as R, SAGA_HANDLERS as S, getActor as T, getGraphToken as U, getNodeToken as V, observeSSE as W, observeSubscription as X, type ActorExtractor as a, CQRS_EVENT_HANDLERS as b, cqrs$1 as c, CRON_HANDLERS as d, CommandHandler$1 as e, type CommandHandlerMeta as f, EventHandler as g, type EventHandlerMeta as h, index as i, GRAPHREFLY_ROOT_GRAPH as j, GraphCron as k, type GraphCronMeta as l, GraphInterval as m, type GraphIntervalMeta as n, type GraphReflyCqrsOptions as o, GraphReflyEventExplorer as p, type GraphReflyFeatureOptions as q, GraphReflyGuard as r, GraphReflyGuardImpl as s, GraphReflyModule as t, type GraphReflyRootOptions as u, InjectCqrsGraph as v, InjectGraph as w, InjectNode as x, type ObserveGatewayOptions as y, type ObserveSSEOptions as z };
+export { ACTOR_KEY as A, type ObserveWsCommand as B, COMMAND_HANDLERS as C, type ObserveWsMessage as D, EVENT_HANDLERS as E, OnGraphEvent as F, GRAPHREFLY_REQUEST_GRAPH as G, type OnGraphEventMeta as H, INTERVAL_HANDLERS as I, QueryHandler as J, type QueryHandlerMeta as K, SagaHandler as L, type SagaHandlerMeta as M, fromHeader as N, ObserveGateway as O, fromJwtPayload as P, QUERY_HANDLERS as Q, getActor as R, SAGA_HANDLERS as S, getGraphToken as T, getNodeToken as U, observeSSE as V, observeSubscription as W, type ActorExtractor as a, CQRS_EVENT_HANDLERS as b, CRON_HANDLERS as c, CommandHandler as d, type CommandHandlerMeta as e, EventHandler as f, type EventHandlerMeta as g, GRAPHREFLY_ROOT_GRAPH as h, index as i, GraphCron as j, type GraphCronMeta as k, GraphInterval as l, type GraphIntervalMeta as m, type GraphReflyCqrsOptions as n, GraphReflyEventExplorer as o, type GraphReflyFeatureOptions as p, GraphReflyGuard as q, GraphReflyGuardImpl as r, GraphReflyModule as s, type GraphReflyRootOptions as t, InjectCqrsGraph as u, InjectGraph as v, InjectNode as w, type ObserveGatewayOptions as x, type ObserveSSEOptions as y, type ObserveSubscriptionOptions as z };

package/dist/index-A65LZhoM.d.ts

@@ -0,0 +1,186 @@
+import { a as Node, N as NodeOptions } from './node-Dd6wHSib.js';
+import { a as GraphOptions, G as Graph } from './graph-Qjg9gWHI.js';
+
+/**
+ * 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 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 index_BudgetConstraint<T = unknown> = BudgetConstraint<T>;
+type index_BudgetGateOptions = BudgetGateOptions;
+type index_EffectivenessEntry = EffectivenessEntry;
+type index_EffectivenessSnapshot = EffectivenessSnapshot;
+type index_EffectivenessTrackerBundle = EffectivenessTrackerBundle;
+type index_EffectivenessTrackerOptions = EffectivenessTrackerOptions;
+type index_FeedbackOptions = FeedbackOptions;
+type index_FunnelOptions = FunnelOptions;
+type index_FunnelStage = FunnelStage;
+type index_ScoredItem<T = unknown> = ScoredItem<T>;
+type index_ScorerOptions = ScorerOptions;
+type index_StepRef = StepRef;
+declare const index_budgetGate: typeof budgetGate;
+declare const index_effectivenessTracker: typeof effectivenessTracker;
+declare const index_feedback: typeof feedback;
+declare const index_funnel: typeof funnel;
+declare const index_scorer: typeof scorer;
+declare namespace index {
+  export { type index_BudgetConstraint as BudgetConstraint, type index_BudgetGateOptions as BudgetGateOptions, type index_EffectivenessEntry as EffectivenessEntry, type index_EffectivenessSnapshot as EffectivenessSnapshot, type index_EffectivenessTrackerBundle as EffectivenessTrackerBundle, type index_EffectivenessTrackerOptions as EffectivenessTrackerOptions, type index_FeedbackOptions as FeedbackOptions, type index_FunnelOptions as FunnelOptions, type index_FunnelStage as FunnelStage, type index_ScoredItem as ScoredItem, type index_ScorerOptions as ScorerOptions, type index_StepRef as StepRef, index_budgetGate as budgetGate, index_effectivenessTracker as effectivenessTracker, index_feedback as feedback, index_funnel as funnel, index_scorer as scorer };
+}
+
+export { type BudgetConstraint as B, type EffectivenessEntry as E, type FeedbackOptions as F, type ScoredItem as S, type BudgetGateOptions as a, type EffectivenessSnapshot as b, type EffectivenessTrackerBundle as c, type EffectivenessTrackerOptions as d, type FunnelOptions as e, type FunnelStage as f, type ScorerOptions as g, type StepRef as h, index as i, budgetGate as j, effectivenessTracker as k, feedback as l, funnel as m, scorer as s };