@graphrefly/graphrefly 0.47.0 → 0.47.2

package/dist/utils/memory/index.cjs

@@ -20,15 +20,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils/memory/index.ts
 var memory_exports = {};
 __export(memory_exports, {
+  admissionLlmJudge: () => admissionLlmJudge,
+  bitemporalQuery: () => bitemporalQuery,
   collection: () => collection,
+  consolidationRem: () => consolidationRem,
   cosineSimilarity: () => cosineSimilarity,
+  decayExponential: () => decayExponential,
+  influenceAnalysis: () => influenceAnalysis,
+  invalidationTracer: () => invalidationTracer,
   knowledgeGraph: () => knowledgeGraph,
+  persistentReactiveFactStore: () => persistentReactiveFactStore,
   reactiveFactStore: () => reactiveFactStore,
+  scoringByOutcome: () => scoringByOutcome,
+  shardByTenant: () => shardByTenant,
   vectorIndex: () => vectorIndex
 });
 module.exports = __toCommonJS(memory_exports);
-var import_core3 = require("@graphrefly/pure-ts/core");
-var import_extra3 = require("@graphrefly/pure-ts/extra");
+var import_core10 = require("@graphrefly/pure-ts/core");
+var import_extra8 = require("@graphrefly/pure-ts/extra");
 var import_graph3 = require("@graphrefly/pure-ts/graph");
 
 // src/base/meta/domain-meta.ts
@@ -628,6 +637,57 @@ function reactiveFactStore(config) {
   );
   graph.add(consolidated, { name: "consolidated" });
   graph.addDisposer((0, import_extra2.keepalive)(consolidated));
