@graphrefly/graphrefly 0.46.0 → 0.47.1

package/dist/utils/index.cjs

@@ -43,9 +43,9 @@ function resolveReactiveOption(arg, onChange) {
   if (!isNode(arg)) {
     return { current: () => arg, unsub: () => void 0 };
   }
-  const node58 = arg;
-  let latest = node58.cache;
-  const unsub = node58.subscribe((msgs) => {
+  const node65 = arg;
+  let latest = node65.cache;
+  const unsub = node65.subscribe((msgs) => {
     for (const m of msgs) {
       if (m[0] === import_core13.DATA) {
         latest = m[1];
@@ -378,6 +378,7 @@ __export(utils_exports, {
   JobFlowGraph: () => JobFlowGraph,
   JobQueueGraph: () => JobQueueGraph,
   LLMTimeoutError: () => LLMTimeoutError,
+  LogProjectorGraph: () => LogProjectorGraph,
   MemoryRetrievalGraph: () => MemoryRetrievalGraph,
   MemoryWithKGGraph: () => MemoryWithKGGraph,
   MemoryWithTiersGraph: () => MemoryWithTiersGraph,
@@ -414,6 +415,7 @@ __export(utils_exports, {
   actuatorExecutor: () => actuatorExecutor,
   adaptiveRateLimiter: () => adaptiveRateLimiter,
   admissionFilter3D: () => admissionFilter3D,
+  admissionLlmJudge: () => admissionLlmJudge,
   admissionScored: () => admissionScored,
   affectedTaskFilter: () => affectedTaskFilter,
   analyzeAndMeasure: () => analyzeAndMeasure,
@@ -422,6 +424,7 @@ __export(utils_exports, {
   auditTrail: () => auditTrail,
   autoSolidify: () => autoSolidify,
   beforeAfterCompare: () => beforeAfterCompare,
+  bitemporalQuery: () => bitemporalQuery,
   budgetGate: () => budgetGate,
   carveTextLineSlots: () => carveTextLineSlots,
   cascadingLlmAdapter: () => cascadingLlmAdapter,
@@ -440,6 +443,7 @@ __export(utils_exports, {
   computeLineBreaks: () => computeLineBreaks,
   computePrice: () => computePrice,
   computeTotalHeight: () => computeTotalHeight,
+  consolidationRem: () => consolidationRem,
   contentGate: () => contentGate,
   contentModerationGraph: () => contentModerationGraph,
   cosineSimilarity: () => cosineSimilarity,
@@ -452,6 +456,7 @@ __export(utils_exports, {
   createIntakeBridge: () => createIntakeBridge,
   createPricingRegistry: () => createPricingRegistry,
   dataQualityGraph: () => dataQualityGraph,
+  decayExponential: () => decayExponential,
   decisionKeyOf: () => decisionKeyOf,
   decompileSpec: () => decompileSpec,
   defaultErrorClassifier: () => defaultErrorClassifier,
@@ -481,6 +486,8 @@ __export(utils_exports, {
   healthReportEqual: () => healthReportEqual,
   hubRemoveTopicKeyOf: () => hubRemoveTopicKeyOf,
   humanInput: () => humanInput,
+  influenceAnalysis: () => influenceAnalysis,
+  invalidationTracer: () => invalidationTracer,
   isRichFnEntry: () => isRichFnEntry,
   isRichSourceEntry: () => isRichSourceEntry,
   issueTrackerGraph: () => issueTrackerGraph,
@@ -496,6 +503,7 @@ __export(utils_exports, {
   llmConsolidator: () => llmConsolidator,
   llmExtractor: () => llmExtractor,
   llmRefine: () => llmRefine,
+  logProjector: () => logProjector,
   measureBlock: () => measureBlock,
   measureBlocks: () => measureBlocks,
   memoryRetrieval: () => memoryRetrieval,
@@ -508,6 +516,7 @@ __export(utils_exports, {
   observableAdapter: () => observableAdapter,
   openAICompatAdapter: () => openAICompatAdapter,
   parseRateLimitFromError: () => parseRateLimitFromError,
+  persistentReactiveFactStore: () => persistentReactiveFactStore,
   pipelineGraph: () => pipelineGraph,
   policyGate: () => policyGate,
   pricingFor: () => pricingFor,
@@ -533,6 +542,8 @@ __export(utils_exports, {
   sagaInvocationKeyOf: () => sagaInvocationKeyOf,
   saveSnapshot: () => saveSnapshot,
   scorer: () => scorer,
+  scoringByOutcome: () => scoringByOutcome,
+  shardByTenant: () => shardByTenant,
   specDiff: () => specDiff,
   strategyKey: () => strategyKey,
   strategyModel: () => strategyModel,
@@ -6079,6 +6090,113 @@ function subscription(name, topicGraph, opts) {
 function topicBridge(name, sourceTopic, targetTopic, opts) {
   return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
 }
+var LogProjectorGraph = class extends import_graph2.Graph {
+  /** Reactive count of fully-projected entries (the cursor; read-only). */
+  position;
+  /**
+   * Poison entries (populated when `onPoison: "deadLetter"`). A real topic —
+   * subscribable + visible in `describe()`.
+   */
+  deadLetter;
+  _inFlight = Promise.resolve();
+  constructor(name, source, opts) {
+    super(name, opts.graph);
+    const onPoison = opts.onPoison ?? "halt";
+    const sink = opts.sink;
+    const dl = new TopicGraph(`${name}_dead_letter`, {
+      retainedLimit: opts.deadLetterRetainedLimit ?? DEFAULT_TOPIC_RETAINED_LIMIT
+    });
+    this.mount("deadLetter", dl);
+    this.deadLetter = dl;
+    let available;
+    let cursorBase;
+    let advance;
+    if (source instanceof TopicGraph) {
+      const sub = new SubscriptionGraph(`${name}_subscription`, source, {
+        from: opts.from ?? "retained"
+      });
+      this.mount("subscription", sub);
+      available = sub.available;
+      this.position = sub.cursor;
+      cursorBase = () => sub.cursor.cache;
+      advance = (n) => {
+        if (n > 0) sub.ack(n);
+      };
+    } else {
+      const log = source;
+      let initialCursor;
+      if (opts.from === "now") {
+        initialCursor = log.size;
+      } else if (typeof opts.from === "number") {
+        initialCursor = requireNonNegativeInt(opts.from, "logProjector from");
+      } else {
+        initialCursor = 0;
+      }
+      const cursor = this.state("cursor", initialCursor, {
+        meta: messagingMeta("log_projector_cursor")
+      });
+      this.position = cursor;
+      cursorBase = () => cursor.cache;
+      available = log.view({ kind: "fromCursor", cursor });
+      advance = (n) => {
+        if (n > 0) cursor.emit(cursor.cache + n);
+      };
+    }
+    let halted = false;
+    const runDrain = async () => {
+      if (halted) return;
+      const snapshot = available.cache ?? [];
+      if (snapshot.length === 0) return;
+      let consumed = 0;
+      for (let i = 0; i < snapshot.length; i += 1) {
+        const item = snapshot[i];
+        try {
+          await sink(item);
+          consumed += 1;
+        } catch (e) {
+          const error = e instanceof Error ? e.message : String(e);
+          if (onPoison === "deadLetter") {
+            dl.publish({ item, error, cursorPos: cursorBase() + consumed });
+            consumed += 1;
+            continue;
+          }
+          halted = true;
+          break;
+        }
+      }
+      if (consumed > 0) advance(consumed);
+    };
+    const schedule = () => {
+      if (halted) return;
+      this._inFlight = this._inFlight.then(runDrain, runDrain);
+    };
+    const drain = (0, import_core30.node)(
+      [available],
+      (batchData, _actions, ctx) => {
+        const b = batchData[0];
+        const snap = b != null && b.length > 0 ? b.at(-1) : ctx.prevData[0];
+        if (snap && snap.length > 0) schedule();
+      },
+      {
+        name: "drain",
+        describeKind: "effect",
+        meta: messagingMeta("log_projector_drain")
+      }
+    );
+    this.add(drain, { name: "drain" });
+    this.addDisposer((0, import_extra21.keepalive)(drain));
+  }
+  /**
+   * Await any in-flight drain pass. **Test convenience only** — the canonical
+   * reactive observable is {@link LogProjectorGraph.position}.
+   */
+  idle() {
+    return this._inFlight;
+  }
+};
+function logProjector(name, source, opts) {
+  return new LogProjectorGraph(name, source, opts);
+}
 
 // src/utils/orchestration/human-input.ts
 var import_core31 = require("@graphrefly/pure-ts/core");
@@ -7609,8 +7727,8 @@ function admissionFilter3D(opts) {
 }
 
 // src/utils/ai/memory/memory-composers.ts
-var import_core50 = require("@graphrefly/pure-ts/core");
-var import_extra35 = require("@graphrefly/pure-ts/extra");
+var import_core57 = require("@graphrefly/pure-ts/core");
+var import_extra40 = require("@graphrefly/pure-ts/extra");
 var import_graph8 = require("@graphrefly/pure-ts/graph");
 
 // src/base/composition/distill.ts
@@ -7640,8 +7758,8 @@ function forEach(source, fn, opts) {
 function isNodeLike2(value) {
   return typeof value === "object" && value !== null && "cache" in value && typeof value.subscribe === "function";
 }
-function keepalive9(node58) {
-  node58.subscribe(() => void 0);
+function keepalive9(node65) {
+  node65.subscribe(() => void 0);
 }
 function mapFromSnapshot(snapshot) {
   if (snapshot instanceof Map) return snapshot;
@@ -7782,8 +7900,8 @@ function decay(baseScore, ageSeconds2, ratePerSecond, minScore = 0) {
 }
 
 // src/utils/memory/index.ts
-var import_core49 = require("@graphrefly/pure-ts/core");
-var import_extra34 = require("@graphrefly/pure-ts/extra");
+var import_core56 = require("@graphrefly/pure-ts/core");
+var import_extra39 = require("@graphrefly/pure-ts/extra");
 var import_graph7 = require("@graphrefly/pure-ts/graph");
 
 // src/utils/memory/fact-store.ts
@@ -7835,6 +7953,8 @@ function reactiveFactStore(config) {
     graph
   });
   const seqCursor = registerCursor(graph, "seq", 0);
+  const ingestLog = config.recordIngest ? (0, import_extra33.reactiveLog)([], { name: "ingest_log" }) : void 0;
+  if (ingestLog) graph.addDisposer(() => ingestLog.dispose());
   const emptyStore = () => ({ byId: /* @__PURE__ */ new Map() });
   const shards = [];
   for (let s = 0; s < shardCount; s += 1) {
@@ -7990,6 +8110,8 @@ function reactiveFactStore(config) {
             factId: dep,
             rootFactId: f.id,
             reason: "obsolete",
+            // `obsolete` guard above guarantees `f.validTo` is set.
+            rootValidTo: f.validTo,
             iteration: cascadeIteration + 1,
             causalReason: `dependentsIndex[${f.id}] \u2192 ${dep} (obsolete: validTo set)`
           });
@@ -8062,11 +8184,10 @@ function reactiveFactStore(config) {
         actions.emit([]);
         return;
       }
-      const now = (0, import_core48.monotonicNs)();
-      for (const [id] of byId) {
+      for (const [id, e] of byId) {
         replaceFragment(
           id,
-          (prev) => prev.validTo !== void 0 ? prev : { ...prev, validTo: BigInt(now) }
+          (prev) => prev.validTo !== void 0 ? prev : { ...prev, validTo: e.rootValidTo }
         );
       }
       actions.emit([...byId.values()]);
@@ -8224,6 +8345,7 @@ function reactiveFactStore(config) {
           t_ns: (0, import_core48.wallClockNs)(),
           seq: bumpCursor(seqCursor)
         });
+        ingestLog?.append(f);
       }
       actions.emit(f ?? null);
     },
@@ -8260,19 +8382,436 @@ function reactiveFactStore(config) {
     review,
     consolidated,
     events,
+    ...ingestLog ? { ingestLog } : {},
     itemNode
   });
   return out;
 }
 
+// src/utils/memory/persistent-fact-store.ts
+var import_core49 = require("@graphrefly/pure-ts/core");
+var import_extra34 = require("@graphrefly/pure-ts/extra");
+function persistMeta(kind) {
+  return domainMeta("memory", kind);
+}
+function persistentReactiveFactStore(config) {
+  const persistName = config.persistName ?? "fact_store_ingest";
+  const codec = config.codec ?? (0, import_extra34.bigintJsonCodecFor)();
+  const tier2 = (0, import_extra34.appendLogStorage)(config.storage, {
+    name: persistName,
+    codec
+  });
+  const store = reactiveFactStore({ ...config, recordIngest: true });
+  const ingestLog = store.ingestLog;
+  async function* loadHistory() {
+    if (typeof tier2.loadEntries !== "function") return;
+    const page = await tier2.loadEntries();
+    for (const f of page.entries) yield f;
+  }
+  const replaySource = (0, import_extra34.fromAny)(loadHistory(), {
+    name: "_replay_source",
+    meta: persistMeta("persist_replay_source")
+  });
+  store.add(replaySource, { name: "_replay_source" });
+  let replayed = 0;
+  const replayPump = (0, import_core49.node)(
+    [replaySource],
+    (batchData, actions) => {
+      const b = batchData[0];
+      if (b != null && b.length > 0) {
+        for (const f of b) {
+          config.ingest.emit(f);
+          replayed += 1;
+        }
+        actions.emit(replayed);
+      }
+    },
+    {
+      name: "_replay_pump",
+      describeKind: "derived",
+      initial: 0,
+      meta: persistMeta("persist_replay_pump")
+    }
+  );
+  store.add(replayPump, { name: "_replay_pump" });
+  store.addDisposer((0, import_extra34.keepalive)(replayPump));
+  const attached = (0, import_core49.node)([], {
+    initial: false,
+    name: "_storage_attached",
+    describeKind: "state",
+    meta: persistMeta("persist_attached")
+  });
+  store.add(attached, { name: "_storage_attached" });
+  store.addDisposer((0, import_extra34.keepalive)(attached));
+  let detachStorage;
+  const replaySub = replaySource.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] === import_core49.COMPLETE && detachStorage === void 0) {
+        const sizeAtAttach = ingestLog.size;
+        detachStorage = ingestLog.attachStorage([tier2]);
+        if (sizeAtAttach > replayed) {
+          const slice = [];
+          for (let i = replayed; i < sizeAtAttach; i += 1) {
+            const v = ingestLog.at(i);
+            if (v === void 0) {
+              throw new Error(
+                `persistentReactiveFactStore: ingestLog hole at index ${i} in reconciliation slice [${replayed}, ${sizeAtAttach}); pre-attach-live durability cannot be guaranteed.`
+              );
+            }
+            slice.push(v);
+          }
+          if (slice.length > 0) {
+            const r = tier2.appendEntries(slice);
+            if (r instanceof Promise) r.catch(() => {
+            });
+          }
+        }
+        attached.emit(true);
+      }
+    }
+  });
+  store.addDisposer(() => {
+    replaySub();
+    detachStorage?.();
+  });
+  const position = (0, import_core49.node)(
+    [ingestLog.entries, attached],
+    (batchData, actions, ctx) => {
+      const eb = batchData[0];
+      const arr = eb != null && eb.length > 0 ? eb.at(-1) : ctx.prevData[0];
+      const ab = batchData[1];
+      const isAttached = ab != null && ab.length > 0 ? ab.at(-1) : ctx.prevData[1];
+      actions.emit(isAttached === true ? arr?.length ?? 0 : 0);
+    },
+    {
+      name: "_durable_position",
+      describeKind: "derived",
+      initial: 0,
+      meta: persistMeta("persist_position")
+    }
+  );
+  store.add(position, { name: "_durable_position" });
+  store.addDisposer((0, import_extra34.keepalive)(position));
+  const out = Object.assign(store, {
+    position,
+    replayedCount: replayPump,
+    tier: tier2,
+    async flush() {
+      await tier2.flush?.();
+    }
+  });
+  return out;
+}
+
+// src/utils/memory/recipes/admission-llm-judge.ts
+var import_core50 = require("@graphrefly/pure-ts/core");
+function admissionLlmJudge(verdicts, opts = {}) {
+  const dflt = opts.defaultVerdict ?? false;
+  const buildFilter = (m) => (f) => m.get(f.id) ?? dflt;
+  return (0, import_core50.node)(
+    [verdicts],
+    (batchData, actions, ctx) => {
+      const m = batchData[0]?.at(-1) ?? ctx.prevData[0] ?? /* @__PURE__ */ new Map();
+      actions.emit(buildFilter(m));
+    },
+    {
+      name: opts.name ?? "admission_llm_judge",
+      describeKind: "derived",
+      // Before any verdict arrives, apply the default policy.
+      initial: buildFilter(/* @__PURE__ */ new Map())
+    }
+  );
+}
+
+// src/utils/memory/recipes/bitemporal-query.ts
+var import_core51 = require("@graphrefly/pure-ts/core");
+
+// src/utils/memory/recipes/_shared.ts
+function lastOf2(batch14, prev) {
+  return batch14 != null && batch14.length > 0 ? batch14.at(-1) : prev;
+}
+function validAt(f, asOf) {
+  if (asOf === void 0) return f.validTo === void 0;
+  if (f.validFrom !== void 0 && asOf < f.validFrom) return false;
+  if (f.validTo !== void 0 && asOf >= f.validTo) return false;
+  return true;
+}
+
+// src/utils/memory/recipes/bitemporal-query.ts
+function bitemporalQuery(mem, asOf, opts = {}) {
+  const asOfOrNull = (0, import_core51.node)(
+    [asOf],
+    (b, a, c) => a.emit(lastOf2(b[0], c.prevData[0]) ?? null),
+    { name: `${opts.name ?? "bitemporal_query"}_asof`, describeKind: "derived", initial: null }
+  );
+  return (0, import_core51.node)(
+    [asOfOrNull, mem.factStore],
+    (batchData, actions, ctx) => {
+      const raw = lastOf2(batchData[0], ctx.prevData[0]);
+      const at = raw ?? void 0;
+      const fs = lastOf2(batchData[1], ctx.prevData[1]);
+      if (fs == null) {
+        actions.emit([]);
+        return;
+      }
+      const results = [...fs.byId.values()].filter((f) => {
+        if (!validAt(f, at)) return false;
+        if (opts.tags && opts.tags.length > 0 && !opts.tags.some((t) => f.tags.includes(t))) {
+          return false;
+        }
+        if (opts.minConfidence !== void 0 && f.confidence < opts.minConfidence) return false;
+        return true;
+      });
+      results.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
+      actions.emit(results);
+    },
+    {
+      name: opts.name ?? "bitemporal_query",
+      describeKind: "derived",
+      initial: []
+    }
+  );
+}
+
+// src/utils/memory/recipes/consolidation-rem.ts
+var import_extra35 = require("@graphrefly/pure-ts/extra");
+function consolidationRem(opts) {
+  const consolidateTrigger = (0, import_extra35.fromTimer)(opts.periodMs, { period: opts.periodMs });
+  const consolidate = (store) => {
+    const live = [...store.values()].filter((f) => f.validTo === void 0);
+    if (live.length === 0) return [];
+    let pool = live;
+    if (opts.recentWindowNs !== void 0) {
+      const newest = live.reduce((m, f) => f.t_ns > m ? f.t_ns : m, live[0].t_ns);
+      const cutoff = newest - opts.recentWindowNs;
+      pool = live.filter((f) => f.t_ns >= cutoff);
+    }
+    pool.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
+    const replayed = pool.slice(0, Math.max(0, opts.topK));
+    return replayed.length > 0 ? opts.summarize(replayed) : [];
+  };
+  return { consolidateTrigger, consolidate };
+}
+
+// src/utils/memory/recipes/decay-exponential.ts
+var import_core52 = require("@graphrefly/pure-ts/core");
+var import_extra36 = require("@graphrefly/pure-ts/extra");
+function decayExponential(mem, ingest, opts) {
+  const floor = opts.floor ?? 0;
+  const epsilon = Math.max(opts.epsilon ?? 1e-4, Number.EPSILON);
+  const half = Number(opts.halfLifeNs);
+  const lastTick = /* @__PURE__ */ new Map();
+  const timer = (0, import_extra36.fromTimer)(opts.periodMs, { period: opts.periodMs });
+  const driver = (0, import_core52.node)(
+    [timer],
+    (_batchData, actions) => {
+      const fs = mem.factStore.cache;
+      if (!fs) {
+        actions.emit([]);
+        return;
+      }
+      const now = BigInt((0, import_core52.wallClockNs)());
+      const decayed = [];
+      const liveIds = /* @__PURE__ */ new Set();
+      for (const f of fs.byId.values()) {
+        liveIds.add(f.id);
+        if (f.validTo !== void 0) continue;
+        if (f.confidence <= floor) continue;
+        const lt = lastTick.get(f.id);
+        const since = lt !== void 0 && lt >= f.t_ns ? lt : f.t_ns;
+        const elapsed = Number(now - since);
+        if (elapsed <= 0) continue;
+        const factor = 0.5 ** (half > 0 ? elapsed / half : 0);
+        if (!Number.isFinite(factor)) continue;
+        let next = f.confidence * factor;
+        if (next < floor) next = floor;
+        if (f.confidence - next < epsilon) continue;
+        const liveNow = mem.factStore.cache?.byId.get(f.id);
+        if (liveNow && liveNow.validTo !== void 0) continue;
+        lastTick.set(f.id, now);
+        const drifted = { ...f, confidence: next };
+        decayed.push(drifted);
+        ingest.emit(drifted);
+      }
+      if (lastTick.size > liveIds.size) {
+        for (const id of lastTick.keys()) if (!liveIds.has(id)) lastTick.delete(id);
+      }
+      actions.emit(decayed);
+    },
+    {
+      name: opts.name ?? "decay_exponential",
+      describeKind: "derived",
+      initial: []
+    }
+  );
+  mem.add(driver, { name: opts.name ?? "decay_exponential" });
+  mem.addDisposer((0, import_extra36.keepalive)(timer));
+  mem.addDisposer((0, import_extra36.keepalive)(driver));
+  return driver;
+}
+
+// src/utils/memory/recipes/influence-analysis.ts
+var import_core53 = require("@graphrefly/pure-ts/core");
+var import_extra37 = require("@graphrefly/pure-ts/extra");
+function closureOf(index, root) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [root];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const dep of index.get(cur) ?? []) {
+      if (seen.has(dep) || dep === root) continue;
+      seen.add(dep);
+      queue.push(dep);
+    }
+  }
+  return [...seen];
+}
+function influenceAnalysis(mem, opts = {}) {
+  const prefix = opts.name ?? "influence";
+  const maxRanked = Math.max(1, opts.maxRanked ?? 64);
+  const ranked = (0, import_core53.node)(
+    [mem.dependentsIndex],
+    (batchData, actions, ctx) => {
+      const index = lastOf2(batchData[0], ctx.prevData[0]);
+      if (index == null) {
+        actions.emit([]);
+        return;
+      }
+      const rows = [];
+      for (const key of index.keys()) {
+        rows.push({ factId: key, influence: closureOf(index, key).length });
+      }
+      rows.sort((a, b) => b.influence - a.influence);
+      actions.emit(rows.slice(0, maxRanked));
+    },
+    {
+      name: `${prefix}_ranked`,
+      describeKind: "derived",
+      initial: []
+    }
+  );
+  mem.add(ranked, { name: `${prefix}_ranked` });
+  mem.addDisposer((0, import_extra37.keepalive)(ranked));
+  const builtFor = /* @__PURE__ */ new Map();
+  function influenceOf(rootId) {
+    const existing = builtFor.get(rootId);
+    if (existing) return existing;
+    const n = (0, import_core53.node)(
+      [mem.dependentsIndex],
+      (batchData, actions, ctx) => {
+        const index = lastOf2(batchData[0], ctx.prevData[0]);
+        actions.emit(index == null ? [] : closureOf(index, rootId));
+      },
+      {
+        name: `${prefix}_of_${rootId}`,
+        describeKind: "derived",
+        initial: []
+      }
+    );
+    mem.add(n, { name: `${prefix}_of_${rootId}` });
+    mem.addDisposer((0, import_extra37.keepalive)(n));
+    builtFor.set(rootId, n);
+    return n;
+  }
+  return { influenceOf, ranked };
+}
+
+// src/utils/memory/recipes/invalidation-tracer.ts
+var import_core54 = require("@graphrefly/pure-ts/core");
+var import_extra38 = require("@graphrefly/pure-ts/extra");
+function invalidationTracer(mem, opts = {}) {
+  const limit = Math.max(1, opts.limit ?? 256);
+  const ring = [];
+  const push = (e) => {
+    ring.push(e);
+    if (ring.length > limit) ring.splice(0, ring.length - limit);
+  };
+  const tracer = (0, import_core54.node)(
+    [mem.cascade, mem.cascadeOverflow],
+    (batchData, actions) => {
+      const cascadeWaves = batchData[0] ?? [];
+      for (const wave of cascadeWaves) {
+        for (const ev of wave) {
+          push({
+            kind: "cascade",
+            factId: ev.factId,
+            rootFactId: ev.rootFactId,
+            reason: ev.reason,
+            iteration: ev.iteration,
+            causalReason: ev.causalReason
+          });
+        }
+      }
+      const overflows = batchData[1] ?? [];
+      for (const ov of overflows) {
+        if (ov == null) continue;
+        push({
+          kind: "overflow",
+          factId: ov.sample[0] ?? "",
+          rootFactId: ov.rootFactId,
+          reason: "overflow",
+          causalReason: `cascade overflow: ${ov.droppedCount} dropped (root ${ov.rootFactId})`
+        });
+      }
+      actions.emit([...ring]);
+    },
+    {
+      name: opts.name ?? "invalidation_tracer",
+      describeKind: "derived",
+      initial: []
+    }
+  );
+  mem.add(tracer, { name: opts.name ?? "invalidation_tracer" });
+  mem.addDisposer((0, import_extra38.keepalive)(tracer));
+  return tracer;
+}
+
+// src/utils/memory/recipes/scoring-by-outcome.ts
+var import_core55 = require("@graphrefly/pure-ts/core");
+var clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+function scoringByOutcome(outcomes, opts = {}) {
+  const base = opts.base ?? ((f) => f.confidence);
+  const learningRate = opts.learningRate ?? 1;
+  const acc = /* @__PURE__ */ new Map();
+  const buildPolicy = () => (fragment) => clamp01(base(fragment) + learningRate * (acc.get(fragment.id) ?? 0));
+  return (0, import_core55.node)(
+    [outcomes],
+    (batchData, actions) => {
+      const wave = batchData[0] ?? [];
+      for (const sig of wave) acc.set(sig.factId, (acc.get(sig.factId) ?? 0) + sig.reward);
+      actions.emit(buildPolicy());
+    },
+    {
+      name: opts.name ?? "scoring_by_outcome",
+      describeKind: "derived",
+      // Usable scorer before any outcome arrives (base-only).
+      initial: buildPolicy()
+    }
+  );
+}
+
+// src/utils/memory/recipes/shard-by-tenant.ts
+function shardByTenant(tenantOf, opts = {}) {
+  if (opts.tenants && opts.tenants.length > 0) {
+    const idx = new Map(opts.tenants.map((t, i) => [t, i]));
+    const overflow = opts.tenants.length;
+    return {
+      shardBy: (f) => idx.get(tenantOf(f)) ?? overflow,
+      shardCount: opts.tenants.length + 1
+    };
+  }
+  const shardCount = Math.max(1, opts.shardCount ?? 4);
+  return { shardBy: (f) => tenantOf(f), shardCount };
+}
+
 // src/utils/memory/index.ts
 var NS_PER_SEC2 = 1e9;
 function memoryMeta(kind, extra) {
   return domainMeta("memory", kind, extra);
 }
 function toNode(v, name) {
-  if (v instanceof import_core49.NodeImpl) return v;
-  return (0, import_core49.node)([], { initial: v, ...name ? { name } : void 0 });
+  if (v instanceof import_core56.NodeImpl) return v;
+  return (0, import_core56.node)([], { initial: v, ...name ? { name } : void 0 });
 }
 function ageSeconds(now, lastNs) {
   return (now - lastNs) / NS_PER_SEC2;
@@ -8326,14 +8865,14 @@ function collection(name, opts = {}) {
   }
   const scoreFnDefault = () => ranked ? 1 : 0;
   const scoreInput = opts.score ?? scoreFnDefault;
-  const scoreNode = ranked && scoreInput instanceof import_core49.NodeImpl ? scoreInput : void 0;
+  const scoreNode = ranked && scoreInput instanceof import_core56.NodeImpl ? scoreInput : void 0;
   const readScoreFn = () => {
     if (scoreNode) return scoreNode.cache ?? scoreFnDefault;
     return scoreInput;
   };
   const graph = new import_graph7.Graph(name);
-  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds((0, import_core49.monotonicNs)(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
-  const items = (0, import_extra34.reactiveMap)({
+  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds((0, import_core56.monotonicNs)(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
+  const items = (0, import_extra39.reactiveMap)({
     name: "items",
     ...maxSize !== void 0 ? { retention: { score: retentionScore, maxSize } } : {}
   });
@@ -8341,16 +8880,16 @@ function collection(name, opts = {}) {
   let refreshTick;
   if (ranked && decayRate > 0) {
     const intervalMs = opts.refreshIntervalMs ?? Math.max(1, 1e3 * Math.LN2 / (10 * decayRate));
-    const tickCounter = (0, import_extra34.fromTimer)(intervalMs, { period: intervalMs });
-    refreshTick = (0, import_core49.node)(
+    const tickCounter = (0, import_extra39.fromTimer)(intervalMs, { period: intervalMs });
+    refreshTick = (0, import_core56.node)(
       [tickCounter],
       (_batchData, actions) => {
-        actions.emit((0, import_core49.monotonicNs)());
+        actions.emit((0, import_core56.monotonicNs)());
       },
       {
         name: "refresh_tick_ns",
         describeKind: "derived",
-        initial: (0, import_core49.monotonicNs)(),
+        initial: (0, import_core56.monotonicNs)(),
         meta: memoryMeta("clock")
       }
     );
@@ -8361,7 +8900,7 @@ function collection(name, opts = {}) {
     const rankedDeps = [items.entries];
     if (refreshTick) rankedDeps.push(refreshTick);
     if (scoreNode) rankedDeps.push(scoreNode);
-    rankedNode = (0, import_core49.node)(
+    rankedNode = (0, import_core56.node)(
       rankedDeps,
       (batchData, actions, ctx) => {
         const values = batchData.map(
@@ -8371,9 +8910,9 @@ function collection(name, opts = {}) {
         let now;
         if (refreshTick) {
           const tickValue = values[1];
-          now = typeof tickValue === "number" ? tickValue : (0, import_core49.monotonicNs)();
+          now = typeof tickValue === "number" ? tickValue : (0, import_core56.monotonicNs)();
         } else {
-          now = (0, import_core49.monotonicNs)();
+          now = (0, import_core56.monotonicNs)();
         }
         if (!snapshot || snapshot.size === 0) {
           actions.emit([]);
@@ -8398,7 +8937,7 @@ function collection(name, opts = {}) {
     );
     graph.add(rankedNode, { name: "ranked" });
   } else {
-    rankedNode = (0, import_core49.node)([], {
+    rankedNode = (0, import_core56.node)([], {
       initial: [],
       name: "ranked",
       describeKind: "state",
@@ -8406,7 +8945,7 @@ function collection(name, opts = {}) {
     });
     graph.add(rankedNode, { name: "ranked" });
   }
-  const size = (0, import_core49.node)(
+  const size = (0, import_core56.node)(
     [items.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -8423,7 +8962,7 @@ function collection(name, opts = {}) {
     }
   );
   graph.add(size, { name: "size" });
-  graph.addDisposer((0, import_extra34.keepalive)(size));
+  graph.addDisposer((0, import_extra39.keepalive)(size));
   const events = createAuditLog({
     name: "events",
     retainedLimit: 1024,
@@ -8431,7 +8970,7 @@ function collection(name, opts = {}) {
   });
   const seqCursor = registerCursor(graph, "seq", 0);
   const upsertImpl = (id, value, _opts) => {
-    const now = (0, import_core49.monotonicNs)();
+    const now = (0, import_core56.monotonicNs)();
     const prev = items.get(id);
     const baseScore = _opts?.score ?? readScoreFn()(value);
     items.set(id, {
@@ -8487,7 +9026,7 @@ function collection(name, opts = {}) {
   });
   function itemNode(id) {
     const idN = toNode(id, "id");
-    return (0, import_core49.node)(
+    return (0, import_core56.node)(
       [items.entries, idN],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -8505,7 +9044,7 @@ function collection(name, opts = {}) {
   }
   function hasNode(id) {
     const idN = toNode(id, "id");
-    return (0, import_core49.node)(
+    return (0, import_core56.node)(
       [items.entries, idN],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -8580,7 +9119,7 @@ function vectorIndex(opts = {}) {
     graph
   });
   const seqCursor = registerCursor(graph, "seq", 0);
-  const entries = (0, import_extra34.reactiveMap)({
+  const entries = (0, import_extra39.reactiveMap)({
     name: "entries",
     ...maxSize !== void 0 ? {
       retention: {
@@ -8592,7 +9131,7 @@ function vectorIndex(opts = {}) {
           events.append({
             action: "evict",
             id: key,
-            t_ns: (0, import_core49.wallClockNs)(),
+            t_ns: (0, import_core56.wallClockNs)(),
             seq: bumpCursor(seqCursor)
           });
         }
@@ -8600,7 +9139,7 @@ function vectorIndex(opts = {}) {
     } : {}
   });
   graph.add(entries.entries, { name: "entries" });
-  graph.addDisposer((0, import_extra34.keepalive)(entries.entries));
+  graph.addDisposer((0, import_extra39.keepalive)(entries.entries));
   if (hnsw?.dispose) {
     const disposeAdapter = hnsw.dispose.bind(hnsw);
     graph.addDisposer(() => disposeAdapter());
@@ -8617,7 +9156,7 @@ function vectorIndex(opts = {}) {
       id,
       vector: [...vector],
       ...copiedMeta !== void 0 ? { meta: copiedMeta } : {},
-      upsertedAtNs: (0, import_core49.monotonicNs)()
+      upsertedAtNs: (0, import_core56.monotonicNs)()
     };
     entries.set(id, record);
   };
@@ -8673,7 +9212,7 @@ function vectorIndex(opts = {}) {
   });
   function searchNode(query, k = 5) {
     const kN = toNode(k, "k");
-    return (0, import_core49.node)(
+    return (0, import_core56.node)(
       [entries.entries, query, kN],
       (batchData, actions, ctx) => {
         const values = batchData.map(
@@ -8779,17 +9318,17 @@ function knowledgeGraph(name, opts = {}) {
     throw new RangeError("knowledgeGraph: edgesMaxSize must be >= 1");
   }
   const graph = new import_graph7.Graph(name);
-  const entitiesMap = (0, import_extra34.reactiveMap)({
+  const entitiesMap = (0, import_extra39.reactiveMap)({
     name: "entities",
     ...opts.entitiesMaxSize !== void 0 ? { maxSize: opts.entitiesMaxSize } : {}
   });
-  const edgesMap = (0, import_extra34.reactiveMap)({
+  const edgesMap = (0, import_extra39.reactiveMap)({
     name: "edges",
     ...opts.edgesMaxSize !== void 0 ? { maxSize: opts.edgesMaxSize } : {}
   });
   graph.add(entitiesMap.entries, { name: "entities" });
   graph.add(edgesMap.entries, { name: "edges" });
-  const adjacencyOut = (0, import_core49.node)(
+  const adjacencyOut = (0, import_core56.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -8806,7 +9345,7 @@ function knowledgeGraph(name, opts = {}) {
       meta: memoryMeta("adjacency_out")
     }
   );
-  const adjacencyIn = (0, import_core49.node)(
+  const adjacencyIn = (0, import_core56.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -8825,9 +9364,9 @@ function knowledgeGraph(name, opts = {}) {
   );
   graph.add(adjacencyOut, { name: "adjacencyOut" });
   graph.add(adjacencyIn, { name: "adjacencyIn" });
-  graph.addDisposer((0, import_extra34.keepalive)(adjacencyOut));
-  graph.addDisposer((0, import_extra34.keepalive)(adjacencyIn));
-  const entityCount = (0, import_core49.node)(
+  graph.addDisposer((0, import_extra39.keepalive)(adjacencyOut));
+  graph.addDisposer((0, import_extra39.keepalive)(adjacencyIn));
+  const entityCount = (0, import_core56.node)(
     [entitiesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -8838,7 +9377,7 @@ function knowledgeGraph(name, opts = {}) {
     },
     { name: "entityCount", describeKind: "derived", initial: 0, meta: memoryMeta("entity_count") }
   );
-  const edgeCount = (0, import_core49.node)(
+  const edgeCount = (0, import_core56.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -8851,8 +9390,8 @@ function knowledgeGraph(name, opts = {}) {
   );
   graph.add(entityCount, { name: "entityCount" });
   graph.add(edgeCount, { name: "edgeCount" });
-  graph.addDisposer((0, import_extra34.keepalive)(entityCount));
-  graph.addDisposer((0, import_extra34.keepalive)(edgeCount));
+  graph.addDisposer((0, import_extra39.keepalive)(entityCount));
+  graph.addDisposer((0, import_extra39.keepalive)(edgeCount));
   const events = createAuditLog({
     name: "events",
     retainedLimit: 1024,
@@ -8875,7 +9414,7 @@ function knowledgeGraph(name, opts = {}) {
       events.append({
         action: "orphanRemove",
         id: candidate,
-        t_ns: (0, import_core49.wallClockNs)(),
+        t_ns: (0, import_core56.wallClockNs)(),
         seq: bumpCursor(seqCursor)
       });
     }
@@ -8970,7 +9509,7 @@ function knowledgeGraph(name, opts = {}) {
     const idN = toNode(id, "id");
     const relN = relation !== void 0 ? toNode(relation, "relation") : void 0;
     const deps = relN ? [adjacencyOut, adjacencyIn, idN, relN] : [adjacencyOut, adjacencyIn, idN];
-    return (0, import_core49.node)(
+    return (0, import_core56.node)(
       deps,
       (batchData, actions, ctx) => {
         const values = batchData.map(
@@ -9046,7 +9585,7 @@ var MemoryWithVectorsGraph = class extends import_graph8.Graph {
     this.mount("vectorIndex", this.vectors);
     const embedFn = opts.embedFn;
     const vectorsRef = this.vectors;
-    const indexer = (0, import_core50.node)(
+    const indexer = (0, import_core57.node)(
       [opts.store.store.entries],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -9061,7 +9600,7 @@ var MemoryWithVectorsGraph = class extends import_graph8.Graph {
       { name: "indexer", describeKind: "effect" }
     );
     this.add(indexer, { name: "indexer" });
-    this.addDisposer((0, import_extra35.keepalive)(indexer));
+    this.addDisposer((0, import_extra40.keepalive)(indexer));
   }
 };
 function memoryWithVectors(opts) {
@@ -9079,7 +9618,7 @@ var MemoryWithKGGraph = class extends import_graph8.Graph {
     if (!opts.entityFn) return;
     const entityFn = opts.entityFn;
     const kgRef = this.kg;
-    const indexer = (0, import_core50.node)(
+    const indexer = (0, import_core57.node)(
       [opts.store.store.entries],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -9100,7 +9639,7 @@ var MemoryWithKGGraph = class extends import_graph8.Graph {
       { name: "indexer", describeKind: "effect" }
     );
     this.add(indexer, { name: "indexer" });
-    this.addDisposer((0, import_extra35.keepalive)(indexer));
+    this.addDisposer((0, import_extra40.keepalive)(indexer));
   }
 };
 function memoryWithKG(opts) {
@@ -9122,20 +9661,20 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
     const permanentFilter = opts.permanentFilter ?? (() => false);
     this.permanent = collection("permanent", { ranked: false });
     this.mount("permanent", this.permanent);
-    this.permanentKeys = (0, import_extra35.reactiveMap)({ name: "permanentKeys" });
+    this.permanentKeys = (0, import_extra40.reactiveMap)({ name: "permanentKeys" });
     this.add(this.permanentKeys.entries, { name: "permanentKeys" });
-    this.entryCreatedAtNs = (0, import_extra35.reactiveMap)({ name: "entryCreatedAtNs" });
+    this.entryCreatedAtNs = (0, import_extra40.reactiveMap)({ name: "entryCreatedAtNs" });
     this.add(this.entryCreatedAtNs.entries, { name: "entryCreatedAtNs" });
     let contextNode;
     if (opts.context) {
-      contextNode = (0, import_extra35.fromAny)(opts.context);
+      contextNode = (0, import_extra40.fromAny)(opts.context);
     } else {
-      contextNode = (0, import_core50.node)([], { initial: null });
+      contextNode = (0, import_core57.node)([], { initial: null });
       this.add(contextNode, { name: "context" });
     }
     let latestCtx = contextNode.cache;
     const ctxUnsub = contextNode.subscribe((msgs) => {
-      for (const m of msgs) if (m[0] === import_core50.DATA) latestCtx = m[1];
+      for (const m of msgs) if (m[0] === import_core57.DATA) latestCtx = m[1];
     });
     this.addDisposer(ctxUnsub);
     const permanentKeysRef = this.permanentKeys;
@@ -9145,7 +9684,7 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
       score: (key, value) => {
         if (permanentFilter(key, value)) return Number.POSITIVE_INFINITY;
         if (permanentKeysRef.has(key)) return Number.POSITIVE_INFINITY;
-        const nowNs = (0, import_core50.monotonicNs)();
+        const nowNs = (0, import_core57.monotonicNs)();
         const createdNs = entryCreatedAtNsRef.get(key) ?? nowNs;
         const ageSeconds2 = Number(nowNs - createdNs) / 1e9;
         return decay(score(value, latestCtx), ageSeconds2, decayRate);
@@ -9180,20 +9719,20 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
       permanentKeysRef.set(key, true);
       permanentRef.upsert(key, value);
     };
-    const syncCreatedAt = (0, import_core50.node)(
+    const syncCreatedAt = (0, import_core57.node)(
       [this.store.store.entries],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
           (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
         );
         const map = data[0] ?? /* @__PURE__ */ new Map();
-        const nowNs = (0, import_core50.monotonicNs)();
+        const nowNs = (0, import_core57.monotonicNs)();
         const toAdd = [];
         for (const key of map.keys()) {
           if (!entryCreatedAtNsRef.has(key)) toAdd.push(key);
         }
         if (toAdd.length > 0) {
-          (0, import_core50.batch)(() => {
+          (0, import_core57.batch)(() => {
             for (const key of toAdd) entryCreatedAtNsRef.set(key, nowNs);
           });
         }
@@ -9201,10 +9740,10 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
       { name: "entryCreatedAtNs/sync", describeKind: "effect" }
     );
     this.add(syncCreatedAt, { name: "entryCreatedAtNs/sync" });
-    this.addDisposer((0, import_extra35.keepalive)(syncCreatedAt));
+    this.addDisposer((0, import_extra40.keepalive)(syncCreatedAt));
     const entriesUnsub = this.store.store.entries.subscribe((msgs) => {
       for (const m of msgs) {
-        if (m[0] !== import_core50.DATA) continue;
+        if (m[0] !== import_core57.DATA) continue;
         const map = m[1];
         const created = entryCreatedAtNsRef.entries.cache;
         if (created == null) continue;
@@ -9213,14 +9752,14 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
           if (!map.has(key)) toDelete.push(key);
         }
         if (toDelete.length > 0) {
-          (0, import_core50.batch)(() => {
+          (0, import_core57.batch)(() => {
             for (const key of toDelete) entryCreatedAtNsRef.delete(key);
           });
         }
       }
     });
     this.addDisposer(entriesUnsub);
-    const promoter = (0, import_core50.node)(
+    const promoter = (0, import_core57.node)(
       [this.store.store.entries],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -9230,7 +9769,7 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
         for (const [key, mem] of map) {
           if (permanentKeysRef.has(key)) continue;
           if (permanentFilter(key, mem)) {
-            (0, import_core50.batch)(() => {
+            (0, import_core57.batch)(() => {
               markPermanent(key, mem);
             });
           }
@@ -9239,7 +9778,7 @@ var MemoryWithTiersGraph = class extends import_graph8.Graph {
       { name: "promoter", describeKind: "effect" }
     );
     this.add(promoter, { name: "promoter" });
-    this.addDisposer((0, import_extra35.keepalive)(promoter));
+    this.addDisposer((0, import_extra40.keepalive)(promoter));
     let archiveHandle = null;
     if (opts.archiveTier) {
       archiveHandle = this.attachSnapshotStorage(
@@ -9295,7 +9834,7 @@ var MemoryRetrievalGraph = class extends import_graph8.Graph {
     this._budget = opts.budget ?? 2e3;
     this._contextWeight = opts.contextWeight ?? 0;
     if (opts.context) {
-      this._contextNode = (0, import_extra35.fromAny)(opts.context);
+      this._contextNode = (0, import_extra40.fromAny)(opts.context);
     } else {
       this._contextNode = this.state("_context", null);
     }
@@ -9441,7 +9980,7 @@ var MemoryRetrievalGraph = class extends import_graph8.Graph {
     const id = ++this._retrieveSeq;
     const segment = `retrieve_${id}`;
     const sub = new import_graph8.Graph(segment);
-    const inputNode = (0, import_extra35.fromAny)(queryInput);
+    const inputNode = (0, import_extra40.fromAny)(queryInput);
     const localContext = sub.derived(
       "context",
       [inputNode],
@@ -9486,7 +10025,7 @@ var MemoryRetrievalGraph = class extends import_graph8.Graph {
         initial: { packed: [], trace: null }
       }
     );
-    const projection = (0, import_core50.node)(
+    const projection = (0, import_core57.node)(
       [result],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -9526,18 +10065,18 @@ function gaugesAsContext(graph, actor, options) {
   const separator = options?.separator ?? "\n";
   const entries = [];
   const sinceVersion = options?.sinceVersion;
-  for (const [path, node58] of Object.entries(described.nodes)) {
-    const meta2 = node58.meta ?? {};
+  for (const [path, node65] of Object.entries(described.nodes)) {
+    const meta2 = node65.meta ?? {};
     const desc = meta2.description;
     const format = meta2.format;
     if (!desc && !format) continue;
-    if (sinceVersion != null && node58.v != null) {
+    if (sinceVersion != null && node65.v != null) {
       const lastSeen = sinceVersion.get(path);
-      if (lastSeen != null && lastSeen.id === node58.v.id && node58.v.version <= lastSeen.version)
+      if (lastSeen != null && lastSeen.id === node65.v.id && node65.v.version <= lastSeen.version)
         continue;
     }
     const label = desc ?? path;
-    const value = node58.value;
+    const value = node65.value;
     const unit = meta2.unit;
     let formatted;
     if (format === "currency" && typeof value === "number") {
@@ -9559,8 +10098,8 @@ function gaugesAsContext(graph, actor, options) {
     const tagGroups = /* @__PURE__ */ new Map();
     const ungrouped = [];
     for (const entry of entries) {
-      const node58 = described.nodes[entry.path];
-      const tags = node58.meta?.tags;
+      const node65 = described.nodes[entry.path];
+      const tags = node65.meta?.tags;
       if (tags && tags.length > 0) {
         const tag = tags[0];
         let group = tagGroups.get(tag);
@@ -9591,18 +10130,18 @@ function gaugesAsContext(graph, actor, options) {
 }
 
 // src/utils/ai/graph-integration/graph-from-spec.ts
-var import_core53 = require("@graphrefly/pure-ts/core");
-var import_extra38 = require("@graphrefly/pure-ts/extra");
+var import_core60 = require("@graphrefly/pure-ts/core");
+var import_extra43 = require("@graphrefly/pure-ts/extra");
 
 // src/utils/graphspec/index.ts
-var import_core52 = require("@graphrefly/pure-ts/core");
+var import_core59 = require("@graphrefly/pure-ts/core");
 var import_graph10 = require("@graphrefly/pure-ts/graph");
 
 // src/utils/reduction/index.ts
-var import_core51 = require("@graphrefly/pure-ts/core");
-var import_extra36 = require("@graphrefly/pure-ts/extra");
+var import_core58 = require("@graphrefly/pure-ts/core");
+var import_extra41 = require("@graphrefly/pure-ts/extra");
 var import_graph9 = require("@graphrefly/pure-ts/graph");
-var import_extra37 = require("@graphrefly/pure-ts/extra");
+var import_extra42 = require("@graphrefly/pure-ts/extra");
 function baseMeta(kind, meta2) {
   return domainMeta("reduction", kind, meta2);
 }
@@ -9610,7 +10149,7 @@ function funnel(name, sources, stages, opts) {
   if (sources.length === 0) throw new RangeError("funnel requires at least one source");
   if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
   const g = new import_graph9.Graph(name, opts);
-  const merged = sources.length === 1 ? sources[0] : (0, import_extra36.merge)(...sources);
+  const merged = sources.length === 1 ? sources[0] : (0, import_extra41.merge)(...sources);
   g.add(merged, { name: "merged" });
   let prevOutputPath = "merged";
   for (let i = 0; i < stages.length; i++) {
@@ -9632,7 +10171,7 @@ function funnel(name, sources, stages, opts) {
     const stageInputPath = `${stage.name}::input`;
     const stageInput = g.resolve(stageInputPath);
     const bridgeName = `__bridge_${prevOutputPath}\u2192${stage.name}_input`;
-    const br = (0, import_core51.node)(
+    const br = (0, import_core58.node)(
       [prevNode],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -9644,7 +10183,7 @@ function funnel(name, sources, stages, opts) {
       { describeKind: "effect", name: bridgeName }
     );
     g.add(br, { name: bridgeName });
-    g.addDisposer((0, import_extra37.keepalive)(br));
+    g.addDisposer((0, import_extra42.keepalive)(br));
     prevOutputPath = `${stage.name}::output`;
   }
   return g;
@@ -9652,7 +10191,7 @@ function funnel(name, sources, stages, opts) {
 function feedback(graph, condition, reentry, opts) {
   const maxIter = opts?.maxIterations ?? 10;
   const counterName = `__feedback_${condition}`;
-  const counter = (0, import_core51.node)([], {
+  const counter = (0, import_core58.node)([], {
     ...{
       meta: baseMeta("feedback_counter", {
         maxIterations: maxIter,
@@ -9666,22 +10205,22 @@ function feedback(graph, condition, reentry, opts) {
   const condNode = graph.resolve(condition);
   const reentryNode = graph.resolve(reentry);
   const feedbackEffectName = `__feedback_effect_${condition}`;
-  const feedbackEffect = (0, import_core51.node)(
+  const feedbackEffect = (0, import_core58.node)(
     [],
     (_data, _feedbackActions) => {
       const unsub = condNode.subscribe((msgs) => {
         for (const msg of msgs) {
           const t = msg[0];
-          if (t === import_core51.DATA) {
+          if (t === import_core58.DATA) {
             const condValue = msg[1];
             if (condValue == null) return;
-            (0, import_core51.batch)(() => {
+            (0, import_core58.batch)(() => {
               if (tryIncrementBounded(counter, maxIter)) {
                 reentryNode.emit(condValue);
               }
             });
-          } else if (t === import_core51.COMPLETE || t === import_core51.ERROR) {
-            const terminal = t === import_core51.ERROR && msg.length > 1 ? [import_core51.ERROR, msg[1]] : [t];
+          } else if (t === import_core58.COMPLETE || t === import_core58.ERROR) {
+            const terminal = t === import_core58.ERROR && msg.length > 1 ? [import_core58.ERROR, msg[1]] : [t];
             counter.down([terminal]);
           }
         }
@@ -9701,7 +10240,7 @@ function feedback(graph, condition, reentry, opts) {
     }
   );
   graph.add(feedbackEffect, { name: feedbackEffectName });
-  graph.addDisposer((0, import_extra37.keepalive)(feedbackEffect));
+  graph.addDisposer((0, import_extra42.keepalive)(feedbackEffect));
   return graph;
 }
 function scorer(sources, weights, opts) {
@@ -9712,7 +10251,7 @@ function scorer(sources, weights, opts) {
   const allDeps = [...sources, ...weights];
   const n = sources.length;
   const scoreFns = opts?.scoreFns;
-  return (0, import_core51.node)(
+  return (0, import_core58.node)(
     allDeps,
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -9749,18 +10288,18 @@ function scorer(sources, weights, opts) {
 }
 
 // src/utils/graphspec/index.ts
-function readFactory(node58) {
-  const f = node58.meta?.factory;
+function readFactory(node65) {
+  const f = node65.meta?.factory;
   return typeof f === "string" ? f : void 0;
 }
-function readFactoryArgs(node58) {
-  const a = node58.meta?.factoryArgs;
+function readFactoryArgs(node65) {
+  const a = node65.meta?.factoryArgs;
   return a != null && typeof a === "object" ? a : {};
 }
-function readStateInitial(node58) {
-  const args = readFactoryArgs(node58);
+function readStateInitial(node65) {
+  const args = readFactoryArgs(node65);
   if ("initial" in args) return args.initial;
-  return node58.value;
+  return node65.value;
 }
 function isRichFnEntry(entry) {
   return typeof entry === "object" && entry !== null && "factory" in entry;
@@ -9833,11 +10372,11 @@ function validateSpecAgainstCatalog(spec, catalog) {
   const sourceNames = new Set(Object.keys(catalog.sources ?? {}));
   for (const [nodeName, nodeRaw] of Object.entries(spec.nodes)) {
     if (nodeRaw.type === "template") continue;
-    const node58 = nodeRaw;
-    const factoryName = readFactory(node58);
+    const node65 = nodeRaw;
+    const factoryName = readFactory(node65);
     if (factoryName == null) continue;
-    const isProducer = node58.type === "producer";
-    if (node58.type === "state" && factoryName === "state") continue;
+    const isProducer = node65.type === "producer";
+    if (node65.type === "state" && factoryName === "state") continue;
     if (isProducer) {
       const inSources = sourceNames.has(factoryName);
       const inFns = fnNames.has(factoryName);
@@ -9861,7 +10400,7 @@ function validateSpecAgainstCatalog(spec, catalog) {
         }
       }
     }
-    const factoryArgs = readFactoryArgs(node58);
+    const factoryArgs = readFactoryArgs(node65);
     if (!isProducer && catalog.fns?.[factoryName]) {
       const entry = catalog.fns[factoryName];
       if (isRichFnEntry(entry) && entry.configSchema) {
@@ -9901,11 +10440,11 @@ function validateSpecAgainstCatalog(spec, catalog) {
   }
   if (spec.templates) {
     for (const [tName, template] of Object.entries(spec.templates)) {
-      for (const [nodeName, node58] of Object.entries(template.nodes)) {
-        const factoryName = readFactory(node58);
+      for (const [nodeName, node65] of Object.entries(template.nodes)) {
+        const factoryName = readFactory(node65);
         if (factoryName == null) continue;
-        if (node58.type === "state" && factoryName === "state") continue;
-        if (node58.type === "producer") continue;
+        if (node65.type === "state" && factoryName === "state") continue;
+        if (node65.type === "producer") continue;
         if (fnNames.size > 0 && !fnNames.has(factoryName)) {
           const suggestion = findClosest(factoryName, fnNames);
           errors.push(
@@ -10120,8 +10659,8 @@ function validateSpec(spec) {
     warnings
   };
 }
-function readOwner(node58) {
-  const o = node58.meta?.owner;
+function readOwner(node65) {
+  const o = node65.meta?.owner;
   return typeof o === "string" && o.length > 0 ? o : void 0;
 }
 var OVERRIDE_OWNER_TRAILER = /^\s*override-owner\s*:\s*(.+?)\s*$/im;
@@ -10220,7 +10759,7 @@ ${catalogValidation.errors.join("\n")}`
     const factoryArgs = readFactoryArgs(n);
     if (n.type === "state") {
       const initial = readStateInitial(n);
-      const nd = (0, import_core52.node)([], {
+      const nd = (0, import_core59.node)([], {
         name,
         initial,
         meta: stripFactoryMeta(n.meta)
@@ -10240,7 +10779,7 @@ ${catalogValidation.errors.join("\n")}`
         created.set(name, nd);
       } else {
         if (factoryName) recordMissing(name, "source", factoryName);
-        const nd = (0, import_core52.node)([], () => {
+        const nd = (0, import_core59.node)([], () => {
         }, {
           name,
           describeKind: "producer",
@@ -10269,11 +10808,11 @@ ${catalogValidation.errors.join("\n")}`
         nd = fnFactory(resolvedDeps, factoryArgs);
       } else if (n.type === "effect") {
         if (factoryName) recordMissing(name, "fn", factoryName);
-        nd = (0, import_core52.node)(resolvedDeps, () => {
+        nd = (0, import_core59.node)(resolvedDeps, () => {
         }, { describeKind: "effect" });
       } else {
         if (factoryName) recordMissing(name, "fn", factoryName);
-        nd = (0, import_core52.node)(
+        nd = (0, import_core59.node)(
           resolvedDeps,
           (batchData, actions, ctx) => {
             const data = batchData.map(
@@ -10313,7 +10852,7 @@ ${catalogValidation.errors.join("\n")}`
       const factoryArgs = readFactoryArgs(nSpec);
       if (nSpec.type === "state") {
         const initial = readStateInitial(nSpec);
-        const nd = (0, import_core52.node)([], {
+        const nd = (0, import_core59.node)([], {
           name: nName,
           initial,
           meta: stripFactoryMeta(nSpec.meta)
@@ -10333,7 +10872,7 @@ ${catalogValidation.errors.join("\n")}`
           subCreated.set(nName, nd);
         } else {
           if (factoryName) recordMissing(`${name}.${nName}`, "source", factoryName);
-          const nd = (0, import_core52.node)([], () => {
+          const nd = (0, import_core59.node)([], () => {
           }, {
             name: nName,
             describeKind: "producer",
@@ -10363,11 +10902,11 @@ ${catalogValidation.errors.join("\n")}`
           nd = fnFactory(resolvedDeps, factoryArgs);
         } else if (nSpec.type === "effect") {
           if (factoryName) recordMissing(`${name}.${nName}`, "fn", factoryName);
-          nd = (0, import_core52.node)(resolvedDeps, () => {
+          nd = (0, import_core59.node)(resolvedDeps, () => {
           }, { describeKind: "effect" });
         } else {
           if (factoryName) recordMissing(`${name}.${nName}`, "fn", factoryName);
-          nd = (0, import_core52.node)(
+          nd = (0, import_core59.node)(
             resolvedDeps,
             (batchData, actions, ctx) => {
               const data = batchData.map(
@@ -10854,12 +11393,12 @@ ${opts.systemPromptExtra}` : GRAPH_FROM_SPEC_SYSTEM_PROMPT;
   return compileSpec(parsed, { catalog: opts?.catalog });
 }
 function graphFromSpecReactive(input, adapter, opts) {
-  const inputNode = (0, import_extra38.fromAny)(input);
-  return (0, import_extra38.switchMap)(inputNode, (nl) => {
+  const inputNode = (0, import_extra43.fromAny)(input);
+  return (0, import_extra43.switchMap)(inputNode, (nl) => {
     if (!nl || typeof nl !== "string" || nl.trim().length === 0) {
-      return (0, import_core53.node)([], { initial: null });
+      return (0, import_core60.node)([], { initial: null });
     }
-    return (0, import_core53.node)(
+    return (0, import_core60.node)(
       (_data, actions) => {
         const controller = new AbortController();
         let cancelled = false;
@@ -10869,10 +11408,10 @@ function graphFromSpecReactive(input, adapter, opts) {
             return;
           }
           actions.emit(g);
-          actions.down([[import_core53.COMPLETE]]);
+          actions.down([[import_core60.COMPLETE]]);
         }).catch((err) => {
           if (cancelled) return;
-          actions.down([[import_core53.ERROR, err]]);
+          actions.down([[import_core60.ERROR, err]]);
         });
         return () => {
           cancelled = true;
@@ -10923,11 +11462,11 @@ function knobsAsTools(graph, actor) {
   const openai = [];
   const mcp = [];
   const definitions = [];
-  for (const [path, node58] of Object.entries(described.nodes)) {
-    if (node58.type !== "state") continue;
+  for (const [path, node65] of Object.entries(described.nodes)) {
+    if (node65.type !== "state") continue;
     if (path.includes("::__meta__::")) continue;
-    if (node58.status === "completed" || node58.status === "errored") continue;
-    const meta2 = node58.meta ?? {};
+    if (node65.status === "completed" || node65.status === "errored") continue;
+    const meta2 = node65.meta ?? {};
     const access = meta2.access;
     if (access === "human" || access === "system") continue;
     const description = meta2.description ?? `Set the value of ${path}`;
@@ -10956,7 +11495,7 @@ function knobsAsTools(graph, actor) {
     });
     const graphRef = graph;
     const actorRef = actor;
-    const nv = node58.v;
+    const nv = node65.v;
     definitions.push({
       name: path,
       description,
@@ -10972,8 +11511,8 @@ function knobsAsTools(graph, actor) {
 }
 
 // src/utils/ai/graph-integration/suggest-strategy.ts
-var import_core54 = require("@graphrefly/pure-ts/core");
-var import_extra39 = require("@graphrefly/pure-ts/extra");
+var import_core61 = require("@graphrefly/pure-ts/core");
+var import_extra44 = require("@graphrefly/pure-ts/extra");
 var SUGGEST_STRATEGY_SYSTEM_PROMPT = `You are a reactive graph optimizer for GraphReFly.
 
 Given a graph's current structure (from describe()) and a problem statement, suggest topology and parameter changes to solve the problem.
@@ -11042,26 +11581,26 @@ async function suggestStrategy(graph, problem, adapter, opts) {
   };
 }
 function suggestStrategyReactive(graph, problem, adapter, opts) {
-  const problemNode = (0, import_extra39.fromAny)(problem);
-  const paired = (0, import_extra39.withLatestFrom)(problemNode, graph);
-  return (0, import_extra39.switchMap)(paired, (pair) => {
-    if (pair == null) return (0, import_core54.node)([], { initial: null });
+  const problemNode = (0, import_extra44.fromAny)(problem);
+  const paired = (0, import_extra44.withLatestFrom)(problemNode, graph);
+  return (0, import_extra44.switchMap)(paired, (pair) => {
+    if (pair == null) return (0, import_core61.node)([], { initial: null });
     const [pText, g] = pair;
     if (!g || !pText || typeof pText !== "string" || pText.trim().length === 0) {
-      return (0, import_core54.node)([], { initial: null });
+      return (0, import_core61.node)([], { initial: null });
     }
-    if (g.destroyed) return (0, import_core54.node)([], { initial: null });
-    return (0, import_core54.node)(
+    if (g.destroyed) return (0, import_core61.node)([], { initial: null });
+    return (0, import_core61.node)(
       (_data, actions) => {
         const controller = new AbortController();
         let cancelled = false;
         suggestStrategy(g, pText, adapter, { ...opts, signal: controller.signal }).then((plan) => {
           if (cancelled) return;
           actions.emit(plan);
-          actions.down([[import_core54.COMPLETE]]);
+          actions.down([[import_core61.COMPLETE]]);
         }).catch((err) => {
           if (cancelled) return;
-          actions.down([[import_core54.ERROR, err]]);
+          actions.down([[import_core61.ERROR, err]]);
         });
         return () => {
           cancelled = true;
@@ -11094,14 +11633,14 @@ function validateGraphDef(def) {
       errors.push(`Node "${name}": must be an object`);
       continue;
     }
-    const node58 = raw;
-    if (typeof node58.type !== "string" || !VALID_NODE_TYPES2.has(node58.type)) {
+    const node65 = raw;
+    if (typeof node65.type !== "string" || !VALID_NODE_TYPES2.has(node65.type)) {
       errors.push(
-        `Node "${name}": invalid type "${String(node58.type)}" (expected: ${[...VALID_NODE_TYPES2].join(", ")})`
+        `Node "${name}": invalid type "${String(node65.type)}" (expected: ${[...VALID_NODE_TYPES2].join(", ")})`
       );
     }
-    if (Array.isArray(node58.deps)) {
-      for (const dep of node58.deps) {
+    if (Array.isArray(node65.deps)) {
+      for (const dep of node65.deps) {
         if (typeof dep === "string" && !nodeNames.has(dep)) {
           errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
         }
@@ -11138,21 +11677,21 @@ function validateGraphDef(def) {
 }
 
 // src/utils/cqrs/index.ts
-var import_core55 = require("@graphrefly/pure-ts/core");
-var import_extra40 = require("@graphrefly/pure-ts/extra");
+var import_core62 = require("@graphrefly/pure-ts/core");
+var import_extra45 = require("@graphrefly/pure-ts/extra");
 var import_graph11 = require("@graphrefly/pure-ts/graph");
-var import_extra41 = require("@graphrefly/pure-ts/extra");
-var COMMAND_GUARD = (0, import_core55.policy)((allow, deny) => {
+var import_extra46 = require("@graphrefly/pure-ts/extra");
+var COMMAND_GUARD = (0, import_core62.policy)((allow, deny) => {
   allow("write");
   allow("signal");
   deny("observe");
 });
-var PROJECTION_GUARD = (0, import_core55.policy)((allow, deny) => {
+var PROJECTION_GUARD = (0, import_core62.policy)((allow, deny) => {
   allow("observe");
   allow("signal");
   deny("write");
 });
-var EVENT_GUARD = (0, import_core55.policy)((allow, deny) => {
+var EVENT_GUARD = (0, import_core62.policy)((allow, deny) => {
   allow("observe");
   allow("signal");
   deny("write");
@@ -11262,7 +11801,7 @@ var CqrsGraph = class extends import_graph11.Graph {
         aggregateId,
         type,
         lastVersion,
-        t_ns: (0, import_core55.wallClockNs)()
+        t_ns: (0, import_core62.wallClockNs)()
       });
     }
   }
@@ -11323,7 +11862,7 @@ var CqrsGraph = class extends import_graph11.Graph {
     }
     const existing = this._eventLogs.get(name);
     if (existing) return existing.node;
-    const log = (0, import_extra40.reactiveLog)([], {
+    const log = (0, import_extra45.reactiveLog)([], {
       name,
       versioning: 0,
       maxSize: this._retainedLimit
@@ -11343,7 +11882,7 @@ var CqrsGraph = class extends import_graph11.Graph {
         initial: entries.cache
       }
     );
-    this.addDisposer((0, import_extra41.keepalive)(guarded));
+    this.addDisposer((0, import_extra46.keepalive)(guarded));
     this._eventLogs.set(name, { log, node: guarded });
     this._autoWireStreamStorage(name, log);
     return guarded;
@@ -11365,7 +11904,7 @@ var CqrsGraph = class extends import_graph11.Graph {
     const existing = byType.get(aggregateId);
     if (existing) return existing;
     const nodeName = `${type}_${aggregateId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-    const log = (0, import_extra40.reactiveLog)([], {
+    const log = (0, import_extra45.reactiveLog)([], {
       name: nodeName,
       versioning: 0,
       maxSize: this._retainedLimit
@@ -11397,7 +11936,7 @@ var CqrsGraph = class extends import_graph11.Graph {
         }
       );
     } catch {
-      guarded = (0, import_core55.node)(
+      guarded = (0, import_core62.node)(
         [entries],
         (batchData, actions, ctx) => {
           const latest = batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0];
@@ -11415,7 +11954,7 @@ var CqrsGraph = class extends import_graph11.Graph {
         }
       );
     }
-    this.addDisposer((0, import_extra41.keepalive)(guarded));
+    this.addDisposer((0, import_extra46.keepalive)(guarded));
     const entry = { log, node: guarded };
     byType.set(aggregateId, entry);
     this._autoWireStreamStorage(`${type}::${aggregateId}`, log);
@@ -11455,7 +11994,7 @@ var CqrsGraph = class extends import_graph11.Graph {
     const evt = {
       type: eventName,
       payload: frozenPayload,
-      timestampNs: (0, import_core55.wallClockNs)(),
+      timestampNs: (0, import_core62.wallClockNs)(),
       seq: ++this._seq,
       ...extra?.aggregateId !== void 0 ? { aggregateId: extra.aggregateId } : {},
       ...aggregateVersion !== void 0 ? { aggregateVersion } : {},
@@ -11703,7 +12242,7 @@ var CqrsGraph = class extends import_graph11.Graph {
         initial: seedState
       }
     );
-    this.addDisposer((0, import_extra41.keepalive)(projNode));
+    this.addDisposer((0, import_extra46.keepalive)(projNode));
     this.addDisposer(() => {
       if (saveTimer !== void 0) {
         clearTimeout(saveTimer);
@@ -11813,7 +12352,7 @@ var CqrsGraph = class extends import_graph11.Graph {
       const cursor = cursors[eName];
       latestCursors.set(eName, cursor.cache ?? 0);
       const sub = cursor.subscribe((msgs) => {
-        for (const m of msgs) if (m[0] === import_core55.DATA) latestCursors.set(eName, m[1]);
+        for (const m of msgs) if (m[0] === import_core62.DATA) latestCursors.set(eName, m[1]);
       });
       this.addDisposer(sub);
     }
@@ -11893,7 +12432,7 @@ var CqrsGraph = class extends import_graph11.Graph {
       }
     );
     sagaRef.n = sagaNode;
-    this.addDisposer((0, import_extra41.keepalive)(sagaNode));
+    this.addDisposer((0, import_extra46.keepalive)(sagaNode));
     this._sagas.add(name);
     return {
       node: sagaNode,
@@ -11906,12 +12445,12 @@ var CqrsGraph = class extends import_graph11.Graph {
 function cqrs(name, opts) {
   const g = new CqrsGraph(name, opts);
   const { factory: _f, factoryArgs: _fa, ...tagArgs } = opts ?? {};
-  g.tagFactory("cqrs", (0, import_core55.placeholderArgs)(tagArgs));
+  g.tagFactory("cqrs", (0, import_core62.placeholderArgs)(tagArgs));
   return g;
 }
 
 // src/utils/demo-shell/index.ts
-var import_core58 = require("@graphrefly/pure-ts/core");
+var import_core65 = require("@graphrefly/pure-ts/core");
 var import_graph13 = require("@graphrefly/pure-ts/graph");
 
 // src/base/render/_ascii-width.ts
@@ -12534,14 +13073,14 @@ function graphSpecToMermaid(g, opts) {
 }
 
 // src/utils/reactive-layout/reactive-layout.ts
-var import_core57 = require("@graphrefly/pure-ts/core");
+var import_core64 = require("@graphrefly/pure-ts/core");
 var import_graph12 = require("@graphrefly/pure-ts/graph");
 
 // src/base/meta/emit-to-meta.ts
-var import_core56 = require("@graphrefly/pure-ts/core");
+var import_core63 = require("@graphrefly/pure-ts/core");
 function emitToMeta(metaNode, value) {
   if (metaNode == null) return;
-  (0, import_core56.downWithBatch)((msgs) => metaNode.down(msgs), [[import_core56.DATA, value]], import_core56.defaultConfig.tierOf);
+  (0, import_core63.downWithBatch)((msgs) => metaNode.down(msgs), [[import_core63.DATA, value]], import_core63.defaultConfig.tierOf);
 }
 
 // src/utils/reactive-layout/reactive-layout.ts
@@ -13242,16 +13781,16 @@ function reactiveLayout(opts) {
   const { adapter, name = "reactive-layout" } = opts;
   const g = new import_graph12.Graph(name);
   const measureCache = /* @__PURE__ */ new Map();
-  const textNode = (0, import_core57.node)([], { name: "text", initial: opts.text ?? "" });
-  const fontNode = (0, import_core57.node)([], {
+  const textNode = (0, import_core64.node)([], { name: "text", initial: opts.text ?? "" });
+  const fontNode = (0, import_core64.node)([], {
     name: "font",
     initial: opts.font ?? "16px sans-serif"
   });
-  const lineHeightNode = (0, import_core57.node)([], {
+  const lineHeightNode = (0, import_core64.node)([], {
     name: "line-height",
     initial: opts.lineHeight ?? 20
   });
-  const maxWidthNode = (0, import_core57.node)([], {
+  const maxWidthNode = (0, import_core64.node)([], {
     name: "max-width",
     initial: Math.max(0, opts.maxWidth ?? 800)
   });
@@ -13263,14 +13802,14 @@ function reactiveLayout(opts) {
     }
     return true;
   }
-  const segmentsNode = (0, import_core57.node)(
+  const segmentsNode = (0, import_core64.node)(
     [textNode, fontNode],
     (data, actions, ctx) => {
       const b0 = data[0];
       const textVal = b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0];
       const b1 = data[1];
       const fontVal = b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1];
-      const t0 = (0, import_core57.monotonicNs)();
+      const t0 = (0, import_core64.monotonicNs)();
       const measureStats = { hits: 0, misses: 0 };
       const result = analyzeAndMeasure(
         textVal,
@@ -13279,7 +13818,7 @@ function reactiveLayout(opts) {
         measureCache,
         measureStats
       );
-      const elapsed = (0, import_core57.monotonicNs)() - t0;
+      const elapsed = (0, import_core64.monotonicNs)() - t0;
       const lookups = measureStats.hits + measureStats.misses;
       const hitRate = lookups === 0 ? 1 : measureStats.hits / lookups;
       const meta2 = segmentsNode.meta;
@@ -13318,7 +13857,7 @@ function reactiveLayout(opts) {
       }
     }
   );
-  const lineBreaksNode = (0, import_core57.node)(
+  const lineBreaksNode = (0, import_core64.node)(
     [segmentsNode, maxWidthNode, fontNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13352,7 +13891,7 @@ function reactiveLayout(opts) {
       }
     }
   );
-  const heightNode = (0, import_core57.node)(
+  const heightNode = (0, import_core64.node)(
     [lineBreaksNode, lineHeightNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13362,7 +13901,7 @@ function reactiveLayout(opts) {
     },
     { describeKind: "derived", name: "height" }
   );
-  const charPositionsNode = (0, import_core57.node)(
+  const charPositionsNode = (0, import_core64.node)(
     [lineBreaksNode, segmentsNode, lineHeightNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13414,32 +13953,32 @@ function reactiveLayout(opts) {
 }
 
 // src/utils/demo-shell/index.ts
-function clamp01(v) {
+function clamp012(v) {
   return Math.max(0, Math.min(1, v));
 }
 function demoShell(opts) {
-  const mainRatioInit = clamp01(opts?.mainRatio ?? 0.65);
-  const sideSplitInit = clamp01(opts?.sideSplit ?? 0.5);
+  const mainRatioInit = clamp012(opts?.mainRatio ?? 0.65);
+  const sideSplitInit = clamp012(opts?.sideSplit ?? 0.5);
   const viewportInit = Math.max(0, opts?.viewportWidth ?? 1280);
   const registry = opts?.nodeRegistry ?? /* @__PURE__ */ new Map();
   const adapter = opts?.adapter ?? null;
   const layoutFont = opts?.layoutFont ?? "14px monospace";
   const onHighlight = opts?.onHighlight;
   const g = new import_graph13.Graph("demo-shell");
-  const paneMainRatio = (0, import_core58.node)([], { ...{ name: "pane/main-ratio" }, initial: mainRatioInit });
-  const paneSideSplit = (0, import_core58.node)([], { ...{ name: "pane/side-split" }, initial: sideSplitInit });
-  const paneFullscreen = (0, import_core58.node)([], {
+  const paneMainRatio = (0, import_core65.node)([], { ...{ name: "pane/main-ratio" }, initial: mainRatioInit });
+  const paneSideSplit = (0, import_core65.node)([], { ...{ name: "pane/side-split" }, initial: sideSplitInit });
+  const paneFullscreen = (0, import_core65.node)([], {
     ...{
       name: "pane/fullscreen"
     },
     initial: null
   });
-  const viewportWidth = (0, import_core58.node)([], { ...{ name: "viewport/width" }, initial: viewportInit });
+  const viewportWidth = (0, import_core65.node)([], { ...{ name: "viewport/width" }, initial: viewportInit });
   g.add(paneMainRatio, { name: "pane/main-ratio" });
   g.add(paneSideSplit, { name: "pane/side-split" });
   g.add(paneFullscreen, { name: "pane/fullscreen" });
   g.add(viewportWidth, { name: "viewport/width" });
-  const paneMainWidth = (0, import_core58.node)(
+  const paneMainWidth = (0, import_core65.node)(
     [paneMainRatio, viewportWidth, paneFullscreen],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13454,7 +13993,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "pane/main-width" } }
   );
-  const paneSideWidth = (0, import_core58.node)(
+  const paneSideWidth = (0, import_core65.node)(
     [paneMainWidth, viewportWidth, paneFullscreen],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13469,7 +14008,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "pane/side-width" } }
   );
-  const paneGraphHeight = (0, import_core58.node)(
+  const paneGraphHeight = (0, import_core65.node)(
     [paneSideSplit, paneFullscreen],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13480,11 +14019,11 @@ function demoShell(opts) {
       if (fullscreen === "graph") actions.emit(1);
       else if (fullscreen === "code") actions.emit(0);
       else if (fullscreen === "main") actions.emit(0);
-      else actions.emit(clamp01(split));
+      else actions.emit(clamp012(split));
     },
     { describeKind: "derived", ...{ name: "pane/graph-height-ratio" } }
   );
-  const paneCodeHeight = (0, import_core58.node)(
+  const paneCodeHeight = (0, import_core65.node)(
     [paneGraphHeight, paneFullscreen],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13502,16 +14041,16 @@ function demoShell(opts) {
   g.add(paneSideWidth, { name: "pane/side-width" });
   g.add(paneGraphHeight, { name: "pane/graph-height-ratio" });
   g.add(paneCodeHeight, { name: "pane/code-height-ratio" });
-  const demoGraphRef = (0, import_core58.node)([], {
+  const demoGraphRef = (0, import_core65.node)([], {
     ...{
       name: "demo/graph-ref"
     },
     initial: null
   });
-  const demoGraphTick = (0, import_core58.node)([], { ...{ name: "demo/graph-tick" }, initial: 0 });
+  const demoGraphTick = (0, import_core65.node)([], { ...{ name: "demo/graph-tick" }, initial: 0 });
   g.add(demoGraphRef, { name: "demo/graph-ref" });
   g.add(demoGraphTick, { name: "demo/graph-tick" });
-  const graphMermaid = (0, import_core58.node)(
+  const graphMermaid = (0, import_core65.node)(
     [demoGraphRef, demoGraphTick],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13522,7 +14061,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "graph/mermaid" } }
   );
-  const graphDescribe = (0, import_core58.node)(
+  const graphDescribe = (0, import_core65.node)(
     [demoGraphRef, demoGraphTick],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13540,9 +14079,9 @@ function demoShell(opts) {
   );
   g.add(graphMermaid, { name: "graph/mermaid" });
   g.add(graphDescribe, { name: "graph/describe" });
-  const hoverTarget = (0, import_core58.node)([], { ...{ name: "hover/target" }, initial: null });
+  const hoverTarget = (0, import_core65.node)([], { ...{ name: "hover/target" }, initial: null });
   g.add(hoverTarget, { name: "hover/target" });
-  const highlightCodeScroll = (0, import_core58.node)(
+  const highlightCodeScroll = (0, import_core65.node)(
     [hoverTarget],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13558,7 +14097,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "highlight/code-scroll" } }
   );
-  const highlightVisual = (0, import_core58.node)(
+  const highlightVisual = (0, import_core65.node)(
     [hoverTarget],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13574,7 +14113,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "highlight/visual" } }
   );
-  const highlightGraph = (0, import_core58.node)(
+  const highlightGraph = (0, import_core65.node)(
     [hoverTarget],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13590,7 +14129,7 @@ function demoShell(opts) {
   g.add(highlightGraph, { name: "highlight/graph" });
   if (onHighlight?.codeScroll) {
     const cb = onHighlight.codeScroll;
-    const applyCodeScroll = (0, import_core58.node)(
+    const applyCodeScroll = (0, import_core65.node)(
       [highlightCodeScroll],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -13604,7 +14143,7 @@ function demoShell(opts) {
   }
   if (onHighlight?.visual) {
     const cb = onHighlight.visual;
-    const applyVisual = (0, import_core58.node)(
+    const applyVisual = (0, import_core65.node)(
       [highlightVisual],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -13618,7 +14157,7 @@ function demoShell(opts) {
   }
   if (onHighlight?.graph) {
     const cb = onHighlight.graph;
-    const applyGraph = (0, import_core58.node)(
+    const applyGraph = (0, import_core65.node)(
       [highlightGraph],
       (batchData, _actions, ctx) => {
         const data = batchData.map(
@@ -13630,14 +14169,14 @@ function demoShell(opts) {
     );
     g.add(applyGraph, { name: "highlight/apply-graph" });
   }
-  const inspectSelected = (0, import_core58.node)([], {
+  const inspectSelected = (0, import_core65.node)([], {
     ...{
       name: "inspect/selected-node"
     },
     initial: null
   });
   g.add(inspectSelected, { name: "inspect/selected-node" });
-  const inspectNodeDetail = (0, import_core58.node)(
+  const inspectNodeDetail = (0, import_core65.node)(
     [inspectSelected, demoGraphRef, demoGraphTick],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13663,7 +14202,7 @@ function demoShell(opts) {
     },
     { describeKind: "derived", ...{ name: "inspect/node-detail" } }
   );
-  const inspectTraceLog = (0, import_core58.node)(
+  const inspectTraceLog = (0, import_core65.node)(
     [demoGraphRef, demoGraphTick],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13676,9 +14215,9 @@ function demoShell(opts) {
   );
   g.add(inspectNodeDetail, { name: "inspect/node-detail" });
   g.add(inspectTraceLog, { name: "inspect/trace-log" });
-  const metaDebug = (0, import_core58.node)([], { ...{ name: "meta/debug" }, initial: false });
+  const metaDebug = (0, import_core65.node)([], { ...{ name: "meta/debug" }, initial: false });
   g.add(metaDebug, { name: "meta/debug" });
-  const metaShellMermaid = (0, import_core58.node)(
+  const metaShellMermaid = (0, import_core65.node)(
     [metaDebug, demoGraphTick],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13689,11 +14228,11 @@ function demoShell(opts) {
     { describeKind: "derived", ...{ name: "meta/shell-mermaid" } }
   );
   g.add(metaShellMermaid, { name: "meta/shell-mermaid" });
-  const codeTextNode = (0, import_core58.node)([], { ...{ name: "layout/code-text" }, initial: "" });
+  const codeTextNode = (0, import_core65.node)([], { ...{ name: "layout/code-text" }, initial: "" });
   g.add(codeTextNode, { name: "layout/code-text" });
   if (adapter) {
     const measureCache = /* @__PURE__ */ new Map();
-    const graphLabels = (0, import_core58.node)(
+    const graphLabels = (0, import_core65.node)(
       [graphDescribe],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -13732,7 +14271,7 @@ function demoShell(opts) {
         }
       }
     );
-    const codeLines = (0, import_core58.node)(
+    const codeLines = (0, import_core65.node)(
       [codeTextNode, paneSideWidth],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -13751,7 +14290,7 @@ function demoShell(opts) {
       },
       { describeKind: "derived", name: "layout/code-lines" }
     );
-    const sideWidthHint = (0, import_core58.node)(
+    const sideWidthHint = (0, import_core65.node)(
       [graphLabels],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -13778,10 +14317,10 @@ function demoShell(opts) {
   return {
     graph: g,
     setMainRatio(ratio) {
-      g.set("pane/main-ratio", clamp01(ratio));
+      g.set("pane/main-ratio", clamp012(ratio));
     },
     setSideSplit(ratio) {
-      g.set("pane/side-split", clamp01(ratio));
+      g.set("pane/side-split", clamp012(ratio));
     },
     setFullscreen(pane) {
       g.set("pane/fullscreen", pane);
@@ -13808,7 +14347,7 @@ function demoShell(opts) {
       g.set("layout/code-text", text);
     },
     batch(fn) {
-      (0, import_core58.batch)(fn);
+      (0, import_core65.batch)(fn);
     },
     destroy() {
       g.destroy();
@@ -13817,10 +14356,10 @@ function demoShell(opts) {
 }
 
 // src/utils/domain-templates/index.ts
-var import_core59 = require("@graphrefly/pure-ts/core");
-var import_extra42 = require("@graphrefly/pure-ts/extra");
+var import_core66 = require("@graphrefly/pure-ts/core");
+var import_extra47 = require("@graphrefly/pure-ts/extra");
 var import_graph14 = require("@graphrefly/pure-ts/graph");
-var import_extra43 = require("@graphrefly/pure-ts/extra");
+var import_extra48 = require("@graphrefly/pure-ts/extra");
 function baseMeta2(kind, extra) {
   return domainMeta("domain_template", kind, extra);
 }
@@ -13837,12 +14376,12 @@ function observabilityGraph(name, opts) {
     name: b.name,
     classify: b.classify
   }));
-  const strat = (0, import_extra42.stratify)("stratify", opts.source, rules);
+  const strat = (0, import_extra47.stratify)("stratify", opts.source, rules);
   g.mount("stratify", strat);
   const branchNodes = branches.map((b) => {
     try {
       const raw = g.resolve(`stratify::branch/${b.name}`);
-      return (0, import_core59.node)(
+      return (0, import_core66.node)(
         [raw],
         (batchData, actions, ctx) => {
           const data = batchData.map(
@@ -13853,11 +14392,11 @@ function observabilityGraph(name, opts) {
         { initial: null, describeKind: "derived" }
       );
     } catch {
-      return (0, import_core59.node)([], { initial: null });
+      return (0, import_core66.node)([], { initial: null });
     }
   });
   const correlateFn = opts.correlate ?? ((vals) => vals);
-  const correlateNode = (0, import_core59.node)(
+  const correlateNode = (0, import_core66.node)(
     branchNodes,
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -13872,7 +14411,7 @@ function observabilityGraph(name, opts) {
   );
   g.add(correlateNode, { name: "correlate" });
   const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
-  const sloValue = (0, import_core59.node)(
+  const sloValue = (0, import_core66.node)(
     [correlateNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13885,7 +14424,7 @@ function observabilityGraph(name, opts) {
       meta: baseMeta2("observability", { stage: "slo_value" })
     }
   );
-  const sloVerified = (0, import_core59.node)(
+  const sloVerified = (0, import_core66.node)(
     [sloValue],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13902,7 +14441,7 @@ function observabilityGraph(name, opts) {
   g.add(sloVerified, { name: "slo_verified" });
   const weightValues = opts.weights ?? branches.map(() => 1);
   const signalNodes = branchNodes.map(
-    (bn) => (0, import_core59.node)(
+    (bn) => (0, import_core66.node)(
       [bn],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -13913,7 +14452,7 @@ function observabilityGraph(name, opts) {
       { describeKind: "derived" }
     )
   );
-  const weightNodes = weightValues.map((w) => (0, import_core59.node)([], { initial: w }));
+  const weightNodes = weightValues.map((w) => (0, import_core66.node)([], { initial: w }));
   for (let i = 0; i < signalNodes.length; i++) {
     g.add(signalNodes[i], { name: `__signal_${i}` });
     g.add(weightNodes[i], { name: `__weight_${i}` });
@@ -13923,7 +14462,7 @@ function observabilityGraph(name, opts) {
     weightNodes
   );
   g.add(alerts, { name: "alerts" });
-  const output = (0, import_core59.node)(
+  const output = (0, import_core66.node)(
     [alerts, sloVerified],
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -13940,12 +14479,12 @@ function observabilityGraph(name, opts) {
     }
   );
   g.add(output, { name: "output" });
-  const fbReentry = (0, import_core59.node)([], {
+  const fbReentry = (0, import_core66.node)([], {
     initial: null,
     meta: baseMeta2("observability", { stage: "feedback_reentry" })
   });
   g.add(fbReentry, { name: "feedback_reentry" });
-  const fbCondition = (0, import_core59.node)(
+  const fbCondition = (0, import_core66.node)(
     [sloVerified],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13977,7 +14516,7 @@ function issueTrackerGraph(name, opts) {
     raw
   });
   const extractFn = opts.extract ?? defaultExtract;
-  const extractNode = (0, import_core59.node)(
+  const extractNode = (0, import_core66.node)(
     [opts.source],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -13992,7 +14531,7 @@ function issueTrackerGraph(name, opts) {
   );
   g.add(extractNode, { name: "extract" });
   const verifyFn = opts.verify ?? (() => ({ valid: true }));
-  const verifyNode = (0, import_core59.node)(
+  const verifyNode = (0, import_core66.node)(
     [extractNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14007,13 +14546,13 @@ function issueTrackerGraph(name, opts) {
     }
   );
   g.add(verifyNode, { name: "verify" });
-  const knownPatterns = (0, import_core59.node)([], {
+  const knownPatterns = (0, import_core66.node)([], {
     initial: [],
     meta: baseMeta2("issue_tracker", { stage: "known_patterns" })
   });
   g.add(knownPatterns, { name: "known_patterns" });
   const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
-  const regressionNode = (0, import_core59.node)(
+  const regressionNode = (0, import_core66.node)(
     [extractNode, knownPatterns],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14026,7 +14565,7 @@ function issueTrackerGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("issue_tracker", { stage: "regression" }) }
   );
   g.add(regressionNode, { name: "regression" });
-  const severitySignal = (0, import_core59.node)(
+  const severitySignal = (0, import_core66.node)(
     [extractNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14037,7 +14576,7 @@ function issueTrackerGraph(name, opts) {
     },
     { describeKind: "derived" }
   );
-  const regressionSignal = (0, import_core59.node)(
+  const regressionSignal = (0, import_core66.node)(
     [regressionNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14050,13 +14589,13 @@ function issueTrackerGraph(name, opts) {
   );
   g.add(severitySignal, { name: "__severity_signal" });
   g.add(regressionSignal, { name: "__regression_signal" });
-  const severityWeight = (0, import_core59.node)([], { initial: 1 });
-  const regressionWeight = (0, import_core59.node)([], { initial: 1.5 });
+  const severityWeight = (0, import_core66.node)([], { initial: 1 });
+  const regressionWeight = (0, import_core66.node)([], { initial: 1.5 });
   g.add(severityWeight, { name: "__severity_weight" });
   g.add(regressionWeight, { name: "__regression_weight" });
   const priority = scorer([severitySignal, regressionSignal], [severityWeight, regressionWeight]);
   g.add(priority, { name: "priority" });
-  const output = (0, import_core59.node)(
+  const output = (0, import_core66.node)(
     [verifyNode, regressionNode, priority],
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -14071,12 +14610,12 @@ function issueTrackerGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("issue_tracker", { stage: "output" }) }
   );
   g.add(output, { name: "output" });
-  const fbReentry = (0, import_core59.node)([], {
+  const fbReentry = (0, import_core66.node)([], {
     initial: null,
     meta: baseMeta2("issue_tracker", { stage: "feedback_reentry" })
   });
   g.add(fbReentry, { name: "feedback_reentry" });
-  const fbCondition = (0, import_core59.node)(
+  const fbCondition = (0, import_core66.node)(
     [verifyNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14112,7 +14651,7 @@ function contentModerationGraph(name, opts) {
     original: content
   });
   const classifyFn = opts.classify ?? defaultClassify;
-  const classifyNode = (0, import_core59.node)(
+  const classifyNode = (0, import_core66.node)(
     [opts.source],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14126,13 +14665,13 @@ function contentModerationGraph(name, opts) {
     }
   );
   g.add(classifyNode, { name: "classify" });
-  const strat = (0, import_extra42.stratify)("stratify", classifyNode, [
+  const strat = (0, import_extra47.stratify)("stratify", classifyNode, [
     { name: "safe", classify: (v) => v.label === "safe" },
     { name: "review", classify: (v) => v.label === "review" },
     { name: "block", classify: (v) => v.label === "block" }
   ]);
   g.mount("stratify", strat);
-  const reviewLog = (0, import_extra42.reactiveLog)([], {
+  const reviewLog = (0, import_extra47.reactiveLog)([], {
     name: "review_queue",
     maxSize: opts.maxQueueSize
   });
@@ -14141,10 +14680,10 @@ function contentModerationGraph(name, opts) {
   try {
     reviewBranch = g.resolve("stratify::branch/review");
   } catch {
-    reviewBranch = (0, import_core59.node)([], { initial: null });
+    reviewBranch = (0, import_core66.node)([], { initial: null });
     g.add(reviewBranch, { name: "__review_fallback" });
   }
-  const reviewAccumulator = (0, import_core59.node)(
+  const reviewAccumulator = (0, import_core66.node)(
     [reviewBranch],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14158,11 +14697,11 @@ function contentModerationGraph(name, opts) {
     { describeKind: "effect" }
   );
   g.add(reviewAccumulator, { name: "__review_accumulator" });
-  g.addDisposer((0, import_extra43.keepalive)(reviewAccumulator));
+  g.addDisposer((0, import_extra48.keepalive)(reviewAccumulator));
   try {
   } catch {
   }
-  const policy3 = (0, import_core59.node)([], {
+  const policy3 = (0, import_core66.node)([], {
     initial: {},
     meta: baseMeta2("content_moderation", {
       stage: "policy",
@@ -14172,7 +14711,7 @@ function contentModerationGraph(name, opts) {
   });
   g.add(policy3, { name: "policy" });
   const weights = opts.weights ?? [0.1, 1, 2];
-  const confidenceSignal = (0, import_core59.node)(
+  const confidenceSignal = (0, import_core66.node)(
     [classifyNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14183,7 +14722,7 @@ function contentModerationGraph(name, opts) {
     },
     { describeKind: "derived" }
   );
-  const severitySignal = (0, import_core59.node)(
+  const severitySignal = (0, import_core66.node)(
     [classifyNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14202,13 +14741,13 @@ function contentModerationGraph(name, opts) {
   );
   g.add(confidenceSignal, { name: "__confidence_signal" });
   g.add(severitySignal, { name: "__severity_signal" });
-  const wConfidence = (0, import_core59.node)([], { initial: 1 });
-  const wSeverity = (0, import_core59.node)([], { initial: 1 });
+  const wConfidence = (0, import_core66.node)([], { initial: 1 });
+  const wSeverity = (0, import_core66.node)([], { initial: 1 });
   g.add(wConfidence, { name: "__w_confidence" });
   g.add(wSeverity, { name: "__w_severity" });
   const priority = scorer([confidenceSignal, severitySignal], [wConfidence, wSeverity]);
   g.add(priority, { name: "priority" });
-  const output = (0, import_core59.node)(
+  const output = (0, import_core66.node)(
     [classifyNode, priority],
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -14222,7 +14761,7 @@ function contentModerationGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("content_moderation", { stage: "output" }) }
   );
   g.add(output, { name: "output" });
-  const fbCondition = (0, import_core59.node)(
+  const fbCondition = (0, import_core66.node)(
     [reviewLog.entries, policy3],
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -14257,7 +14796,7 @@ function dataQualityGraph(name, opts) {
     errors: [],
     record
   }));
-  const validateNode = (0, import_core59.node)(
+  const validateNode = (0, import_core66.node)(
     [opts.source],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14273,7 +14812,7 @@ function dataQualityGraph(name, opts) {
     score: 0,
     record
   }));
-  const anomalyNode = (0, import_core59.node)(
+  const anomalyNode = (0, import_core66.node)(
     [opts.source],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14284,7 +14823,7 @@ function dataQualityGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "anomaly" }) }
   );
   g.add(anomalyNode, { name: "anomaly" });
-  const baseline = (0, import_core59.node)([], {
+  const baseline = (0, import_core66.node)([], {
     initial: null,
     meta: baseMeta2("data_quality", {
       stage: "baseline",
@@ -14292,7 +14831,7 @@ function dataQualityGraph(name, opts) {
     })
   });
   g.add(baseline, { name: "baseline" });
-  const baselineUpdater = (0, import_core59.node)(
+  const baselineUpdater = (0, import_core66.node)(
     [validateNode],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14300,7 +14839,7 @@ function dataQualityGraph(name, opts) {
       );
       const result = data[0];
       if (result?.valid) {
-        (0, import_core59.batch)(() => {
+        (0, import_core66.batch)(() => {
           baseline.emit(result.record);
         });
       }
@@ -14308,9 +14847,9 @@ function dataQualityGraph(name, opts) {
     { describeKind: "effect" }
   );
   g.add(baselineUpdater, { name: "__baseline_updater" });
-  (0, import_extra43.keepalive)(baselineUpdater);
+  (0, import_extra48.keepalive)(baselineUpdater);
   const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
-  const driftNode = (0, import_core59.node)(
+  const driftNode = (0, import_core66.node)(
     [opts.source, baseline],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14322,7 +14861,7 @@ function dataQualityGraph(name, opts) {
   );
   g.add(driftNode, { name: "drift" });
   const suggestFn = opts.suggest ?? (() => null);
-  const remediateNode = (0, import_core59.node)(
+  const remediateNode = (0, import_core66.node)(
     [validateNode, anomalyNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14338,7 +14877,7 @@ function dataQualityGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "remediate" }) }
   );
   g.add(remediateNode, { name: "remediate" });
-  const output = (0, import_core59.node)(
+  const output = (0, import_core66.node)(
     [validateNode, anomalyNode, driftNode, remediateNode],
     (batchData, actions, ctx) => {
       const vals = batchData.map(
@@ -14354,12 +14893,12 @@ function dataQualityGraph(name, opts) {
     { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "output" }) }
   );
   g.add(output, { name: "output" });
-  const validationRules = (0, import_core59.node)([], {
+  const validationRules = (0, import_core66.node)([], {
     initial: [],
     meta: baseMeta2("data_quality", { stage: "validation_rules" })
   });
   g.add(validationRules, { name: "validation_rules" });
-  const fbCondition = (0, import_core59.node)(
+  const fbCondition = (0, import_core66.node)(
     [anomalyNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14386,8 +14925,8 @@ function isTagged(value, tag) {
 }
 
 // src/utils/harness/actuator-executor.ts
-var import_core60 = require("@graphrefly/pure-ts/core");
-var import_extra44 = require("@graphrefly/pure-ts/extra");
+var import_core67 = require("@graphrefly/pure-ts/core");
+var import_extra49 = require("@graphrefly/pure-ts/extra");
 function defaultToOutput(record, item) {
   return {
     outcome: "success",
@@ -14421,7 +14960,7 @@ function actuatorExecutor(config) {
         execution: { item, outcome: "failure", detail: skipDetail(item) }
       };
     }
-    return (0, import_core60.node)(
+    return (0, import_core67.node)(
       [],
       (_data, actions) => {
         const ac = new AbortController();
@@ -14442,8 +14981,8 @@ function actuatorExecutor(config) {
           if (captured) return;
           captured = true;
           actions.down([
-            [import_core60.DATA, { ...job.payload, execution: { item, ...out } }],
-            [import_core60.COMPLETE]
+            [import_core67.DATA, { ...job.payload, execution: { item, ...out } }],
+            [import_core67.COMPLETE]
           ]);
           unsub?.();
           unsub = null;
@@ -14451,7 +14990,7 @@ function actuatorExecutor(config) {
         let inner;
         try {
           const rawResult = config.apply(item, { signal: ac.signal });
-          inner = (0, import_extra44.fromAny)(rawResult, { signal: ac.signal });
+          inner = (0, import_extra49.fromAny)(rawResult, { signal: ac.signal });
         } catch (err) {
           emitOnce(onError(err, item));
           return () => {
@@ -14462,15 +15001,15 @@ function actuatorExecutor(config) {
         unsub = inner.subscribe((batch14) => {
           for (const m of batch14) {
             if (captured) return;
-            if (m[0] === import_core60.DATA) {
+            if (m[0] === import_core67.DATA) {
               emitOnce(toOutput(m[1], item));
               return;
             }
-            if (m[0] === import_core60.ERROR) {
+            if (m[0] === import_core67.ERROR) {
               emitOnce(onError(m[1], item));
               return;
             }
-            if (m[0] === import_core60.COMPLETE) {
+            if (m[0] === import_core67.COMPLETE) {
               emitOnce(onError(new Error("actuator inner completed without emitting DATA"), item));
               return;
             }
@@ -14510,12 +15049,12 @@ function dispatchActuator(config) {
 }
 
 // src/utils/harness/auto-solidify.ts
-var import_core61 = require("@graphrefly/pure-ts/core");
+var import_core68 = require("@graphrefly/pure-ts/core");
 function autoSolidify(config) {
   const name = config.name ?? "auto-solidify";
   const extract = config.extract ?? ((vr) => vr.execution.artifact ?? null);
   const predicate = config.predicate ?? (() => true);
-  return (0, import_core61.node)(
+  return (0, import_core68.node)(
     [],
     (_data, actions) => {
       let unsub = null;
@@ -14528,16 +15067,16 @@ function autoSolidify(config) {
       };
       const emitTerminalError = (err) => {
         if (terminated) return;
-        actions.down([[import_core61.ERROR, err]]);
+        actions.down([[import_core68.ERROR, err]]);
         tearDown();
       };
       unsub = config.verifyResults.subscribe((batch14) => {
         if (terminated) return;
         for (const m of batch14) {
           if (terminated) return;
-          if (m[0] !== import_core61.DATA) {
-            if (m[0] === import_core61.COMPLETE) {
-              actions.down([[import_core61.COMPLETE]]);
+          if (m[0] !== import_core68.DATA) {
+            if (m[0] === import_core68.COMPLETE) {
+              actions.down([[import_core68.COMPLETE]]);
               tearDown();
               return;
             }
@@ -14568,7 +15107,7 @@ function autoSolidify(config) {
             emitTerminalError(err);
             return;
           }
-          actions.down([[import_core61.DATA, artifact]]);
+          actions.down([[import_core68.DATA, artifact]]);
         }
       });
       if (terminated && unsub) {
@@ -14584,11 +15123,11 @@ function autoSolidify(config) {
 }
 
 // src/utils/harness/bridge.ts
-var import_core62 = require("@graphrefly/pure-ts/core");
-var import_extra45 = require("@graphrefly/pure-ts/extra");
+var import_core69 = require("@graphrefly/pure-ts/core");
+var import_extra50 = require("@graphrefly/pure-ts/extra");
 function createIntakeBridge(opts) {
   const { graph, source, intakeTopic, parser, name = "intake-bridge" } = opts;
-  const eff = (0, import_core62.node)(
+  const eff = (0, import_core69.node)(
     [source],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14614,7 +15153,7 @@ function evalIntakeBridge(opts) {
     name = "eval-intake-bridge",
     defaultSeverity = "medium"
   } = opts;
-  const eff = (0, import_core62.node)(
+  const eff = (0, import_core69.node)(
     [source],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14659,11 +15198,11 @@ function evalIntakeBridge(opts) {
   return eff;
 }
 function evalSource(trigger, runner) {
-  return (0, import_extra45.switchMap)(trigger, () => (0, import_extra45.fromAny)(runner()));
+  return (0, import_extra50.switchMap)(trigger, () => (0, import_extra50.fromAny)(runner()));
 }
 function beforeAfterCompare(opts) {
   const { graph, before, after, name = "eval-delta" } = opts;
-  const der = (0, import_core62.node)(
+  const der = (0, import_core69.node)(
     [before, after],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14706,7 +15245,7 @@ function affectedTaskFilter(opts) {
   let taskSetNode = null;
   if (fullTaskSet != null) {
     if (Array.isArray(fullTaskSet)) {
-      const inlineSet = (0, import_core62.node)([], { initial: fullTaskSet });
+      const inlineSet = (0, import_core69.node)([], { initial: fullTaskSet });
       graph.add(inlineSet, { name: `${name}/fullTaskSet` });
       taskSetNode = inlineSet;
     } else {
@@ -14715,7 +15254,7 @@ function affectedTaskFilter(opts) {
   }
   const deps = [issues];
   if (taskSetNode) deps.push(taskSetNode);
-  const der = (0, import_core62.node)(
+  const der = (0, import_core69.node)(
     deps,
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -14769,7 +15308,7 @@ function codeChangeBridge(opts) {
     return items;
   }
   const resolve = parser ?? defaultParser;
-  const eff = (0, import_core62.node)(
+  const eff = (0, import_core69.node)(
     [source],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14788,7 +15327,7 @@ function codeChangeBridge(opts) {
 }
 function notifyEffect(opts) {
   const { graph, topic: topic2, transport, name = "notify-effect" } = opts;
-  const eff = (0, import_core62.node)(
+  const eff = (0, import_core69.node)(
     [topic2.latest],
     (batchData, _actions, ctx) => {
       const data = batchData.map(
@@ -14881,10 +15420,10 @@ function resolvePromptFn(raw, fallbackTemplate, substitute) {
 }
 
 // src/utils/harness/strategy.ts
-var import_core63 = require("@graphrefly/pure-ts/core");
+var import_core70 = require("@graphrefly/pure-ts/core");
 
 // src/utils/orchestration/audited-success-tracker.ts
-var import_extra46 = require("@graphrefly/pure-ts/extra");
+var import_extra51 = require("@graphrefly/pure-ts/extra");
 var import_graph15 = require("@graphrefly/pure-ts/graph");
 var AuditedSuccessTrackerGraph = class extends import_graph15.Graph {
   /** Reactive entries — `Node<ReadonlyMap<TKey, TEntry>>`, fresh map per mutation. */
@@ -14892,10 +15431,10 @@ var AuditedSuccessTrackerGraph = class extends import_graph15.Graph {
   _map;
   constructor(opts) {
     super(opts?.name ?? "audited-success-tracker", opts?.graph);
-    this._map = (0, import_extra46.reactiveMap)({ name: "entries" });
+    this._map = (0, import_extra51.reactiveMap)({ name: "entries" });
     this.entries = this._map.entries;
     this.add(this.entries, { name: "entries" });
-    this.addDisposer((0, import_extra46.keepalive)(this.entries));
+    this.addDisposer((0, import_extra51.keepalive)(this.entries));
     this.addDisposer(() => this._map.dispose());
   }
   /**
@@ -14958,7 +15497,7 @@ function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
   const effectivenessBoost = signals?.effectivenessBoost ?? 15;
   const deps = [item, strategy, lastInteractionNs];
   if (urgency) deps.push(urgency);
-  return (0, import_core63.node)(
+  return (0, import_core70.node)(
     deps,
     (batchData, actions, ctx) => {
       const values = batchData.map(
@@ -14969,7 +15508,7 @@ function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
       const lastNs = values[2];
       const urg = urgency ? values[3] : 0;
       const baseWeight = severityWeights[itm.severity ?? "medium"];
-      const ageSeconds2 = ((0, import_core63.monotonicNs)() - lastNs) / 1e9;
+      const ageSeconds2 = ((0, import_core70.monotonicNs)() - lastNs) / 1e9;
       let score = decay(baseWeight, ageSeconds2, decayRate, 0);
       const key = strategyKey(DEFAULT_PRESET_ID, itm.rootCause, itm.intervention);
       const entry = strat.get(key);
@@ -14984,8 +15523,8 @@ function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
 }
 
 // src/utils/inspect/audit.ts
-var import_core64 = require("@graphrefly/pure-ts/core");
-var import_extra47 = require("@graphrefly/pure-ts/extra");
+var import_core71 = require("@graphrefly/pure-ts/core");
+var import_extra52 = require("@graphrefly/pure-ts/extra");
 var import_graph16 = require("@graphrefly/pure-ts/graph");
 function auditMeta(kind, extra) {
   return domainMeta("audit", kind, extra);
@@ -15023,7 +15562,7 @@ var AuditTrailGraph = class extends import_graph16.Graph {
   constructor(target, opts) {
     super(opts.name ?? `${target.name}_audit`, opts.graph);
     this._target = target;
-    this._log = (0, import_extra47.reactiveLog)([], {
+    this._log = (0, import_extra52.reactiveLog)([], {
       name: "entries",
       ...opts.maxSize != null ? { maxSize: opts.maxSize } : {}
     });
@@ -15040,7 +15579,7 @@ var AuditTrailGraph = class extends import_graph16.Graph {
       },
       { meta: auditMeta("count") }
     );
-    this.addDisposer((0, import_extra47.keepalive)(this.count));
+    this.addDisposer((0, import_extra52.keepalive)(this.count));
     const includeTypes = opts.includeTypes != null ? new Set(opts.includeTypes) : new Set(DEFAULT_INCLUDE_TYPES);
     this.includeTypes = includeTypes;
     const filter2 = opts.filter;
@@ -15053,13 +15592,13 @@ var AuditTrailGraph = class extends import_graph16.Graph {
       const path = event.path ?? "";
       const entry = {
         seq: seq++,
-        timestamp_ns: event.timestamp_ns ?? (0, import_core64.monotonicNs)(),
-        wall_clock_ns: (0, import_core64.wallClockNs)(),
+        timestamp_ns: event.timestamp_ns ?? (0, import_core71.monotonicNs)(),
+        wall_clock_ns: (0, import_core71.wallClockNs)(),
         path,
         type
       };
-      const node58 = path ? safeNode(target, path) : void 0;
-      const lastMutation = node58?.lastMutation;
+      const node65 = path ? safeNode(target, path) : void 0;
+      const lastMutation = node65?.lastMutation;
       if (lastMutation != null) entry.actor = lastMutation.actor;
       if (type === "data") entry.value = event.data;
       if (type === "error") entry.error = event.data;
@@ -15120,7 +15659,7 @@ var PolicyGateGraph = class extends import_graph16.Graph {
     super(opts.name ?? `${target.name}_policy`, opts.graph);
     this._target = target;
     this._mode = opts.mode ?? "audit";
-    const policiesNode = isNode2(policies) ? policies : (0, import_core64.node)([], { name: "policies", initial: policies });
+    const policiesNode = isNode2(policies) ? policies : (0, import_core71.node)([], { name: "policies", initial: policies });
     this.policies = policiesNode;
     this.add(this.policies, { name: "policies" });
     this.violations = new TopicGraph("violations", {
@@ -15140,15 +15679,15 @@ var PolicyGateGraph = class extends import_graph16.Graph {
         meta: auditMeta("policy_violation_count")
       }
     );
-    this.addDisposer((0, import_extra47.keepalive)(this.violationCount));
+    this.addDisposer((0, import_extra52.keepalive)(this.violationCount));
     const initialRules = policiesNode.cache ?? [];
     let latestRules = initialRules;
-    this._currentGuard = (0, import_core64.policyFromRules)(latestRules);
+    this._currentGuard = (0, import_core71.policyFromRules)(latestRules);
     const offPolicies = policiesNode.subscribe((msgs) => {
       for (const m of msgs) {
-        if (m[0] === import_core64.DATA) {
+        if (m[0] === import_core71.DATA) {
           latestRules = m[1] ?? [];
-          this._currentGuard = (0, import_core64.policyFromRules)(latestRules);
+          this._currentGuard = (0, import_core71.policyFromRules)(latestRules);
         }
       }
     });
@@ -15162,7 +15701,7 @@ var PolicyGateGraph = class extends import_graph16.Graph {
     if (this._mode !== "enforce" && pathsNode != null) {
       const offAuditPaths = pathsNode.subscribe((msgs) => {
         for (const m of msgs) {
-          if (m[0] !== import_core64.DATA) continue;
+          if (m[0] !== import_core71.DATA) continue;
           latestPaths = m[1] ?? [];
         }
       });
@@ -15172,8 +15711,8 @@ var PolicyGateGraph = class extends import_graph16.Graph {
       const restorers = /* @__PURE__ */ new Map();
       const wrapAndPush = (path) => {
         if (restorers.has(path)) return;
-        const node58 = safeNode(target, path);
-        if (!(node58 instanceof import_core64.NodeImpl)) return;
+        const node65 = safeNode(target, path);
+        if (!(node65 instanceof import_core71.NodeImpl)) return;
         const pathGuard = (actor, action) => {
           const ok = this._currentGuard(actor, action);
           if (!ok) {
@@ -15181,17 +15720,17 @@ var PolicyGateGraph = class extends import_graph16.Graph {
           }
           return ok;
         };
-        restorers.set(path, node58._pushGuard(pathGuard));
+        restorers.set(path, node65._pushGuard(pathGuard));
       };
       for (const path of paths) wrapAndPush(path);
       if (pathsNode != null) {
         const offReactivePaths = pathsNode.subscribe((msgs) => {
           for (const m of msgs) {
-            if (m[0] !== import_core64.DATA) continue;
+            if (m[0] !== import_core71.DATA) continue;
             const next = m[1] ?? [];
             const nextSet = new Set(next);
             const prevSet = new Set(latestPaths ?? []);
-            (0, import_core64.batch)(() => {
+            (0, import_core71.batch)(() => {
               for (const p of prevSet) {
                 if (nextSet.has(p)) continue;
                 const r = restorers.get(p);
@@ -15250,7 +15789,7 @@ var PolicyGateGraph = class extends import_graph16.Graph {
       } else {
         const offCleanup = target.topology.subscribe((msgs) => {
           for (const m of msgs) {
-            if (m[0] !== import_core64.DATA) continue;
+            if (m[0] !== import_core71.DATA) continue;
             const event = m[1];
             if (event.kind !== "removed" || event.nodeKind !== "node") continue;
             const r = restorers.get(event.name);
@@ -15287,8 +15826,8 @@ var PolicyGateGraph = class extends import_graph16.Graph {
   }
   _publishViolation(actor, action, path, result) {
     this.violations.publish({
-      timestamp_ns: (0, import_core64.monotonicNs)(),
-      wall_clock_ns: (0, import_core64.wallClockNs)(),
+      timestamp_ns: (0, import_core71.monotonicNs)(),
+      wall_clock_ns: (0, import_core71.wallClockNs)(),
       path,
       actor,
       action,
@@ -15309,14 +15848,14 @@ var PolicyGateGraph = class extends import_graph16.Graph {
 };
 function policyGate(target, policies, opts = {}) {
   const g = new PolicyGateGraph(target, policies, opts);
-  g.tagFactory("policyGate", (0, import_core64.placeholderArgs)(opts));
+  g.tagFactory("policyGate", (0, import_core71.placeholderArgs)(opts));
   return g;
 }
 function complianceSnapshot(target, opts = {}) {
   const result = {
     format_version: 1,
-    timestamp_ns: (0, import_core64.monotonicNs)(),
-    wall_clock_ns: (0, import_core64.wallClockNs)(),
+    timestamp_ns: (0, import_core71.monotonicNs)(),
+    wall_clock_ns: (0, import_core71.wallClockNs)(),
     graph: target.snapshot()
   };
   if (opts.actor != null) result.actor = opts.actor;
@@ -15357,7 +15896,7 @@ function collectPaths(target) {
   return Object.keys(described.nodes);
 }
 function computeFingerprint(value) {
-  return (0, import_core64.defaultHash)(JSON.stringify(canonicalize(value)));
+  return (0, import_core71.defaultHash)(JSON.stringify(canonicalize(value)));
 }
 function canonicalize(value) {
   const stack = /* @__PURE__ */ new Set();
@@ -15410,8 +15949,8 @@ function canonicalize(value) {
 }
 
 // src/utils/inspect/lens.ts
-var import_core65 = require("@graphrefly/pure-ts/core");
-var import_extra48 = require("@graphrefly/pure-ts/extra");
+var import_core72 = require("@graphrefly/pure-ts/core");
+var import_extra53 = require("@graphrefly/pure-ts/extra");
 var import_graph17 = require("@graphrefly/pure-ts/graph");
 var import_graph18 = require("@graphrefly/pure-ts/graph");
 function computeHealthReport(described) {
@@ -15451,7 +15990,7 @@ function graphLens(target) {
     reactiveName: "graphLens.topology"
   });
   const topology = topologyHandle.node;
-  const health = (0, import_core65.node)(
+  const health = (0, import_core72.node)(
     [topology],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -15466,11 +16005,11 @@ function graphLens(target) {
       meta: domainMeta("lens", "health")
     }
   );
-  const stopHealthKeep = (0, import_extra48.keepalive)(health);
+  const stopHealthKeep = (0, import_extra53.keepalive)(health);
   const flowMap = /* @__PURE__ */ new Map();
   let lastAppliedFlush_ns = -1;
   const dataFlow = target.observe({ reactive: true, tiers: ["data"] });
-  const flow = (0, import_core65.node)(
+  const flow = (0, import_core72.node)(
     [dataFlow, topology],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -15508,7 +16047,7 @@ function graphLens(target) {
       meta: domainMeta("lens", "flow")
     }
   );
-  const stopFlowKeep = (0, import_extra48.keepalive)(flow);
+  const stopFlowKeep = (0, import_extra53.keepalive)(flow);
   let disposed = false;
   return {
     topology,
@@ -15525,8 +16064,8 @@ function graphLens(target) {
 }
 
 // src/utils/job-queue/index.ts
-var import_core66 = require("@graphrefly/pure-ts/core");
-var import_extra49 = require("@graphrefly/pure-ts/extra");
+var import_core73 = require("@graphrefly/pure-ts/core");
+var import_extra54 = require("@graphrefly/pure-ts/extra");
 var import_graph19 = require("@graphrefly/pure-ts/graph");
 var DEFAULT_MAX_PER_PUMP2 = 256;
 var DEFAULT_COMPLETED_RETAINED_LIMIT = 1024;
@@ -15562,13 +16101,13 @@ var JobQueueGraph = class extends import_graph19.Graph {
   _removeByIdImpl;
   constructor(name, opts = {}) {
     super(name, opts.graph);
-    this._pending = (0, import_extra49.reactiveList)([], { name: "pending" });
-    this._jobs = (0, import_extra49.reactiveMap)({ name: "jobs" });
+    this._pending = (0, import_extra54.reactiveList)([], { name: "pending" });
+    this._jobs = (0, import_extra54.reactiveMap)({ name: "jobs" });
     this.pending = this._pending.items;
     this.jobs = this._jobs.entries;
     this.add(this.pending, { name: "pending" });
     this.add(this.jobs, { name: "jobs" });
-    this.depth = (0, import_core66.node)(
+    this.depth = (0, import_core73.node)(
       [this.pending],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -15584,7 +16123,7 @@ var JobQueueGraph = class extends import_graph19.Graph {
       }
     );
     this.add(this.depth, { name: "depth" });
-    this.addDisposer((0, import_extra49.keepalive)(this.depth));
+    this.addDisposer((0, import_extra54.keepalive)(this.depth));
     this.events = createAuditLog({
       name: "events",
       retainedLimit: 1024,
@@ -15721,7 +16260,7 @@ var JobQueueGraph = class extends import_graph19.Graph {
         action: "claim",
         id,
         attempts: inflight.attempts,
-        t_ns: (0, import_core66.wallClockNs)(),
+        t_ns: (0, import_core73.wallClockNs)(),
         seq: bumpCursor(this._seqCursor)
       });
     }
@@ -15772,7 +16311,7 @@ var JobQueueGraph = class extends import_graph19.Graph {
   consumeFrom(source, opts) {
     return source.subscribe((msgs) => {
       for (const m of msgs) {
-        if (m[0] !== import_core66.DATA) continue;
+        if (m[0] !== import_core73.DATA) continue;
         const payload = m[1];
         this.enqueue(payload, opts ? { metadata: opts.metadata } : void 0);
       }
@@ -15832,13 +16371,13 @@ var JobFlowGraph = class extends import_graph19.Graph {
       this._queues.set(stage, q);
       this.mount(stage, q);
     }
-    this._completed = (0, import_extra49.reactiveLog)([], {
+    this._completed = (0, import_extra54.reactiveLog)([], {
       name: "completed",
       maxSize: DEFAULT_COMPLETED_RETAINED_LIMIT
     });
     this.completed = this._completed.entries;
     this.add(this.completed, { name: "completed" });
-    this.completedCount = (0, import_core66.node)(
+    this.completedCount = (0, import_core73.node)(
       [this.completed],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -15854,7 +16393,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
       }
     );
     this.add(this.completedCount, { name: "completedCount" });
-    this.addDisposer((0, import_extra49.keepalive)(this.completedCount));
+    this.addDisposer((0, import_extra54.keepalive)(this.completedCount));
     const defaultMaxPerPump = Math.max(
       1,
       requireNonNegativeInt2(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP2, "job flow maxPerPump")
@@ -15866,14 +16405,14 @@ var JobFlowGraph = class extends import_graph19.Graph {
       const workFn = this._stageWorkFns.get(stage);
       const stagePerPump = stageMaxPerPump.get(stage) ?? defaultMaxPerPump;
       const stageMaxInflightCap = stageMaxInflight.get(stage);
-      const inflightCounter = stageMaxInflightCap !== void 0 ? (0, import_core66.node)([], { name: `__inflight__/${stage}`, initial: 0 }) : null;
+      const inflightCounter = stageMaxInflightCap !== void 0 ? (0, import_core73.node)([], { name: `__inflight__/${stage}`, initial: 0 }) : null;
       if (inflightCounter) {
         this.add(inflightCounter, { name: `__inflight__/${stage}` });
       }
       const isTerminal = next === null;
       if (workFn) {
         const pumpDeps = inflightCounter != null ? [current.pending, inflightCounter] : [current.pending];
-        const pump = (0, import_core66.node)(
+        const pump = (0, import_core73.node)(
           pumpDeps,
           (_data, _actions, ctx) => {
             if (!("inflight" in ctx.store)) {
@@ -15909,7 +16448,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
                 processed += 1;
                 continue;
               }
-              const resultNode = (0, import_extra49.fromAny)(result);
+              const resultNode = (0, import_extra54.fromAny)(result);
               let settled = false;
               let unsub;
               const cleanupSub = () => {
@@ -15926,7 +16465,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
               unsub = resultNode.subscribe((msgs) => {
                 if (settled) return;
                 for (const m of msgs) {
-                  if (m[0] === import_core66.DATA) {
+                  if (m[0] === import_core73.DATA) {
                     settled = true;
                     cleanupSub();
                     const newPayload = m[1];
@@ -15940,12 +16479,12 @@ var JobFlowGraph = class extends import_graph19.Graph {
                         payload: newPayload,
                         metadata: Object.freeze(newMetadata)
                       };
-                      (0, import_core66.batch)(() => {
+                      (0, import_core73.batch)(() => {
                         current.ack(job.id);
                         this._completed.append(completedJob);
                       });
                     } else {
-                      (0, import_core66.batch)(() => {
+                      (0, import_core73.batch)(() => {
                         current.ack(job.id);
                         next.enqueue(newPayload, {
                           metadata: newMetadata
@@ -15953,7 +16492,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
                       });
                     }
                     return;
-                  } else if (m[0] === import_core66.ERROR) {
+                  } else if (m[0] === import_core73.ERROR) {
                     settled = true;
                     cleanupSub();
                     current.nack(job.id, { requeue: false });
@@ -15986,7 +16525,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
             meta: jobQueueMeta("job_flow_pump", { stage, has_work: true })
           }
         );
-        this.addDisposer((0, import_extra49.keepalive)(pump));
+        this.addDisposer((0, import_extra54.keepalive)(pump));
       } else {
         const pump = this.effect(
           `pump_${stage}`,
@@ -16006,12 +16545,12 @@ var JobFlowGraph = class extends import_graph19.Graph {
                   ...job,
                   metadata: Object.freeze(newMetadata)
                 };
-                (0, import_core66.batch)(() => {
+                (0, import_core73.batch)(() => {
                   current.ack(job.id);
                   this._completed.append(completedJob);
                 });
               } else {
-                (0, import_core66.batch)(() => {
+                (0, import_core73.batch)(() => {
                   current.ack(job.id);
                   next.enqueue(job.payload, {
                     metadata: newMetadata
@@ -16025,7 +16564,7 @@ var JobFlowGraph = class extends import_graph19.Graph {
             meta: jobQueueMeta("job_flow_pump", { stage, has_work: false })
           }
         );
-        this.addDisposer((0, import_extra49.keepalive)(pump));
+        this.addDisposer((0, import_extra54.keepalive)(pump));
       }
     }
   }
@@ -16050,19 +16589,19 @@ function jobQueue(name, opts) {
 function jobFlow(name, opts) {
   const g = new JobFlowGraph(name, opts);
   const { factory: _f, factoryArgs: _fa, ...tagArgs } = opts ?? {};
-  g.tagFactory("jobFlow", (0, import_core66.placeholderArgs)(tagArgs));
+  g.tagFactory("jobFlow", (0, import_core73.placeholderArgs)(tagArgs));
   return g;
 }
 
 // src/utils/process/index.ts
-var import_core67 = require("@graphrefly/pure-ts/core");
-var import_extra50 = require("@graphrefly/pure-ts/extra");
+var import_core74 = require("@graphrefly/pure-ts/core");
+var import_extra55 = require("@graphrefly/pure-ts/extra");
 var import_graph20 = require("@graphrefly/pure-ts/graph");
 var processInstanceKeyOf = (i) => i.correlationId;
 var processStateKeyOf = (s) => s.correlationId;
 function toPromise(input) {
   if (input == null) return Promise.resolve(void 0);
-  const n = (0, import_extra50.fromAny)(input);
+  const n = (0, import_extra55.fromAny)(input);
   return new Promise((resolve, reject) => {
     let settled = false;
     let unsub;
@@ -16074,19 +16613,19 @@ function toPromise(input) {
     unsub = n.subscribe((msgs) => {
       if (settled) return;
       for (const m of msgs) {
-        if (m[0] === import_core67.DATA) {
+        if (m[0] === import_core74.DATA) {
           settled = true;
           Promise.resolve().then(cleanup);
           resolve(m[1]);
           return;
         }
-        if (m[0] === import_core67.ERROR) {
+        if (m[0] === import_core74.ERROR) {
           settled = true;
           Promise.resolve().then(cleanup);
           reject(m[1]);
           return;
         }
-        if (m[0] === import_core67.COMPLETE) {
+        if (m[0] === import_core74.COMPLETE) {
           settled = true;
           Promise.resolve().then(cleanup);
           resolve(void 0);
@@ -16167,8 +16706,8 @@ function processManager(cqrsGraph, name, opts) {
       correlationId,
       state: stateValue,
       status,
-      startedAt: startedAt.get(correlationId) ?? (0, import_core67.wallClockNs)(),
-      updatedAt: (0, import_core67.wallClockNs)(),
+      startedAt: startedAt.get(correlationId) ?? (0, import_core74.wallClockNs)(),
+      updatedAt: (0, import_core74.wallClockNs)(),
       ...opts.handlerVersion !== void 0 ? { handlerVersion: opts.handlerVersion } : {}
     };
   };
@@ -16266,10 +16805,10 @@ function processManager(cqrsGraph, name, opts) {
       if (result.schedule) {
         const { afterMs, eventType } = result.schedule;
         let timerUnsub;
-        const timerNode = (0, import_extra50.fromTimer)(afterMs);
+        const timerNode = (0, import_extra55.fromTimer)(afterMs);
         const timerCb = (msgs) => {
           for (const m of msgs) {
-            if (m[0] === import_core67.DATA) {
+            if (m[0] === import_core74.DATA) {
               if (timerUnsub) {
                 timerUnsub();
               } else {
@@ -16286,7 +16825,7 @@ function processManager(cqrsGraph, name, opts) {
                 // seq: Number.NaN — sentinel for synthetic events that do not
                 // participate in cross-event ordering.
                 payload: null,
-                timestampNs: (0, import_core67.wallClockNs)(),
+                timestampNs: (0, import_core74.wallClockNs)(),
                 seq: Number.NaN,
                 correlationId,
                 aggregateId: correlationId
@@ -16347,13 +16886,13 @@ function processManager(cqrsGraph, name, opts) {
     });
   }
   let _disposed = false;
-  const restoreState = (0, import_core67.node)([], {
+  const restoreState = (0, import_core74.node)([], {
     initial: "pending",
     name: "restoreState",
     describeKind: "state"
   });
   subgraph.add(restoreState, { name: "restoreState" });
-  const gateOpen = (0, import_core67.node)(
+  const gateOpen = (0, import_core74.node)(
     [restoreState],
     (data, a, ctx) => {
       const batch0 = data[0];
@@ -16366,11 +16905,11 @@ function processManager(cqrsGraph, name, opts) {
   const watchDisposers = [];
   for (const eventType of opts.watching) {
     const eventNode = cqrsGraph.event(eventType);
-    const gated = (0, import_extra50.valve)(eventNode, gateOpen, { name: `gatedEvent:${eventType}` });
+    const gated = (0, import_extra55.valve)(eventNode, gateOpen, { name: `gatedEvent:${eventType}` });
     let lastCount = 0;
     const unsub = gated.subscribe((msgs) => {
       for (const m of msgs) {
-        if (m[0] !== import_core67.DATA) continue;
+        if (m[0] !== import_core74.DATA) continue;
         const events = m[1];
         if (events.length <= lastCount) continue;
         const newEvents = events.slice(lastCount);
@@ -16395,7 +16934,7 @@ function processManager(cqrsGraph, name, opts) {
         correlationId,
         aggregateId: correlationId
       });
-      startedAt.set(correlationId, (0, import_core67.wallClockNs)());
+      startedAt.set(correlationId, (0, import_core74.wallClockNs)());
       instanceStates.set(correlationId, opts.initial);
       activeInstances.add(correlationId);
       persistStateThrowing(correlationId, "running");
@@ -16447,21 +16986,21 @@ function processManager(cqrsGraph, name, opts) {
     }
     const tierLoad = tier2.load.bind(tier2);
     const tierList = tier2.list.bind(tier2);
-    const listSource = (0, import_extra50.fromAny)(tierList());
-    const flattened = (0, import_extra50.mergeMap)(listSource, (keys) => {
+    const listSource = (0, import_extra55.fromAny)(tierList());
+    const flattened = (0, import_extra55.mergeMap)(listSource, (keys) => {
       if (keys.length === 0) {
-        return (0, import_extra50.fromIter)([]);
+        return (0, import_extra55.fromIter)([]);
       }
-      return (0, import_extra50.mergeMap)(
-        (0, import_extra50.fromIter)(keys),
-        (key) => (0, import_extra50.fromAny)(tierLoad(key)),
+      return (0, import_extra55.mergeMap)(
+        (0, import_extra55.fromIter)(keys),
+        (key) => (0, import_extra55.fromAny)(tierLoad(key)),
         // Bound concurrent in-flight loads (D2, 2026-05-01) so a
         // large persisted-instance count doesn't exhaust file
         // handles / connection pools on the storage backend.
         { concurrent: opts.restoreConcurrency ?? 8 }
       );
     });
-    const restoreEffect = (0, import_core67.node)(
+    const restoreEffect = (0, import_core74.node)(
       [flattened],
       (data, _a, ctx) => {
         if (_disposed) return;
@@ -16469,7 +17008,7 @@ function processManager(cqrsGraph, name, opts) {
         const hasSnapshots = batch0 != null && batch0.length > 0;
         const allDone = ctx.terminalDeps[0] === true;
         if (!hasSnapshots && !allDone) return;
-        (0, import_core67.batch)(() => {
+        (0, import_core74.batch)(() => {
           if (hasSnapshots) {
             for (const snap of batch0) {
               if (snap == null) continue;
@@ -16697,7 +17236,7 @@ var ImageSizeAdapter = class {
 };
 
 // src/utils/reactive-layout/reactive-block-layout.ts
-var import_core68 = require("@graphrefly/pure-ts/core");
+var import_core75 = require("@graphrefly/pure-ts/core");
 var import_graph21 = require("@graphrefly/pure-ts/graph");
 function measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, index) {
   switch (block.type) {
@@ -16793,18 +17332,18 @@ function reactiveBlockLayout(opts) {
   } = opts;
   const g = new import_graph21.Graph(name);
   const measureCache = /* @__PURE__ */ new Map();
-  const blocksNode = (0, import_core68.node)([], { name: "blocks", initial: opts.blocks ?? [] });
-  const maxWidthNode = (0, import_core68.node)([], {
+  const blocksNode = (0, import_core75.node)([], { name: "blocks", initial: opts.blocks ?? [] });
+  const maxWidthNode = (0, import_core75.node)([], {
     name: "max-width",
     initial: Math.max(0, opts.maxWidth ?? 800)
   });
-  const gapNode = (0, import_core68.node)([], { name: "gap", initial: opts.gap ?? 0 });
-  const measuredBlocksNode = (0, import_core68.node)(
+  const gapNode = (0, import_core75.node)([], { name: "gap", initial: opts.gap ?? 0 });
+  const measuredBlocksNode = (0, import_core75.node)(
     [blocksNode, maxWidthNode],
     (data, actions, ctx) => {
       const blocksVal = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
       const mwVal = data[1] != null && data[1].length > 0 ? data[1].at(-1) : ctx.prevData[1];
-      const t0 = (0, import_core68.monotonicNs)();
+      const t0 = (0, import_core75.monotonicNs)();
       const result = measureBlocks(
         blocksVal,
         mwVal,
@@ -16813,7 +17352,7 @@ function reactiveBlockLayout(opts) {
         defaultFont,
         defaultLineHeight
       );
-      const elapsed = (0, import_core68.monotonicNs)() - t0;
+      const elapsed = (0, import_core75.monotonicNs)() - t0;
       const meta2 = measuredBlocksNode.meta;
       if (meta2) {
         emitToMeta(meta2["block-count"], result.length);
@@ -16845,7 +17384,7 @@ function reactiveBlockLayout(opts) {
       }
     }
   );
-  const blockFlowNode = (0, import_core68.node)(
+  const blockFlowNode = (0, import_core75.node)(
     [measuredBlocksNode, gapNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -16871,7 +17410,7 @@ function reactiveBlockLayout(opts) {
       }
     }
   );
-  const totalHeightNode = (0, import_core68.node)(
+  const totalHeightNode = (0, import_core75.node)(
     [blockFlowNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -16899,7 +17438,7 @@ function reactiveBlockLayout(opts) {
 }
 
 // src/utils/reactive-layout/reactive-flow-layout.ts
-var import_core69 = require("@graphrefly/pure-ts/core");
+var import_core76 = require("@graphrefly/pure-ts/core");
 var import_graph22 = require("@graphrefly/pure-ts/graph");
 function circleIntervalForBand(o, bandTop, bandBottom) {
   const hPad = o.hPad ?? 0;
@@ -16991,23 +17530,23 @@ function reactiveFlowLayout(opts) {
   const { adapter, name = "reactive-flow-layout", minSlotWidth = 20 } = opts;
   const g = new import_graph22.Graph(name);
   const measureCache = /* @__PURE__ */ new Map();
-  const textNode = (0, import_core69.node)([], { name: "text", initial: opts.text ?? "" });
-  const fontNode = (0, import_core69.node)([], { name: "font", initial: opts.font ?? "16px sans-serif" });
-  const lineHeightNode = (0, import_core69.node)([], { name: "line-height", initial: opts.lineHeight ?? 20 });
-  const containerNode = (0, import_core69.node)([], {
+  const textNode = (0, import_core76.node)([], { name: "text", initial: opts.text ?? "" });
+  const fontNode = (0, import_core76.node)([], { name: "font", initial: opts.font ?? "16px sans-serif" });
+  const lineHeightNode = (0, import_core76.node)([], { name: "line-height", initial: opts.lineHeight ?? 20 });
+  const containerNode = (0, import_core76.node)([], {
     name: "container",
     initial: opts.container ?? { width: 800, height: 600, paddingX: 0, paddingY: 0 }
   });
-  const columnsNode = (0, import_core69.node)([], {
+  const columnsNode = (0, import_core76.node)([], {
     name: "columns",
     initial: opts.columns ?? { count: 1, gap: 0 }
   });
-  const obstaclesNode = (0, import_core69.node)([], { name: "obstacles", initial: opts.obstacles ?? [] });
-  const paragraphSpacingNode = (0, import_core69.node)([], {
+  const obstaclesNode = (0, import_core76.node)([], { name: "obstacles", initial: opts.obstacles ?? [] });
+  const paragraphSpacingNode = (0, import_core76.node)([], {
     name: "paragraph-spacing",
     initial: opts.paragraphSpacing ?? null
   });
-  const segmentsNode = (0, import_core69.node)(
+  const segmentsNode = (0, import_core76.node)(
     [textNode, fontNode],
     (data, actions, ctx) => {
       const b0 = data[0];
@@ -17024,14 +17563,14 @@ function reactiveFlowLayout(opts) {
     },
     { name: "segments", describeKind: "derived" }
   );
-  const flowLinesNode = (0, import_core69.node)(
+  const flowLinesNode = (0, import_core76.node)(
     [segmentsNode, containerNode, columnsNode, obstaclesNode, lineHeightNode, paragraphSpacingNode],
     (batchData, actions, ctx) => {
       const data = batchData.map(
         (batch14, i) => batch14 != null && batch14.length > 0 ? batch14.at(-1) : ctx.prevData[i]
       );
       const segments = data[0];
-      const t0 = (0, import_core69.monotonicNs)();
+      const t0 = (0, import_core76.monotonicNs)();
       const effectiveSpacing = data[5] ?? data[4];
       const { lines: result, cursor } = computeFlowLines(
         segments,
@@ -17042,7 +17581,7 @@ function reactiveFlowLayout(opts) {
         minSlotWidth,
         { paragraphSpacing: effectiveSpacing }
       );
-      const elapsed = (0, import_core69.monotonicNs)() - t0;
+      const elapsed = (0, import_core76.monotonicNs)() - t0;
       const overflow = Math.max(0, segments.length - cursor.segmentIndex);
       const meta2 = flowLinesNode.meta;
       if (meta2) {
@@ -17166,7 +17705,7 @@ ${catalogValidation.errors.join("\n")}`,
 }
 
 // src/utils/surface/reduce.ts
-var import_core70 = require("@graphrefly/pure-ts/core");
+var import_core77 = require("@graphrefly/pure-ts/core");
 var DEFAULT_TIMEOUT_MS2 = 3e4;
 async function runReduction(spec, input, opts) {
   const inputPath = opts?.inputPath ?? "input";
@@ -17217,16 +17756,16 @@ async function runReduction(spec, input, opts) {
         for (const m of msgs) {
           if (settled) return;
           if (!primed) continue;
-          if (m[0] === import_core70.DATA) {
+          if (m[0] === import_core77.DATA) {
             finish(() => resolve(m[1]));
             return;
           }
-          if (m[0] === import_core70.RESOLVED) {
+          if (m[0] === import_core77.RESOLVED) {
             const cached = outputNode.cache;
             finish(() => resolve(cached));
             return;
           }
-          if (m[0] === import_core70.ERROR) {
+          if (m[0] === import_core77.ERROR) {
             const payload = m[1];
             const message = payload instanceof Error ? payload.message : String(payload);
             const cause = payload instanceof Error ? payload : void 0;
@@ -17241,7 +17780,7 @@ async function runReduction(spec, input, opts) {
             );
             return;
           }
-          if (m[0] === import_core70.COMPLETE) {
+          if (m[0] === import_core77.COMPLETE) {
             finish(
               () => reject(
                 new SurfaceError(
@@ -17296,7 +17835,7 @@ async function runReduction(spec, input, opts) {
 }
 
 // src/utils/surface/snapshot.ts
-var import_core71 = require("@graphrefly/pure-ts/core");
+var import_core78 = require("@graphrefly/pure-ts/core");
 var import_graph23 = require("@graphrefly/pure-ts/graph");
 var SNAPSHOT_WIRE_VERSION = import_graph23.SNAPSHOT_VERSION;
 var SNAPSHOT_KEY_PREFIX = "snapshot:";
@@ -17365,7 +17904,7 @@ async function saveSnapshot(graph, snapshotId, tier2) {
     name: graph.name,
     mode: "full",
     seq: 0,
-    timestamp_ns: (0, import_core71.wallClockNs)(),
+    timestamp_ns: (0, import_core78.wallClockNs)(),
     format_version: SNAPSHOT_WIRE_VERSION,
     snapshot
   };