@graphrefly/graphrefly 0.42.0 → 0.44.0

package/dist/{index-B-i4_g3k.d.ts → index-B1F8Enjf.d.ts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.js';
+import { N as Node } from './node-kK3CvTrR.js';
 
 /**
  * Backoff strategies for {@link retry} (roadmap §3.1). Delays are in **nanoseconds**.
@@ -227,8 +227,8 @@ type RetryFactoryOptions<T> = RetryOptions & {
  *
  * @category extra
  */
-declare function retry<T>(input: Node<T>, opts?: RetryOptions): Node<T>;
-declare function retry<T>(input: () => Node<T>, opts?: RetryFactoryOptions<T>): Node<T>;
+declare function retry<T>(input: Node<T>, opts?: NodeOrValue<RetryOptions>): Node<T>;
+declare function retry<T>(input: () => Node<T>, opts?: NodeOrValue<RetryFactoryOptions<T>>): Node<T>;
 type CircuitState = "closed" | "open" | "half-open";
 /**
  * Thrown when {@link withBreaker} is configured with `onOpen: "error"` and the breaker rejects work.
@@ -275,6 +275,13 @@ interface CircuitBreaker {
     readonly failureCount: number;
     /** Manually reset to closed state, clearing all counters. */
     reset(): void;
+    /**
+     * Release the reactive-options subscription (Tier 6.5 3.2.4, 2026-04-29).
+     * No-op when constructed with static options. Call when retiring a
+     * breaker whose options came from a `Node<CircuitBreakerOptions>` to
+     * avoid leaking the option-Node subscription.
+     */
+    dispose(): void;
 }
 /**
  * Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.
@@ -282,12 +289,24 @@ interface CircuitBreaker {
  * Supports escalating cooldown via an optional {@link BackoffStrategy} — each consecutive
  * open→half-open→open cycle increments the backoff attempt.
  *
- * @param options - Threshold, cooldown, half-open limit, and optional clock override.
+ * @param options - Threshold, cooldown, half-open limit, and optional clock
+ *   override; OR a `Node<CircuitBreakerOptions>` carrying the same shape
+ *   reactively (Tier 6.5 3.2.4).
  * @returns {@link CircuitBreaker} instance.
  *
  * @remarks
  * **Timing:** Uses `monotonicNs()` by default (nanoseconds). Override `now` for tests.
  *
+ * **Reactive options (locked semantics, Tier 6.5 3.2.4, 2026-04-29).**
+ * When `options` is a `Node<CircuitBreakerOptions>`, the breaker
+ * subscribes at construction and re-reads `failureThreshold` /
+ * `cooldownNs` / `cooldown` / `halfOpenMax` / `now` on each DATA. **An
+ * option swap RESETS the breaker to `"closed"`** with all counters
+ * cleared — operators tuning a runaway breaker get a clean baseline.
+ * If retaining failure history across re-tunings matters, derive a new
+ * breaker per-tuning instead. Call `breaker.dispose()` when retiring to
+ * release the option-Node subscription.
+ *
  * @example
  * ```ts
  * import { circuitBreaker, exponential, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
@@ -300,7 +319,7 @@ interface CircuitBreaker {
  *
  * @category extra
  */
