@graphrefly/graphrefly 0.26.0 → 0.28.0

package/dist/index-Czq6ynh8.d.ts

@@ -0,0 +1,143 @@
+import { a as Node, N as NodeOptions, c as NodeActions } from './node-Cc1TniY8.js';
+import { D as DerivedFn } from './sugar-Dtyrq2_q.js';
+import { G as Graph, a as GraphOptions } from './graph-BZGRXwOm.js';
+
+/**
+ * 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 = string | Node<unknown>;
+type OrchestrationMeta = {
+    orchestration?: true;
+    orchestration_type?: string;
+};
+type OrchestrationStepOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    deps?: ReadonlyArray<StepRef>;
+    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;
+};
+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: DerivedFn<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, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<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>;
+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, opts?: GateOptions): GateController<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;
+}, 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>;
+/**
+ * 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<unknown>, "name" | "describeKind" | "meta"> & {
+    meta?: Record<string, unknown>;
+}): SensorControls<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>;
+
+type index_ApprovalOptions = ApprovalOptions;
+type index_BranchResult<T> = BranchResult<T>;
+type index_GateController<T> = GateController<T>;
+type index_GateOptions = GateOptions;
+type index_LoopOptions = LoopOptions;
+type index_OrchestrationStepOptions = OrchestrationStepOptions;
+type index_SensorControls<T> = SensorControls<T>;
+type index_StepRef = StepRef;
+type index_SubPipelineBuilder = SubPipelineBuilder;
+declare const index_approval: typeof approval;
+declare const index_branch: typeof branch;
+declare const index_gate: typeof gate;
+declare const index_join: typeof join;
+declare const index_loop: typeof loop;
+declare const index_onFailure: typeof onFailure;
+declare const index_pipeline: typeof pipeline;
+declare const index_sensor: typeof sensor;
+declare const index_subPipeline: typeof subPipeline;
+declare const index_task: typeof task;
+declare namespace index {
+  export { type index_ApprovalOptions as ApprovalOptions, type index_BranchResult as BranchResult, type index_GateController as GateController, type index_GateOptions as GateOptions, type index_LoopOptions as LoopOptions, type index_OrchestrationStepOptions as OrchestrationStepOptions, type index_SensorControls as SensorControls, type index_StepRef as StepRef, type index_SubPipelineBuilder as SubPipelineBuilder, index_approval as approval, index_branch as branch, index_gate as gate, index_join as join, index_loop as loop, index_onFailure as onFailure, index_pipeline as pipeline, index_sensor as sensor, index_subPipeline as subPipeline, index_task as task };
+}
+
+export { type ApprovalOptions as A, type BranchResult as B, type GateController as G, type LoopOptions as L, type OrchestrationStepOptions as O, type SensorControls as S, type GateOptions as a, type StepRef as b, type SubPipelineBuilder as c, approval as d, branch as e, subPipeline as f, gate as g, index as i, join as j, loop as l, onFailure as o, pipeline as p, sensor as s, task as t };

package/dist/index-D-YB-Vl3.d.ts

@@ -0,0 +1,195 @@
+import { b as Messages, A as Actor, C as COMPLETE, f as COMPLETE_MSG, g as COMPLETE_ONLY_BATCH, D as DATA, h as DEFAULT_ACTOR, i as DIRTY, j as DIRTY_MSG, k as DIRTY_ONLY_BATCH, l as DepRecord, E as ERROR, F as FnCtx, m as GlobalInspectorEvent, n as GlobalInspectorHook, o as GraphReFlyConfig, G as GuardAction, p as GuardDenied, q as GuardDeniedDetails, H as HashFn, I as INVALIDATE, r as INVALIDATE_MSG, s as INVALIDATE_ONLY_BATCH, M as Message, t as MessageContext, u as MessageTypeRegistration, v as MessageTypeRegistrationInput, a as Node, c as NodeActions, w as NodeCtx, e as NodeDescribeKind, x as NodeFn, d as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, N as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, W as PolicyDeny, P as PolicyRuleData, X as RESOLVED, Y as RESOLVED_MSG, Z as RESOLVED_ONLY_BATCH, _ as RESUME, $ as START, a0 as START_MSG, a1 as SubscribeContext, a2 as TEARDOWN, a3 as TEARDOWN_MSG, a4 as TEARDOWN_ONLY_BATCH, a5 as V0, a6 as V1, V as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-Cc1TniY8.js';
+import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CwesDrMD.js';
+import { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-Dtyrq2_q.js';
+
+/**
+ * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside
+ * explicit `batch()` scopes.
+ *
+ * **Canonical invariant:** GRAPHREFLY-SPEC.md §1.3.7 — inside a batch,
+ * tier 0–2 signals propagate immediately; tier 3 (DATA/RESOLVED), tier 4
+ * (COMPLETE/ERROR), and tier 5 (TEARDOWN) are queued and drained in ascending
+ * phase order after the outermost `batch()` callback returns.
+ *
+ * **Per-node emit coalescing (Bug 2 fix, 2026-04-17).** Inside an explicit
+ * `batch()` scope, consecutive emissions from the same node accumulate in
+ * `NodeImpl._batchPendingMessages` (see JSDoc there) instead of each producing
+ * a separate downstream wave. K `.emit()` calls to the same source collapse to
+ * one coalesced `downWithBatch` call per child edge at batch end. Outside batch
+ * (or during drain), coalescing does NOT apply — each emit produces its own wave.
+ *
+ * **Phase vocabulary:**
+ * - Phase 1 = tiers 0–2 — immediate, never queued.
+ * - Phase 2 = tier 3 — {@link drainPhase2}. Value settlements.
+ * - Phase 3 = tier 4 — {@link drainPhase3}. Terminal signals.
+ * - Phase 4 = tier 5 — {@link drainPhase4}. TEARDOWN (unified deferral).
+ *
+ * Drain rule: fire any pending flush hooks first, then the lowest non-empty
+ * phase. Re-enqueues during drain (and hooks registered by reentrant batches
+ * inside subscriber callbacks) bump the loop back to the top so newly-added
+ * hooks and closures get processed.
+ */
+
+/**
+ * Returns whether the current call stack is inside a batch scope **or** while
+ * a deferred drain is in progress. Nested `downWithBatch` calls during drain
+ * still defer (they bump the drain loop).
+ */
+declare function isBatching(): boolean;
+/**
+ * Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral
+ * queue. If `fn` throws, deferred work for the outer frame is discarded
+ * (unless a drain is already in progress — cross-language decision A4).
+ */
+declare function batch(fn: () => void): void;
+/**
+ * Deliver pre-sorted messages through `sink` with tier-based deferral applied.
+ *
+ * `messages` MUST be in ascending tier order (produced by `_frameBatch` in
+ * `node.ts`); the walker exploits that invariant to find phase cuts in one
+ * pass without re-sorting.
+ *
+ * Behavior:
+ * - Tier 0–2 — delivered synchronously.
+ * - Tier 3 — deferred to {@link drainPhase2} when batching, else synchronous.
+ * - Tier 4 — deferred to {@link drainPhase3} when batching, else synchronous.
+ * - Tier 5 — deferred to {@link drainPhase4} when batching, else synchronous.
+ *
+ * Tier-classification uses the caller-supplied `tierOf` so that batch stays
+ * decoupled from `GraphReFlyConfig`. NodeImpl passes `config.tierOf` (a
+ * pre-bound closure built once in the config constructor) at the emit site;
+ * alternate configs can pass their own lookup.
+ */
+declare function downWithBatch(sink: (messages: Messages) => void, messages: Messages, tierOf: (t: symbol) => number): void;
+
+/**
+ * Centralised timestamp utilities.
+ *
+ * Convention: all graphrefly-ts timestamps use nanoseconds (`_ns` suffix).
+ *
+ * - {@link monotonicNs} — monotonic clock (ordering, durations, timeline events).
+ * - {@link wallClockNs} — wall-clock (mutation attribution, cron emission).
+ *
+ * **Precision limits (JS platform):**
+ *
+ * - `monotonicNs`: effective ~microsecond precision. `performance.now()` returns
+ *   milliseconds with ~5µs resolution; the last 3 digits of the nanosecond value
+ *   are always zero. Python's `time.monotonic_ns()` gives true nanoseconds.
+ *
+ * - `wallClockNs`: ~256ns precision loss at current epoch. `Date.now() * 1e6`
+ *   produces values around 1.8×10¹⁸ which exceed IEEE 754's 2⁵³ safe integer
+ *   limit. Python's `time.time_ns()` (arbitrary-precision `int`) has no loss.
+ *   In practice this is irrelevant — JS is single-threaded, so sub-microsecond
+ *   timestamp collisions cannot occur.
+ */
+/** Monotonic nanosecond timestamp via `performance.now()`. */
+declare function monotonicNs(): number;
+/** Wall-clock nanosecond timestamp via `Date.now()`. */
+declare function wallClockNs(): number;
+
+/**
+ * Core layer: message protocol, node primitive, lifecycle (Phase 0).
+ */
+
+declare const index_Actor: typeof Actor;
+declare const index_AutoTrackOptions: typeof AutoTrackOptions;
+declare const index_COMPLETE: typeof COMPLETE;
+declare const index_COMPLETE_MSG: typeof COMPLETE_MSG;
+declare const index_COMPLETE_ONLY_BATCH: typeof COMPLETE_ONLY_BATCH;
+declare const index_DATA: typeof DATA;
+declare const index_DEFAULT_ACTOR: typeof DEFAULT_ACTOR;
+declare const index_DIRTY: typeof DIRTY;
+declare const index_DIRTY_MSG: typeof DIRTY_MSG;
+declare const index_DIRTY_ONLY_BATCH: typeof DIRTY_ONLY_BATCH;
+declare const index_DepRecord: typeof DepRecord;
+declare const index_DerivedFn: typeof DerivedFn;
+declare const index_DescribeDetail: typeof DescribeDetail;
+declare const index_DescribeField: typeof DescribeField;
+declare const index_DescribeNodeOutput: typeof DescribeNodeOutput;
+declare const index_DynamicFn: typeof DynamicFn;
+declare const index_ERROR: typeof ERROR;
+declare const index_EffectFn: typeof EffectFn;
+declare const index_FnCtx: typeof FnCtx;
+declare const index_GlobalInspectorEvent: typeof GlobalInspectorEvent;
+declare const index_GlobalInspectorHook: typeof GlobalInspectorHook;
+declare const index_GraphReFlyConfig: typeof GraphReFlyConfig;
+declare const index_GuardAction: typeof GuardAction;
+declare const index_GuardDenied: typeof GuardDenied;
+declare const index_GuardDeniedDetails: typeof GuardDeniedDetails;
+declare const index_HashFn: typeof HashFn;
+declare const index_INVALIDATE: typeof INVALIDATE;
+declare const index_INVALIDATE_MSG: typeof INVALIDATE_MSG;
+declare const index_INVALIDATE_ONLY_BATCH: typeof INVALIDATE_ONLY_BATCH;
+declare const index_Message: typeof Message;
+declare const index_MessageContext: typeof MessageContext;
+declare const index_MessageTypeRegistration: typeof MessageTypeRegistration;
+declare const index_MessageTypeRegistrationInput: typeof MessageTypeRegistrationInput;
+declare const index_Messages: typeof Messages;
+declare const index_Node: typeof Node;
+declare const index_NodeActions: typeof NodeActions;
+declare const index_NodeCtx: typeof NodeCtx;
+declare const index_NodeDescribeKind: typeof NodeDescribeKind;
+declare const index_NodeFn: typeof NodeFn;
+declare const index_NodeFnCleanup: typeof NodeFnCleanup;
+declare const index_NodeGuard: typeof NodeGuard;
+declare const index_NodeImpl: typeof NodeImpl;
+declare const index_NodeInspectorHook: typeof NodeInspectorHook;
+declare const index_NodeInspectorHookEvent: typeof NodeInspectorHookEvent;
+declare const index_NodeOptions: typeof NodeOptions;
+declare const index_NodeSink: typeof NodeSink;
+declare const index_NodeStatus: typeof NodeStatus;
+declare const index_NodeTransportOptions: typeof NodeTransportOptions;
+declare const index_NodeVersionInfo: typeof NodeVersionInfo;
+declare const index_OnMessageHandler: typeof OnMessageHandler;
+declare const index_OnSubscribeHandler: typeof OnSubscribeHandler;
+declare const index_PAUSE: typeof PAUSE;
+declare const index_PipeOperator: typeof PipeOperator;
+declare const index_PolicyAllow: typeof PolicyAllow;
+declare const index_PolicyDeny: typeof PolicyDeny;
+declare const index_PolicyRuleData: typeof PolicyRuleData;
+declare const index_ProducerFn: typeof ProducerFn;
+declare const index_RESOLVED: typeof RESOLVED;
+declare const index_RESOLVED_MSG: typeof RESOLVED_MSG;
+declare const index_RESOLVED_ONLY_BATCH: typeof RESOLVED_ONLY_BATCH;
+declare const index_RESUME: typeof RESUME;
+declare const index_START: typeof START;
+declare const index_START_MSG: typeof START_MSG;
+declare const index_SubscribeContext: typeof SubscribeContext;
+declare const index_TEARDOWN: typeof TEARDOWN;
+declare const index_TEARDOWN_MSG: typeof TEARDOWN_MSG;
+declare const index_TEARDOWN_ONLY_BATCH: typeof TEARDOWN_ONLY_BATCH;
+declare const index_TrackFn: typeof TrackFn;
+declare const index_V0: typeof V0;
+declare const index_V1: typeof V1;
+declare const index_VersioningLevel: typeof VersioningLevel;
+declare const index_VersioningOptions: typeof VersioningOptions;
+declare const index_accessHintForGuard: typeof accessHintForGuard;
+declare const index_advanceVersion: typeof advanceVersion;
+declare const index_autoTrackNode: typeof autoTrackNode;
+declare const index_batch: typeof batch;
+declare const index_configure: typeof configure;
+declare const index_createVersioning: typeof createVersioning;
+declare const index_defaultConfig: typeof defaultConfig;
+declare const index_defaultHash: typeof defaultHash;
+declare const index_derived: typeof derived;
+declare const index_downWithBatch: typeof downWithBatch;
+declare const index_dynamicNode: typeof dynamicNode;
+declare const index_effect: typeof effect;
+declare const index_isBatching: typeof isBatching;
+declare const index_isV1: typeof isV1;
+declare const index_monotonicNs: typeof monotonicNs;
+declare const index_node: typeof node;
+declare const index_normalizeActor: typeof normalizeActor;
+declare const index_pipe: typeof pipe;
+declare const index_policy: typeof policy;
+declare const index_policyFromRules: typeof policyFromRules;
+declare const index_producer: typeof producer;
+declare const index_registerBuiltins: typeof registerBuiltins;
+declare const index_resolveDescribeFields: typeof resolveDescribeFields;
+declare const index_state: typeof state;
+declare const index_wallClockNs: typeof wallClockNs;
+declare namespace index {
+  export { index_Actor as Actor, index_AutoTrackOptions as AutoTrackOptions, index_COMPLETE as COMPLETE, index_COMPLETE_MSG as COMPLETE_MSG, index_COMPLETE_ONLY_BATCH as COMPLETE_ONLY_BATCH, index_DATA as DATA, index_DEFAULT_ACTOR as DEFAULT_ACTOR, index_DIRTY as DIRTY, index_DIRTY_MSG as DIRTY_MSG, index_DIRTY_ONLY_BATCH as DIRTY_ONLY_BATCH, index_DepRecord as DepRecord, index_DerivedFn as DerivedFn, index_DescribeDetail as DescribeDetail, index_DescribeField as DescribeField, index_DescribeNodeOutput as DescribeNodeOutput, index_DynamicFn as DynamicFn, index_ERROR as ERROR, index_EffectFn as EffectFn, index_FnCtx as FnCtx, index_GlobalInspectorEvent as GlobalInspectorEvent, index_GlobalInspectorHook as GlobalInspectorHook, index_GraphReFlyConfig as GraphReFlyConfig, index_GuardAction as GuardAction, index_GuardDenied as GuardDenied, index_GuardDeniedDetails as GuardDeniedDetails, index_HashFn as HashFn, index_INVALIDATE as INVALIDATE, index_INVALIDATE_MSG as INVALIDATE_MSG, index_INVALIDATE_ONLY_BATCH as INVALIDATE_ONLY_BATCH, index_Message as Message, index_MessageContext as MessageContext, index_MessageTypeRegistration as MessageTypeRegistration, index_MessageTypeRegistrationInput as MessageTypeRegistrationInput, index_Messages as Messages, index_Node as Node, index_NodeActions as NodeActions, index_NodeCtx as NodeCtx, index_NodeDescribeKind as NodeDescribeKind, index_NodeFn as NodeFn, index_NodeFnCleanup as NodeFnCleanup, index_NodeGuard as NodeGuard, index_NodeImpl as NodeImpl, index_NodeInspectorHook as NodeInspectorHook, index_NodeInspectorHookEvent as NodeInspectorHookEvent, index_NodeOptions as NodeOptions, index_NodeSink as NodeSink, index_NodeStatus as NodeStatus, index_NodeTransportOptions as NodeTransportOptions, index_NodeVersionInfo as NodeVersionInfo, index_OnMessageHandler as OnMessageHandler, index_OnSubscribeHandler as OnSubscribeHandler, index_PAUSE as PAUSE, index_PipeOperator as PipeOperator, index_PolicyAllow as PolicyAllow, index_PolicyDeny as PolicyDeny, index_PolicyRuleData as PolicyRuleData, index_ProducerFn as ProducerFn, index_RESOLVED as RESOLVED, index_RESOLVED_MSG as RESOLVED_MSG, index_RESOLVED_ONLY_BATCH as RESOLVED_ONLY_BATCH, index_RESUME as RESUME, index_START as START, index_START_MSG as START_MSG, index_SubscribeContext as SubscribeContext, index_TEARDOWN as TEARDOWN, index_TEARDOWN_MSG as TEARDOWN_MSG, index_TEARDOWN_ONLY_BATCH as TEARDOWN_ONLY_BATCH, index_TrackFn as TrackFn, index_V0 as V0, index_V1 as V1, index_VersioningLevel as VersioningLevel, index_VersioningOptions as VersioningOptions, index_accessHintForGuard as accessHintForGuard, index_advanceVersion as advanceVersion, index_autoTrackNode as autoTrackNode, index_batch as batch, index_configure as configure, index_createVersioning as createVersioning, index_defaultConfig as defaultConfig, index_defaultHash as defaultHash, index_derived as derived, index_downWithBatch as downWithBatch, index_dynamicNode as dynamicNode, index_effect as effect, index_isBatching as isBatching, index_isV1 as isV1, index_monotonicNs as monotonicNs, index_node as node, index_normalizeActor as normalizeActor, index_pipe as pipe, index_policy as policy, index_policyFromRules as policyFromRules, index_producer as producer, index_registerBuiltins as registerBuiltins, index_resolveDescribeFields as resolveDescribeFields, index_state as state, index_wallClockNs as wallClockNs };
+}
+
+export { isBatching as a, batch as b, downWithBatch as d, index as i, monotonicNs as m, wallClockNs as w };

