@graphrefly/graphrefly 0.38.0 → 0.40.0

package/dist/{index-Di7OdwlO.d.ts → index-bXXLSvor.d.ts}

@@ -1,17 +1,19 @@
-import { a as Node } from './node-fSc-hCv8.js';
-import { R as ReactiveLogBundle } from './reactive-log-BgWSA1fg.js';
-import { G as Graph } from './graph-BjW1taJl.js';
-import { B as BaseAuditRecord } from './imperative-audit-ahAE65a9.js';
+import { N as Node } from './node-BYInONRr.js';
+import { B as BaseAuditRecord } from './index-BQ1fR4li.js';
+import { a as ReactiveLogBundle } from './reactive-log-BlAsPLl2.js';
+import { G as Graph } from './graph-BkIkog4h.js';
 
 /**
  * Memory patterns (roadmap §4.3) — public-face Phase-4 primitives audited under
  * `archive/docs/SESSION-public-face-blocks-review.md` (Wave A, locked 2026-04-25).
  *
- * Five primitives:
- * - {@link decay} — pure exponential-decay utility.
- * - {@link lightCollection} — Map + LRU eviction + audit log; non-Graph bundle.
- * - {@link collection} / {@link CollectionGraph} — scored memory store with live
- *   decay-ranking via reactive timer dep.
+ * Three primitives (the pure `decay` helper was promoted to `extra/utils/decay.ts`
+ * per Tier 2.2 and is no longer re-exported here; `lightCollection` was folded
+ * into `collection({ranked:false})` per Tier 2.3 and is no longer a separate
+ * factory):
+ * - {@link collection} / {@link CollectionGraph} — keyed memory store with
+ *   optional decay-aware ranking. Pass `{ ranked: false }` for the previous
+ *   `lightCollection` shape (Map + LRU + audit, no scoring).
  * - {@link vectorIndex} / {@link VectorIndexGraph} — reactive vector store with
  *   optional HNSW backend, retention, and reactive {@link VectorIndexGraph.searchNode}.
  * - {@link knowledgeGraph} / {@link KnowledgeGraph} — entities + typed edges with
@@ -29,23 +31,6 @@ import { B as BaseAuditRecord } from './imperative-audit-ahAE65a9.js';
  * @module
  */
 
-/**
- * Exponential decay with floor: `score = max(minScore, baseScore * exp(-ratePerSecond * ageSeconds))`.
- *
- * Tolerant fallbacks (deliberate for use inside reactive derived fns):
- * - non-finite `baseScore` → `minScore`
- * - non-positive `ageSeconds` (incl. clock skew) → `max(minScore, baseScore)` (no decay)
- * - non-positive `ratePerSecond` → `max(minScore, baseScore)` (no decay; rate=0 disables)
- *
- * Underflow boundary: `Math.exp(-745) === 0`. For very long ages × rates the
- * result clamps to `minScore`; if you need slow decay over years, choose a
- * smaller `ratePerSecond` rather than relying on graceful underflow.
- *
- * Half-life conversion: `ratePerSecond = Math.LN2 / halfLifeSeconds`.
- *
- * @category memory
- */
-declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: number, minScore?: number): number;
 /**
  * Cosine similarity over `(a, b)`. When lengths differ, the shorter is
  * implicitly zero-padded to the longer length. Returns `0` if either vector
@@ -66,66 +51,11 @@ declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: num
 declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
 /** Public alias for the `Node | value` shape accepted by reactive read factories. */
 type NodeOrValue<T> = T | Node<T>;
