@graphrefly/graphrefly 0.39.0 → 0.40.0

package/dist/index-D1Gc7wV5.d.ts

@@ -0,0 +1,230 @@
+import { f as factoryTag, p as placeholderArgs } from './meta-D8OyedKp.js';
+import { N as Node } from './node-BYInONRr.js';
+import { S as StatusValue, C as CircuitState, R as RateLimiterState, a as RateLimiterOptions, b as CircuitBreakerOptions, c as RetryOptions, F as FallbackInput, N as NS_PER_MS, d as NS_PER_SEC } from './index-BAQrjuZF.js';
+import { G as Graph, a as GraphOptions } from './graph-BkIkog4h.js';
+import { B as BudgetConstraint } from './budget-gate-CmmVtasH.js';
+
+/**
+ * Resilience composition with correct nesting order (roadmap §9.0b — Tier 5.2 Wave-B rebuild).
+ *
+ * {@link resilientPipeline} composes the resilience primitives from
+ * `extra/resilience/` in the canonical nesting order:
+ *
+ * ```text
+ *   rateLimit → budget → breaker → timeout → retry → fallback → status
+ * ```
+ *
+ * Returns a {@link ResilientPipelineGraph} (Graph subclass) with mounted
+ * intermediate nodes and per-layer status companions, replacing the prior
+ * bundle return. Each intermediate is mounted under a stable name so
+ * `pipeline.describe()` shows the resilience chain in topology snapshots,
+ * mermaid renders, and `lens.health` aggregations.
+ *
+ * **Per-attempt timeout vs. retry ordering.** `timeout` is applied BEFORE
+ * `retry` so each retry attempt resubscribes to a fresh deadline (per-attempt
+ * semantics). If `timeout` wrapped `retry`, a single deadline would apply to
+ * the entire retry chain — not what callers expect.
+ *
+ * **`breakerOnOpen` + `retry` interaction.** With `breakerOnOpen: "error"` AND
+ * `retry`, retry sees `CircuitOpenError` and resubscribes; the next attempt
+ * very likely also breaker-open → another error → retry burns its budget
+ * against an open circuit. Either set retry's `backoff` long enough for the
+ * breaker reset window OR keep the default `breakerOnOpen: "skip"` (emits
+ * RESOLVED when open; downstream drops the beat without retry firing).
+ *
+ * **Reactive options (switchMap rebuild).** Every primitive option accepts a
+ * `T | Node<T>` (precedent-aligned with `FallbackInput<T>`). When the caller
+ * supplies a static value, the layer is built once at construction. When the
+ * caller supplies a `Node<T>`, the pipeline subscribes via `switchMap` and
+ * **rebuilds the layer on every option emission** — the chain stalls until
+ * the option Node emits its first DATA. Each rebuild creates a fresh
+ * primitive instance, so internal state is lost (rate-limiter pending buffer,
+ * breaker failure count, retry attempt count, in-flight timeout). Per-layer
+ * **companion Nodes** (`droppedCount`, `rateLimitState`, `breakerState`) are
+ * therefore exposed ONLY for the static-options path. Primitive-side widening
+ * (filed in `docs/optimizations.md` under "Tier 5.2 follow-up — primitive-side
+ * reactive-options widening") will preserve internal state once it lands and
+ * the pipeline will trivially forward Node-form options to the primitive.
+ *
+ * @module
+ */
+
+/**
+ * `T | Node<T>` for primitive options — precedent-aligned with
+ * {@link FallbackInput} and `policyGate.policies`. When the caller supplies a
+ * static value, the layer is built once at construction. When the caller
+ * supplies a `Node<T>`, the pipeline subscribes via {@link switchMap}: the
+ * layer is rebuilt on every option emission. **State-loss caveat:** each
+ * rebuild creates a fresh primitive instance — `rateLimiter` loses its pending
+ * buffer, `circuitBreaker` resets failure count, `retry` resets attempt
+ * count, `timeout` cancels in-flight deadline. This is the documented
+ * switchMap-pattern semantics; primitive-side widening (filed in
+ * `docs/optimizations.md`) will preserve internal state once it lands and the
+ * pipeline can forward Node-form options directly.
+ *
+ * Per-layer **companion Nodes** (`droppedCount`, `rateLimitState`,
+ * `breakerState`) are exposed only for the static-options path — Node-form
+ * leaves them as `undefined` because each rebuild creates new companion
+ * instances and a switchMap-mirrored companion would track only the latest
+ * bundle. Callers needing both reactive options AND companions wait for
+ * primitive-side widening.
+ */
+type NodeOrValue<T> = T | Node<T>;
+/**
+ * Options for {@link resilientPipeline}. Every layer is optional — omit a
+ * field and that layer is skipped.
+ *
+ * Reactive (`Node<T>`) forms are accepted everywhere a primitive value would
+ * fit; the pipeline subscribes via `switchMap` and rebuilds the layer on each
+ * emission. See module JSDoc for the rebuild semantics + state-loss caveat.
+ */
+interface ResilientPipelineOptions<T> {
+    /**
+     * Admission control — at most `maxEvents` `DATA` per `windowNs`. See
+     * {@link rateLimiter}.
+     *
+     * `maxBuffer` is optional at the pipeline layer (defaults to `Infinity`,
+     * preserving the historical unbounded behavior). Pass an explicit positive
+     * integer to opt in to a bounded queue.
+     */
+    rateLimit?: NodeOrValue<Omit<RateLimiterOptions, "maxBuffer"> & {
+        maxBuffer?: number;
+    }>;
+    /** Cost/constraint gate. See {@link budgetGate}. */
+    budget?: NodeOrValue<ReadonlyArray<BudgetConstraint>>;
+    /** Circuit breaker — fail-fast when the downstream resource is unhealthy. See {@link circuitBreaker}. */
+    breaker?: NodeOrValue<CircuitBreakerOptions>;
+    /**
+     * Behavior when the breaker is open:
+     * - `"skip"` (default) — emit `RESOLVED` (lets downstream drop the beat).
+     * - `"error"` — emit a `CircuitOpenError` so `retry` / `fallback` can react.
+     *   See module JSDoc for the retry-budget burn caveat.
+     *
+     * Static (configuration-only — no reactive form).
+     */
+    breakerOnOpen?: "skip" | "error";
+    /** Retry policy on terminal `ERROR`. See {@link retry}. */
+    retry?: NodeOrValue<RetryOptions>;
+    /**
+     * Per-attempt deadline in milliseconds. Converted to ns internally. Omit
+     * to skip the timeout wrap.
+     *
+     * Specified in ms (not ns) because callers consistently think in
+     * millisecond deadlines; the underlying {@link timeout} primitive takes ns
+     * internally.
+     */
+    timeoutMs?: NodeOrValue<number>;
+    /** Final fallback value emitted on terminal `ERROR` after retry exhausts. See {@link fallback}. */
+    fallback?: FallbackInput<T>;
+    /**
+     * Initial status reported by the status node. Default `"pending"`. Static.
+     */
+    initialStatus?: StatusValue;
+    /** Wrapper graph name. Default `"resilient_pipeline"`. */
+    name?: string;
+    /** Wrapper graph options. */
+    graph?: GraphOptions;
+}
+/**
+ * Graph subclass returned by {@link resilientPipeline}. Mounts each
+ * configured intermediate under a stable name and exposes per-layer status
+ * companions.
+ *
+ * @category patterns
+ */
+declare class ResilientPipelineGraph<T> extends Graph {
+    /**
+     * Final resilient node — subscribe to this for `DATA` emissions.
+     *
+     * Named `output` (not `node`) because `Graph.node(name)` already names the
+     * path-resolution method on the base class; a `readonly node` field would
+     * shadow it.
+     */
+    readonly output: Node<T>;
+    /** Live status: `"pending" | "running" | "completed" | "errored"`. */
+    readonly status: Node<StatusValue>;
+    /**
+     * Last error payload, or `null` when not errored.
+     *
+     * Named `lastError` (not `error`) because `Graph.error(name, err)` already
+     * names a method on the base class.
+     */
+    readonly lastError: Node<unknown | null>;
+    /** Breaker state when `opts.breaker` is provided; `undefined` otherwise. */
+    readonly breakerState: Node<CircuitState> | undefined;
+    /**
+     * Drop-counter when `opts.rateLimit` is provided; `undefined` otherwise.
+     *
+     * **Lifetime note:** `droppedCount` retains its final value through
+     * terminal (`COMPLETE` / `ERROR` / `TEARDOWN`); the underlying counter
+     * resets to `0` only at the next subscription cycle.
+     */
+    readonly droppedCount: Node<number> | undefined;
+    /**
+     * Combined rate-limit state when `opts.rateLimit` is provided; `undefined`
+     * otherwise. Same lifecycle as {@link droppedCount} but exposes
+     * `pendingCount` and `paused` alongside the drop counter for richer
+     * backpressure observability (Tier 5.2 D7).
+     */
+    readonly rateLimitState: Node<RateLimiterState> | undefined;
+    constructor(source: Node<T>, opts?: ResilientPipelineOptions<T>);
+}
+/**
+ * Compose a resilient pipeline around `source` in the canonical nesting
+ * order — `rateLimit → budget → breaker → timeout → retry → fallback → status`.
+ * Omit any option to skip that layer.
+ *
+ * Returns a {@link ResilientPipelineGraph} (Graph subclass) —
+ * `pipeline.output` is the externally visible final node; `pipeline.status`
+ * / `pipeline.lastError` / `pipeline.breakerState` / `pipeline.droppedCount`
+ * are the per-layer companions. Call `pipeline.describe()` to see the
+ * mounted intermediates; compose with {@link graphLens}'s `health` for
+ * aggregate status.
+ *
+ * **Naming note:** `output` and `lastError` (not `node` / `error`) avoid
+ * clashes with `Graph.node(name)` and `Graph.error(name, err)` on the base
+ * class.
+ *
+ * @param source - Upstream node to wrap.
+ * @param opts - See {@link ResilientPipelineOptions}. All fields optional.
+ *
+ * @example
+ * ```ts
+ * const safeFetch = resilientPipeline(fetchNode, {
+ *   rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC },
+ *   breaker: { failureThreshold: 5 },
+ *   retry: { count: 3, backoff: "exponential" },
+ *   timeoutMs: 10_000,
+ *   fallback: null,
+ * });
+ * safeFetch.output.subscribe(msgs => console.log(msgs));
+ * safeFetch.status.subscribe(msgs => console.log(msgs));
+ * safeFetch.describe({ format: "ascii" }); // visualize the chain
+ * ```
+ *
+ * @category patterns
+ */
+declare function resilientPipeline<T>(source: Node<T>, opts?: ResilientPipelineOptions<T>): ResilientPipelineGraph<T>;
+
+declare const index_BudgetConstraint: typeof BudgetConstraint;
+declare const index_CircuitBreakerOptions: typeof CircuitBreakerOptions;
+declare const index_CircuitState: typeof CircuitState;
+declare const index_FallbackInput: typeof FallbackInput;
+declare const index_NS_PER_MS: typeof NS_PER_MS;
+declare const index_NS_PER_SEC: typeof NS_PER_SEC;
+type index_NodeOrValue<T> = NodeOrValue<T>;
+declare const index_RateLimiterOptions: typeof RateLimiterOptions;
+declare const index_RateLimiterState: typeof RateLimiterState;
+type index_ResilientPipelineGraph<T> = ResilientPipelineGraph<T>;
+declare const index_ResilientPipelineGraph: typeof ResilientPipelineGraph;
+type index_ResilientPipelineOptions<T> = ResilientPipelineOptions<T>;
+declare const index_RetryOptions: typeof RetryOptions;
+declare const index_StatusValue: typeof StatusValue;
+declare const index_factoryTag: typeof factoryTag;
+declare const index_placeholderArgs: typeof placeholderArgs;
+declare const index_resilientPipeline: typeof resilientPipeline;
+declare namespace index {
+  export { index_BudgetConstraint as BudgetConstraint, index_CircuitBreakerOptions as CircuitBreakerOptions, index_CircuitState as CircuitState, index_FallbackInput as FallbackInput, index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, type index_NodeOrValue as NodeOrValue, index_RateLimiterOptions as RateLimiterOptions, index_RateLimiterState as RateLimiterState, index_ResilientPipelineGraph as ResilientPipelineGraph, type index_ResilientPipelineOptions as ResilientPipelineOptions, index_RetryOptions as RetryOptions, index_StatusValue as StatusValue, index_factoryTag as factoryTag, index_placeholderArgs as placeholderArgs, index_resilientPipeline as resilientPipeline };
+}
+
+export { type NodeOrValue as N, ResilientPipelineGraph as R, type ResilientPipelineOptions as a, index as i, resilientPipeline as r };

