@graphrefly/graphrefly 0.8.0 → 0.10.0

package/dist/index.d.ts

@@ -1329,6 +1329,220 @@ declare namespace demoShell$1 {
   export { type demoShell$1_DemoShellHandle as DemoShellHandle, type demoShell$1_DemoShellOptions as DemoShellOptions, type demoShell$1_FullscreenPane as FullscreenPane, type demoShell$1_GraphLabelSize as GraphLabelSize, type demoShell$1_HighlightCallbacks as HighlightCallbacks, type demoShell$1_HoverPaneType as HoverPaneType, type demoShell$1_HoverTarget as HoverTarget, type demoShell$1_NodeRegistry as NodeRegistry, demoShell$1_demoShell as demoShell };
 }
 
+/**
+ * LLM graph composition (roadmap §8.3).
+ *
+ * Declarative GraphSpec schema + compiler/decompiler for graph topology.
+ * The LLM designs graphs as JSON; compileSpec instantiates them; decompileGraph
+ * extracts them back. Templates support reusable subgraph patterns. Feedback
+ * edges express bounded cycles via §8.1 feedback().
+ *
+ * @module
+ */
+
+/** A single node declaration in a GraphSpec. */
+type GraphSpecNode = {
+    /** Node kind: state, producer, derived, effect, operator. */
+    type: "state" | "producer" | "derived" | "effect" | "operator";
+    /** Dependency node names (for derived/effect/operator). */
+    deps?: string[];
+    /** Named function from the catalog (for derived/effect/operator/producer). */
+    fn?: string;
+    /** Named source from the catalog (for producer). */
+    source?: string;
+    /** Freeform config passed to the catalog fn/source factory. */
+    config?: Record<string, unknown>;
+    /** Initial value (for state nodes). */
+    initial?: unknown;
+    /** Human/LLM-readable metadata. */
+    meta?: Record<string, unknown>;
+};
+/** Template instantiation node — expanded at compile time. */
+type GraphSpecTemplateRef = {
+    type: "template";
+    /** Name of the template to instantiate. */
+    template: string;
+    /** Parameter bindings: template param name → node name. */
+    bind: Record<string, string>;
+};
+/** A reusable subgraph pattern with parameter substitution. */
+type GraphSpecTemplate = {
+    /** Parameter names (prefixed with $ in node refs). */
+    params: string[];
+    /** Node declarations within the template. */
+    nodes: Record<string, GraphSpecNode>;
+    /** Which node's output is the template's output. */
+    output: string;
+};
+/** A feedback edge: bounded cycle from condition to reentry. */
+type GraphSpecFeedbackEdge = {
+    /** Node whose DATA triggers the feedback. */
+    from: string;
+    /** State node that receives the feedback value. */
+    to: string;
+    /** Max iterations before stopping (default: 10). */
+    maxIterations?: number;
+};
+/** Declarative graph topology for LLM composition (§8.3). */
+type GraphSpec = {
+    /** Graph name. */
+    name: string;
+    /** Node declarations (keyed by node name). */
+    nodes: Record<string, GraphSpecNode | GraphSpecTemplateRef>;
+    /** Reusable subgraph templates. */
+    templates?: Record<string, GraphSpecTemplate>;
+    /** Feedback edges (bounded cycles). */
+    feedback?: GraphSpecFeedbackEdge[];
+};
+/**
+ * Factory for creating a derived/effect/operator node from catalog.
+ * Receives resolved dep nodes and the config from the spec.
+ */
+type FnFactory = (deps: Node<unknown>[], config: Record<string, unknown>) => Node<unknown>;
+/**
+ * Factory for creating a producer node from catalog.
+ * Receives the config from the spec.
+ */
+type SourceFactory = (config: Record<string, unknown>) => Node<unknown>;
+/** Fn/source lookup table passed to compileSpec. */
+type GraphSpecCatalog = {
+    fns?: Record<string, FnFactory>;
+    sources?: Record<string, SourceFactory>;
+};
+/** Validation result from {@link validateSpec}. */
+type GraphSpecValidation = {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate a GraphSpec JSON object.
+ *
+ * Checks structural validity: required fields, node types, dep references,
+ * template references, feedback edge targets, self-cycles, and bind completeness.
+ */
+declare function validateSpec(spec: unknown): GraphSpecValidation;
+/** Options for {@link compileSpec}. */
+type CompileSpecOptions = {
+    /** Fn/source catalog for resolving named factories. */
+    catalog?: GraphSpecCatalog;
+};
+/**
+ * Instantiate a Graph from a GraphSpec.
+ *
+ * Handles template expansion (mounted subgraphs), feedback wiring via §8.1
+ * feedback(), node factory lookup from the catalog, and topology validation.
+ *
+ * @param spec - Declarative graph topology.
+ * @param opts - Catalog and compile options.
+ * @returns A running Graph.
+ * @throws On validation failure, missing catalog entries, or unresolvable deps.
+ *
+ * @category patterns
+ */
+declare function compileSpec(spec: GraphSpec, opts?: CompileSpecOptions): Graph;
+/**
+ * Extract a GraphSpec from a running graph.
+ *
+ * Uses `describe({ detail: "standard" })` as a starting point, then enriches:
+ * - Feedback edges recovered from counter node meta (`feedbackFrom`/`feedbackTo`)
+ * - Template refs recovered from output node meta (`_templateName`/`_templateBind`)
+ * - Structural fingerprinting as fallback for 2+ identical mounted subgraphs
+ *
+ * @param graph - Running graph to decompile.
+ * @returns A GraphSpec representation.
+ *
+ * @category patterns
+ */
+declare function decompileGraph(graph: Graph): GraphSpec;
+/** A single change in a spec diff. */
+type SpecDiffEntry = {
+    type: "added" | "removed" | "changed";
+    path: string;
+    detail?: string;
+};
+/** Structural diff between two GraphSpecs. */
+type SpecDiffResult = {
+    entries: SpecDiffEntry[];
+    summary: string;
+};
+/**
+ * Compute a structural diff between two GraphSpecs.
+ *
+ * Template-aware: reports "changed template definition" vs "changed
+ * instantiation bindings." No runtime needed — pure JSON comparison.
+ *
+ * @param specA - The "before" spec.
+ * @param specB - The "after" spec.
+ * @returns Diff entries and a human-readable summary.
+ *
+ * @category patterns
+ */
+declare function specDiff(specA: GraphSpec, specB: GraphSpec): SpecDiffResult;
+/** Options for {@link llmCompose}. */
+type LLMComposeOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Extra instructions appended to the system prompt. */
+    systemPromptExtra?: string;
+    /** Available fn/source catalog names for the LLM to reference. */
+    catalogDescription?: string;
+};
+/**
+ * Ask an LLM to compose a GraphSpec from a natural-language problem description.
+ *
+ * The LLM generates a GraphSpec (with templates + feedback), validated before
+ * returning. The spec is for human review before compilation via compileSpec().
+ *
+ * @param problem - Natural language problem description.
+ * @param adapter - LLM adapter for the generation call.
+ * @param opts - Model options and catalog description.
+ * @returns A validated GraphSpec.
+ * @throws On invalid LLM output or validation failure.
+ *
+ * @category patterns
+ */
+declare function llmCompose(problem: string, adapter: LLMAdapter, opts?: LLMComposeOptions): Promise<GraphSpec>;
+/** Options for {@link llmRefine}. */
+type LLMRefineOptions = LLMComposeOptions;
+/**
+ * Ask an LLM to modify an existing GraphSpec based on feedback or changed requirements.
+ *
+ * @param currentSpec - The current GraphSpec to modify.
+ * @param feedback - Natural language feedback or changed requirements.
+ * @param adapter - LLM adapter for the generation call.
+ * @param opts - Model options.
+ * @returns A new GraphSpec incorporating the feedback.
+ * @throws On invalid LLM output or validation failure.
+ *
+ * @category patterns
+ */
+declare function llmRefine(currentSpec: GraphSpec, feedback: string, adapter: LLMAdapter, opts?: LLMRefineOptions): Promise<GraphSpec>;
+
+type graphspec_CompileSpecOptions = CompileSpecOptions;
+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_llmCompose: typeof llmCompose;
+declare const graphspec_llmRefine: typeof llmRefine;
+declare const graphspec_specDiff: typeof specDiff;
+declare const graphspec_validateSpec: typeof validateSpec;
+declare namespace graphspec {
+  export { type graphspec_CompileSpecOptions as CompileSpecOptions, 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_llmCompose as llmCompose, graphspec_llmRefine as llmRefine, graphspec_specDiff as specDiff, graphspec_validateSpec as validateSpec };
+}
+
 /**
  * Messaging patterns (roadmap §4.2).
  *
@@ -1490,13 +1704,13 @@ declare namespace messaging {
  * Phase 2 operator names (for example `gate`, `forEach`).
  */
 