-type LightCollectionEntry<T> = {
+type CollectionEntry<T> = {
     readonly id: string;
     readonly value: T;
     readonly createdAtNs: number;
     readonly lastAccessNs: number;
-};
-type LightCollectionOptions = {
-    name?: string;
-    maxSize?: number;
-};
-interface LightCollectionAuditRecord extends BaseAuditRecord {
-    readonly action: "upsert" | "remove" | "clear";
-    readonly id?: string;
-}
-type LightCollectionBundle<T> = {
-    readonly entries: Node<ReadonlyMap<string, LightCollectionEntry<T>>>;
-    readonly events: ReactiveLogBundle<LightCollectionAuditRecord>;
-    upsert: (id: string, value: T) => void;
-    remove: (id: string) => void;
-    clear: () => void;
-    itemNode: (id: NodeOrValue<string>) => Node<LightCollectionEntry<T> | undefined>;
-    hasNode: (id: NodeOrValue<string>) => Node<boolean>;
-};
-/**
- * Reactive Map of {@link LightCollectionEntry} with native LRU eviction by
- * `maxSize`. Backed by `reactiveMap` so iteration order, snapshot delivery,
- * and copy-on-write semantics match the rest of the data-structure tier.
- *
- * **No-Graph composition.** `bundle.entries` is a detached `state()` — mount
- * manually with `parent.add(bundle.entries)` for `describe()` / `lens.flow`
- * coverage.
- *
- * **`createdAtNs` preservation.** Re-upserting an existing id keeps the
- * original `createdAtNs`; only `lastAccessNs` advances. Eviction is purely
- * LRU-by-`lastAccessNs` (newest wins) via `reactiveMap`'s native `maxSize`.
- *
- * **No imperative reads.** Per the no-imperative-reads policy: subscribe to
- * `entries` for the live snapshot, or use `itemNode(id)` / `hasNode(id)` for
- * single-key reactive reads. For one-shot snapshots use `firstValueFrom` or
- * `node.cache` after `awaitSettled`.
- *
- * **Audit log freeze contract.** Mutations are wrapped via `lightMutation`,
- * which deep-freezes args at entry by default (per the Audit 2 framework).
- * That means the `value` you pass to `upsert(id, value)` is frozen by the
- * time it lands in `LightCollectionEntry.value`. If you store mutable
- * payloads and need them mutable post-upsert, opt out via `lightMutation`'s
- * `freeze: false` (currently internal — not exposed on the bundle; if you
- * hit this, file in `docs/optimizations.md`).
- *
- * **Audit no-op records.** Mutations record an audit entry even when the
- * impl was a no-op (`remove(id)` for a missing id, `clear()` on empty store).
- * The framework records attempts, not state changes — this is intentional
- * (see `_internal/imperative-audit.ts` rationale). Audit consumers that
- * reconstruct state by replaying records can ignore no-op redundant entries
- * without losing correctness.
- *
- * @category memory
- */
-declare function lightCollection<T>(opts?: LightCollectionOptions): LightCollectionBundle<T>;
-type CollectionEntry<T> = LightCollectionEntry<T> & {
     readonly baseScore: number;
 };
 type RankedCollectionEntry<T> = CollectionEntry<T> & {
@@ -134,11 +64,22 @@ type RankedCollectionEntry<T> = CollectionEntry<T> & {
 type CollectionScoreFn<T> = (value: T) => number;
 type CollectionOptions<T> = {
     maxSize?: number;
+    /**
+     * Whether to expose a live decay-aware `ranked` node + `rescore` mutator.
+     * Default `true`. Pass `false` to fold in the previous `lightCollection`
+     * shape — entries are still keyed/audited/LRU-evicted, but the timer-driven
+     * `ranked` + scoring machinery is skipped. `ranked` then resolves to a
+     * static empty array Node and `rescore()` is a no-op (so callers writing
+     * type-generic code don't need to special-case the unranked path).
+     */
+    ranked?: boolean;
     /**
      * Produces a base score at insert/update time. Static fn or a reactive
      * `Node<(value: T) => number>` — when supplied as a Node, `ranked` re-derives
      * whenever the score fn changes, but `baseScore` on each entry is only
      * recomputed via {@link CollectionGraph.rescore}. Default `() => 1`.
+     *
+     * Ignored when `ranked: false` (entries record `baseScore: 0`).
      */
     score?: CollectionScoreFn<T> | Node<CollectionScoreFn<T>>;
     /**
@@ -146,6 +87,8 @@ type CollectionOptions<T> = {
      * positive, `ranked` becomes fully reactive on time via a `fromTimer` source
      * (cadence auto-derived from `decayRate` unless overridden via
      * `refreshIntervalMs`). Half-life: `ratePerSecond = Math.LN2 / halfLifeSeconds`.
+     *
+     * Ignored when `ranked: false`.
      */
     decayRate?: number;
     /** Minimum score floor after decay. Default `0`. */
@@ -164,6 +107,11 @@ interface CollectionAuditRecord extends BaseAuditRecord {
 type CollectionGraph<T> = Graph & {
     readonly events: ReactiveLogBundle<CollectionAuditRecord>;
     readonly items: Node<ReadonlyMap<string, CollectionEntry<T>>>;
+    /**
+     * Live decay-aware ranking, sorted by score descending. When the
+     * collection was constructed with `ranked: false`, this is a static
+     * empty-array Node (kept for type uniformity).
+     */
     readonly ranked: Node<readonly RankedCollectionEntry<T>[]>;
     readonly size: Node<number>;
     upsert: (id: string, value: T, opts?: {
@@ -175,9 +123,14 @@ type CollectionGraph<T> = Graph & {
      * Recompute every entry's `baseScore` via the latest score fn. O(N). Useful
      * when a reactive `score` Node has emitted a new fn and the caller wants
      * existing entries re-scored without an explicit re-upsert.
+     *
+     * No-op (still records an audit entry) when constructed with
+     * `ranked: false`.
      */
     rescore: () => void;
     itemNode: (id: NodeOrValue<string>) => Node<CollectionEntry<T> | undefined>;
+    /** Reactive `true` once the entry exists; tracks upsert / remove. */
+    hasNode: (id: NodeOrValue<string>) => Node<boolean>;
 };
 /**
  * Scored memory store with live decay-aware ranking.
@@ -402,10 +355,6 @@ type index_KnowledgeEdge<TRelation extends string = string> = KnowledgeEdge<TRel
 type index_KnowledgeGraph<TEntity, TRelation extends string = string> = KnowledgeGraph<TEntity, TRelation>;
 type index_KnowledgeGraphAuditRecord = KnowledgeGraphAuditRecord;
 type index_KnowledgeGraphOptions = KnowledgeGraphOptions;
-type index_LightCollectionAuditRecord = LightCollectionAuditRecord;
-type index_LightCollectionBundle<T> = LightCollectionBundle<T>;
-type index_LightCollectionEntry<T> = LightCollectionEntry<T>;
-type index_LightCollectionOptions = LightCollectionOptions;
 type index_NodeOrValue<T> = NodeOrValue<T>;
 type index_RankedCollectionEntry<T> = RankedCollectionEntry<T>;
 type index_VectorBackend = VectorBackend;
@@ -416,12 +365,10 @@ type index_VectorRecord<TMeta> = VectorRecord<TMeta>;
 type index_VectorSearchResult<TMeta> = VectorSearchResult<TMeta>;
 declare const index_collection: typeof collection;
 declare const index_cosineSimilarity: typeof cosineSimilarity;
-declare const index_decay: typeof decay;
 declare const index_knowledgeGraph: typeof knowledgeGraph;
-declare const index_lightCollection: typeof lightCollection;
 declare const index_vectorIndex: typeof vectorIndex;
 declare namespace index {
-  export { type index_CollectionAuditRecord as CollectionAuditRecord, type index_CollectionEntry as CollectionEntry, type index_CollectionGraph as CollectionGraph, type index_CollectionOptions as CollectionOptions, type index_CollectionScoreFn as CollectionScoreFn, type index_HnswAdapter as HnswAdapter, type index_KnowledgeEdge as KnowledgeEdge, type index_KnowledgeGraph as KnowledgeGraph, type index_KnowledgeGraphAuditRecord as KnowledgeGraphAuditRecord, type index_KnowledgeGraphOptions as KnowledgeGraphOptions, type index_LightCollectionAuditRecord as LightCollectionAuditRecord, type index_LightCollectionBundle as LightCollectionBundle, type index_LightCollectionEntry as LightCollectionEntry, type index_LightCollectionOptions as LightCollectionOptions, type index_NodeOrValue as NodeOrValue, type index_RankedCollectionEntry as RankedCollectionEntry, type index_VectorBackend as VectorBackend, type index_VectorIndexAuditRecord as VectorIndexAuditRecord, type index_VectorIndexGraph as VectorIndexGraph, type index_VectorIndexOptions as VectorIndexOptions, type index_VectorRecord as VectorRecord, type index_VectorSearchResult as VectorSearchResult, index_collection as collection, index_cosineSimilarity as cosineSimilarity, index_decay as decay, index_knowledgeGraph as knowledgeGraph, index_lightCollection as lightCollection, index_vectorIndex as vectorIndex };
+  export { type index_CollectionAuditRecord as CollectionAuditRecord, type index_CollectionEntry as CollectionEntry, type index_CollectionGraph as CollectionGraph, type index_CollectionOptions as CollectionOptions, type index_CollectionScoreFn as CollectionScoreFn, type index_HnswAdapter as HnswAdapter, type index_KnowledgeEdge as KnowledgeEdge, type index_KnowledgeGraph as KnowledgeGraph, type index_KnowledgeGraphAuditRecord as KnowledgeGraphAuditRecord, type index_KnowledgeGraphOptions as KnowledgeGraphOptions, type index_NodeOrValue as NodeOrValue, type index_RankedCollectionEntry as RankedCollectionEntry, type index_VectorBackend as VectorBackend, type index_VectorIndexAuditRecord as VectorIndexAuditRecord, type index_VectorIndexGraph as VectorIndexGraph, type index_VectorIndexOptions as VectorIndexOptions, type index_VectorRecord as VectorRecord, type index_VectorSearchResult as VectorSearchResult, index_collection as collection, index_cosineSimilarity as cosineSimilarity, index_knowledgeGraph as knowledgeGraph, index_vectorIndex as vectorIndex };
 }
 
-export { type CollectionAuditRecord as C, type HnswAdapter as H, type KnowledgeGraph as K, type LightCollectionBundle as L, type NodeOrValue as N, type RankedCollectionEntry as R, type VectorSearchResult as V, type VectorIndexGraph as a, type CollectionEntry as b, type CollectionGraph as c, type CollectionOptions as d, type CollectionScoreFn as e, type KnowledgeEdge as f, type KnowledgeGraphAuditRecord as g, type KnowledgeGraphOptions as h, index as i, type LightCollectionAuditRecord as j, type LightCollectionEntry as k, type LightCollectionOptions as l, type VectorBackend as m, type VectorIndexAuditRecord as n, type VectorIndexOptions as o, type VectorRecord as p, collection as q, cosineSimilarity as r, decay as s, knowledgeGraph as t, lightCollection as u, vectorIndex as v };
+export { type CollectionGraph as C, type HnswAdapter as H, type KnowledgeGraph as K, type NodeOrValue as N, type RankedCollectionEntry as R, type VectorSearchResult as V, type VectorIndexGraph as a, type CollectionAuditRecord as b, type CollectionEntry as c, type CollectionOptions as d, type CollectionScoreFn as e, type KnowledgeEdge as f, type KnowledgeGraphAuditRecord as g, type KnowledgeGraphOptions as h, index as i, type VectorBackend as j, type VectorIndexAuditRecord as k, type VectorIndexOptions as l, type VectorRecord as m, collection as n, cosineSimilarity as o, knowledgeGraph as p, vectorIndex as v };

package/dist/index-da2V5vPy.d.ts

@@ -0,0 +1,113 @@
+import { N as Node, a as NodeOptions } from './node-BYInONRr.js';
+import { a as GraphOptions, G as Graph } from './graph-BkIkog4h.js';
+
+/**
+ * Reduction primitives (roadmap §8.1).
+ *
+ * Composable building blocks for taking heterogeneous massive inputs and producing
+ * prioritized, auditable, human-actionable output. Each primitive is either a Graph
+ * factory or a Node factory, built on top of core + extra primitives.
+ *
+ * @module
+ */
+
+type StepRef = string | Node<unknown>;
+/** A named stage for {@link funnel}. */
+type FunnelStage = {
+    /** Stage name (mounted as subgraph). */
+    name: string;
+    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
+    build: (sub: Graph) => void;
+};
+/** Options for {@link funnel}. */
+type FunnelOptions = GraphOptions & {
+    meta?: Record<string, unknown>;
+};
+/**
+ * Multi-source merge with sequential reduction stages.
+ *
+ * Sources are merged into a single stream. Each stage is a named subgraph
+ * (mounted via `graph.mount()`). Stages connect linearly:
+ * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
+ *
+ * @param name - Graph name.
+ * @param sources - Input nodes to merge.
+ * @param stages - Sequential reduction stages.
+ * @param opts - Optional graph/meta options.
+ * @returns Graph with `"merged"` and mounted stage subgraphs.
+ *
+ * @category patterns
+ */
+declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
+/** Options for {@link feedback}. */
+type FeedbackOptions = {
+    /** Maximum feedback iterations before stopping (default: 10). */
+    maxIterations?: number;
+    /** Optional budget gate node path for cost-bounded iteration. */
+    budgetNode?: StepRef;
+    meta?: Record<string, unknown>;
+};
+/**
+ * Introduce a bounded reactive cycle into an existing graph.
+ *
+ * When `condition` emits a non-null DATA value, the feedback effect routes it
+ * back to the `reentry` state node — creating a cycle. Bounded by
+ * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
+ * is the source of truth — reset it to 0 to allow more iterations.
+ *
+ * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
+ *
+ * @param graph - Existing graph to augment with a feedback cycle.
+ * @param condition - Path to a node whose DATA triggers feedback.
+ * @param reentry - Path to a state node that receives the feedback value.
+ * @param opts - Iteration bounds and metadata.
+ * @returns The same graph (mutated with feedback nodes added).
+ *
+ * @category patterns
+ */
+declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
+/** A scored item with full breakdown. */
+type ScoredItem<T = unknown> = {
+    /** Original value. */
+    value: T;
+    /** Final weighted score. */
+    score: number;
+    /** Per-signal breakdown: signal index → weighted contribution. */
+    breakdown: number[];
+};
+/** Options for {@link scorer}. */
+type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    meta?: Record<string, unknown>;
+    /** Custom scoring function per signal. Default: identity (signal value IS the score). */
+    scoreFns?: ReadonlyArray<(value: unknown) => number>;
+};
+/**
+ * Reactive multi-signal scoring with live weights.
+ *
+ * Each source emits items to score. Weights are reactive state nodes that
+ * LLM or human can adjust live. Output is sorted scored items with full
+ * breakdown.
+ *
+ * @param sources - Signal nodes (each emits a numeric score dimension).
+ * @param weights - Reactive weight nodes (one per source).
+ * @param opts - Optional node/meta options.
+ * @returns Node emitting scored output.
+ *
+ * @category patterns
+ */
+declare function scorer(sources: ReadonlyArray<Node<number>>, weights: ReadonlyArray<Node<number>>, opts?: ScorerOptions): Node<ScoredItem<number[]>>;
+
+type index_FeedbackOptions = FeedbackOptions;
+type index_FunnelOptions = FunnelOptions;
+type index_FunnelStage = FunnelStage;
+type index_ScoredItem<T = unknown> = ScoredItem<T>;
+type index_ScorerOptions = ScorerOptions;
+type index_StepRef = StepRef;
+declare const index_feedback: typeof feedback;
+declare const index_funnel: typeof funnel;
+declare const index_scorer: typeof scorer;
+declare namespace index {
+  export { type index_FeedbackOptions as FeedbackOptions, type index_FunnelOptions as FunnelOptions, type index_FunnelStage as FunnelStage, type index_ScoredItem as ScoredItem, type index_ScorerOptions as ScorerOptions, type index_StepRef as StepRef, index_feedback as feedback, index_funnel as funnel, index_scorer as scorer };
+}
+
+export { type FeedbackOptions as F, type ScoredItem as S, type FunnelOptions as a, type FunnelStage as b, type ScorerOptions as c, type StepRef as d, funnel as e, feedback as f, index as i, scorer as s };

package/dist/{index-DY2f2b9z.d.ts → index-eaQuGJnv.d.ts}

@@ -1,6 +1,6 @@
-import { b as Messages, A as Actor, C as COMPLETE, g as COMPLETE_MSG, h as COMPLETE_ONLY_BATCH, D as DATA, i as DEFAULT_ACTOR, j as DIRTY, k as DIRTY_MSG, l as DIRTY_ONLY_BATCH, m as DepRecord, E as ERROR, F as FnCtx, n as GlobalInspectorEvent, o as GlobalInspectorHook, p as GraphReFlyConfig, G as GuardAction, q as GuardDenied, r as GuardDeniedDetails, H as HashFn, I as INVALIDATE, s as INVALIDATE_MSG, t as INVALIDATE_ONLY_BATCH, M as Message, u as MessageContext, v as MessageTypeRegistration, w as MessageTypeRegistrationInput, a as Node, c as NodeActions, x as NodeCtx, e as NodeDescribeKind, y as NodeFn, d as NodeFnCleanup, f 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 RigorRecorder, a0 as START, a1 as START_MSG, a2 as SubscribeContext, a3 as TEARDOWN, a4 as TEARDOWN_MSG, a5 as TEARDOWN_ONLY_BATCH, a6 as V0, a7 as V1, V as VersioningLevel, a8 as VersioningOptions, a9 as accessHintForGuard, aa as advanceVersion, ab as configure, ac as createVersioning, ad as defaultConfig, ae as defaultHash, af as isV1, ag as node, ah as normalizeActor, ai as policy, aj as policyFromRules, ak as registerBuiltins } from './node-fSc-hCv8.js';
-import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, f as factoryTag, p as placeholderArgs, r as resolveDescribeFields } from './meta-BYqlATmg.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-D13E2M_z.js';
+import { M 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, t as Message, u as MessageContext, v as MessageTypeRegistration, w as MessageTypeRegistrationInput, N as Node, c as NodeActions, x as NodeCtx, e as NodeDescribeKind, y as NodeFn, d as NodeFnCleanup, b as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, a 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 RigorRecorder, a0 as START, a1 as START_MSG, a2 as SubscribeContext, a3 as TEARDOWN, a4 as TEARDOWN_MSG, a5 as TEARDOWN_ONLY_BATCH, a6 as V0, a7 as V1, V as VersioningLevel, a8 as VersioningOptions, a9 as accessHintForGuard, aa as advanceVersion, ab as configure, ac as createVersioning, ad as defaultConfig, ae as defaultHash, af as isV1, ag as node, ah as normalizeActor, ai as policy, aj as policyFromRules, ak as registerBuiltins } from './node-BYInONRr.js';
+import { a as DescribeDetail, b as DescribeField, D as DescribeNodeOutput, f as factoryTag, p as placeholderArgs, r as resolveDescribeFields } from './meta-D8OyedKp.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-BhfjgetH.js';
 
 /**
  * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside

package/dist/{index-BsgxnHN8.d.cts → index-t6L2qpHh.d.cts}

@@ -1,7 +1,7 @@
-import { a as Node } from './node-fSc-hCv8.cjs';
+import { N as Node } from './node-BYInONRr.cjs';
 import { NodeInput } from './extra/sources.cjs';
-import { a as GraphOptions, G as Graph } from './graph-CHsVwf9S.cjs';
-import { T as TopicGraph } from './index-BpMZzX9P.cjs';
+import { a as GraphOptions, G as Graph } from './graph-E6likq7w.cjs';
+import { T as TopicGraph } from './index-Cnr1WrlX.cjs';
 
 /**
  * refineLoop — universal prompt/artifact optimization loop as a reactive Graph.

package/dist/{index-C-3UXnHT.d.cts → index-tV3AA9hI.d.cts}

@@ -1,5 +1,5 @@
-import { a as Node } from './node-fSc-hCv8.cjs';
-import { a as GraphOptions, G as Graph } from './graph-CHsVwf9S.cjs';
+import { N as Node } from './node-BYInONRr.cjs';
+import { a as GraphOptions, G as Graph } from './graph-E6likq7w.cjs';
 
 /**
  * Domain templates (roadmap §8.2).

package/dist/{index-8OxXae3g.d.ts → index-yLt-aPMp.d.ts}

@@ -1,4 +1,4 @@
-import { a as Node } from './node-fSc-hCv8.js';
+import { N as Node } from './node-BYInONRr.js';
 
 /**
  * A Nanostores-compatible atom.

package/dist/{index-CqSJ25A9.d.cts → index-z8WFPVI8.d.cts}

@@ -1,5 +1,5 @@
 import { Ref, WatchSource } from 'vue';
-import { a as Node } from './node-fSc-hCv8.cjs';
+import { N as Node } from './node-BYInONRr.cjs';
 
 /**
  * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.