package/dist/{index-iTX5IqSP.d.ts → index-D1IEZUsj.d.ts}

@@ -1,11 +1,11 @@
 import { NodeInput } from './extra/sources.js';
 import { N as Node } from './node-BYInONRr.js';
 import { L as LLMAdapter } from './types-39jk0kaV.js';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-DszPlZzK.js';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-PqbnoScQ.js';
-import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-30XSgtVX.js';
-import { G as GateController } from './pipeline-graph-D8vKcO_p.js';
-import { J as JobQueueGraph } from './index-C19qqa38.js';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-40ZT4MHj.js';
+import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-BgjS2b8N.js';
+import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-BkIkog4h.js';
+import { G as GateController } from './pipeline-graph-CB4La-UW.js';
+import { J as JobQueueGraph } from './index-IUCY0OFN.js';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).

package/dist/{index-CWHtYmSh.d.cts → index-D4uimgee.d.cts}

@@ -1,4 +1,4 @@
-import { C as CatchOptions, a as ClassifyResult, D as Decision, b as DecisionAction, G as GateController, c as GateOptions, P as PipelineGraph, S as StepRef, T as TerminalCause, d as decisionKeyOf, p as pipelineGraph } from './pipeline-graph-BQPr2Lqs.cjs';
+import { C as CatchOptions, a as ClassifyResult, D as Decision, b as DecisionAction, G as GateController, c as GateOptions, P as PipelineGraph, S as StepRef, T as TerminalCause, d as decisionKeyOf, p as pipelineGraph } from './pipeline-graph-MWrQZXCq.cjs';
 
 /**
  * Orchestration patterns (roadmap §4.1).

package/dist/{index-CwP_KAMS.d.cts → index-DGTo1yka.d.cts}

@@ -169,6 +169,13 @@ type RetryOptions = {
     count?: number;
     /** Delay between attempts; strategies use **nanoseconds**. */
     backoff?: BackoffStrategy | BackoffPreset;