-type StepRef = string | Node<unknown>;
+type StepRef$1 = string | Node<unknown>;
 type OrchestrationMeta = {
     orchestration?: true;
     orchestration_type?: string;
 };
 type OrchestrationStepOptions = Omit<NodeOptions, "describeKind" | "name" | "meta"> & {
-    deps?: ReadonlyArray<StepRef>;
+    deps?: ReadonlyArray<StepRef$1>;
     meta?: Record<string, unknown> & OrchestrationMeta;
 };
 type BranchResult<T> = {
@@ -1510,7 +1724,7 @@ type SensorControls<T> = {
     complete(): void;
 };
 type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
-    iterations?: number | StepRef;
+    iterations?: number | StepRef$1;
 };
 type WaitOptions = Omit<OrchestrationStepOptions, "deps">;
 type SubPipelineBuilder = (sub: Graph) => void;
@@ -1525,32 +1739,32 @@ declare function task<T>(graph: Graph, name: string, run: NodeFn<T>, opts?: Orch
 /**
  * Emits tagged branch outcomes (`then` / `else`) for each source value.
  */
-declare function branch<T>(graph: Graph, name: string, source: StepRef, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
+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 gate<T>(graph: Graph, name: string, source: StepRef, control: StepRef, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+declare function gate<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, approver: StepRef, opts?: ApprovalOptions): Node<T>;
+declare function approval<T>(graph: Graph, name: string, source: StepRef$1, approver: StepRef$1, opts?: ApprovalOptions): Node<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, run: (value: T, actions: NodeActions) => void, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+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;
+    [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, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
+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.
  */
@@ -1564,18 +1778,17 @@ declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<
 /**
  * Registers a delayed-forwarding step (value-level wait).
  */
-declare function wait<T>(graph: Graph, name: string, source: StepRef, ms: number, opts?: WaitOptions): Node<T>;
+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, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+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_LoopOptions = LoopOptions;
 type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
 type orchestration_SensorControls<T> = SensorControls<T>;
-type orchestration_StepRef = StepRef;
 type orchestration_SubPipelineBuilder = SubPipelineBuilder;
 type orchestration_WaitOptions = WaitOptions;
 declare const orchestration_approval: typeof approval;
@@ -1591,7 +1804,182 @@ declare const orchestration_subPipeline: typeof subPipeline;
 declare const orchestration_task: typeof task;
 declare const orchestration_wait: typeof wait;
 declare namespace orchestration {
-  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type orchestration_StepRef 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_wait as wait };
+  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, 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_wait as wait };
+}
+
+/**
+ * Reduction primitives (roadmap §8.1).
+ *
+ * Composable building blocks for taking heterogeneous massive inputs and producing
+ * prioritized, auditable, human-actionable output. Each primitive is either a Graph
+ * factory or a Node factory, built on top of core + extra primitives.
+ *
+ * @module
+ */
+
+type StepRef = string | Node<unknown>;
+/** A single routing rule for {@link stratify}. */
+type StratifyRule<T> = {
+    /** Branch name (used as node name under `branch/<name>`). */
+    name: string;
+    /** Classifier: returns `true` if the value belongs to this branch. */
+    classify: (value: T) => boolean;
+    /** Optional operator chain applied to the branch after classification. */
+    ops?: (n: Node<T>) => Node;
+};
+/** Options for {@link stratify}. */
+type StratifyOptions = GraphOptions & {
+    meta?: Record<string, unknown>;
+};
+/**
+ * Route input to different reduction branches based on classifier functions.
+ *
+ * Each branch gets an independent operator chain. Rules are reactive — update
+ * the `"rules"` state node to rewrite classification at runtime. Rule updates
+ * affect **future items only** (streaming classification, not retroactive).
+ *
+ * Branch nodes are structural — created at construction time and persist for
+ * the graph's lifetime. If a rule name is removed from the rules array, the
+ * corresponding branch silently drops items (classifier not found). To tear
+ * down a dead branch, call `graph.remove("branch/<name>")`.
+ *
+ * @param name - Graph name.
+ * @param source - Input node (registered externally or will be added as `"source"`).
+ * @param rules - Initial routing rules.
+ * @param opts - Optional graph/meta options.
+ * @returns Graph with `"source"`, `"rules"`, and `"branch/<name>"` nodes.
+ *
+ * @category patterns
+ */
+declare function stratify<T>(name: string, source: Node<T>, rules: ReadonlyArray<StratifyRule<T>>, opts?: StratifyOptions): Graph;
+/** A named stage for {@link funnel}. */
+type FunnelStage = {
+    /** Stage name (mounted as subgraph). */
+    name: string;
+    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
+    build: (sub: Graph) => void;
+};
+/** Options for {@link funnel}. */
+type FunnelOptions = GraphOptions & {
+    meta?: Record<string, unknown>;
+};
+/**
+ * Multi-source merge with sequential reduction stages.
+ *
+ * Sources are merged into a single stream. Each stage is a named subgraph
+ * (mounted via `graph.mount()`). Stages connect linearly:
+ * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
+ *
+ * @param name - Graph name.
+ * @param sources - Input nodes to merge.
+ * @param stages - Sequential reduction stages.
+ * @param opts - Optional graph/meta options.
+ * @returns Graph with `"merged"` and mounted stage subgraphs.
+ *
+ * @category patterns
+ */
+declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
+/** Options for {@link feedback}. */
+type FeedbackOptions = {
+    /** Maximum feedback iterations before stopping (default: 10). */
+    maxIterations?: number;
+    /** Optional budget gate node path for cost-bounded iteration. */
+    budgetNode?: StepRef;
+    meta?: Record<string, unknown>;
+};
+/**
+ * Introduce a bounded reactive cycle into an existing graph.
+ *
+ * When `condition` emits a non-null DATA value, the feedback effect routes it
+ * back to the `reentry` state node — creating a cycle. Bounded by
+ * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
+ * is the source of truth — reset it to 0 to allow more iterations.
+ *
+ * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
+ *
+ * @param graph - Existing graph to augment with a feedback cycle.
+ * @param condition - Path to a node whose DATA triggers feedback.
+ * @param reentry - Path to a state node that receives the feedback value.
+ * @param opts - Iteration bounds and metadata.
+ * @returns The same graph (mutated with feedback nodes added).
+ *
+ * @category patterns
+ */
+declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
+/** A reactive constraint for {@link budgetGate}. */
+type BudgetConstraint<T = unknown> = {
+    /** Constraint node whose value is checked. */
+    node: Node<T>;
+    /** Returns `true` when the constraint is satisfied (budget available). */
+    check: (value: T) => boolean;
+};
+/** Options for {@link budgetGate}. */
+type BudgetGateOptions = Omit<NodeOptions, "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, "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[]>>;
+
+type reduction_BudgetConstraint<T = unknown> = BudgetConstraint<T>;
+type reduction_BudgetGateOptions = BudgetGateOptions;
+type reduction_FeedbackOptions = FeedbackOptions;
+type reduction_FunnelOptions = FunnelOptions;
+type reduction_FunnelStage = FunnelStage;
+type reduction_ScoredItem<T = unknown> = ScoredItem<T>;
+type reduction_ScorerOptions = ScorerOptions;
+type reduction_StepRef = StepRef;
+type reduction_StratifyOptions = StratifyOptions;
+type reduction_StratifyRule<T> = StratifyRule<T>;
+declare const reduction_budgetGate: typeof budgetGate;
+declare const reduction_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 };
 }
 
 /**
@@ -1600,11 +1988,13 @@ declare namespace orchestration {
 
 declare const index_ai: typeof ai;
 declare const index_cqrs: typeof cqrs;
+declare const index_graphspec: typeof graphspec;
 declare const index_memory: typeof memory;
 declare const index_messaging: typeof messaging;
 declare const index_orchestration: typeof orchestration;
+declare const index_reduction: typeof reduction;
 declare namespace index {
-  export { index_ai as ai, index_cqrs as cqrs, demoShell$1 as demoShell, index$b as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration };
+  export { index_ai as ai, index_cqrs as cqrs, demoShell$1 as demoShell, index_graphspec as graphspec, index$b as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration, index_reduction as reduction };
 }
 
 /**
@@ -1612,4 +2002,4 @@ declare namespace index {
  */
 declare const version = "0.0.0";
 