package/dist/index-DAlweici.d.ts

@@ -0,0 +1,231 @@
+import { a as Node } from './node-Cc1TniY8.js';
+import { a as GraphOptions, G as Graph } from './graph-BZGRXwOm.js';
+
+/**
+ * Domain templates (roadmap §8.2).
+ *
+ * Opinionated Graph factories for common "info → action" domains.
+ * Each template wires up §8.1 reduction primitives (stratify, funnel, feedback,
+ * budgetGate, scorer) with domain-specific stages. Users fork/extend by
+ * accessing named nodes and swapping stages.
+ *
+ * **Source injection (option B):** templates accept a `source` node, not a
+ * hardcoded adapter. Pass `fromOTel(...)`, `fromGitHook(...)`, or a test
+ * `state()` — the topology is the same.
+ *
+ * @module
+ */
+
+/** Stratification branch config for observability signals. */
+type ObservabilityBranch = {
+    name: string;
+    classify: (value: unknown) => boolean;
+};
+/** Options for {@link observabilityGraph}. */
+type ObservabilityGraphOptions = GraphOptions & {
+    /** Ingested signal source (e.g. fromOTel(...) or test state). */
+    source: Node<unknown>;
+    /**
+     * Classification rules for signal stratification.
+     * Default: errors / traces / metrics branches.
+     */
+    branches?: ObservabilityBranch[];
+    /**
+     * Correlation function: receives stratified branch values and produces
+     * correlated insights. Default: identity pass-through.
+     */
+    correlate?: (values: unknown[]) => unknown;
+    /**
+     * SLO verification function: returns a verification result for a
+     * correlated insight. Default: always passes.
+     */
+    sloCheck?: (value: unknown) => unknown;
+    /**
+     * Scorer weights for alert prioritization. One per branch.
+     * Default: equal weights [1, 1, 1].
+     */
+    weights?: number[];
+    /** Max feedback iterations for false-positive learning. Default: 5. */
+    maxFeedbackIterations?: number;
+};
+/**
+ * OTel ingest → stratified reduction → correlation → SLO verification →
+ * alert prioritization → output.
+ *
+ * Well-known node names:
+ * - `"source"` — injected signal source
+ * - `"stratify::branch/<name>"` — per-branch classification
+ * - `"correlate"` — cross-branch correlation
+ * - `"slo_value"`, `"slo_verified"` — SLO verification pair
+ * - `"alerts"` — scored, prioritized output
+ * - `"output"` — final output (alias for alerts)
+ *
+ * @category patterns
+ */
+declare function observabilityGraph(name: string, opts: ObservabilityGraphOptions): Graph;
+/** A structured issue extracted from raw findings. */
+type ExtractedIssue = {
+    id: string;
+    title: string;
+    severity: number;
+    source: string;
+    raw: unknown;
+};
+/** Options for {@link issueTrackerGraph}. */
+type IssueTrackerGraphOptions = GraphOptions & {
+    /** Findings source (e.g. fromGitHook(...), fromFSWatch(...)). */
+    source: Node<unknown>;
+    /**
+     * Extract structured issues from raw findings.
+     * Default: wraps raw value as a single issue.
+     */
+    extract?: (raw: unknown) => ExtractedIssue;
+    /**
+     * Verify an extracted issue (assertion check).
+     * Default: always valid.
+     */
+    verify?: (issue: ExtractedIssue) => unknown;
+    /**
+     * Detect regression by comparing against known patterns.
+     * Receives (current issue, known patterns).
+     * Default: no regression detected.
+     */
+    detectRegression?: (issue: ExtractedIssue, known: unknown) => unknown;
+    /** Max feedback iterations for re-scanning. Default: 3. */
+    maxFeedbackIterations?: number;
+};
+/**
+ * Findings ingest → extraction → verification → regression detection →
+ * distillation → prioritized queue.
+ *
+ * Well-known node names:
+ * - `"source"` — injected findings source
+ * - `"extract"` — structured issue extraction
+ * - `"verify"` — issue verification
+ * - `"known_patterns"` — accumulated known issue patterns (state)
+ * - `"regression"` — regression detection
+ * - `"priority"` — severity-based prioritization
+ * - `"output"` — final prioritized output
+ *
+ * @category patterns
+ */
+declare function issueTrackerGraph(name: string, opts: IssueTrackerGraphOptions): Graph;
+/** Classification result from LLM moderation. */
+type ModerationResult = {
+    label: "safe" | "review" | "block";
+    confidence: number;
+    reason?: string;
+    original: unknown;
+};
+/** Options for {@link contentModerationGraph}. */
+type ContentModerationGraphOptions = GraphOptions & {
+    /** Content source (text/multimedia ingest). */
+    source: Node<unknown>;
+    /**
+     * Classification function: returns a ModerationResult.
+     * Default: labels everything "review" with confidence 0.5.
+     */
+    classify?: (content: unknown) => ModerationResult;
+    /** System prompt for LLM classification. */
+    systemPrompt?: string;
+    /** Scorer weights: [safe, review, block]. Default: [0.1, 1, 2]. */
+    weights?: [number, number, number];
+    /** Max feedback iterations for policy refinement. Default: 5. */
+    maxFeedbackIterations?: number;
+    /** Max review queue size. When set, oldest entries are trimmed on overflow. */
+    maxQueueSize?: number;
+};
+/**
+ * Content ingest → LLM/rule classification → stratified routing (safe/review/block) →
+ * human review queue → scorer → feedback (false positives → policy refinement) → output.
+ *
+ * Well-known node names:
+ * - `"source"` — content ingest
+ * - `"classify"` — LLM or rule-based classification
+ * - `"stratify::branch/safe"`, `"stratify::branch/review"`, `"stratify::branch/block"` — routed branches
+ * - `"review_queue"` — state node for human review items
+ * - `"priority"` — scored priority output
+ * - `"policy"` — writable state for policy refinement
+ * - `"output"` — final moderation output
+ *
+ * @category patterns
+ */
+declare function contentModerationGraph(name: string, opts: ContentModerationGraphOptions): Graph;
+/** Schema validation result. */
+type ValidationResult = {
+    valid: boolean;
+    errors: string[];
+    record: unknown;
+};
+/** Anomaly detection result. */
+type AnomalyResult = {
+    anomaly: boolean;
+    score: number;
+    detail?: string;
+    record: unknown;
+};
+/** Options for {@link dataQualityGraph}. */
+type DataQualityGraphOptions = GraphOptions & {
+    /** Data source (e.g. fromPrisma(...), fromKysely(...)). */
+    source: Node<unknown>;
+    /**
+     * Schema validation function.
+     * Default: always valid.
+     */
+    validate?: (record: unknown) => ValidationResult;
+    /**
+     * Anomaly detection function.
+     * Default: no anomaly.
+     */
+    detectAnomaly?: (record: unknown) => AnomalyResult;
+    /**
+     * Drift detection: compares current record against baseline.
+     * Default: no drift.
+     */
+    detectDrift?: (record: unknown, baseline: unknown) => unknown;
+    /**
+     * Remediation suggestion function.
+     * Default: no suggestion.
+     */
+    suggest?: (result: {
+        validation: ValidationResult;
+        anomaly: AnomalyResult;
+    }) => unknown;
+    /** Max feedback iterations for rule refinement. Default: 3. */
+    maxFeedbackIterations?: number;
+};
+/**
+ * Data ingest → schema validation → anomaly detection → drift alerting →
+ * auto-remediation suggestions → output.
+ *
+ * Well-known node names:
+ * - `"source"` — data ingest
+ * - `"validate"` — schema validation
+ * - `"anomaly"` — anomaly detection
+ * - `"baseline"` — rolling baseline state
+ * - `"drift"` — drift detection
+ * - `"remediate"` — auto-remediation suggestions
+ * - `"output"` — combined quality report
+ *
+ * @category patterns
+ */
+declare function dataQualityGraph(name: string, opts: DataQualityGraphOptions): Graph;
+
+type index_AnomalyResult = AnomalyResult;
+type index_ContentModerationGraphOptions = ContentModerationGraphOptions;
+type index_DataQualityGraphOptions = DataQualityGraphOptions;
+type index_ExtractedIssue = ExtractedIssue;
+type index_IssueTrackerGraphOptions = IssueTrackerGraphOptions;
+type index_ModerationResult = ModerationResult;
+type index_ObservabilityBranch = ObservabilityBranch;
+type index_ObservabilityGraphOptions = ObservabilityGraphOptions;
+type index_ValidationResult = ValidationResult;
+declare const index_contentModerationGraph: typeof contentModerationGraph;
+declare const index_dataQualityGraph: typeof dataQualityGraph;
+declare const index_issueTrackerGraph: typeof issueTrackerGraph;
+declare const index_observabilityGraph: typeof observabilityGraph;
+declare namespace index {
+  export { type index_AnomalyResult as AnomalyResult, type index_ContentModerationGraphOptions as ContentModerationGraphOptions, type index_DataQualityGraphOptions as DataQualityGraphOptions, type index_ExtractedIssue as ExtractedIssue, type index_IssueTrackerGraphOptions as IssueTrackerGraphOptions, type index_ModerationResult as ModerationResult, type index_ObservabilityBranch as ObservabilityBranch, type index_ObservabilityGraphOptions as ObservabilityGraphOptions, type index_ValidationResult as ValidationResult, index_contentModerationGraph as contentModerationGraph, index_dataQualityGraph as dataQualityGraph, index_issueTrackerGraph as issueTrackerGraph, index_observabilityGraph as observabilityGraph };
+}
+
+export { type AnomalyResult as A, type ContentModerationGraphOptions as C, type DataQualityGraphOptions as D, type ExtractedIssue as E, type IssueTrackerGraphOptions as I, type ModerationResult as M, type ObservabilityBranch as O, type ValidationResult as V, type ObservabilityGraphOptions as a, issueTrackerGraph as b, contentModerationGraph as c, dataQualityGraph as d, index as i, observabilityGraph as o };