+    /**
+     * Caller-supplied metadata merged into the produced node's `meta` (Tier 5.2
+     * D8 widening). Use {@link domainMeta} to tag the layer for `describe()`
+     * grouping. The primitive's `factoryTag("retry", …)` always wins against
+     * caller keys.
+     */
+    meta?: Record<string, unknown>;
 };
 /** Factory-mode-only options. `initial` seeds the outer node's cache before the first attempt. */
 type RetryFactoryOptions<T> = RetryOptions & {
@@ -323,6 +330,7 @@ type WithBreakerBundle<T> = {
  */
 declare function withBreaker<T>(breaker: CircuitBreaker, options?: {
     onOpen?: "skip" | "error";
+    meta?: Record<string, unknown>;
 }): (source: Node<T>) => WithBreakerBundle<T>;
 interface TokenBucket {
     /**
@@ -409,6 +417,15 @@ type RateLimiterOptions = {
     maxBuffer: number;
     /** Overflow policy when `maxBuffer` is exceeded. Default: `"drop-newest"`. */
     onOverflow?: RateLimiterOverflowPolicy;
+    /**
+     * Caller-supplied metadata merged into the produced node's `meta` (Tier 5.2
+     * D8 widening). Use {@link domainMeta} to tag the layer for `describe()` /
+     * mermaid grouping (e.g. `domainMeta("resilient", "rate-limit")`). The
+     * primitive's own `factoryTag("rateLimiter", opts)` and the `droppedCount`
+     * / `rateLimitState` companion seeds always win against caller-supplied
+     * keys so the audit trail can't be silently overwritten.
+     */
+    meta?: Record<string, unknown>;
 };
 /**
  * Thrown by {@link rateLimiter} when `onOverflow: "error"` and the pending buffer is full.
@@ -419,24 +436,60 @@ declare class RateLimiterOverflowError extends Error {
     name: string;
     constructor(maxBuffer: number);
 }
+/**
+ * Combined runtime state surfaced by {@link rateLimiter} alongside `droppedCount`.
+ * Tier 5.2 D7 widening — exposes pending-buffer occupancy and a `paused`
+ * flag so consumers can render backpressure (UI), feed `lens.health`, or
+ * gate downstream effects.
+ */
+type RateLimiterState = {
+    /** Cumulative `DATA` items dropped due to overflow since this subscription cycle started. */
+    droppedCount: number;
+    /** Items currently buffered awaiting a token refill. `0` when the limiter is passing through. */
+    pendingCount: number;
+    /** `true` when at least one item is queued (the limiter is actively throttling). */
+    paused: boolean;
+};
 /** Bundle returned by {@link rateLimiter}. */
 type RateLimiterBundle<T> = {
     /** The throttled stream — at most `maxEvents` `DATA` per `windowNs`. */
     node: Node<T>;
     /**
-     * Reactive companion: count of `DATA` items dropped since subscription start.
+     * Reactive companion: count of `DATA` items dropped since the producer
+     * activated.
      *
      * - Increments on every drop under any overflow policy (`drop-newest`,
      *   `drop-oldest`). The `error` policy terminates the stream after a single
      *   overflow, so `droppedCount` increments at most once in that path.
-     * - Resets to `0` on terminal (`COMPLETE` / `ERROR` / `TEARDOWN`) — i.e. the
-     *   counter scopes to the active subscription cycle.
+     * - **Lifecycle scoping (qa A1 + EC7):** the counter retains its final
+     *   value through terminal (`COMPLETE` / `ERROR` / `TEARDOWN`) so consumers
+     *   see the final drop count, not zero. The closure-held counter resets to
+     *   `0` only when the producer fn re-runs — which only happens on a new
+     *   subscription cycle, and only if the producer was constructed with
+     *   `resubscribable: true`. The default `rateLimiter` producer is NOT
+     *   resubscribable, so a single producer-fn run is the typical lifetime.
      * - Producer-pattern note: this companion is invisible to `describe()`
      *   traversal from `node` (effect-mirror limitation; same shape as
      *   `withBreaker.breakerState` and `withStatus.status`). Surface it via
      *   `node.meta.droppedCount` if you need it in topology snapshots.
      */
     droppedCount: Node<number>;
+    /**
+     * Reactive companion: combined `{droppedCount, pendingCount, paused}` view.
+     *
+     * - `pendingCount` reflects the live buffer occupancy and updates on every
+     *   push / shift / overflow drop; `paused` is shorthand for
+     *   `pendingCount > 0`.
+     * - Equality-deduped — re-emits only when one of the three fields actually
+     *   changes (so a busy steady-state where every DATA passes immediately
+     *   produces one `paused: false` emission, not one per DATA).
+     * - **Lifecycle scoping (qa EC7):** same contract as `droppedCount` —
+     *   retains its final value through terminal; resets to the initial
+     *   `{droppedCount: 0, pendingCount: 0, paused: false}` only on a new
+     *   producer-fn run (resubscribable upstream required).
+     * - Same producer-pattern caveat as `droppedCount` re: `describe()` visibility.
+     */
+    rateLimitState: Node<RateLimiterState>;
 };
 /**
  * Token-bucket rate limiter: at most `maxEvents` `DATA` values per `windowNs`.
@@ -519,6 +572,7 @@ type WithStatusBundle<T> = {
  */
 declare function withStatus<T>(src: Node<T>, options?: {
     initialStatus?: StatusValue;
+    meta?: Record<string, unknown>;
 }): WithStatusBundle<T>;
 /**
  * Thrown by {@link timeout} when no `DATA` arrives within the deadline.
@@ -562,7 +616,9 @@ type FallbackInput<T> = T | Node<T> | PromiseLike<T> | AsyncIterable<T>;
  *
  * @category extra
  */
-declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>): Node<T>;
+declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
+    meta?: Record<string, unknown>;
+}): Node<T>;
 /**
  * Emits `ERROR` with {@link TimeoutError} if no `DATA` arrives within the deadline.
  *
@@ -588,6 +644,8 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>): Node<T>;
  *
  * @category extra
  */