-export { Actor, AutoCheckpointAdapter, DistillBundle, Extraction, Graph, GraphAutoCheckpointHandle, GraphAutoCheckpointOptions, GraphOptions, Node, NodeActions, NodeFn, NodeInput, NodeOptions, ReactiveListSnapshot, ReactiveLogSnapshot, ReactiveMapSnapshot, ai, index$1 as compat, cqrs, demoShell$1 as demoShell, index$9 as jotai, index$b as layout, memory, messaging, index$8 as nanostores, index$a as nestjs, orchestration, index as patterns, index$7 as react, index$6 as signals, index$5 as solid, index$4 as svelte, version, index$3 as vue, index$2 as zustand };
+export { Actor, AutoCheckpointAdapter, DistillBundle, Extraction, Graph, GraphAutoCheckpointHandle, GraphAutoCheckpointOptions, GraphOptions, Node, NodeActions, NodeFn, NodeInput, NodeOptions, ReactiveListSnapshot, ReactiveLogSnapshot, ReactiveMapSnapshot, ai, index$1 as compat, cqrs, demoShell$1 as demoShell, graphspec, index$9 as jotai, index$b as layout, memory, messaging, index$8 as nanostores, index$a as nestjs, orchestration, index as patterns, index$7 as react, reduction, index$6 as signals, index$5 as solid, index$4 as svelte, version, index$3 as vue, index$2 as zustand };