+  if (config.decayTrigger) {
+    const decayProcessor = (0, import_core2.node)(
+      config.decay ? [config.decayTrigger, config.decay] : [config.decayTrigger],
+      (batchData, actions, ctx) => {
+        const policy2 = config.decay ? lastOf(batchData[1], ctx.prevData[1]) : void 0;
+        if (!policy2) {
+          actions.emit([]);
+          return;
+        }
+        const now = BigInt((0, import_core2.monotonicNs)());
+        const changes = [];
+        for (const f of allFacts().values()) {
+          if (f.validTo !== void 0) continue;
+          const ageNs = now - f.t_ns;
+          const raw = policy2(f.confidence, ageNs);
+          if (!Number.isFinite(raw)) continue;
+          const next = raw < 0 ? 0 : raw > 1 ? 1 : raw;
+          if (next === f.confidence) continue;
+          changes.push({ id: f.id, next });
+        }
+        const decayed = [];
+        for (const { id, next } of changes) {
+          const idx = findShardOf(id);
+          const fs = idx < 0 ? void 0 : shards[idx].cache;
+          const live = fs?.byId.get(id);
+          if (!live || live.validTo !== void 0) continue;
+          replaceFragment(
+            id,
+            (prev) => prev.validTo !== void 0 ? prev : { ...prev, confidence: next }
+          );
+          decayed.push({ ...live, confidence: next });
+        }
+        if (decayed.length > 0) {
+          events.append({
+            action: "decay",
+            t_ns: (0, import_core2.wallClockNs)(),
+            seq: bumpCursor(seqCursor)
+          });
+        }
+        actions.emit(decayed);
+      },
+      {
+        name: "decay_processor",
+        describeKind: "derived",
+        initial: [],
+        meta: factMeta("decay")
+      }
+    );
+    graph.add(decayProcessor, { name: "decay_processor" });
+    graph.addDisposer((0, import_extra2.keepalive)(decayProcessor));
+  }
   const ingestAudit = (0, import_core2.node)(
     [extractOp],
     (batchData, actions, ctx) => {
@@ -682,14 +742,430 @@ function reactiveFactStore(config) {
   return out;
 }
 
+// src/utils/memory/persistent-fact-store.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra3 = 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_extra3.bigintJsonCodecFor)();
+  const tier = (0, import_extra3.appendLogStorage)(config.storage, {
+    name: persistName,
+    codec
+  });
+  const store = reactiveFactStore({ ...config, recordIngest: true });
+  const ingestLog = store.ingestLog;
+  async function* loadHistory() {
+    if (typeof tier.loadEntries !== "function") return;
+    const page = await tier.loadEntries();
+    for (const f of page.entries) yield f;
+  }
+  const replaySource = (0, import_extra3.fromAny)(loadHistory(), {
+    name: "_replay_source",
+    meta: persistMeta("persist_replay_source")
+  });
+  store.add(replaySource, { name: "_replay_source" });
+  let replayed = 0;
+  const replayPump = (0, import_core3.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_extra3.keepalive)(replayPump));
+  const attached = (0, import_core3.node)([], {
+    initial: false,
+    name: "_storage_attached",
+    describeKind: "state",
+    meta: persistMeta("persist_attached")
+  });
+  store.add(attached, { name: "_storage_attached" });
+  store.addDisposer((0, import_extra3.keepalive)(attached));
+  let detachStorage;
+  const replaySub = replaySource.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] === import_core3.COMPLETE && detachStorage === void 0) {
+        const sizeAtAttach = ingestLog.size;
+        detachStorage = ingestLog.attachStorage([tier]);
+        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 = tier.appendEntries(slice);
+            if (r instanceof Promise) r.catch(() => {
+            });
+          }
+        }
+        attached.emit(true);
+      }
+    }
+  });
+  store.addDisposer(() => {
+    replaySub();
+    detachStorage?.();
+  });
+  const position = (0, import_core3.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_extra3.keepalive)(position));
+  const out = Object.assign(store, {
+    position,
+    replayedCount: replayPump,
+    tier,
+    async flush() {
+      await tier.flush?.();
+    }
+  });
+  return out;
+}
+
+// src/utils/memory/recipes/admission-llm-judge.ts
+var import_core4 = 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_core4.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_core5 = require("@graphrefly/pure-ts/core");
+
+// src/utils/memory/recipes/_shared.ts
+function lastOf2(batch2, prev) {
+  return batch2 != null && batch2.length > 0 ? batch2.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_core5.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_core5.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_extra4 = require("@graphrefly/pure-ts/extra");
+function consolidationRem(opts) {
+  const consolidateTrigger = (0, import_extra4.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_core6 = require("@graphrefly/pure-ts/core");
+var import_extra5 = 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_extra5.fromTimer)(opts.periodMs, { period: opts.periodMs });
+  const driver = (0, import_core6.node)(
+    [timer],
+    (_batchData, actions) => {
+      const fs = mem.factStore.cache;
+      if (!fs) {
+        actions.emit([]);
+        return;
+      }
+      const now = BigInt((0, import_core6.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_extra5.keepalive)(timer));
+  mem.addDisposer((0, import_extra5.keepalive)(driver));
+  return driver;
+}
+
+// src/utils/memory/recipes/influence-analysis.ts
+var import_core7 = require("@graphrefly/pure-ts/core");
+var import_extra6 = 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_core7.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_extra6.keepalive)(ranked));
+  const builtFor = /* @__PURE__ */ new Map();
+  function influenceOf(rootId) {
+    const existing = builtFor.get(rootId);
+    if (existing) return existing;
+    const n = (0, import_core7.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_extra6.keepalive)(n));
+    builtFor.set(rootId, n);
+    return n;
+  }
+  return { influenceOf, ranked };
+}
+
+// src/utils/memory/recipes/invalidation-tracer.ts
+var import_core8 = require("@graphrefly/pure-ts/core");
+var import_extra7 = 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_core8.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_extra7.keepalive)(tracer));
+  return tracer;
+}
+
+// src/utils/memory/recipes/scoring-by-outcome.ts
+var import_core9 = 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_core9.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_SEC = 1e9;
 function memoryMeta(kind, extra) {
   return domainMeta("memory", kind, extra);
 }
 function toNode(v, name) {
-  if (v instanceof import_core3.NodeImpl) return v;
-  return (0, import_core3.node)([], { initial: v, ...name ? { name } : void 0 });
+  if (v instanceof import_core10.NodeImpl) return v;
+  return (0, import_core10.node)([], { initial: v, ...name ? { name } : void 0 });
 }
 function ageSeconds(now, lastNs) {
   return (now - lastNs) / NS_PER_SEC;
@@ -743,14 +1219,14 @@ function collection(name, opts = {}) {
   }
   const scoreFnDefault = () => ranked ? 1 : 0;
   const scoreInput = opts.score ?? scoreFnDefault;
-  const scoreNode = ranked && scoreInput instanceof import_core3.NodeImpl ? scoreInput : void 0;
+  const scoreNode = ranked && scoreInput instanceof import_core10.NodeImpl ? scoreInput : void 0;
   const readScoreFn = () => {
     if (scoreNode) return scoreNode.cache ?? scoreFnDefault;
     return scoreInput;
   };
   const graph = new import_graph3.Graph(name);
-  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds((0, import_core3.monotonicNs)(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
-  const items = (0, import_extra3.reactiveMap)({
+  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds((0, import_core10.monotonicNs)(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
+  const items = (0, import_extra8.reactiveMap)({
     name: "items",
     ...maxSize !== void 0 ? { retention: { score: retentionScore, maxSize } } : {}
   });
@@ -758,16 +1234,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_extra3.fromTimer)(intervalMs, { period: intervalMs });
-    refreshTick = (0, import_core3.node)(
+    const tickCounter = (0, import_extra8.fromTimer)(intervalMs, { period: intervalMs });
+    refreshTick = (0, import_core10.node)(
       [tickCounter],
       (_batchData, actions) => {
-        actions.emit((0, import_core3.monotonicNs)());
+        actions.emit((0, import_core10.monotonicNs)());
       },
       {
         name: "refresh_tick_ns",
         describeKind: "derived",
-        initial: (0, import_core3.monotonicNs)(),
+        initial: (0, import_core10.monotonicNs)(),
         meta: memoryMeta("clock")
       }
     );
@@ -778,7 +1254,7 @@ function collection(name, opts = {}) {
     const rankedDeps = [items.entries];
     if (refreshTick) rankedDeps.push(refreshTick);
     if (scoreNode) rankedDeps.push(scoreNode);
-    rankedNode = (0, import_core3.node)(
+    rankedNode = (0, import_core10.node)(
       rankedDeps,
       (batchData, actions, ctx) => {
         const values = batchData.map(
@@ -788,9 +1264,9 @@ function collection(name, opts = {}) {
         let now;
         if (refreshTick) {
           const tickValue = values[1];
-          now = typeof tickValue === "number" ? tickValue : (0, import_core3.monotonicNs)();
+          now = typeof tickValue === "number" ? tickValue : (0, import_core10.monotonicNs)();
         } else {
-          now = (0, import_core3.monotonicNs)();
+          now = (0, import_core10.monotonicNs)();
         }
         if (!snapshot || snapshot.size === 0) {
           actions.emit([]);
@@ -815,7 +1291,7 @@ function collection(name, opts = {}) {
     );
     graph.add(rankedNode, { name: "ranked" });
   } else {
-    rankedNode = (0, import_core3.node)([], {
+    rankedNode = (0, import_core10.node)([], {
       initial: [],
       name: "ranked",
       describeKind: "state",
@@ -823,7 +1299,7 @@ function collection(name, opts = {}) {
     });
     graph.add(rankedNode, { name: "ranked" });
   }
-  const size = (0, import_core3.node)(
+  const size = (0, import_core10.node)(
     [items.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -840,7 +1316,7 @@ function collection(name, opts = {}) {
     }
   );
   graph.add(size, { name: "size" });
-  graph.addDisposer((0, import_extra3.keepalive)(size));
+  graph.addDisposer((0, import_extra8.keepalive)(size));
   const events = createAuditLog({
     name: "events",
     retainedLimit: 1024,
@@ -848,7 +1324,7 @@ function collection(name, opts = {}) {
   });
   const seqCursor = registerCursor(graph, "seq", 0);
   const upsertImpl = (id, value, _opts) => {
-    const now = (0, import_core3.monotonicNs)();
+    const now = (0, import_core10.monotonicNs)();
     const prev = items.get(id);
     const baseScore = _opts?.score ?? readScoreFn()(value);
     items.set(id, {
@@ -904,7 +1380,7 @@ function collection(name, opts = {}) {
   });
   function itemNode(id) {
     const idN = toNode(id, "id");
-    return (0, import_core3.node)(
+    return (0, import_core10.node)(
       [items.entries, idN],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -922,7 +1398,7 @@ function collection(name, opts = {}) {
   }
   function hasNode(id) {
     const idN = toNode(id, "id");
-    return (0, import_core3.node)(
+    return (0, import_core10.node)(
       [items.entries, idN],
       (batchData, actions, ctx) => {
         const data = batchData.map(
@@ -997,7 +1473,7 @@ function vectorIndex(opts = {}) {
     graph
   });
   const seqCursor = registerCursor(graph, "seq", 0);
-  const entries = (0, import_extra3.reactiveMap)({
+  const entries = (0, import_extra8.reactiveMap)({
     name: "entries",
     ...maxSize !== void 0 ? {
       retention: {
@@ -1009,7 +1485,7 @@ function vectorIndex(opts = {}) {
           events.append({
             action: "evict",
             id: key,
-            t_ns: (0, import_core3.wallClockNs)(),
+            t_ns: (0, import_core10.wallClockNs)(),
             seq: bumpCursor(seqCursor)
           });
         }
@@ -1017,7 +1493,7 @@ function vectorIndex(opts = {}) {
     } : {}
   });
   graph.add(entries.entries, { name: "entries" });
-  graph.addDisposer((0, import_extra3.keepalive)(entries.entries));
+  graph.addDisposer((0, import_extra8.keepalive)(entries.entries));
   if (hnsw?.dispose) {
     const disposeAdapter = hnsw.dispose.bind(hnsw);
     graph.addDisposer(() => disposeAdapter());
@@ -1034,7 +1510,7 @@ function vectorIndex(opts = {}) {
       id,
       vector: [...vector],
       ...copiedMeta !== void 0 ? { meta: copiedMeta } : {},
-      upsertedAtNs: (0, import_core3.monotonicNs)()
+      upsertedAtNs: (0, import_core10.monotonicNs)()
     };
     entries.set(id, record);
   };
@@ -1090,7 +1566,7 @@ function vectorIndex(opts = {}) {
   });
   function searchNode(query, k = 5) {
     const kN = toNode(k, "k");
-    return (0, import_core3.node)(
+    return (0, import_core10.node)(
       [entries.entries, query, kN],
       (batchData, actions, ctx) => {
         const values = batchData.map(
@@ -1196,17 +1672,17 @@ function knowledgeGraph(name, opts = {}) {
     throw new RangeError("knowledgeGraph: edgesMaxSize must be >= 1");
   }
   const graph = new import_graph3.Graph(name);
-  const entitiesMap = (0, import_extra3.reactiveMap)({
+  const entitiesMap = (0, import_extra8.reactiveMap)({
     name: "entities",
     ...opts.entitiesMaxSize !== void 0 ? { maxSize: opts.entitiesMaxSize } : {}
   });
-  const edgesMap = (0, import_extra3.reactiveMap)({
+  const edgesMap = (0, import_extra8.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_core3.node)(
+  const adjacencyOut = (0, import_core10.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -1223,7 +1699,7 @@ function knowledgeGraph(name, opts = {}) {
       meta: memoryMeta("adjacency_out")
     }
   );
-  const adjacencyIn = (0, import_core3.node)(
+  const adjacencyIn = (0, import_core10.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -1242,9 +1718,9 @@ function knowledgeGraph(name, opts = {}) {
   );
   graph.add(adjacencyOut, { name: "adjacencyOut" });
   graph.add(adjacencyIn, { name: "adjacencyIn" });
-  graph.addDisposer((0, import_extra3.keepalive)(adjacencyOut));
-  graph.addDisposer((0, import_extra3.keepalive)(adjacencyIn));
-  const entityCount = (0, import_core3.node)(
+  graph.addDisposer((0, import_extra8.keepalive)(adjacencyOut));
+  graph.addDisposer((0, import_extra8.keepalive)(adjacencyIn));
+  const entityCount = (0, import_core10.node)(
     [entitiesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -1255,7 +1731,7 @@ function knowledgeGraph(name, opts = {}) {
     },
     { name: "entityCount", describeKind: "derived", initial: 0, meta: memoryMeta("entity_count") }
   );
-  const edgeCount = (0, import_core3.node)(
+  const edgeCount = (0, import_core10.node)(
     [edgesMap.entries],
     (batchData, actions, ctx) => {
       const data = batchData.map(
@@ -1268,8 +1744,8 @@ function knowledgeGraph(name, opts = {}) {
   );
   graph.add(entityCount, { name: "entityCount" });
   graph.add(edgeCount, { name: "edgeCount" });
-  graph.addDisposer((0, import_extra3.keepalive)(entityCount));
-  graph.addDisposer((0, import_extra3.keepalive)(edgeCount));
+  graph.addDisposer((0, import_extra8.keepalive)(entityCount));
+  graph.addDisposer((0, import_extra8.keepalive)(edgeCount));
   const events = createAuditLog({
     name: "events",
     retainedLimit: 1024,
@@ -1292,7 +1768,7 @@ function knowledgeGraph(name, opts = {}) {
       events.append({
         action: "orphanRemove",
         id: candidate,
-        t_ns: (0, import_core3.wallClockNs)(),
+        t_ns: (0, import_core10.wallClockNs)(),
         seq: bumpCursor(seqCursor)
       });
     }
@@ -1387,7 +1863,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_core3.node)(
+    return (0, import_core10.node)(
       deps,
       (batchData, actions, ctx) => {
         const values = batchData.map(