-declare function timeout<T>(source: Node<T>, timeoutNs: number): Node<T>;
+declare function timeout<T>(source: Node<T>, timeoutNs: number, options?: {
+    meta?: Record<string, unknown>;
+}): Node<T>;
 
-export { type BackoffPreset as B, type CircuitState as C, type ExponentialBackoffOptions as E, type FallbackInput as F, type JitterMode as J, NS_PER_MS as N, type RateLimiterOptions as R, type StatusValue as S, TimeoutError as T, type WithBreakerBundle as W, type CircuitBreakerOptions as a, type RetryOptions as b, NS_PER_SEC as c, type BackoffStrategy as d, type CircuitBreaker as e, CircuitOpenError as f, RateLimiterOverflowError as g, type RateLimiterOverflowPolicy as h, type TokenBucket as i, type WithStatusBundle as j, circuitBreaker as k, constant as l, decorrelatedJitter as m, exponential as n, fallback as o, fibonacci as p, linear as q, rateLimiter as r, resolveBackoffPreset as s, retry as t, timeout as u, tokenBucket as v, withBreaker as w, withMaxAttempts as x, withStatus as y };
+export { type BackoffPreset as B, type CircuitState as C, type ExponentialBackoffOptions as E, type FallbackInput as F, type JitterMode as J, NS_PER_MS as N, type RateLimiterState as R, type StatusValue as S, TimeoutError as T, type WithBreakerBundle as W, type RateLimiterOptions as a, type CircuitBreakerOptions as b, type RetryOptions as c, NS_PER_SEC as d, type BackoffStrategy as e, type CircuitBreaker as f, CircuitOpenError as g, RateLimiterOverflowError as h, type RateLimiterOverflowPolicy as i, type TokenBucket as j, type WithStatusBundle as k, circuitBreaker as l, constant as m, decorrelatedJitter as n, exponential as o, fallback as p, fibonacci as q, linear as r, rateLimiter as s, resolveBackoffPreset as t, retry as u, timeout as v, tokenBucket as w, withBreaker as x, withMaxAttempts as y, withStatus as z };

