@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/chunk-FR6RGA3B.js

@@ -0,0 +1,1277 @@
+import {
+  decay
+} from "./chunk-QMBYUVRL.js";
+import {
+  domainMeta
+} from "./chunk-FMPF42Q4.js";
+import {
+  bumpCursor,
+  createAuditLog,
+  mutate,
+  registerCursor
+} from "./chunk-BXGZFGZ4.js";
+
+// src/utils/memory/index.ts
+import { monotonicNs as monotonicNs2, NodeImpl, node as node2, wallClockNs as wallClockNs2 } from "@graphrefly/pure-ts/core";
+import { fromTimer, keepalive as keepalive2, reactiveMap } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph2 } from "@graphrefly/pure-ts/graph";
+
+// src/utils/memory/fact-store.ts
+import { monotonicNs, node, wallClockNs } from "@graphrefly/pure-ts/core";
+import { keepalive } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+var OVERFLOW_SAMPLE_SIZE = 8;
+function factMeta(kind, extra) {
+  return domainMeta("memory", kind, extra);
+}
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h >>> 0;
+}
+function makeReadHandle(byId) {
+  return {
+    get: (id) => byId.get(id),
+    has: (id) => byId.has(id),
+    get size() {
+      return byId.size;
+    },
+    values: () => byId.values()
+  };
+}
+function currentlyValid(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;
+}
+function lastOf(batch, prev) {
+  return batch != null && batch.length > 0 ? batch.at(-1) : prev;
+}
+function reactiveFactStore(config) {
+  const shardCount = Math.max(1, config.shardCount ?? 4);
+  const maxIterations = Math.max(1, config.cascadeMaxIterations ?? 8);
+  const reviewThreshold = config.reviewThreshold ?? 0.3;
+  const shardBy = config.shardBy ?? ((f) => fnv1a(String(f.id)) % shardCount);
+  let cascadeIteration = 0;
+  const processedRoots = /* @__PURE__ */ new Set();
+  const graph = new Graph("reactive_fact_store");
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  const emptyStore = () => ({ byId: /* @__PURE__ */ new Map() });
+  const shards = [];
+  for (let s = 0; s < shardCount; s += 1) {
+    const shard = node([], {
+      initial: emptyStore(),
+      name: `shard_${s}`,
+      describeKind: "state",
+      meta: factMeta("factstore", { shard: s })
+    });
+    graph.add(shard, { name: `shard_${s}` });
+    graph.addDisposer(keepalive(shard));
+    shards.push(shard);
+  }
+  const shardIndexFor = (f) => {
+    const key = shardBy(f);
+    const n = typeof key === "number" ? key : fnv1a(String(key));
+    const idx = (n % shardCount + shardCount) % shardCount;
+    return idx;
+  };
+  const findShardOf = (id) => {
+    for (let s = 0; s < shardCount; s += 1) {
+      const fs = shards[s].cache;
+      if (fs?.byId.has(id)) return s;
+    }
+    return -1;
+  };
+  const allFacts = () => {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const sh of shards) {
+      const fs = sh.cache;
+      if (!fs) continue;
+      for (const [k, v] of fs.byId) out2.set(k, v);
+    }
+    return out2;
+  };
+  const commitFragment = (f) => {
+    const idx = shardIndexFor(f);
+    const cur = shards[idx].cache ?? emptyStore();
+    const next = new Map(cur.byId);
+    next.set(f.id, f);
+    shards[idx].emit({ byId: next });
+  };
+  const replaceFragment = (id, mut) => {
+    const idx = findShardOf(id);
+    if (idx < 0) return false;
+    const cur = shards[idx].cache;
+    const prev = cur.byId.get(id);
+    if (!prev) return false;
+    const next = new Map(cur.byId);
+    next.set(id, mut(prev));
+    shards[idx].emit({ byId: next });
+    return true;
+  };
+  const dependentsIndex = node([], {
+    initial: /* @__PURE__ */ new Map(),
+    name: "dependents_index",
+    describeKind: "state",
+    meta: factMeta("factstore", { role: "dependents_index" })
+  });
+  graph.add(dependentsIndex, { name: "dependents_index" });
+  graph.addDisposer(keepalive(dependentsIndex));
+  const indexFragment = (f, deps) => {
+    const cur = dependentsIndex.cache;
+    const next = /* @__PURE__ */ new Map();
+    for (const [k, v] of cur) next.set(k, [...v]);
+    for (const src of deps) {
+      const bucket = next.get(src) ?? [];
+      if (!bucket.includes(f.id)) bucket.push(f.id);
+      next.set(src, bucket);
+    }
+    dependentsIndex.emit(next);
+  };
+  const factStore = node(
+    shards,
+    (batchData, actions, ctx) => {
+      void batchData;
+      void ctx;
+      actions.emit({ byId: allFacts() });
+    },
+    {
+      name: "fact_store",
+      describeKind: "derived",
+      initial: emptyStore(),
+      meta: factMeta("factstore", { role: "read_view" }),
+      // F10a: `allFacts()` builds a fresh Map every detector retrigger.
+      // Fragments are immutable (replaced wholesale on mutation), so a
+      // same-size + per-key-identity check is a sound structural equality
+      // that stops `factStore` (and its `review` dependent) from re-firing
+      // every cascade wave when nothing actually changed.
+      equals: (a, b) => {
+        if (a === b) return true;
+        if (a.byId.size !== b.byId.size) return false;
+        for (const [k, v] of a.byId) {
+          if (b.byId.get(k) !== v) return false;
+        }
+        return true;
+      }
+    }
+  );
+  graph.add(factStore, { name: "fact_store" });
+  graph.addDisposer(keepalive(factStore));
+  const extractOp = node(
+    config.admissionFilter ? [config.ingest, config.admissionFilter] : [config.ingest],
+    (batchData, actions, ctx) => {
+      const f = lastOf(batchData[0], ctx.prevData[0]);
+      if (f == null) {
+        actions.emit(null);
+        return;
+      }
+      if (config.admissionFilter) {
+        const filter = lastOf(batchData[1], ctx.prevData[1]);
+        if (filter && !filter(f)) {
+          actions.emit(null);
+          return;
+        }
+      }
+      const deps = config.extractDependencies(f);
+      cascadeIteration = 0;
+      processedRoots.delete(f.id);
+      commitFragment(f);
+      indexFragment(f, deps);
+      actions.emit(f);
+    },
+    {
+      name: "extract_op",
+      describeKind: "derived",
+      meta: factMeta("extract")
+    }
+  );
+  graph.add(extractOp, { name: "extract_op" });
+  graph.addDisposer(keepalive(extractOp));
+  const invalidationDetector = node(
+    [...shards],
+    (batchData, actions, ctx) => {
+      void batchData;
+      void ctx;
+      const facts = allFacts();
+      const index = dependentsIndex.cache;
+      const out2 = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const f of facts.values()) {
+        const obsolete = f.validTo !== void 0;
+        if (!obsolete) continue;
+        if (processedRoots.has(f.id)) continue;
+        const dependents = index.get(f.id) ?? [];
+        for (const dep of dependents) {
+          const depFact = facts.get(dep);
+          if (!depFact || depFact.validTo !== void 0) continue;
+          const k = `${f.id}->${dep}`;
+          if (seen.has(k)) continue;
+          seen.add(k);
+          out2.push({
+            factId: dep,
+            rootFactId: f.id,
+            reason: "obsolete",
+            iteration: cascadeIteration + 1,
+            causalReason: `dependentsIndex[${f.id}] \u2192 ${dep} (obsolete: validTo set)`
+          });
+        }
+        processedRoots.add(f.id);
+      }
+      if (out2.length === 0) {
+        cascadeIteration = 0;
+      }
+      actions.emit(out2);
+    },
+    {
+      name: "invalidation_detector",
+      describeKind: "derived",
+      initial: [],
+      meta: factMeta("invalidation", { cycle: "cascade" })
+    }
+  );
+  graph.add(invalidationDetector, { name: "invalidation_detector" });
+  graph.addDisposer(keepalive(invalidationDetector));
+  const cascade = node(
+    [invalidationDetector],
+    (batchData, actions, ctx) => {
+      const evts = lastOf(batchData[0], ctx.prevData[0]) ?? [];
+      actions.emit(evts);
+    },
+    {
+      name: "cascade",
+      describeKind: "derived",
+      initial: [],
+      meta: factMeta("cascade_topic", { cycle: "cascade" })
+    }
+  );
+  graph.add(cascade, { name: "cascade" });
+  graph.addDisposer(keepalive(cascade));
+  const cascadeOverflow = node([], {
+    initial: null,
+    name: "cascade_overflow",
+    describeKind: "state",
+    meta: factMeta("cascade_overflow")
+  });
+  graph.add(cascadeOverflow, { name: "cascade_overflow" });
+  graph.addDisposer(keepalive(cascadeOverflow));
+  const cascadeProcessor = node(
+    [cascade],
+    (batchData, actions, ctx) => {
+      const evts = lastOf(batchData[0], ctx.prevData[0]) ?? [];
+      if (evts.length === 0) {
+        actions.emit([]);
+        return;
+      }
+      const byId = /* @__PURE__ */ new Map();
+      for (const e of evts) if (!byId.has(e.factId)) byId.set(e.factId, e);
+      cascadeIteration += 1;
+      if (cascadeIteration > maxIterations) {
+        const sample = [...byId.keys()].slice(0, OVERFLOW_SAMPLE_SIZE);
+        const rootFactId = evts[0]?.rootFactId ?? "";
+        cascadeOverflow.emit({
+          droppedCount: byId.size,
+          sample,
+          rootFactId
+        });
+        events.append({
+          action: "overflow",
+          reason: "cascade",
+          id: rootFactId,
+          t_ns: wallClockNs(),
+          seq: bumpCursor(seqCursor)
+        });
+        actions.emit([]);
+        return;
+      }
+      const now = monotonicNs();
+      for (const [id] of byId) {
+        replaceFragment(
+          id,
+          (prev) => prev.validTo !== void 0 ? prev : { ...prev, validTo: BigInt(now) }
+        );
+      }
+      actions.emit([...byId.values()]);
+    },
+    {
+      name: "cascade_processor",
+      describeKind: "derived",
+      initial: [],
+      meta: factMeta("cascade_processor", { cycle: "cascade" })
+    }
+  );
+  graph.add(cascadeProcessor, { name: "cascade_processor" });
+  graph.addDisposer(keepalive(cascadeProcessor));
+  const review = node(
+    [factStore],
+    (batchData, actions, ctx) => {
+      const fs = lastOf(batchData[0], ctx.prevData[0]);
+      if (fs == null) {
+        actions.emit(null);
+        return;
+      }
+      for (const f of fs.byId.values()) {
+        if (f.confidence < reviewThreshold && f.validTo === void 0) {
+          actions.emit({
+            factId: f.id,
+            confidence: f.confidence,
+            threshold: reviewThreshold
+          });
+          return;
+        }
+      }
+      actions.emit(null);
+    },
+    {
+      name: "review",
+      describeKind: "derived",
+      initial: null,
+      meta: factMeta("review"),
+      // F10a: dedupe on the requested factId (null === no request) so a
+      // stable low-confidence fact does not re-emit a review every wave.
+      equals: (a, b) => (a?.factId ?? null) === (b?.factId ?? null)
+    }
+  );
+  graph.add(review, { name: "review" });
+  graph.addDisposer(keepalive(review));
+  if (config.outcome) {
+    const outcomeProcessor = node(
+      config.scoring ? [config.outcome, config.scoring] : [config.outcome],
+      (batchData, actions, ctx) => {
+        const sig = lastOf(batchData[0], ctx.prevData[0]);
+        if (sig == null) {
+          actions.emit(null);
+          return;
+        }
+        replaceFragment(sig.factId, (prev) => {
+          let nextConf = prev.confidence;
+          if (config.scoring) {
+            const policy = lastOf(batchData[1], ctx.prevData[1]);
+            if (policy) {
+              nextConf = policy(prev, makeReadHandle(allFacts()));
+            }
+          } else {
+            nextConf = Math.max(0, Math.min(1, prev.confidence + sig.reward));
+          }
+          return { ...prev, confidence: nextConf };
+        });
+        actions.emit(sig);
+      },
+      {
+        name: "outcome_processor",
+        describeKind: "derived",
+        initial: null,
+        meta: factMeta("outcome")
+      }
+    );
+    graph.add(outcomeProcessor, { name: "outcome_processor" });
+    graph.addDisposer(keepalive(outcomeProcessor));
+  }
+  const answer = node(
+    config.query ? [config.query, factStore] : [factStore],
+    (batchData, actions, ctx) => {
+      if (!config.query) {
+        actions.emit(null);
+        return;
+      }
+      const q = lastOf(batchData[0], ctx.prevData[0]);
+      const fs = lastOf(batchData[1], ctx.prevData[1]);
+      if (q == null) {
+        actions.emit(null);
+        return;
+      }
+      const store = fs ?? emptyStore();
+      let results = [...store.byId.values()].filter((f) => {
+        if (q.tags && q.tags.length > 0 && !q.tags.some((t) => f.tags.includes(t))) {
+          return false;
+        }
+        if (q.minConfidence !== void 0 && f.confidence < q.minConfidence) return false;
+        if (!currentlyValid(f, q.asOf)) return false;
+        return true;
+      });
+      results.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
+      if (q.limit !== void 0) results = results.slice(0, Math.max(0, q.limit));
+      actions.emit({ query: q, results });
+    },
+    {
+      name: "answer",
+      describeKind: "derived",
+      initial: null,
+      meta: factMeta("query", { role: "output" })
+    }
+  );
+  graph.add(answer, { name: "answer" });
+  graph.addDisposer(keepalive(answer));
+  const consolidated = node(
+    config.consolidateTrigger ? [config.consolidateTrigger] : [],
+    (batchData, actions, ctx) => {
+      void batchData;
+      void ctx;
+      if (!config.consolidateTrigger || !config.consolidate) {
+        actions.emit([]);
+        return;
+      }
+      const fragments = config.consolidate(makeReadHandle(allFacts()));
+      for (const f of fragments) {
+        const deps = config.extractDependencies(f);
+        processedRoots.delete(f.id);
+        commitFragment(f);
+        indexFragment(f, deps);
+        events.append({
+          action: "consolidate",
+          id: f.id,
+          t_ns: wallClockNs(),
+          seq: bumpCursor(seqCursor)
+        });
+      }
+      actions.emit(fragments);
+    },
+    {
+      name: "consolidated",
+      describeKind: "derived",
+      initial: [],
+      meta: factMeta("consolidator")
+    }
+  );
+  graph.add(consolidated, { name: "consolidated" });
+  graph.addDisposer(keepalive(consolidated));
+  const ingestAudit = node(
+    [extractOp],
+    (batchData, actions, ctx) => {
+      const f = lastOf(batchData[0], ctx.prevData[0]);
+      if (f != null) {
+        events.append({
+          action: "ingest",
+          id: f.id,
+          t_ns: wallClockNs(),
+          seq: bumpCursor(seqCursor)
+        });
+      }
+      actions.emit(f ?? null);
+    },
+    {
+      name: "_ingest_audit",
+      describeKind: "derived",
+      initial: null,
+      meta: factMeta("audit")
+    }
+  );
+  graph.add(ingestAudit, { name: "_ingest_audit" });
+  graph.addDisposer(keepalive(ingestAudit));
+  function itemNode(id) {
+    return node(
+      [factStore],
+      (batchData, actions, ctx) => {
+        const fs = lastOf(batchData[0], ctx.prevData[0]);
+        actions.emit(fs?.byId.get(id));
+      },
+      {
+        name: `item_${id}`,
+        describeKind: "derived",
+        meta: factMeta("item")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    shards,
+    factStore,
+    dependentsIndex,
+    answer,
+    cascade,
+    cascadeOverflow,
+    review,
+    consolidated,
+    events,
+    itemNode
+  });
+  return out;
+}
+
+// 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 NodeImpl) return v;
+  return node2([], { initial: v, ...name ? { name } : void 0 });
+}
+function ageSeconds(now, lastNs) {
+  return (now - lastNs) / NS_PER_SEC;
+}
+function cosineSimilarity(a, b) {
+  const n = Math.max(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  const score = dot / Math.sqrt(na * nb);
+  return Number.isFinite(score) ? score : 0;
+}
+function searchResultsEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (x.id !== y.id || x.score !== y.score || x.meta !== y.meta) return false;
+  }
+  return true;
+}
+function rankedEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (x.id !== y.id || x.score !== y.score || x.lastAccessNs !== y.lastAccessNs || x.value !== y.value)
+      return false;
+  }
+  return true;
+}
+function collection(name, opts = {}) {
+  const maxSize = opts.maxSize;
+  const ranked = opts.ranked ?? true;
+  const decayRate = ranked ? opts.decayRate ?? 0 : 0;
+  const minScore = opts.minScore ?? 0;
+  if (maxSize !== void 0 && maxSize < 1) {
+    throw new RangeError("collection: maxSize must be >= 1");
+  }
+  const scoreFnDefault = () => ranked ? 1 : 0;
+  const scoreInput = opts.score ?? scoreFnDefault;
+  const scoreNode = ranked && scoreInput instanceof NodeImpl ? scoreInput : void 0;
+  const readScoreFn = () => {
+    if (scoreNode) return scoreNode.cache ?? scoreFnDefault;
+    return scoreInput;
+  };
+  const graph = new Graph2(name);
+  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds(monotonicNs2(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
+  const items = reactiveMap({
+    name: "items",
+    ...maxSize !== void 0 ? { retention: { score: retentionScore, maxSize } } : {}
+  });
+  graph.add(items.entries, { name: "items" });
+  let refreshTick;
+  if (ranked && decayRate > 0) {
+    const intervalMs = opts.refreshIntervalMs ?? Math.max(1, 1e3 * Math.LN2 / (10 * decayRate));
+    const tickCounter = fromTimer(intervalMs, { period: intervalMs });
+    refreshTick = node2(
+      [tickCounter],
+      (_batchData, actions) => {
+        actions.emit(monotonicNs2());
+      },
+      {
+        name: "refresh_tick_ns",
+        describeKind: "derived",
+        initial: monotonicNs2(),
+        meta: memoryMeta("clock")
+      }
+    );
+    graph.add(refreshTick, { name: "refresh_tick_ns" });
+  }
+  let rankedNode;
+  if (ranked) {
+    const rankedDeps = [items.entries];
+    if (refreshTick) rankedDeps.push(refreshTick);
+    if (scoreNode) rankedDeps.push(scoreNode);
+    rankedNode = node2(
+      rankedDeps,
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+        );
+        const snapshot = values[0];
+        let now;
+        if (refreshTick) {
+          const tickValue = values[1];
+          now = typeof tickValue === "number" ? tickValue : monotonicNs2();
+        } else {
+          now = monotonicNs2();
+        }
+        if (!snapshot || snapshot.size === 0) {
+          actions.emit([]);
+          return;
+        }
+        const out2 = [];
+        for (const entry of snapshot.values()) {
+          out2.push({
+            ...entry,
+            score: decay(entry.baseScore, ageSeconds(now, entry.lastAccessNs), decayRate, minScore)
+          });
+        }
+        out2.sort((a, b) => b.score - a.score || b.lastAccessNs - a.lastAccessNs);
+        actions.emit(out2);
+      },
+      {
+        name: "ranked",
+        describeKind: "derived",
+        equals: rankedEqual,
+        meta: memoryMeta("ranked")
+      }
+    );
+    graph.add(rankedNode, { name: "ranked" });
+  } else {
+    rankedNode = node2([], {
+      initial: [],
+      name: "ranked",
+      describeKind: "state",
+      meta: memoryMeta("ranked_disabled")
+    });
+    graph.add(rankedNode, { name: "ranked" });
+  }
+  const size = node2(
+    [items.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit((snapshot ?? /* @__PURE__ */ new Map()).size);
+    },
+    {
+      name: "size",
+      describeKind: "derived",
+      initial: 0,
+      meta: memoryMeta("size")
+    }
+  );
+  graph.add(size, { name: "size" });
+  graph.addDisposer(keepalive2(size));
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  const upsertImpl = (id, value, _opts) => {
+    const now = monotonicNs2();
+    const prev = items.get(id);
+    const baseScore = _opts?.score ?? readScoreFn()(value);
+    items.set(id, {
+      id,
+      value,
+      baseScore,
+      createdAtNs: prev?.createdAtNs ?? now,
+      lastAccessNs: now
+    });
+  };
+  const removeImpl = (id) => {
+    if (!items.has(id)) return;
+    items.delete(id);
+  };
+  const clearImpl = () => {
+    if (items.size === 0) return;
+    items.clear();
+  };
+  const rescoreImpl = () => {
+    if (!ranked) return;
+    const fn = readScoreFn();
+    const snapshot = items.entries.cache;
+    if (!snapshot || snapshot.size === 0) return;
+    const updates = [];
+    for (const entry of snapshot.values()) {
+      updates.push([entry.id, { ...entry, baseScore: fn(entry.value) }]);
+    }
+    items.setMany(updates);
+  };
+  const upsert = mutate(upsertImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "upsert", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const remove = mutate(removeImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "remove", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const clear = mutate(clearImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "clear", t_ns: m.t_ns, seq: m.seq })
+  });
+  const rescore = mutate(rescoreImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "rescore", t_ns: m.t_ns, seq: m.seq })
+  });
+  function itemNode(id) {
+    const idN = toNode(id, "id");
+    return node2(
+      [items.entries, idN],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0];
+        const key = data[1];
+        actions.emit(map?.get(key));
+      },
+      {
+        describeKind: "derived",
+        meta: memoryMeta("collection_item")
+      }
+    );
+  }
+  function hasNode(id) {
+    const idN = toNode(id, "id");
+    return node2(
+      [items.entries, idN],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0];
+        const key = data[1];
+        actions.emit(map?.has(key) ?? false);
+      },
+      {
+        describeKind: "derived",
+        meta: memoryMeta("collection_has")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    events,
+    items: items.entries,
+    ranked: rankedNode,
+    size,
+    upsert,
+    remove,
+    clear,
+    rescore,
+    itemNode,
+    hasNode
+  });
+  return out;
+}
+function vectorIndex(opts = {}) {
+  const backend = opts.backend ?? "flat";
+  const dimension = opts.dimension;
+  const strictDimension = opts.strictDimension ?? true;
+  const maxSize = opts.maxSize;
+  const userRetentionScore = opts.retentionScore;
+  let hnsw;
+  if (backend === "hnsw") {
+    hnsw = opts.hnswFactory?.();
+    if (!hnsw) {
+      throw new Error(
+        'vectorIndex backend "hnsw" requires an optional dependency adapter; install your HNSW package and provide `hnswFactory`.'
+      );
+    }
+  }
+  const graph = new Graph2(opts.name ?? "vector_index");
+  let inferredDimension;
+  function assertDimension(vector) {
+    if (dimension !== void 0) {
+      if (vector.length !== dimension) {
+        throw new RangeError(
+          `vector dimension mismatch: expected ${dimension}, got ${vector.length}`
+        );
+      }
+      return;
+    }
+    if (!strictDimension) return;
+    if (inferredDimension === void 0) {
+      inferredDimension = vector.length;
+      return;
+    }
+    if (vector.length !== inferredDimension) {
+      throw new RangeError(
+        `vector dimension mismatch: inferred ${inferredDimension} from first upsert, got ${vector.length}. Pass \`strictDimension: false\` to opt into zero-pad behavior, or set an explicit \`dimension\`.`
+      );
+    }
+  }
+  const baseRetentionScore = userRetentionScore ?? ((r) => r.upsertedAtNs);
+  let clearInProgress = false;
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  const entries = reactiveMap({
+    name: "entries",
+    ...maxSize !== void 0 ? {
+      retention: {
+        score: (_k, v) => baseRetentionScore(v),
+        maxSize,
+        onArchive: (key) => {
+          if (clearInProgress) return;
+          if (backend === "hnsw") hnsw.remove(key);
+          events.append({
+            action: "evict",
+            id: key,
+            t_ns: wallClockNs2(),
+            seq: bumpCursor(seqCursor)
+          });
+        }
+      }
+    } : {}
+  });
+  graph.add(entries.entries, { name: "entries" });
+  graph.addDisposer(keepalive2(entries.entries));
+  if (hnsw?.dispose) {
+    const disposeAdapter = hnsw.dispose.bind(hnsw);
+    graph.addDisposer(() => disposeAdapter());
+  }
+  const upsertImpl = (id, vector, meta) => {
+    assertDimension(vector);
+    if (backend === "hnsw") hnsw.upsert(id, vector, meta);
+    const copiedMeta = (() => {
+      if (meta === void 0) return void 0;
+      if (meta === null || typeof meta !== "object") return meta;
+      return Array.isArray(meta) ? [...meta] : { ...meta };
+    })();
+    const record = {
+      id,
+      vector: [...vector],
+      ...copiedMeta !== void 0 ? { meta: copiedMeta } : {},
+      upsertedAtNs: monotonicNs2()
+    };
+    entries.set(id, record);
+  };
+  const removeImpl = (id) => {
+    if (!entries.has(id)) return;
+    if (backend === "hnsw") hnsw.remove(id);
+    entries.delete(id);
+  };
+  const clearImpl = () => {
+    if (entries.size === 0) return;
+    clearInProgress = true;
+    try {
+      entries.clear();
+      if (backend === "hnsw") hnsw.clear();
+    } finally {
+      clearInProgress = false;
+    }
+    inferredDimension = void 0;
+  };
+  const reindexImpl = () => {
+    if (backend !== "hnsw") return;
+    const snapshot = entries.entries.cache;
+    if (!snapshot) return;
+    hnsw.clear();
+    for (const r of snapshot.values()) {
+      hnsw.upsert(r.id, r.vector, r.meta);
+    }
+  };
+  const upsert = mutate(upsertImpl, {
+    frame: "inline",
+    log: events,
+    freeze: false,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "upsert", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const remove = mutate(removeImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "remove", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const clear = mutate(clearImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "clear", t_ns: m.t_ns, seq: m.seq })
+  });
+  const reindex = mutate(reindexImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "reindex", t_ns: m.t_ns, seq: m.seq })
+  });
+  function searchNode(query, k = 5) {
+    const kN = toNode(k, "k");
+    return node2(
+      [entries.entries, query, kN],
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+        );
+        const snapshot = values[0];
+        const q = values[1];
+        const kRaw = values[2];
+        const kVal = Number.isFinite(kRaw) ? Math.max(0, Math.floor(kRaw)) : 0;
+        if (!snapshot || snapshot.size === 0 || kVal <= 0) {
+          actions.emit([]);
+          return;
+        }
+        if (q == null || q.length === 0) {
+          actions.emit([]);
+          return;
+        }
+        const expectedDim = dimension ?? (strictDimension ? inferredDimension : void 0);
+        if (expectedDim !== void 0 && q.length !== expectedDim) {
+          actions.emit([]);
+          return;
+        }
+        if (backend === "hnsw") {
+          const adapterResults = hnsw.search(q, kVal);
+          actions.emit([...adapterResults]);
+          return;
+        }
+        const ranked = [...snapshot.values()].map((row) => {
+          const result = {
+            id: row.id,
+            score: cosineSimilarity(q, row.vector),
+            ...row.meta !== void 0 ? { meta: row.meta } : {}
+          };
+          return result;
+        }).sort((a, b) => b.score - a.score).slice(0, kVal);
+        actions.emit(ranked);
+      },
+      {
+        describeKind: "derived",
+        // A1: include `score` in equality. The previous id-only
+        // comparator suppressed re-emissions when the same set of
+        // IDs/order had different scores (re-upsert with new
+        // vector; query change preserving ranking order).
+        equals: (a, b) => searchResultsEqual(a, b),
+        meta: memoryMeta("vector_search")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    backend,
+    events,
+    entries: entries.entries,
+    upsert,
+    remove,
+    clear,
+    reindex,
+    searchNode
+  });
+  return out;
+}
+var TRIPLE_SEP = "\0";
+function tripleKey(from, to, relation) {
+  return `${from}${TRIPLE_SEP}${to}${TRIPLE_SEP}${relation}`;
+}
+function buildAdjacency(edges, side) {
+  if (!edges || edges.size === 0) return /* @__PURE__ */ new Map();
+  const buckets = /* @__PURE__ */ new Map();
+  for (const edge of edges.values()) {
+    const key = side === "from" ? edge.from : edge.to;
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = [];
+      buckets.set(key, bucket);
+    }
+    bucket.push(edge);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of buckets) out.set(key, Object.freeze(bucket));
+  return out;
+}
+function adjacencyEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.size !== b.size) return false;
+  for (const [k, av] of a) {
+    const bv = b.get(k);
+    if (!bv || av.length !== bv.length) return false;
+    for (let i = 0; i < av.length; i += 1) {
+      const ae = av[i];
+      const be = bv[i];
+      if (ae.from !== be.from || ae.to !== be.to || ae.relation !== be.relation || ae.weight !== be.weight)
+        return false;
+    }
+  }
+  return true;
+}
+function knowledgeGraph(name, opts = {}) {
+  const orphanGC = opts.orphanGC ?? "keep";
+  if (opts.entitiesMaxSize !== void 0 && opts.entitiesMaxSize < 1) {
+    throw new RangeError("knowledgeGraph: entitiesMaxSize must be >= 1");
+  }
+  if (opts.edgesMaxSize !== void 0 && opts.edgesMaxSize < 1) {
+    throw new RangeError("knowledgeGraph: edgesMaxSize must be >= 1");
+  }
+  const graph = new Graph2(name);
+  const entitiesMap = reactiveMap({
+    name: "entities",
+    ...opts.entitiesMaxSize !== void 0 ? { maxSize: opts.entitiesMaxSize } : {}
+  });
+  const edgesMap = reactiveMap({
+    name: "edges",
+    ...opts.edgesMaxSize !== void 0 ? { maxSize: opts.edgesMaxSize } : {}
+  });
+  graph.add(entitiesMap.entries, { name: "entities" });
+  graph.add(edgesMap.entries, { name: "edges" });
+  const adjacencyOut = node2(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit(buildAdjacency(snapshot, "from"));
+    },
+    {
+      name: "adjacencyOut",
+      describeKind: "derived",
+      initial: /* @__PURE__ */ new Map(),
+      equals: adjacencyEqual,
+      meta: memoryMeta("adjacency_out")
+    }
+  );
+  const adjacencyIn = node2(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit(buildAdjacency(snapshot, "to"));
+    },
+    {
+      name: "adjacencyIn",
+      describeKind: "derived",
+      initial: /* @__PURE__ */ new Map(),
+      equals: adjacencyEqual,
+      meta: memoryMeta("adjacency_in")
+    }
+  );
+  graph.add(adjacencyOut, { name: "adjacencyOut" });
+  graph.add(adjacencyIn, { name: "adjacencyIn" });
+  graph.addDisposer(keepalive2(adjacencyOut));
+  graph.addDisposer(keepalive2(adjacencyIn));
+  const entityCount = node2(
+    [entitiesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const m = data[0];
+      actions.emit((m ?? /* @__PURE__ */ new Map()).size);
+    },
+    { name: "entityCount", describeKind: "derived", initial: 0, meta: memoryMeta("entity_count") }
+  );
+  const edgeCount = node2(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const m = data[0];
+      actions.emit((m ?? /* @__PURE__ */ new Map()).size);
+    },
+    { name: "edgeCount", describeKind: "derived", initial: 0, meta: memoryMeta("edge_count") }
+  );
+  graph.add(entityCount, { name: "entityCount" });
+  graph.add(edgeCount, { name: "edgeCount" });
+  graph.addDisposer(keepalive2(entityCount));
+  graph.addDisposer(keepalive2(edgeCount));
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  function entityHasReferences(id) {
+    const out2 = adjacencyOut.cache;
+    const inb = adjacencyIn.cache;
+    if ((out2?.get(id)?.length ?? 0) > 0) return true;
+    if ((inb?.get(id)?.length ?? 0) > 0) return true;
+    return false;
+  }
+  function applyOrphanGC(candidates) {
+    if (orphanGC !== "remove") return;
+    for (const candidate of candidates) {
+      if (!entitiesMap.has(candidate)) continue;
+      if (entityHasReferences(candidate)) continue;
+      entitiesMap.delete(candidate);
+      events.append({
+        action: "orphanRemove",
+        id: candidate,
+        t_ns: wallClockNs2(),
+        seq: bumpCursor(seqCursor)
+      });
+    }
+  }
+  const upsertEntityImpl = (id, value) => {
+    entitiesMap.set(id, value);
+  };
+  const removeEntityImpl = (id) => {
+    const snapshot = edgesMap.entries.cache;
+    const cascadedNeighbors = /* @__PURE__ */ new Set();
+    if (snapshot) {
+      const toDrop = [];
+      for (const [key, edge] of snapshot) {
+        if (edge.from === id || edge.to === id) {
+          toDrop.push(key);
+          if (edge.from !== id) cascadedNeighbors.add(edge.from);
+          if (edge.to !== id) cascadedNeighbors.add(edge.to);
+        }
+      }
+      if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
+    }
+    if (entitiesMap.has(id)) entitiesMap.delete(id);
+    applyOrphanGC([...cascadedNeighbors]);
+  };
+  const linkImpl = (from, to, relation, weight = 1) => {
+    edgesMap.set(tripleKey(from, to, relation), { from, to, relation, weight });
+  };
+  const unlinkImpl = (from, to, relation) => {
+    if (relation !== void 0) {
+      edgesMap.delete(tripleKey(from, to, relation));
+    } else {
+      const snapshot = edgesMap.entries.cache;
+      if (!snapshot) return;
+      const toDrop = [];
+      for (const [key, edge] of snapshot) {
+        if (edge.from === from && edge.to === to) toDrop.push(key);
+      }
+      if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
+    }
+    applyOrphanGC([from, to]);
+  };
+  const upsertEntity = mutate(upsertEntityImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({
+      action: "upsertEntity",
+      id,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const removeEntity = mutate(removeEntityImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({
+      action: "removeEntity",
+      id,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const link = mutate(linkImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([from, to, relation, weight], _r, m) => ({
+      action: "link",
+      from,
+      to,
+      relation,
+      weight: weight ?? 1,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const unlink = mutate(unlinkImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([from, to, relation], _r, m) => ({
+      action: "unlink",
+      from,
+      to,
+      ...relation !== void 0 ? { relation } : {},
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  function relatedNode(id, relation) {
+    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 node2(
+      deps,
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+        );
+        const out2 = values[0];
+        const inb = values[1];
+        const key = values[2];
+        const rel = relN ? values[3] : void 0;
+        const outE = out2?.get(key) ?? [];
+        const inE = inb?.get(key) ?? [];
+        const seen = /* @__PURE__ */ new Set();
+        const acc = [];
+        for (const edge of outE) {
+          const k = tripleKey(edge.from, edge.to, edge.relation);
+          if (seen.has(k)) continue;
+          if (rel !== void 0 && edge.relation !== rel) continue;
+          seen.add(k);
+          acc.push(edge);
+        }
+        for (const edge of inE) {
+          const k = tripleKey(edge.from, edge.to, edge.relation);
+          if (seen.has(k)) continue;
+          if (rel !== void 0 && edge.relation !== rel) continue;
+          seen.add(k);
+          acc.push(edge);
+        }
+        actions.emit(acc);
+      },
+      {
+        describeKind: "derived",
+        equals: (a, b) => {
+          const av = a;
+          const bv = b;
+          if (av === bv) return true;
+          if (av == null || bv == null) return false;
+          if (av.length !== bv.length) return false;
+          for (let i = 0; i < av.length; i += 1) {
+            const x = av[i];
+            const y = bv[i];
+            if (x.from !== y.from || x.to !== y.to || x.relation !== y.relation || x.weight !== y.weight)
+              return false;
+          }
+          return true;
+        },
+        meta: memoryMeta("related")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    events,
+    entities: entitiesMap.entries,
+    edges: edgesMap.entries,
+    adjacencyOut,
+    adjacencyIn,
+    entityCount,
+    edgeCount,
+    upsertEntity,
+    removeEntity,
+    link,
+    unlink,
+    relatedNode
+  });
+  return out;
+}
+
+export {
+  reactiveFactStore,
+  cosineSimilarity,
+  collection,
+  vectorIndex,
+  knowledgeGraph
+};
+//# sourceMappingURL=chunk-FR6RGA3B.js.map