-declare function circuitBreaker(options?: CircuitBreakerOptions): CircuitBreaker;
+declare function circuitBreaker(options?: NodeOrValue<CircuitBreakerOptions>): CircuitBreaker;
 type WithBreakerBundle<T> = {
     node: Node<T>;
     breakerState: Node<CircuitState>;
@@ -525,7 +544,7 @@ type RateLimiterBundle<T> = {
  *
  * @category extra
  */
-declare function rateLimiter<T>(source: Node<T>, opts: RateLimiterOptions): RateLimiterBundle<T>;
+declare function rateLimiter<T>(source: Node<T>, opts: NodeOrValue<RateLimiterOptions>): RateLimiterBundle<T>;
 type StatusValue = "pending" | "running" | "completed" | "errored";
 type WithStatusBundle<T> = {
     node: Node<T>;
@@ -557,6 +576,17 @@ type WithStatusBundle<T> = {
  * appear as edges in `describe()` if no consumer subscribes to them (per
  * COMPOSITION-GUIDE §1, push-on-subscribe semantics).
  *
+ * **Per-subscribe lifecycle (DF8, 2026-04-29 doc lock).** When the wrapped
+ * source is `resubscribable: true` and multiple consumers attach in
+ * sequence, each new subscription cycle re-runs the producer fn AND
+ * re-emits the initial `pending` + `null` companion DATAs. Downstream
+ * subscribers to the `status` / `error` companions see thrash:
+ * `pending → running → completed → pending → running …`. This is the
+ * intended fresh-cycle semantic (each subscription cycle reports its own
+ * lifecycle); consumers that need a "stable" status across cycles should
+ * derive a snapshot via a separate `state()` mirror rather than depending
+ * on the per-cycle reset.
+ *
  * @example
  * ```ts
  * import { withStatus, state } from "@graphrefly/graphrefly-ts";
@@ -583,6 +613,20 @@ declare class TimeoutError extends Error {
     name: string;
     constructor(ns: number);
 }
+/**
+ * Either a literal value or a reactive Node carrying it. Mirrors
+ * {@link FallbackInput}'s precedent for "options that may be reactive."
+ *
+ * Used by {@link timeout} / {@link retry} / {@link rateLimiter} /
+ * {@link circuitBreaker} / {@link budgetGate} to accept reactive option
+ * configurations (Tier 6.5 3.2, 2026-04-29). Each primitive subscribes
+ * to the option Node via {@link resolveReactiveOption} and rebinds
+ * internal state per its locked swap-semantic rule (see each primitive's
+ * JSDoc for the rule).
+ *
+ * @category extra
+ */
+type NodeOrValue<T> = T | Node<T>;
 /** Inputs accepted by {@link fallback}. */
 type FallbackInput<T> = T | Node<T> | PromiseLike<T> | AsyncIterable<T>;
 /**
@@ -626,7 +670,9 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  * the timer. Terminal messages (`COMPLETE`/`ERROR`) cancel the timer.
  *
  * @param source - Upstream node.
- * @param timeoutNs - Deadline in **nanoseconds** (must be > 0). Internally converted to milliseconds for `setTimeout` scheduling.
+ * @param timeoutNs - Deadline in **nanoseconds** (must be > 0), or a
+ *   `Node<number>` carrying the deadline reactively (Tier 6.5 3.2.1).
+ *   Internally converted to milliseconds for `setTimeout` scheduling.
  * @returns Node that errors on timeout.
  *
  * @throws {RangeError} when `timeoutNs <= 0`.
@@ -634,6 +680,13 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  * @remarks
  * **Scheduling:** internally uses {@link ResettableTimer} (raw `setTimeout`) per spec §5.10's resilience-operator carve-out. The deadline is `timeoutNs / NS_PER_MS` ms; sub-millisecond `timeoutNs` values get the same minimum-1ms host-scheduler granularity that `setTimeout` provides.
  *
+ * **Reactive `timeoutNs` (locked semantics, Tier 6.5 3.2.1, 2026-04-29).**
+ * When `timeoutNs` is a `Node<number>`, each timer-(re)start reads the
+ * latest value. An option swap mid-flight applies to the **next** timer
+ * window (no in-flight reset) — the active timer keeps its original
+ * deadline; the next DATA-driven `startTimer()` call reads the new
+ * value. Static-form callers see no behavior change.
+ *
  * @example
  * ```ts
  * import { timeout, never, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
@@ -644,7 +697,7 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  *
  * @category extra
  */
-declare function timeout<T>(source: Node<T>, timeoutNs: number, options?: {
+declare function timeout<T>(source: Node<T>, timeoutNs: NodeOrValue<number>, options?: {
     meta?: Record<string, unknown>;
 }): Node<T>;
 

package/dist/{index-DBevwHj_.d.ts → index-B5S8ULbU.d.ts}

@@ -1,6 +1,6 @@
-import { M as MeasurementAdapter, P as PreparedSegment, L as LineBreaksResult, C as CharPosition, a as LayoutCursor, I as Interval, b as LayoutLine, c as LayoutNextLineContext, d as LayoutNextLineResult, R as ReactiveLayoutBundle, e as ReactiveLayoutOptions, S as SegmentBreakKind, f as SegmentMeasureStats, g as analyzeAndMeasure, h as carveTextLineSlots, i as computeCharPositions, j as computeLineBreaks, l as layoutNextLine, r as reactiveLayout } from './reactive-layout-v7KPvxoc.js';
-import { N as Node } from './node-ClS5yC-B.js';
-import { G as Graph } from './graph-7VguS7a4.js';
+import { M as MeasurementAdapter, P as PreparedSegment, L as LineBreaksResult, C as CharPosition, a as LayoutCursor, I as Interval, b as LayoutLine, c as LayoutNextLineContext, d as LayoutNextLineResult, R as ReactiveLayoutBundle, e as ReactiveLayoutOptions, S as SegmentBreakKind, f as SegmentMeasureStats, g as analyzeAndMeasure, h as carveTextLineSlots, i as computeCharPositions, j as computeLineBreaks, l as layoutNextLine, r as reactiveLayout } from './reactive-layout-DOTs9P3X.js';
+import { N as Node } from './node-kK3CvTrR.js';
+import { G as Graph } from './graph-D9LFnda9.js';
 
 /**
  * MeasurementAdapter implementations (roadmap §7.1 — pluggable backends).

package/dist/{index-Dgs8zcj7.d.ts → index-B8YnZpIR.d.ts}

@@ -1,5 +1,5 @@
-import { G as Graph } from './graph-7VguS7a4.js';
-import { M as MeasurementAdapter } from './reactive-layout-v7KPvxoc.js';
+import { G as Graph } from './graph-D9LFnda9.js';
+import { M as MeasurementAdapter } from './reactive-layout-DOTs9P3X.js';
 
 /**
  * Three-pane demo shell (roadmap §7.2).

package/dist/{index-B3OTH1dV.d.ts → index-BHskSB8v.d.ts}

@@ -1,16 +1,16 @@
-import { a as NodeOptions, N as Node, t as Message, M as Messages } from './node-ClS5yC-B.js';
-import { i as GraphCheckpointRecord, a as GraphOptions, G as Graph, D as DescribeChangeset, d as DescribeEvent, M as Meta, Q as topologyDiff } from './graph-7VguS7a4.js';
-import { a as BackoffStrategy, B as BackoffPreset, t as retry, j as WithStatusBundle, C as CircuitBreaker, b as CircuitBreakerOptions, c as CircuitOpenError, d as CircuitState, E as ExponentialBackoffOptions, F as FallbackInput, J as JitterMode, N as NS_PER_MS, e as NS_PER_SEC, R as RateLimiterOptions, f as RateLimiterOverflowError, g as RateLimiterOverflowPolicy, h as RetryOptions, S as StatusValue, T as TimeoutError, i as TokenBucket, W as WithBreakerBundle, k as circuitBreaker, l as constant, m as decorrelatedJitter, n as exponential, o as fallback, p as fibonacci, q as linear, r as rateLimiter, s as resolveBackoffPreset, u as timeout, v as tokenBucket, w as withBreaker, x as withMaxAttempts, y as withStatus } from './index-B-i4_g3k.js';
+import { a as NodeOptions, N as Node, r as Message, M as Messages } from './node-kK3CvTrR.js';
+import { i as GraphCheckpointRecord, a as GraphOptions, G as Graph, D as DescribeChangeset, d as DescribeEvent, M as Meta, Q as topologyDiff } from './graph-D9LFnda9.js';
+import { a as BackoffStrategy, B as BackoffPreset, t as retry, j as WithStatusBundle, C as CircuitBreaker, b as CircuitBreakerOptions, c as CircuitOpenError, d as CircuitState, E as ExponentialBackoffOptions, F as FallbackInput, J as JitterMode, N as NS_PER_MS, e as NS_PER_SEC, R as RateLimiterOptions, f as RateLimiterOverflowError, g as RateLimiterOverflowPolicy, h as RetryOptions, S as StatusValue, T as TimeoutError, i as TokenBucket, W as WithBreakerBundle, k as circuitBreaker, l as constant, m as decorrelatedJitter, n as exponential, o as fallback, p as fibonacci, q as linear, r as rateLimiter, s as resolveBackoffPreset, u as timeout, v as tokenBucket, w as withBreaker, x as withMaxAttempts, y as withStatus } from './index-B1F8Enjf.js';
 import { AsyncSourceOpts, NodeInput, EventTargetLike, FromCronOptions, ReactiveCounterBundle, awaitSettled, cached, defer, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, nodeSignal, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
 import { SnapshotStorageTier, KvStorageTier, AppendCursor, AppendLoadResult, AppendLogStorageOptions, AppendLogStorageTier, BaseStorageTier, Codec, KvStorageOptions, SnapshotStorageOptions, StorageBackend, appendLogStorage, dictKv, dictSnapshot, jsonCodec, jsonCodecFor, kvStorage, memoryAppendLog, memoryBackend, memoryKv, memorySnapshot, snapshotStorage } from './extra/storage-tiers.js';
-import { D as DistillBundle, a as DistillOptions, E as Extraction, V as VerifiableBundle, b as VerifiableOptions, c as VerifyValue, d as decay, e as distill, v as verifiable } from './decay-CdEBmDIs.js';
+import { D as DistillBundle, a as DistillOptions, E as Extraction, V as VerifiableBundle, b as VerifiableOptions, c as VerifyValue, d as decay, e as distill, v as verifiable } from './decay-BvOWTZ00.js';
 import { C as ContentAddressedMissError, a as ContentAddressedMode, b as ContentAddressedStorage, c as ContentAddressedStorageOptions, d as canonicalJson, e as contentAddressedStorage } from './content-addressed-storage-DuYMjV7o.js';
-import { A as AuditLogOpts, B as BaseAuditRecord, D as DEFAULT_AUDIT_GUARD, F as FailureMeta, L as LightMutationOpts, M as MutationOpts, S as SuccessMeta, W as WrapMutationOpts, a as appendAudit, b as bumpCursor, c as createAuditLog, l as lightMutation, r as registerCursor, d as registerCursorMap, t as tryIncrementBounded, w as wrapMutation } from './index-DO9XxMzS.js';
-import { T as ToObservableOptions, t as toObservable } from './observable-BsBzUrcI.js';
+import { A as AuditLogOpts, B as BaseAuditRecord, D as DEFAULT_AUDIT_GUARD, F as FailureMeta, L as LightMutationOpts, M as MutationOpts, S as SuccessMeta, W as WrapMutationOpts, a as appendAudit, b as bumpCursor, c as createAuditLog, l as lightMutation, r as registerCursor, d as registerCursorMap, t as tryIncrementBounded, w as wrapMutation } from './index-Yq60JP3s.js';
+import { T as ToObservableOptions, t as toObservable } from './observable-DWjNfLvC.js';
 import { MergeMapOptions, TapObserver, ThrottleOptions, audit, buffer, bufferCount, bufferTime, catchError, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, distinctUntilChanged, elementAt, exhaustMap, filter, find, first, flatMap, interval, last, map, merge, mergeMap, onFirstData, pairwise, pausable, race, reduce, repeat, rescue, sample, scan, skip, switchMap, take, takeUntil, takeWhile, tap, tapFirst, throttle, throttleTime, valve, window, windowCount, windowTime, withLatestFrom, zip } from './extra/operators.js';
 import { IndexBackend, IndexRow, ListBackend, NativeIndexBackend, NativeListBackend, ReactiveIndexBundle, ReactiveIndexOptions, ReactiveListBundle, ReactiveListOptions, UpsertOptions, reactiveIndex, reactiveList } from './extra/reactive.js';
-import { L as LogBackend, M as MergedReactiveLog, N as NativeLogBackend, a as ReactiveLogBundle, R as ReactiveLogOptions, V as ViewSpec, m as mergeReactiveLogs, r as reactiveLog } from './reactive-log-BezYsbA_.js';
-import { M as MapBackend, N as NativeMapBackend, a as NativeMapBackendOptions, R as ReactiveMapBundle, b as ReactiveMapOptions, c as ReactiveMapRetention, r as reactiveMap } from './reactive-map-BVVPdvmi.js';
+import { L as LogBackend, M as MergedReactiveLog, N as NativeLogBackend, a as ReactiveLogBundle, R as ReactiveLogOptions, V as ViewSpec, m as mergeReactiveLogs, r as reactiveLog } from './reactive-log-BKALbfal.js';
+import { M as MapBackend, N as NativeMapBackend, a as NativeMapBackendOptions, R as ReactiveMapBundle, b as ReactiveMapOptions, c as ReactiveMapRetention, r as reactiveMap } from './reactive-map-DS_SIAxv.js';
 import { StorageHandle, sortJsonValue, stableJsonString } from './extra/storage-core.js';
 
 /**
@@ -418,15 +418,26 @@ type BudgetGateOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "m
  * compositor level (e.g. annotate via `meta.ai.upstream`, or wrap the gate
  * in a parent factory that exposes the deps as constructor args).
  *
- * ## Reference equality
- *
- * The `constraints` array reference and each `BudgetConstraint.check`
- * function are captured at construction. The factory does NOT diff
- * subsequent `constraints` arrays (there is no subsequent — the array is
- * static for the gate's lifetime). To swap constraints reactively, build
- * the swap at the compositor level above the gate (Architecture-2:
- * compositor-only). Identity changes to `constraints` are observed only by
- * constructing a new gate.
+ * ## Reference equality + Tier 6.5 3.2.5 locked semantics
+ *
+ * **Constraint VALUES are reactive.** Each `BudgetConstraint.node` is
+ * subscribed at activation; per-value changes flip the gate (re-evaluate
+ * in the same wave) and trigger PAUSE/RESUME upstream. Per the locked
+ * semantic rule for the reactive-options-widening batch (Tier 6.5 3.2.5,
+ * 2026-04-29): "constraints array re-evaluated immediately against
+ * current source; adding/removing constraints triggers gate
+ * re-evaluation in the same wave" — the per-value half is shipped via
+ * the existing constraint-Node subscription model.
+ *
+ * **The constraints ARRAY shape is static.** The factory captures the
+ * `constraints` array reference and each `check` function at
+ * construction; it does NOT diff subsequent arrays. To add or remove
+ * constraints reactively, build the swap at the compositor level (a
+ * `switchMap` rebuild over a constraint-shape Node), or construct a new
+ * gate. Dynamic constraint-array reactivity is intentionally deferred —
+ * the subscription churn (resub on every constraint add/remove) and
+ * `latestValues` shape mutation overshoot the budget-gate's
+ * fire-and-forget ergonomics.
  *
  * @param source - Input node.
  * @param constraints - Reactive constraint checks. MUST be non-empty.

package/dist/{index-sl4NyzQx.d.cts → index-BIYAkbAi.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-WBlobVhU.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-CIKhynsF.cjs';
 
 /**
  * Orchestration patterns (roadmap §4.1).

package/dist/{index-C9kSENB4.d.cts → index-BQSKmbuG.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
 
 /**
  * A Nanostores-compatible atom.

package/dist/{index-tJoTcnHh.d.cts → index-BaQaY_IQ.d.cts}

@@ -1,5 +1,5 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { a as GraphOptions, G as Graph } from './graph-C4SHb3Ly.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
+import { a as GraphOptions, G as Graph } from './graph-CWvEUQAq.cjs';
 
 /**
  * Domain templates (roadmap §8.2).

package/dist/{index-CJK1JkYy.d.ts → index-BmZXHqkE.d.ts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.js';
+import { N as Node } from './node-kK3CvTrR.js';
 
 /** Solid accessor function — returns current value when called. */
 type Accessor<T> = () => T;

package/dist/{index-pT8sCpOJ.d.ts → index-BoJ5JHxI.d.ts}

@@ -1,6 +1,6 @@
-import { n as GraphReFlyConfig } from './node-ClS5yC-B.js';
-import { r as GraphPersistSnapshot, i as GraphCheckpointRecord, G as Graph, C as CausalChain, c as CausalStep, e as DescribeFilter, E as ExplainPathOptions, f as GRAPH_META_SEGMENT, g as GraphActorOptions, h as GraphAttachStorageOptions, j as GraphDescribeOptions, b as GraphDescribeOutput, k as GraphDiagramDirection, l as GraphDiffChange, m as GraphDiffResult, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q 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-7VguS7a4.js';
-import { w as watchTopologyTree } from './topology-tree-BNGvuG82.js';
+import { l as GraphReFlyConfig } from './node-kK3CvTrR.js';
+import { r as GraphPersistSnapshot, i as GraphCheckpointRecord, G as Graph, C as CausalChain, c as CausalStep, e as DescribeFilter, E as ExplainPathOptions, f as GRAPH_META_SEGMENT, g as GraphActorOptions, h as GraphAttachStorageOptions, j as GraphDescribeOptions, b as GraphDescribeOutput, k as GraphDiagramDirection, l as GraphDiffChange, m as GraphDiffResult, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q 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-D9LFnda9.js';
+import { w as watchTopologyTree } from './topology-tree-xvaD0fOX.js';
 
 /**
  * Approximate in-memory size estimation for arbitrary JS values.
@@ -287,6 +287,15 @@ declare function replayWAL(entries: readonly WALEntry[]): GraphPersistSnapshot;
  * consumers are part of the design. If you have known external-consumer
  * roots, filter them from `result.orphans` before deciding what to act on.
  *
+ * **Synthetic `__internal__/` paths (EH-9).** Compound factories sometimes
+ * surface unnamed helper nodes under the `__internal__/` namespace
+ * (auto-generated when a producer / derived is added without a `name` and
+ * the registrar falls back to a synthetic prefix). These never represent
+ * user-authored topology and should not surface as actionable orphans;
+ * `validateNoIslands` filters them out before reporting. If a real factory
+ * regression accidentally leaks a user-meaningful node under this prefix,
+ * the fix is to give the node a real name — not to remove the filter.
+ *
  * **Non-throwing by default.** Returns a structured result so callers
  * (dry-run blocks, CI smoke tests) can exit non-zero with a diagnostic
  * instead of crashing.

package/dist/{index-BeT2r7sk.d.ts → index-BocU7pqs.d.ts}

@@ -1,7 +1,7 @@
-import { A as Actor, N as Node, W as PolicyRuleData, o as GuardAction } from './node-ClS5yC-B.js';
-import { G as Graph, a as GraphOptions, r as GraphPersistSnapshot, b as GraphDescribeOutput, j as GraphDescribeOptions, C as CausalChain, e as DescribeFilter } from './graph-7VguS7a4.js';
-import { T as TopicGraph } from './index-DBHK8O6H.js';
-import { w as watchTopologyTree } from './topology-tree-BNGvuG82.js';
+import { A as Actor, N as Node, W as PolicyRuleData, m as GuardAction } from './node-kK3CvTrR.js';
+import { G as Graph, a as GraphOptions, r as GraphPersistSnapshot, b as GraphDescribeOutput, j as GraphDescribeOptions, C as CausalChain, e as DescribeFilter } from './graph-D9LFnda9.js';
+import { T as TopicGraph } from './index-nozs3fFC.js';
+import { w as watchTopologyTree } from './topology-tree-xvaD0fOX.js';
 
 /**
  * Audit, policy enforcement, and compliance export (roadmap §9.2).
@@ -58,6 +58,25 @@ interface AuditTrailOptions {
 declare class AuditTrailGraph extends Graph {
     readonly entries: Node<readonly AuditEntry[]>;
     readonly count: Node<number>;
+    /**
+     * Effective set of event types this trail records (EH-18). Reflects
+     * either the caller-supplied `opts.includeTypes` or the default set
+     * (`["data", "error", "complete", "teardown"]`). Captured at construction
+     * — each instance owns its own clone, so a default-using trail can never
+     * leak mutations into the module-level default set.
+     *
+     * **Mutation contract.** Type-system read-only via `ReadonlySet`. Runtime
+     * mutation through an unsafe cast (`(audit.includeTypes as Set<...>)
+     * .add(...)`) is unsupported — it would desync the field from the
+     * recording closure, which captured the original `Set` reference at
+     * construction. The runtime does NOT enforce immutability beyond the
+     * type contract; consumers must respect it.
+     *
+     * Use this to validate that a `complianceSnapshot.fingerprint` was
+     * computed against the same recording surface — fingerprints are stable
+     * only when the recording set is identical across snapshots.
+     */
+    readonly includeTypes: ReadonlySet<AuditEntry["type"]>;
     private readonly _log;
     private readonly _target;
     constructor(target: Graph, opts: AuditTrailOptions);

package/dist/{index-ChOyVLKm.d.cts → index-BrPrLl4e.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
 
 /**
  * Options for creating an atom.

package/dist/{index-D-Xs74HZ.d.cts → index-BxNs2HB9.d.cts}

@@ -1,10 +1,10 @@
 import { NodeInput } from './extra/sources.cjs';
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { L as LLMAdapter } from './types-B1jDWVsM.cjs';
-import { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-3NmAfcH0.cjs';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-BTQtTb_H.cjs';
-import { a as GraphOptions, G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-C4SHb3Ly.cjs';
-import { G as GateController } from './pipeline-graph-WBlobVhU.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
+import { L as LLMAdapter } from './types-C0_yquda.cjs';
+import { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-DV_1YuVk.cjs';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-C5ri2Axc.cjs';
+import { a as GraphOptions, G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-CWvEUQAq.cjs';
+import { G as GateController } from './pipeline-graph-CIKhynsF.cjs';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).
@@ -153,6 +153,16 @@ interface IntakeItem {
     affectsAreas: string[];
     affectsEvalTasks?: string[];
     severity?: Severity;
+    /**
+     * Stable identity carrier for retry / reingestion paths. Per qa D1
+     * (2026-04-29), `relatedTo[0]` MUST be the original tracking key for
+     * items derived from a prior publish so the harness's `routeJobIds`
+     * map preserves identity across decorated retry summaries. First-time
+     * publishes leave this `undefined`; the tracking key falls back to
+     * `summary`. Two first-time publishes with identical `summary` collide
+     * on key — see `trackingKey` JSDoc in `patterns/_internal/index.ts`
+     * for the uniqueness caller contract.
+     */
     relatedTo?: string[];
     /** Item-carried reingestion count. Incremented on each full-loop reingestion. */
     $reingestions?: number;
@@ -325,7 +335,9 @@ interface HarnessJobPayload<A = unknown> {
  * wrapper. `refineExecutor` builds a per-claim `refineLoop`.
  * `actuatorExecutor` runs a side-effecting `apply(item, signal)`.
  */
-type HarnessExecutor<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>) => NodeInput<HarnessJobPayload<A>>;
+type HarnessExecutor<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>, opts?: {
+    signal: AbortSignal;
+}) => NodeInput<HarnessJobPayload<A>>;
 /**
  * Pluggable VERIFY work fn — receives a {@link JobEnvelope} whose payload
  * has `item` + `execution` populated, returns a {@link NodeInput} that
@@ -342,7 +354,9 @@ type HarnessExecutor<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>) =>
  * verified: false, findings: [...], errorClass: "structural" }`) so the
  * dispatch effect can route the item rather than silently drop it.
  */
-type HarnessVerifier<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>) => NodeInput<HarnessJobPayload<A>>;
+type HarnessVerifier<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>, opts?: {
+    signal: AbortSignal;
+}) => NodeInput<HarnessJobPayload<A>>;
 /** Triage prompt callable shape — pair of `[intake item, strategy snapshot]`. */
 type TriagePromptFn = (pair: readonly [IntakeItem, StrategySnapshot]) => string;
 /** Execute prompt callable shape. */
@@ -1478,7 +1492,17 @@ declare class HarnessGraph<A = unknown> extends Graph {
      * in to priority scoring.
      */
     readonly priorityScores?: ReadonlyMap<QueueRoute, Node<number>>;
-    constructor(name: string, queues: MessagingHubGraph, executeFlow: JobFlowGraph<HarnessJobPayload<A>>, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, priorityScores?: Map<QueueRoute, Node<number>>);
+    /**
+     * REFLECT-stage tick marker — emits one DATA per terminal verdict observed
+     * on `executeFlow.completed`. `equals: () => false` so each completion
+     * produces an observable tick (no Object.is collapse on identical
+     * `null` payloads). Inspection tools (`harnessTrace`, dashboards) can
+     * subscribe directly here instead of resolving by string path
+     * (`harness.node("reflect")`) — the field is the lock against rename
+     * drift.
+     */
+    readonly reflect: Node<null>;
+    constructor(name: string, queues: MessagingHubGraph, executeFlow: JobFlowGraph<HarnessJobPayload<A>>, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, reflect: Node<null>, priorityScores?: Map<QueueRoute, Node<number>>);
     /** Intake topic — publish items here to enter the loop. */
     get intake(): TopicGraph<IntakeItem>;
     /** Verify results topic — subscribe to see verification outcomes. */

package/dist/{index-Bf7eqeSF.d.ts → index-Byu-OpX_.d.ts}

@@ -1,5 +1,5 @@
-import { N as Node, a as NodeOptions } from './node-ClS5yC-B.js';
-import { a as GraphOptions, G as Graph } from './graph-7VguS7a4.js';
+import { N as Node, a as NodeOptions } from './node-kK3CvTrR.js';
+import { a as GraphOptions, G as Graph } from './graph-D9LFnda9.js';
 
 /**
  * Reduction primitives (roadmap §8.1).

package/dist/{index-BoLv_OfD.d.cts → index-C1T3d7V-.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
 
 /**
  * Backoff strategies for {@link retry} (roadmap §3.1). Delays are in **nanoseconds**.
@@ -227,8 +227,8 @@ type RetryFactoryOptions<T> = RetryOptions & {
  *
  * @category extra
  */
-declare function retry<T>(input: Node<T>, opts?: RetryOptions): Node<T>;
-declare function retry<T>(input: () => Node<T>, opts?: RetryFactoryOptions<T>): Node<T>;
+declare function retry<T>(input: Node<T>, opts?: NodeOrValue<RetryOptions>): Node<T>;
+declare function retry<T>(input: () => Node<T>, opts?: NodeOrValue<RetryFactoryOptions<T>>): Node<T>;
 type CircuitState = "closed" | "open" | "half-open";
 /**
  * Thrown when {@link withBreaker} is configured with `onOpen: "error"` and the breaker rejects work.
@@ -275,6 +275,13 @@ interface CircuitBreaker {
     readonly failureCount: number;
     /** Manually reset to closed state, clearing all counters. */
     reset(): void;
+    /**
+     * Release the reactive-options subscription (Tier 6.5 3.2.4, 2026-04-29).
+     * No-op when constructed with static options. Call when retiring a
+     * breaker whose options came from a `Node<CircuitBreakerOptions>` to
+     * avoid leaking the option-Node subscription.
+     */
+    dispose(): void;
 }
 /**
  * Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.
@@ -282,12 +289,24 @@ interface CircuitBreaker {
  * Supports escalating cooldown via an optional {@link BackoffStrategy} — each consecutive
  * open→half-open→open cycle increments the backoff attempt.
  *
- * @param options - Threshold, cooldown, half-open limit, and optional clock override.
+ * @param options - Threshold, cooldown, half-open limit, and optional clock
+ *   override; OR a `Node<CircuitBreakerOptions>` carrying the same shape
+ *   reactively (Tier 6.5 3.2.4).
  * @returns {@link CircuitBreaker} instance.
  *
  * @remarks
  * **Timing:** Uses `monotonicNs()` by default (nanoseconds). Override `now` for tests.
  *
+ * **Reactive options (locked semantics, Tier 6.5 3.2.4, 2026-04-29).**
+ * When `options` is a `Node<CircuitBreakerOptions>`, the breaker
+ * subscribes at construction and re-reads `failureThreshold` /
+ * `cooldownNs` / `cooldown` / `halfOpenMax` / `now` on each DATA. **An
+ * option swap RESETS the breaker to `"closed"`** with all counters
+ * cleared — operators tuning a runaway breaker get a clean baseline.
+ * If retaining failure history across re-tunings matters, derive a new
+ * breaker per-tuning instead. Call `breaker.dispose()` when retiring to
+ * release the option-Node subscription.
+ *
  * @example
  * ```ts
  * import { circuitBreaker, exponential, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
@@ -300,7 +319,7 @@ interface CircuitBreaker {
  *
  * @category extra
  */
-declare function circuitBreaker(options?: CircuitBreakerOptions): CircuitBreaker;
+declare function circuitBreaker(options?: NodeOrValue<CircuitBreakerOptions>): CircuitBreaker;
 type WithBreakerBundle<T> = {
     node: Node<T>;
     breakerState: Node<CircuitState>;
@@ -525,7 +544,7 @@ type RateLimiterBundle<T> = {
  *
  * @category extra
  */
-declare function rateLimiter<T>(source: Node<T>, opts: RateLimiterOptions): RateLimiterBundle<T>;
+declare function rateLimiter<T>(source: Node<T>, opts: NodeOrValue<RateLimiterOptions>): RateLimiterBundle<T>;
 type StatusValue = "pending" | "running" | "completed" | "errored";
 type WithStatusBundle<T> = {
     node: Node<T>;
@@ -557,6 +576,17 @@ type WithStatusBundle<T> = {
  * appear as edges in `describe()` if no consumer subscribes to them (per
  * COMPOSITION-GUIDE §1, push-on-subscribe semantics).
  *
+ * **Per-subscribe lifecycle (DF8, 2026-04-29 doc lock).** When the wrapped
+ * source is `resubscribable: true` and multiple consumers attach in
+ * sequence, each new subscription cycle re-runs the producer fn AND
+ * re-emits the initial `pending` + `null` companion DATAs. Downstream
+ * subscribers to the `status` / `error` companions see thrash:
+ * `pending → running → completed → pending → running …`. This is the
+ * intended fresh-cycle semantic (each subscription cycle reports its own
+ * lifecycle); consumers that need a "stable" status across cycles should
+ * derive a snapshot via a separate `state()` mirror rather than depending
+ * on the per-cycle reset.
+ *
  * @example
  * ```ts
  * import { withStatus, state } from "@graphrefly/graphrefly-ts";
@@ -583,6 +613,20 @@ declare class TimeoutError extends Error {
     name: string;
     constructor(ns: number);
 }
+/**
+ * Either a literal value or a reactive Node carrying it. Mirrors
+ * {@link FallbackInput}'s precedent for "options that may be reactive."
+ *
+ * Used by {@link timeout} / {@link retry} / {@link rateLimiter} /
+ * {@link circuitBreaker} / {@link budgetGate} to accept reactive option
+ * configurations (Tier 6.5 3.2, 2026-04-29). Each primitive subscribes
+ * to the option Node via {@link resolveReactiveOption} and rebinds
+ * internal state per its locked swap-semantic rule (see each primitive's
+ * JSDoc for the rule).
+ *
+ * @category extra
+ */
+type NodeOrValue<T> = T | Node<T>;
 /** Inputs accepted by {@link fallback}. */
 type FallbackInput<T> = T | Node<T> | PromiseLike<T> | AsyncIterable<T>;
 /**
@@ -626,7 +670,9 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  * the timer. Terminal messages (`COMPLETE`/`ERROR`) cancel the timer.
  *
  * @param source - Upstream node.
- * @param timeoutNs - Deadline in **nanoseconds** (must be > 0). Internally converted to milliseconds for `setTimeout` scheduling.
+ * @param timeoutNs - Deadline in **nanoseconds** (must be > 0), or a
+ *   `Node<number>` carrying the deadline reactively (Tier 6.5 3.2.1).
+ *   Internally converted to milliseconds for `setTimeout` scheduling.
  * @returns Node that errors on timeout.
  *
  * @throws {RangeError} when `timeoutNs <= 0`.
@@ -634,6 +680,13 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  * @remarks
  * **Scheduling:** internally uses {@link ResettableTimer} (raw `setTimeout`) per spec §5.10's resilience-operator carve-out. The deadline is `timeoutNs / NS_PER_MS` ms; sub-millisecond `timeoutNs` values get the same minimum-1ms host-scheduler granularity that `setTimeout` provides.
  *
+ * **Reactive `timeoutNs` (locked semantics, Tier 6.5 3.2.1, 2026-04-29).**
+ * When `timeoutNs` is a `Node<number>`, each timer-(re)start reads the
+ * latest value. An option swap mid-flight applies to the **next** timer
+ * window (no in-flight reset) — the active timer keeps its original
+ * deadline; the next DATA-driven `startTimer()` call reads the new
+ * value. Static-form callers see no behavior change.
+ *
  * @example
  * ```ts
  * import { timeout, never, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
@@ -644,7 +697,7 @@ declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>, options?: {
  *
  * @category extra
  */
-declare function timeout<T>(source: Node<T>, timeoutNs: number, options?: {
+declare function timeout<T>(source: Node<T>, timeoutNs: NodeOrValue<number>, options?: {
     meta?: Record<string, unknown>;
 }): Node<T>;
 

package/dist/{index-BTQtTb_H.d.cts → index-C5ri2Axc.d.cts}

@@ -1,6 +1,6 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { G as Graph, a as GraphOptions } from './graph-C4SHb3Ly.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-B00laMSQ.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
+import { G as Graph, a as GraphOptions } from './graph-CWvEUQAq.cjs';
+import { a as ReactiveLogBundle } from './reactive-log-DIGdYqQ6.cjs';
 import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
 
 type TopicOptions = {

package/dist/{index-z96luz5O.d.cts → index-C5stwKcw.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
+import { N as Node } from './node-kK3CvTrR.cjs';
 
 /**
  * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.

package/dist/{index-CZmcDtFn.d.ts → index-C9l6OEBL.d.ts}

@@ -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-v8fMvqNk.js';
+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-Sgj0gCwn.js';
 
 /**
  * Orchestration patterns (roadmap §4.1).

package/dist/{index-CCq87F7t.d.ts → index-CBBLl_rc.d.ts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-ClS5yC-B.js';
+import { N as Node } from './node-kK3CvTrR.js';
 
 /**
  * A Nanostores-compatible atom.

package/dist/{index-D6egPFAL.d.ts → index-CBGUK09R.d.ts}

@@ -1,9 +1,9 @@
-import { T as ToObservableOptions, t as toObservable } from './observable-BsBzUrcI.js';
+import { T as ToObservableOptions, t as toObservable } from './observable-DWjNfLvC.js';
 import { OnModuleInit, OnModuleDestroy, ExecutionContext, CanActivate, DynamicModule } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { G as Graph, r as GraphPersistSnapshot } from './graph-7VguS7a4.js';
-import { A as Actor } from './node-ClS5yC-B.js';
-import { c as CqrsOptions, b as CqrsGraph, a as CqrsEvent } from './index-D8l8hNXn.js';
+import { G as Graph, r as GraphPersistSnapshot } from './graph-D9LFnda9.js';
+import { A as Actor } from './node-kK3CvTrR.js';
+import { c as CqrsOptions, b as CqrsGraph, a as CqrsEvent } from './index-CeFiHtAg.js';
 import { AppendLogStorageTier } from './extra/storage-tiers.js';
 
 /** Class constructor key for decorator registries and Nest `ModuleRef.get()`. */