package/dist/{index-BUPVld1w.d.ts → index-DH4fm2Ck.d.ts}

@@ -1,5 +1,5 @@
-import { G as Graph } from './graph-30XSgtVX.js';
-import { M as MeasurementAdapter } from './reactive-layout-DkTXxtSy.js';
+import { G as Graph } from './graph-BkIkog4h.js';
+import { M as MeasurementAdapter } from './reactive-layout-KJj4E2dT.js';
 
 /**
  * Three-pane demo shell (roadmap §7.2).

package/dist/{index-mNwgxC21.d.cts → index-DJ_MPOJ5.d.cts}

@@ -1,11 +1,11 @@
 import { NodeInput } from './extra/sources.cjs';
 import { N as Node } from './node-BYInONRr.cjs';
 import { L as LLMAdapter } from './types-1Dhoi7HM.cjs';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-BndG0cpK.cjs';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-PsVHpPwP.cjs';
-import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-BUwMAxJI.cjs';
-import { G as GateController } from './pipeline-graph-BQPr2Lqs.cjs';
-import { J as JobQueueGraph } from './index-xZYcDqFH.cjs';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-Cnr1WrlX.cjs';
+import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-t6L2qpHh.cjs';
+import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-E6likq7w.cjs';
+import { G as GateController } from './pipeline-graph-MWrQZXCq.cjs';
+import { J as JobQueueGraph } from './index-BTHOTC0Q.cjs';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).

package/dist/{index-DyM4tFAe.d.cts → index-DQQCOIt8.d.cts}

@@ -1,8 +1,8 @@
 import { N as Node } from './node-BYInONRr.cjs';
-import { B as BaseAuditRecord } from './index-DINuaZlJ.cjs';
+import { B as BaseAuditRecord } from './index-DVDapw2k.cjs';
 import { a as ReactiveLogBundle } from './reactive-log-_zeEnB9H.cjs';
 import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
-import { a as GraphOptions, G as Graph } from './graph-BUwMAxJI.cjs';
+import { a as GraphOptions, G as Graph } from './graph-E6likq7w.cjs';
 
 /**
  * CQRS patterns (roadmap §4.5).

package/dist/{index-BJ26eEjs.d.cts → index-DVAlsmEU.d.cts}

@@ -1,8 +1,8 @@
-import { B as BaseAuditRecord } from './index-DINuaZlJ.cjs';
+import { B as BaseAuditRecord } from './index-DVDapw2k.cjs';
 import { a as ReactiveLogBundle } from './reactive-log-_zeEnB9H.cjs';
 import { NodeInput } from './extra/sources.cjs';
 import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
-import { C as CqrsEventMap, a as CqrsEvent, b as CqrsGraph } from './index-DyM4tFAe.cjs';
+import { C as CqrsEventMap, a as CqrsEvent, b as CqrsGraph } from './index-DQQCOIt8.cjs';
 
 /**
  * Process Manager pattern (Phase 7 — roadmap §4.6, Audit 3 — locked 2026-04-24).

package/dist/{index-DINuaZlJ.d.cts → index-DVDapw2k.d.cts}

@@ -1,5 +1,5 @@
 import { b as NodeGuard, N as Node } from './node-BYInONRr.cjs';
-import { G as Graph } from './graph-BUwMAxJI.cjs';
+import { G as Graph } from './graph-E6likq7w.cjs';
 import { R as ReactiveLogOptions, a as ReactiveLogBundle } from './reactive-log-_zeEnB9H.cjs';
 
 /**

package/dist/{index-DTtBpuQy.d.cts → index-DgJc8Zgc.d.cts}

@@ -1,6 +1,6 @@
 import { o as GraphReFlyConfig } from './node-BYInONRr.cjs';
-import { c as GraphPersistSnapshot, k as GraphCheckpointRecord, G as Graph, C as CausalChain, e as CausalStep, D as DescribeFilter, E as ExplainPathOptions, h as GRAPH_META_SEGMENT, i as GraphActorOptions, j as GraphAttachStorageOptions, d as GraphDescribeOptions, b as GraphDescribeOutput, l as GraphDiagramDirection, m as GraphDiffChange, n as GraphDiffResult, o as GraphFactoryContext, p as GraphNodeFactory, q as GraphObserveAll, r as GraphObserveOne, a as GraphOptions, s as GraphProfileOptions, t as GraphProfileResult, u as GraphVersionChange, v as GraphWALDiff, N as NodeProfile, O as ObserveDetail, w as ObserveEvent, x as ObserveOptions, y as ObserveResult, z as ObserveTheme, A as ObserveThemeName, R as ReachableDirection, B as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, F as TraceEntry, H as diffForWAL, I as explainPath, J as graphProfile, K as reachable } from './graph-BUwMAxJI.cjs';
-import { w as watchTopologyTree } from './topology-tree-B5Ngw3j0.cjs';
+import { c as GraphPersistSnapshot, k as GraphCheckpointRecord, G as Graph, C as CausalChain, e as CausalStep, D as DescribeFilter, E as ExplainPathOptions, h as GRAPH_META_SEGMENT, i as GraphActorOptions, j as GraphAttachStorageOptions, d as GraphDescribeOptions, b as GraphDescribeOutput, l as GraphDiagramDirection, m as GraphDiffChange, n as GraphDiffResult, o as GraphFactoryContext, p as GraphNodeFactory, q as GraphObserveAll, r as GraphObserveOne, a as GraphOptions, s as GraphProfileOptions, t as GraphProfileResult, u as GraphVersionChange, v as GraphWALDiff, N as NodeProfile, O as ObserveChangeset, w as ObserveDetail, x as ObserveEvent, y as ObserveOptions, z as ObserveResult, A as ObserveTheme, B as ObserveThemeName, F as ObserveTier, R as ReachableDirection, H as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, I as TraceEntry, J as diffForWAL, K as explainPath, L as graphProfile, P as reachable } from './graph-E6likq7w.cjs';
+import { w as watchTopologyTree } from './topology-tree-3LBKFsUo.cjs';
 
 /**
  * Approximate in-memory size estimation for arbitrary JS values.
@@ -435,12 +435,14 @@ type index_LazyGraphCodec = LazyGraphCodec;
 declare const index_NodeProfile: typeof NodeProfile;
 type index_ObservabilityCheck = ObservabilityCheck;
 type index_ObservabilityDescribeFormat = ObservabilityDescribeFormat;
+declare const index_ObserveChangeset: typeof ObserveChangeset;
 declare const index_ObserveDetail: typeof ObserveDetail;
 declare const index_ObserveEvent: typeof ObserveEvent;
 declare const index_ObserveOptions: typeof ObserveOptions;
 declare const index_ObserveResult: typeof ObserveResult;
 declare const index_ObserveTheme: typeof ObserveTheme;
 declare const index_ObserveThemeName: typeof ObserveThemeName;
+declare const index_ObserveTier: typeof ObserveTier;
 declare const index_ReachableDirection: typeof ReachableDirection;
 declare const index_ReachableOptions: typeof ReachableOptions;
 declare const index_SIZEOF_SYMBOL: typeof SIZEOF_SYMBOL;
@@ -464,7 +466,7 @@ declare const index_sizeof: typeof sizeof;
 declare const index_validateGraphObservability: typeof validateGraphObservability;
 declare const index_watchTopologyTree: typeof watchTopologyTree;
 declare namespace index {
-  export { index_CausalChain as CausalChain, index_CausalStep as CausalStep, index_DescribeFilter as DescribeFilter, index_ENVELOPE_VERSION as ENVELOPE_VERSION, type index_EvictedSubgraphInfo as EvictedSubgraphInfo, type index_EvictionPolicy as EvictionPolicy, index_ExplainPathOptions as ExplainPathOptions, index_GRAPH_META_SEGMENT as GRAPH_META_SEGMENT, index_Graph as Graph, index_GraphActorOptions as GraphActorOptions, index_GraphAttachStorageOptions as GraphAttachStorageOptions, index_GraphCheckpointRecord as GraphCheckpointRecord, type index_GraphCodec as GraphCodec, index_GraphDescribeOptions as GraphDescribeOptions, index_GraphDescribeOutput as GraphDescribeOutput, index_GraphDiagramDirection as GraphDiagramDirection, index_GraphDiffChange as GraphDiffChange, index_GraphDiffResult as GraphDiffResult, index_GraphFactoryContext as GraphFactoryContext, index_GraphNodeFactory as GraphNodeFactory, index_GraphObserveAll as GraphObserveAll, index_GraphObserveOne as GraphObserveOne, index_GraphOptions as GraphOptions, index_GraphPersistSnapshot as GraphPersistSnapshot, index_GraphProfileOptions as GraphProfileOptions, index_GraphProfileResult as GraphProfileResult, index_GraphVersionChange as GraphVersionChange, index_GraphWALDiff as GraphWALDiff, index_JsonCodec as JsonCodec, type index_LazyGraphCodec as LazyGraphCodec, index_NodeProfile as NodeProfile, type index_ObservabilityCheck as ObservabilityCheck, type index_ObservabilityDescribeFormat as ObservabilityDescribeFormat, index_ObserveDetail as ObserveDetail, index_ObserveEvent as ObserveEvent, index_ObserveOptions as ObserveOptions, index_ObserveResult as ObserveResult, index_ObserveTheme as ObserveTheme, index_ObserveThemeName as ObserveThemeName, index_ReachableDirection as ReachableDirection, index_ReachableOptions as ReachableOptions, OVERHEAD as SIZEOF_OVERHEAD, index_SIZEOF_SYMBOL as SIZEOF_SYMBOL, index_SNAPSHOT_VERSION as SNAPSHOT_VERSION, index_TopologyEvent as TopologyEvent, index_TraceEntry as TraceEntry, type index_ValidateObservabilityOptions as ValidateObservabilityOptions, type index_ValidateObservabilityResult as ValidateObservabilityResult, type index_WALEntry as WALEntry, index_createDagCborCodec as createDagCborCodec, index_createDagCborZstdCodec as createDagCborZstdCodec, index_decodeEnvelope as decodeEnvelope, index_diffForWAL as diffForWAL, index_encodeEnvelope as encodeEnvelope, index_explainPath as explainPath, index_graphProfile as graphProfile, index_reachable as reachable, index_registerBuiltinCodecs as registerBuiltinCodecs, index_replayWAL as replayWAL, index_sizeof as sizeof, index_validateGraphObservability as validateGraphObservability, index_watchTopologyTree as watchTopologyTree };
+  export { index_CausalChain as CausalChain, index_CausalStep as CausalStep, index_DescribeFilter as DescribeFilter, index_ENVELOPE_VERSION as ENVELOPE_VERSION, type index_EvictedSubgraphInfo as EvictedSubgraphInfo, type index_EvictionPolicy as EvictionPolicy, index_ExplainPathOptions as ExplainPathOptions, index_GRAPH_META_SEGMENT as GRAPH_META_SEGMENT, index_Graph as Graph, index_GraphActorOptions as GraphActorOptions, index_GraphAttachStorageOptions as GraphAttachStorageOptions, index_GraphCheckpointRecord as GraphCheckpointRecord, type index_GraphCodec as GraphCodec, index_GraphDescribeOptions as GraphDescribeOptions, index_GraphDescribeOutput as GraphDescribeOutput, index_GraphDiagramDirection as GraphDiagramDirection, index_GraphDiffChange as GraphDiffChange, index_GraphDiffResult as GraphDiffResult, index_GraphFactoryContext as GraphFactoryContext, index_GraphNodeFactory as GraphNodeFactory, index_GraphObserveAll as GraphObserveAll, index_GraphObserveOne as GraphObserveOne, index_GraphOptions as GraphOptions, index_GraphPersistSnapshot as GraphPersistSnapshot, index_GraphProfileOptions as GraphProfileOptions, index_GraphProfileResult as GraphProfileResult, index_GraphVersionChange as GraphVersionChange, index_GraphWALDiff as GraphWALDiff, index_JsonCodec as JsonCodec, type index_LazyGraphCodec as LazyGraphCodec, index_NodeProfile as NodeProfile, type index_ObservabilityCheck as ObservabilityCheck, type index_ObservabilityDescribeFormat as ObservabilityDescribeFormat, index_ObserveChangeset as ObserveChangeset, index_ObserveDetail as ObserveDetail, index_ObserveEvent as ObserveEvent, index_ObserveOptions as ObserveOptions, index_ObserveResult as ObserveResult, index_ObserveTheme as ObserveTheme, index_ObserveThemeName as ObserveThemeName, index_ObserveTier as ObserveTier, index_ReachableDirection as ReachableDirection, index_ReachableOptions as ReachableOptions, OVERHEAD as SIZEOF_OVERHEAD, index_SIZEOF_SYMBOL as SIZEOF_SYMBOL, index_SNAPSHOT_VERSION as SNAPSHOT_VERSION, index_TopologyEvent as TopologyEvent, index_TraceEntry as TraceEntry, type index_ValidateObservabilityOptions as ValidateObservabilityOptions, type index_ValidateObservabilityResult as ValidateObservabilityResult, type index_WALEntry as WALEntry, index_createDagCborCodec as createDagCborCodec, index_createDagCborZstdCodec as createDagCborZstdCodec, index_decodeEnvelope as decodeEnvelope, index_diffForWAL as diffForWAL, index_encodeEnvelope as encodeEnvelope, index_explainPath as explainPath, index_graphProfile as graphProfile, index_reachable as reachable, index_registerBuiltinCodecs as registerBuiltinCodecs, index_replayWAL as replayWAL, index_sizeof as sizeof, index_validateGraphObservability as validateGraphObservability, index_watchTopologyTree as watchTopologyTree };
 }
 
 export { ENVELOPE_VERSION as E, type GraphCodec as G, JsonCodec as J, type LazyGraphCodec as L, type ObservabilityCheck as O, SIZEOF_SYMBOL as S, type ValidateObservabilityOptions as V, type WALEntry as W, type EvictedSubgraphInfo as a, type EvictionPolicy as b, type ObservabilityDescribeFormat as c, OVERHEAD as d, type ValidateObservabilityResult as e, createDagCborCodec as f, createDagCborZstdCodec as g, decodeEnvelope as h, encodeEnvelope as i, index as j, replayWAL as k, registerBuiltinCodecs as r, sizeof as s, validateGraphObservability as v };

package/dist/{index-BKMdnYnk.d.ts → index-DhLyOHYZ.d.ts}

@@ -1,6 +1,6 @@
 import { D as DescribeNodeOutput } from './meta-D8OyedKp.js';
 import { N as Node } from './node-BYInONRr.js';
-import { G as Graph, b as GraphDescribeOutput } from './graph-30XSgtVX.js';
+import { G as Graph, b as GraphDescribeOutput } from './graph-BkIkog4h.js';
 import { L as LLMAdapter } from './types-39jk0kaV.js';
 
 /**