@noy-db/hub 0.7.0-pre.12 → 0.7.0-pre.14

package/dist/chunk-RTBJ5IOO.js

@@ -0,0 +1,87 @@
+import {
+  getAtPath
+} from "./chunk-TRGTKX5E.js";
+import {
+  EmbeddingModelMismatchError
+} from "./chunk-7O3Y4PPD.js";
+
+// src/with-lookup/embeddings/descriptor.ts
+function embeddingSourceText(record, source) {
+  const fields = typeof source === "string" ? [source] : source;
+  const parts = [];
+  for (const f of fields) {
+    for (const leaf of getAtPath(record, f)) {
+      if (typeof leaf === "string" && leaf !== "") parts.push(leaf);
+    }
+  }
+  return parts.join(" ");
+}
+
+// src/with-lookup/embeddings/vec-id.ts
+function encodeVecId(collection, recordId) {
+  if (collection.includes("/")) {
+    throw new Error(
+      `encodeVecId: collection name "${collection}" must not contain "/" \u2014 it would make the "${collection}/${recordId}" _vec id ambiguous against another collection's rows.`
+    );
+  }
+  return `${collection}/${recordId}`;
+}
+function decodeVecId(collection, vecId) {
+  const prefix = `${collection}/`;
+  if (!vecId.startsWith(prefix)) return null;
+  return vecId.slice(prefix.length);
+}
+function isVecIdFor(collection, vecId) {
+  return vecId.startsWith(`${collection}/`);
+}
+
+// src/with-lookup/embeddings/cosine.ts
+function cosine(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i], y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+// src/with-lookup/embeddings/vector-set.ts
+var VectorSet = class {
+  vectors;
+  get loaded() {
+    return this.vectors !== void 0;
+  }
+  async ensureLoaded(load) {
+    if (this.vectors === void 0) this.vectors = await load();
+  }
+  markDirty() {
+    this.vectors = void 0;
+  }
+  cosineTopK(query, k, opts = {}) {
+    const all = this.vectors ?? [];
+    const minScore = opts.minScore ?? -Infinity;
+    const hits = [];
+    for (const v of all) {
+      if (opts.expectModel !== void 0 && v.model !== opts.expectModel) {
+        throw new EmbeddingModelMismatchError(opts.expectModel, v.model);
+      }
+      const score = cosine(query, v.vec);
+      if (score >= minScore) hits.push({ id: v.id, score });
+    }
+    hits.sort((a, b) => b.score - a.score);
+    return hits.slice(0, k);
+  }
+};
+
+export {
+  embeddingSourceText,
+  VectorSet,
+  encodeVecId,
+  decodeVecId,
+  isVecIdFor
+};
+//# sourceMappingURL=chunk-RTBJ5IOO.js.map

package/dist/chunk-RTBJ5IOO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-lookup/embeddings/descriptor.ts","../src/with-lookup/embeddings/vec-id.ts","../src/with-lookup/embeddings/cosine.ts","../src/with-lookup/embeddings/vector-set.ts"],"sourcesContent":["/** Per-collection embedding config (L2). The encode hook is host/remote — no bundled model. */\nimport { getAtPath } from '../../via/i18n/core.js'\n\nexport interface EmbeddingDescriptor {\n  readonly source: string | readonly string[]\n  readonly encode: (text: string) => Promise<Float32Array>\n  readonly dim: number\n  readonly model: string\n}\n\n/** Concatenate the record's source-field text (skips empties; supports nested/[]-wildcard paths). */\nexport function embeddingSourceText(record: Record<string, unknown>, source: string | readonly string[]): string {\n  const fields = typeof source === 'string' ? [source] : source\n  const parts: string[] = []\n  for (const f of fields) {\n    for (const leaf of getAtPath(record, f)) {\n      if (typeof leaf === 'string' && leaf !== '') parts.push(leaf)\n    }\n  }\n  return parts.join(' ')\n}\n","/**\n * Collection-namespaced `_vec` side-car ids (#726).\n *\n * `_vec` embedding side-cars used to be keyed by the bare record id,\n * vault-wide — two collections sharing a record id shared one `_vec` row.\n * This was verified to be a clobber/crash bug, NOT a confidentiality leak:\n * every collection has its own DEK, and AES-GCM auth-tag verification means\n * decrypting a foreign collection's `_vec` row under the wrong DEK throws\n * `TamperedError` rather than returning wrong plaintext — no disclosure\n * mechanism exists. The real bug was id collision: a same-id write/forget in\n * one collection could clobber or delete the other collection's row, and a\n * collection whose `similarTo()` / cold semantic `retrieve()` encountered a\n * foreign same-id row crashed with an uncaught `TamperedError` (a DoS). The\n * store-collection bucket stays the literal `'_vec'`; the id becomes\n * composite: `${collection}/${recordId}`. Mirrors `encodeIdxId`\n * (`../indexing/persisted-indexes.js`).\n *\n * Decode is deliberately NOT split-on-`/`: the collection is always known\n * at the decode site (`ctx.name`), so `decodeVecId` strips that known\n * prefix — correct even when `recordId` itself contains `/`.\n *\n * Precondition: `collection` itself must not contain `/` — otherwise\n * `${collection}/${recordId}` is ambiguous (e.g. collection `'a'` would\n * misattribute collection `'a/b'`'s rows via prefix match in `isVecIdFor`).\n * Collection names are NOT currently restricted to a `/`-free charset by\n * `vault.collection()`, so `encodeVecId` enforces the precondition itself,\n * failing loud at the write boundary rather than silently misencoding.\n */\n\n/**\n * Encode the `_vec` side-car id for a (collection, recordId) pair.\n * Format: `<collection>/<recordId>` — no escaping; `recordId` may contain `/`.\n *\n * Throws if `collection` contains `/`: that would make the composite id\n * ambiguous against `isVecIdFor`'s prefix match (collection `'a'` would\n * appear to own collection `'a/b'`'s rows), reintroducing the clobber/crash\n * risk the namespacing fix exists to close.\n */\nexport function encodeVecId(collection: string, recordId: string): string {\n  if (collection.includes('/')) {\n    throw new Error(\n      `encodeVecId: collection name \"${collection}\" must not contain \"/\" — ` +\n        `it would make the \"${collection}/${recordId}\" _vec id ambiguous against another collection's rows.`,\n    )\n  }\n  return `${collection}/${recordId}`\n}\n\n/**\n * Decode a `_vec` id back to the bare record id, given the KNOWN owning\n * collection — strips the `<collection>/` prefix rather than splitting on\n * `/`, so a `recordId` containing `/` round-trips correctly. Returns `null`\n * if `vecId` does not belong to `collection`.\n */\nexport function decodeVecId(collection: string, vecId: string): string | null {\n  const prefix = `${collection}/`\n  if (!vecId.startsWith(prefix)) return null\n  return vecId.slice(prefix.length)\n}\n\n/** Predicate form of {@link decodeVecId} — used to filter `list()` results. */\nexport function isVecIdFor(collection: string, vecId: string): boolean {\n  return vecId.startsWith(`${collection}/`)\n}\n","/** Cosine similarity in [-1,1]; 0 on zero-norm or length mismatch (no NaN). (L2) */\nexport function cosine(a: Float32Array | number[], b: Float32Array | number[]): number {\n  if (a.length !== b.length) return 0\n  let dot = 0, na = 0, nb = 0\n  for (let i = 0; i < a.length; i++) {\n    const x = a[i]!, y = b[i]!\n    dot += x * y; na += x * x; nb += y * y\n  }\n  if (na === 0 || nb === 0) return 0\n  return dot / (Math.sqrt(na) * Math.sqrt(nb))\n}\n","/** In-memory vector set for L2 semantic retrieval. Loaded once per session from\n *  decrypted _vec sidecars (injected loader), brute-force cosine kNN, model-guarded. */\nimport { cosine } from './cosine.js'\nimport { EmbeddingModelMismatchError } from '../../kernel/errors.js'\n\nexport interface StoredVector { readonly id: string; readonly vec: Float32Array; readonly model: string }\nexport interface VectorHit { readonly id: string; readonly score: number }\n\nexport class VectorSet {\n  private vectors: StoredVector[] | undefined\n  get loaded(): boolean { return this.vectors !== undefined }\n\n  async ensureLoaded(load: () => Promise<StoredVector[]>): Promise<void> {\n    if (this.vectors === undefined) this.vectors = await load()\n  }\n\n  markDirty(): void { this.vectors = undefined }\n\n  cosineTopK(query: Float32Array, k: number, opts: { minScore?: number; expectModel?: string } = {}): VectorHit[] {\n    const all = this.vectors ?? []\n    const minScore = opts.minScore ?? -Infinity\n    const hits: VectorHit[] = []\n    for (const v of all) {\n      if (opts.expectModel !== undefined && v.model !== opts.expectModel) {\n        throw new EmbeddingModelMismatchError(opts.expectModel, v.model)\n      }\n      const score = cosine(query, v.vec)\n      if (score >= minScore) hits.push({ id: v.id, score })\n    }\n    hits.sort((a, b) => b.score - a.score)\n    return hits.slice(0, k)\n  }\n}\n"],"mappings":";;;;;;;;AAWO,SAAS,oBAAoB,QAAiC,QAA4C;AAC/G,QAAM,SAAS,OAAO,WAAW,WAAW,CAAC,MAAM,IAAI;AACvD,QAAM,QAAkB,CAAC;AACzB,aAAW,KAAK,QAAQ;AACtB,eAAW,QAAQ,UAAU,QAAQ,CAAC,GAAG;AACvC,UAAI,OAAO,SAAS,YAAY,SAAS,GAAI,OAAM,KAAK,IAAI;AAAA,IAC9D;AAAA,EACF;AACA,SAAO,MAAM,KAAK,GAAG;AACvB;;;ACkBO,SAAS,YAAY,YAAoB,UAA0B;AACxE,MAAI,WAAW,SAAS,GAAG,GAAG;AAC5B,UAAM,IAAI;AAAA,MACR,iCAAiC,UAAU,oDACnB,UAAU,IAAI,QAAQ;AAAA,IAChD;AAAA,EACF;AACA,SAAO,GAAG,UAAU,IAAI,QAAQ;AAClC;AAQO,SAAS,YAAY,YAAoB,OAA8B;AAC5E,QAAM,SAAS,GAAG,UAAU;AAC5B,MAAI,CAAC,MAAM,WAAW,MAAM,EAAG,QAAO;AACtC,SAAO,MAAM,MAAM,OAAO,MAAM;AAClC;AAGO,SAAS,WAAW,YAAoB,OAAwB;AACrE,SAAO,MAAM,WAAW,GAAG,UAAU,GAAG;AAC1C;;;AC9DO,SAAS,OAAO,GAA4B,GAAoC;AACrF,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,MAAI,MAAM,GAAG,KAAK,GAAG,KAAK;AAC1B,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,UAAM,IAAI,EAAE,CAAC,GAAI,IAAI,EAAE,CAAC;AACxB,WAAO,IAAI;AAAG,UAAM,IAAI;AAAG,UAAM,IAAI;AAAA,EACvC;AACA,MAAI,OAAO,KAAK,OAAO,EAAG,QAAO;AACjC,SAAO,OAAO,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,EAAE;AAC5C;;;ACFO,IAAM,YAAN,MAAgB;AAAA,EACb;AAAA,EACR,IAAI,SAAkB;AAAE,WAAO,KAAK,YAAY;AAAA,EAAU;AAAA,EAE1D,MAAM,aAAa,MAAoD;AACrE,QAAI,KAAK,YAAY,OAAW,MAAK,UAAU,MAAM,KAAK;AAAA,EAC5D;AAAA,EAEA,YAAkB;AAAE,SAAK,UAAU;AAAA,EAAU;AAAA,EAE7C,WAAW,OAAqB,GAAW,OAAoD,CAAC,GAAgB;AAC9G,UAAM,MAAM,KAAK,WAAW,CAAC;AAC7B,UAAM,WAAW,KAAK,YAAY;AAClC,UAAM,OAAoB,CAAC;AAC3B,eAAW,KAAK,KAAK;AACnB,UAAI,KAAK,gBAAgB,UAAa,EAAE,UAAU,KAAK,aAAa;AAClE,cAAM,IAAI,4BAA4B,KAAK,aAAa,EAAE,KAAK;AAAA,MACjE;AACA,YAAM,QAAQ,OAAO,OAAO,EAAE,GAAG;AACjC,UAAI,SAAS,SAAU,MAAK,KAAK,EAAE,IAAI,EAAE,IAAI,MAAM,CAAC;AAAA,IACtD;AACA,SAAK,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AACrC,WAAO,KAAK,MAAM,GAAG,CAAC;AAAA,EACxB;AACF;","names":[]}

package/dist/{chunk-KL7AS3HV.js → chunk-SMH6SRX7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5D2ALSM5.js";
 
 // src/with-formula/derivations/stale.ts
-var loadDerivationExecutor = lazy(() => import("./executor-TOLPBHOC.js"));
+var loadDerivationExecutor = lazy(() => import("./executor-5NIMLSKZ.js"));
 var _staleByRegistry = /* @__PURE__ */ new WeakMap();
 var keyFor = (source, sourceId) => `${source}/${sourceId}`;
 async function markStale(registry, strategy, sourceId) {
@@ -32,6 +32,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
     const pending = map.get(k);
     if (!pending || !pending.has(spec)) continue;
     pending.delete(spec);
+    let failedNonStrict = false;
     try {
       const sourceColl = accessor.getCollection(spec.source);
       const source = await sourceColl.get(id);
@@ -52,6 +53,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
             `[derivation] lazy output "${key}" for source "${spec.source}" id="${id}" failed:`,
             err
           );
+          failedNonStrict = true;
           continue;
         }
         if (out.kind === "array") {
@@ -69,7 +71,8 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
         }
         await outputColl.put(id, out.value);
       }
-      pending.delete(spec);
+      if (failedNonStrict) pending.add(spec);
+      else pending.delete(spec);
     } catch (e) {
       pending.add(spec);
       throw e;
@@ -81,4 +84,4 @@ export {
   markStale,
   resolveStaleOnRead
 };
-//# sourceMappingURL=chunk-KL7AS3HV.js.map
+//# sourceMappingURL=chunk-SMH6SRX7.js.map

package/dist/chunk-SMH6SRX7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-formula/derivations/stale.ts"],"sourcesContent":["import type { Collection } from '../../kernel/collection.js'\nimport type { DerivationExecutor as DerivationExecutorType } from './executor.js'\nimport type { ReadOnlyVaultFacade } from '../../with-audit/guards/types.js'\nimport type { TxContext } from '../../with-commit/tx/transaction.js'\nimport type { DerivationRegistry } from './registry.js'\n// Type-only — runtime class loaded via dynamic import in\n// `resolveStaleOnRead` only when a stale flag actually fires. Keeps\n// the executor chunk out of the floor bundle.\nimport type { DerivationSpec } from './types.js'\n\nimport { lazy } from '../../kernel/lazy.js'\n\n/** #846c — one memoized binding instead of a cast at the call site. */\nconst loadDerivationExecutor = lazy(() => import('./executor.js'))\n\n/**\n * Accessor shape passed through from the owning Vault. Provides the\n * registry (used to look up strategies and as the WeakMap key) and a\n * resolver from collection name to the live `Collection` instance.\n * Same shape as `Collection.derivationSource` so callers can pass it\n * through directly.\n */\nexport interface DerivationStaleAccessor {\n  registry(): DerivationRegistry\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  getCollection(name: string): Collection<any>\n  /**\n   * Read-only vault facade handed to `derive(source, ctx)` on the lazy\n   * resolve-on-read path. Same instance/shape as the eager path uses.\n   */\n  getReadOnlyFacade(): ReadOnlyVaultFacade\n  /**\n   * Active multi-record TxContext or `null`. The lazy resolve-on-read\n   * path uses this to register tombstone deletes on `_executed` so a\n   * later rollback restores the prior emission. Mirrors the eager\n   * path's rollback tracking; the lazy `put` was historically\n   * unregistered but the tombstone delete (a NEW write path)\n   * matches the eager registration for symmetry.\n   */\n  getActiveTxContext(): TxContext | null\n}\n\n/**\n * In-memory stale map keyed by `DerivationRegistry` instance (stable\n * per vault). Maps `${source}/${sourceId}` → set of pending strategies.\n *\n * Persistence across vault close is NOT implemented in v1 (concern\n * flagged in the dim14 spec). On vault re-open, derived records'\n * `_derivedFrom.strategyHash` will still match the registered\n * strategies' hash, so an unset stale flag is interpreted as \"fresh.\"\n * `vault.deriveAll()` (Task D13) is the explicit recompute escape\n * hatch.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _staleByRegistry = new WeakMap<DerivationRegistry, Map<string, Set<DerivationSpec<any, any>>>>()\n\nconst keyFor = (source: string, sourceId: string): string => `${source}/${sourceId}`\n\n/** Mark every output of (strategy, sourceId) as stale. */\nexport async function markStale(\n  registry: DerivationRegistry,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  strategy: DerivationSpec<any, any>,\n  sourceId: string,\n): Promise<void> {\n  let map = _staleByRegistry.get(registry)\n  if (!map) {\n    map = new Map()\n    _staleByRegistry.set(registry, map)\n  }\n  const k = keyFor(strategy.source, sourceId)\n  let set = map.get(k)\n  if (!set) {\n    set = new Set()\n    map.set(k, set)\n  }\n  set.add(strategy)\n}\n\n/**\n * Called from `Collection.get` on lazy-mode output collections. If the\n * id has a pending stale flag for any strategy producing this output\n * collection, re-derive before returning the record. No-op when there\n * is no pending work — keeps the read fast path negligible.\n */\nexport async function resolveStaleOnRead(\n  accessor: DerivationStaleAccessor,\n  outputCollection: string,\n  id: string,\n): Promise<void> {\n  const registry = accessor.registry()\n  const producers = registry.strategiesProducingOutput(outputCollection)\n  if (producers.length === 0) return\n\n  const map = _staleByRegistry.get(registry)\n  if (!map) return\n\n  // Dynamic-import the executor only when at least one stale flag\n  // actually fires. Vaults with no derivation strategies never call\n  // this function (gated on `derivationSource` in `Collection.get`);\n  // vaults with strategies but no pending stale ids reach the\n  // `pending.has(spec)` short-circuit below without ever touching\n  // the executor chunk.\n  let DerivationExecutor: typeof DerivationExecutorType | null = null\n\n  for (const { spec, strategyHash } of producers) {\n    const k = keyFor(spec.source, id)\n    const pending = map.get(k)\n    if (!pending || !pending.has(spec)) continue\n\n    // Consume the pending flag BEFORE the source read, not after: for a\n    // self-write output (output.collection === spec.source, e.g. a\n    // reverse-denorm patch), `sourceColl.get(id)` below re-enters this\n    // same collection/id and would otherwise still see this spec pending\n    // — infinite recursion. Restored on a strict failure below so a\n    // future read still retries.\n    pending.delete(spec)\n\n    // Everything from here on can throw (source read, executor, output\n    // put/delete) — restore the consumed flag on ANY throw so a later\n    // read still retries, not just on the strict-failure branch below\n    // (which throws through this same catch, so it does not also\n    // re-add — `Set.add` is idempotent, but the branch no longer needs\n    // its own restore).\n    // #1258 — a NON-STRICT output failure must not launder staleness into\n    // freshness. `strict: false` means \"a failed derivation must not break the\n    // read\", NOT \"report this output as current\". Tracked across the output\n    // loop and re-marked below, so the record is still served (no throw) and\n    // the next read retries — strict-mode behaviour minus the throw.\n    let failedNonStrict = false\n    try {\n      // Read the source record from the source collection and re-derive.\n      // We use the same getCollection accessor that eager dispatch uses\n      // — it returns the live `Collection<any>` instance with full\n      // crypto / keyring wiring.\n      const sourceColl = accessor.getCollection(spec.source)\n      const source = await sourceColl.get(id)\n      if (!source) {\n        continue\n      }\n      const sourceWithId = { ...(source as Record<string, unknown>), id } as Record<string, unknown> & { id: string }\n      // sourceVersion: not tracked in v1 stale map; pass 0 — matches the\n      // forthcoming v0 semantics, `_derivedFrom.sourceVersion` is\n      // informational, not load-bearing for correctness.\n      DerivationExecutor ??= (await loadDerivationExecutor()).DerivationExecutor\n      const ctx = { vault: accessor.getReadOnlyFacade() }\n      const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx)\n      for (const key of Object.keys(spec.outputs)) {\n        const out = result.outputs[key]\n        if (!out) continue\n        if (out.kind === 'failed') {\n          const err = out.error\n          if (spec.strict) throw err\n          console.warn(\n            `[derivation] lazy output \"${key}\" for source \"${spec.source}\" id=\"${id}\" failed:`,\n            err,\n          )\n          failedNonStrict = true\n          continue\n        }\n        if (out.kind === 'array') {\n          // Defensive — array-shape requires `lifecycle: 'eager'`\n          // (validated at withDerivation registration).\n          // Reaching the lazy-resolve path for array-shape would mean\n          // a registration check was bypassed. Log and skip.\n          console.warn(\n            `[derivation] unexpected array-shape output \"${key}\" in lazy resolve path; `\n            + 'array-shape derivations require lifecycle: \"eager\".',\n          )\n          continue\n        }\n        const outSpec = spec.outputs[key]\n        if (!outSpec) continue\n        const outputColl = accessor.getCollection(outSpec.collection)\n        if (out.skipped === true) {\n          // Optional output skipped on lazy resolve — delete any\n          // prior emission so the read returns null (matches eager-path\n          // tombstone semantics). Routed through `_internalDelete` so a\n          // user-registered `onDelete` on the output collection\n          // does NOT fire. The active TxContext (if any) is forwarded:\n          // `resolveStaleOnRead` is reachable from `Collection.get()`\n          // which can be called from inside a transaction, so the\n          // tombstone must be observable to `revertExecuted` on\n          // rollback.\n          await outputColl._internalDelete(id, accessor.getActiveTxContext())\n          continue\n        }\n        await outputColl.put(id, out.value)\n      }\n      // Deliberate cost, stated so nobody \"optimises\" it away: a\n      // permanently-failing non-strict derivation now re-runs on every read of\n      // this id rather than once. Louder and more expensive than serving a\n      // stale value forever, and the trade this project makes everywhere else.\n      if (failedNonStrict) pending.add(spec)\n      else pending.delete(spec)\n    } catch (e) {\n      // Restore the stale flag consumed above so a future read retries.\n      pending.add(spec)\n      throw e\n    }\n  }\n}\n"],"mappings":";;;;;AAaA,IAAM,yBAAyB,KAAK,MAAM,OAAO,wBAAe,CAAC;AA2CjE,IAAM,mBAAmB,oBAAI,QAAwE;AAErG,IAAM,SAAS,CAAC,QAAgB,aAA6B,GAAG,MAAM,IAAI,QAAQ;AAGlF,eAAsB,UACpB,UAEA,UACA,UACe;AACf,MAAI,MAAM,iBAAiB,IAAI,QAAQ;AACvC,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,qBAAiB,IAAI,UAAU,GAAG;AAAA,EACpC;AACA,QAAM,IAAI,OAAO,SAAS,QAAQ,QAAQ;AAC1C,MAAI,MAAM,IAAI,IAAI,CAAC;AACnB,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,QAAI,IAAI,GAAG,GAAG;AAAA,EAChB;AACA,MAAI,IAAI,QAAQ;AAClB;AAQA,eAAsB,mBACpB,UACA,kBACA,IACe;AACf,QAAM,WAAW,SAAS,SAAS;AACnC,QAAM,YAAY,SAAS,0BAA0B,gBAAgB;AACrE,MAAI,UAAU,WAAW,EAAG;AAE5B,QAAM,MAAM,iBAAiB,IAAI,QAAQ;AACzC,MAAI,CAAC,IAAK;AAQV,MAAI,qBAA2D;AAE/D,aAAW,EAAE,MAAM,aAAa,KAAK,WAAW;AAC9C,UAAM,IAAI,OAAO,KAAK,QAAQ,EAAE;AAChC,UAAM,UAAU,IAAI,IAAI,CAAC;AACzB,QAAI,CAAC,WAAW,CAAC,QAAQ,IAAI,IAAI,EAAG;AAQpC,YAAQ,OAAO,IAAI;AAanB,QAAI,kBAAkB;AACtB,QAAI;AAKF,YAAM,aAAa,SAAS,cAAc,KAAK,MAAM;AACrD,YAAM,SAAS,MAAM,WAAW,IAAI,EAAE;AACtC,UAAI,CAAC,QAAQ;AACX;AAAA,MACF;AACA,YAAM,eAAe,EAAE,GAAI,QAAoC,GAAG;AAIlE,8BAAwB,MAAM,uBAAuB,GAAG;AACxD,YAAM,MAAM,EAAE,OAAO,SAAS,kBAAkB,EAAE;AAClD,YAAM,SAAS,MAAM,mBAAmB,IAAI,MAAM,cAAc,GAAG,cAAc,GAAG;AACpF,iBAAW,OAAO,OAAO,KAAK,KAAK,OAAO,GAAG;AAC3C,cAAM,MAAM,OAAO,QAAQ,GAAG;AAC9B,YAAI,CAAC,IAAK;AACV,YAAI,IAAI,SAAS,UAAU;AACzB,gBAAM,MAAM,IAAI;AAChB,cAAI,KAAK,OAAQ,OAAM;AACvB,kBAAQ;AAAA,YACN,6BAA6B,GAAG,iBAAiB,KAAK,MAAM,SAAS,EAAE;AAAA,YACvE;AAAA,UACF;AACA,4BAAkB;AAClB;AAAA,QACF;AACA,YAAI,IAAI,SAAS,SAAS;AAKxB,kBAAQ;AAAA,YACN,+CAA+C,GAAG;AAAA,UAEpD;AACA;AAAA,QACF;AACA,cAAM,UAAU,KAAK,QAAQ,GAAG;AAChC,YAAI,CAAC,QAAS;AACd,cAAM,aAAa,SAAS,cAAc,QAAQ,UAAU;AAC5D,YAAI,IAAI,YAAY,MAAM;AAUxB,gBAAM,WAAW,gBAAgB,IAAI,SAAS,mBAAmB,CAAC;AAClE;AAAA,QACF;AACA,cAAM,WAAW,IAAI,IAAI,IAAI,KAAK;AAAA,MACpC;AAKA,UAAI,gBAAiB,SAAQ,IAAI,IAAI;AAAA,UAChC,SAAQ,OAAO,IAAI;AAAA,IAC1B,SAAS,GAAG;AAEV,cAAQ,IAAI,IAAI;AAChB,YAAM;AAAA,IACR;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-QHW35ZON.js → chunk-TGPST6FK.js}

@@ -1,7 +1,7 @@
 import {
   buildAccessibleBundle,
   resolveAccessibleCollections
-} from "./chunk-ZR2YMODS.js";
+} from "./chunk-EKZ6VZYF.js";
 import {
   buildRecordEnvelope
 } from "./chunk-4RUFYGWG.js";
@@ -117,4 +117,4 @@ export {
   freezeAndDeleteClosure,
   withdrawAccessibleData
 };
-//# sourceMappingURL=chunk-QHW35ZON.js.map
+//# sourceMappingURL=chunk-TGPST6FK.js.map

package/dist/{chunk-THNJ3IKU.js → chunk-ULUMAZ5S.js}

@@ -1,6 +1,6 @@
 import {
   buildLazyCache
-} from "./chunk-NO272T7Q.js";
+} from "./chunk-66TQOPFM.js";
 
 // src/with-store/lazy/active.ts
 function withLazy() {
@@ -14,4 +14,4 @@ function withLazy() {
 export {
   withLazy
 };
-//# sourceMappingURL=chunk-THNJ3IKU.js.map
+//# sourceMappingURL=chunk-ULUMAZ5S.js.map

package/dist/{chunk-E5OHKSBD.js → chunk-V2PNPF6J.js}

@@ -1,6 +1,6 @@
 import {
   createNoydb
-} from "./chunk-XMF3GKUR.js";
+} from "./chunk-DRB6IHPS.js";
 import {
   deriveSchemaManifest
 } from "./chunk-BBWVXF57.js";
@@ -13,7 +13,7 @@ import {
   signRecord,
   verifyPodHeader,
   verifyRecord
-} from "./chunk-PKJ43CMD.js";
+} from "./chunk-NLOLF6LD.js";
 import {
   loadKeyring
 } from "./chunk-VNR2SNVJ.js";
@@ -286,4 +286,4 @@ export {
   followRedirects,
   open
 };
-//# sourceMappingURL=chunk-E5OHKSBD.js.map
+//# sourceMappingURL=chunk-V2PNPF6J.js.map

package/dist/{chunk-NO272T7Q.js → chunk-V4PXLYWM.js}

@@ -157,38 +157,9 @@ function estimateRecordBytes(record) {
   }
 }
 
-// src/port/with/lazy-strategy.ts
-function buildLazyCache(collection, cache) {
-  if (!cache || cache.maxRecords === void 0 && cache.maxBytes === void 0) {
-    throw new Error(
-      `Collection "${collection}": lazy mode (prefetch: false) requires a cache option with maxRecords and/or maxBytes. An unbounded lazy cache defeats the purpose.`
-    );
-  }
-  const lruOptions = {};
-  if (cache.maxRecords !== void 0) lruOptions.maxRecords = cache.maxRecords;
-  if (cache.maxBytes !== void 0) lruOptions.maxBytes = parseBytes(cache.maxBytes);
-  return new Lru(lruOptions);
-}
-var implicitLazyWarned = false;
-var IMPLICIT_LAZY = {
-  createCache(collection, cache) {
-    if (!implicitLazyWarned) {
-      implicitLazyWarned = true;
-      if (!(typeof process !== "undefined" && process.env["NODE_ENV"] === "test")) {
-        console.warn(
-          `[noy-db] Collection "${collection}": lazy mode (prefetch: false) without the lazy service is deprecated \u2014 pass \`lazyStrategy: withLazy()\` (from "@noy-db/hub/lazy") to createNoydb(). The implicit path will be removed at 1.0.`
-        );
-      }
-    }
-    return buildLazyCache(collection, cache);
-  }
-};
-
 export {
   Lru,
   parseBytes,
-  estimateRecordBytes,
-  buildLazyCache,
-  IMPLICIT_LAZY
+  estimateRecordBytes
 };
-//# sourceMappingURL=chunk-NO272T7Q.js.map
+//# sourceMappingURL=chunk-V4PXLYWM.js.map

package/dist/chunk-V4PXLYWM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/cache/lru.ts","../src/kernel/cache/policy.ts"],"sourcesContent":["/**\n * Generic LRU cache for `Collection`'s lazy hydration mode.\n *\n * Backed by a JavaScript `Map`, which preserves insertion order. Promotion\n * is implemented as `delete()` + `set()` — O(1) on `Map` since both\n * operations are constant-time. Eviction walks the iterator from the front\n * (least recently used) until both budgets are satisfied.\n *\n * ships in-memory only. The cache is never persisted; on collection\n * close every entry is dropped. Persisting cache state is a follow-up\n * once the access patterns from real consumers tell us whether it would\n * pay back the complexity.\n */\n\nexport interface LruEntry<V> {\n  /** The cached value. */\n  readonly value: V\n  /**\n   * Approximate decrypted byte size of the entry. Used by the byte-budget\n   * eviction path. Callers compute this once at insert time and pass it\n   * in — recomputing on every access would dominate the per-record cost.\n   */\n  readonly size: number\n}\n\nexport interface LruOptions {\n  /** Maximum number of entries before eviction. Required if `maxBytes` is unset. */\n  maxRecords?: number\n  /** Maximum total bytes before eviction. Computed from per-entry `size`. */\n  maxBytes?: number\n}\n\nexport interface LruStats {\n  /** Total cache hits since construction (or `resetStats()`). */\n  hits: number\n  /** Total cache misses since construction (or `resetStats()`). */\n  misses: number\n  /** Total entries evicted since construction (or `resetStats()`). */\n  evictions: number\n  /** Current number of cached entries. */\n  size: number\n  /** Current sum of cached entry sizes (in bytes, approximate). */\n  bytes: number\n}\n\n/**\n * O(1) LRU cache. Both `get()` and `set()` promote the touched entry to\n * the most-recently-used end. Eviction happens after every insert and\n * walks the front of the Map iterator dropping entries until both\n * budgets are satisfied.\n */\nexport class Lru<K, V> {\n  private readonly entries = new Map<K, LruEntry<V>>()\n  private readonly maxRecords: number | undefined\n  private readonly maxBytes: number | undefined\n  private currentBytes = 0\n  private hits = 0\n  private misses = 0\n  private evictions = 0\n\n  constructor(options: LruOptions) {\n    if (options.maxRecords === undefined && options.maxBytes === undefined) {\n      throw new Error('Lru: must specify maxRecords, maxBytes, or both')\n    }\n    this.maxRecords = options.maxRecords\n    this.maxBytes = options.maxBytes\n  }\n\n  /**\n   * Look up a key. Hits promote the entry to most-recently-used; misses\n   * return undefined. Both update the running stats counters.\n   */\n  get(key: K): V | undefined {\n    const entry = this.entries.get(key)\n    if (!entry) {\n      this.misses++\n      return undefined\n    }\n    // Promote: re-insert moves the entry to the end of the iteration order.\n    this.entries.delete(key)\n    this.entries.set(key, entry)\n    this.hits++\n    return entry.value\n  }\n\n  /**\n   * Insert or update a key. If the key already exists, its size is\n   * accounted for and the entry is promoted to MRU. After insertion,\n   * eviction runs to maintain both budgets.\n   */\n  set(key: K, value: V, size: number): void {\n    const existing = this.entries.get(key)\n    if (existing) {\n      // Update path: subtract the old size before adding the new one.\n      this.currentBytes -= existing.size\n      this.entries.delete(key)\n    }\n    this.entries.set(key, { value, size })\n    this.currentBytes += size\n    this.evictUntilUnderBudget()\n  }\n\n  /**\n   * Remove a key without affecting hit/miss stats. Used by `Collection.delete()`.\n   * Returns true if the key was present.\n   */\n  remove(key: K): boolean {\n    const existing = this.entries.get(key)\n    if (!existing) return false\n    this.currentBytes -= existing.size\n    this.entries.delete(key)\n    return true\n  }\n\n  /** True if the cache currently holds an entry for the given key. */\n  has(key: K): boolean {\n    return this.entries.has(key)\n  }\n\n  /**\n   * Drop every entry. Stats counters survive — call `resetStats()` if you\n   * want a clean slate. Used by `Collection.invalidate()` on key rotation.\n   */\n  clear(): void {\n    this.entries.clear()\n    this.currentBytes = 0\n  }\n\n  /** Reset hit/miss/eviction counters to zero. Does NOT touch entries. */\n  resetStats(): void {\n    this.hits = 0\n    this.misses = 0\n    this.evictions = 0\n  }\n\n  /** Snapshot of current cache statistics. Cheap — no copying. */\n  stats(): LruStats {\n    return {\n      hits: this.hits,\n      misses: this.misses,\n      evictions: this.evictions,\n      size: this.entries.size,\n      bytes: this.currentBytes,\n    }\n  }\n\n  /**\n   * Iterate over all currently-cached values. Order is least-recently-used\n   * first. Used by tests and devtools — production callers should use\n   * `Collection.scan()` instead.\n   */\n  *values(): IterableIterator<V> {\n    for (const entry of this.entries.values()) yield entry.value\n  }\n\n  /**\n   * Walk the cache from the LRU end and drop entries until both budgets\n   * are satisfied. Called after every `set()`. Single pass — entries are\n   * never re-promoted during eviction.\n   */\n  private evictUntilUnderBudget(): void {\n    while (this.overBudget()) {\n      const oldest = this.entries.keys().next()\n      if (oldest.done) return // empty cache; nothing more to evict\n      const key = oldest.value\n      const entry = this.entries.get(key)\n      if (entry) this.currentBytes -= entry.size\n      this.entries.delete(key)\n      this.evictions++\n    }\n  }\n\n  private overBudget(): boolean {\n    if (this.maxRecords !== undefined && this.entries.size > this.maxRecords) return true\n    if (this.maxBytes !== undefined && this.currentBytes > this.maxBytes) return true\n    return false\n  }\n}\n","/**\n * Cache policy helpers — parse human-friendly byte budgets into raw numbers.\n *\n * Accepted shapes (case-insensitive on suffix):\n *   number       — interpreted as raw bytes\n *   '1024'       — string of digits, raw bytes\n *   '50KB'       — kilobytes (×1024)\n *   '50MB'       — megabytes (×1024²)\n *   '1GB'        — gigabytes (×1024³)\n *\n * Decimals are accepted (`'1.5GB'` → 1610612736 bytes).\n *\n * Anything else throws — better to fail loud at construction time than\n * to silently treat a typo as 0 bytes (which would evict everything).\n */\n\nconst UNITS: Record<string, number> = {\n  '': 1,\n  'B': 1,\n  'KB': 1024,\n  'MB': 1024 * 1024,\n  'GB': 1024 * 1024 * 1024,\n  // 'TB' deliberately not supported — if you need it, you're not using NOYDB.\n}\n\n/** Parse a byte budget into a positive integer number of bytes. */\nexport function parseBytes(input: number | string): number {\n  if (typeof input === 'number') {\n    if (!Number.isFinite(input) || input <= 0) {\n      throw new Error(`parseBytes: numeric input must be a positive finite number, got ${String(input)}`)\n    }\n    return Math.floor(input)\n  }\n\n  const trimmed = input.trim()\n  if (trimmed === '') {\n    throw new Error('parseBytes: empty string is not a valid byte budget')\n  }\n\n  // Accept either a bare number or a number followed by a unit suffix.\n  // Regex: optional sign, digits with optional decimal, optional unit.\n  const match = /^([0-9]+(?:\\.[0-9]+)?)\\s*([A-Za-z]*)$/.exec(trimmed)\n  if (!match) {\n    throw new Error(`parseBytes: invalid byte budget \"${input}\". Expected format: \"1024\", \"50KB\", \"50MB\", \"1GB\"`)\n  }\n\n  const value = parseFloat(match[1]!)\n  const unit = (match[2] ?? '').toUpperCase()\n\n  if (!(unit in UNITS)) {\n    throw new Error(`parseBytes: unknown unit \"${match[2]}\" in \"${input}\". Supported: B, KB, MB, GB`)\n  }\n\n  const bytes = Math.floor(value * UNITS[unit]!)\n  if (bytes <= 0) {\n    throw new Error(`parseBytes: byte budget must be > 0, got ${bytes} from \"${input}\"`)\n  }\n  return bytes\n}\n\n/**\n * Estimate the in-memory byte size of a decrypted record.\n *\n * Uses `JSON.stringify().length` as a stand-in for actual heap usage.\n * It's a deliberate approximation: real V8 heap size includes pointer\n * overhead, hidden classes, and string interning that we can't measure\n * from JavaScript. The JSON length is a stable, monotonic proxy that\n * costs O(record size) per insert — fine when records are typically\n * < 1 KB and the cache eviction is the slow path anyway.\n *\n * Returns `0` (and the caller must treat it as 1 for accounting) if\n * stringification throws on circular references; this is documented\n * but in practice records always come from JSON-decoded envelopes.\n */\nexport function estimateRecordBytes(record: unknown): number {\n  try {\n    return JSON.stringify(record).length\n  } catch {\n    return 0\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-BERJ4AWW.js → chunk-VGXZT72I.js}

@@ -124,7 +124,7 @@ function validatePeriodName(name, existing, partition) {
 }
 async function appendPeriodLedgerEntry(ledger, actor, envelope, name, collection = PERIODS_COLLECTION) {
   if (!ledger) return;
-  const { envelopePayloadHash } = await import("./ledger-HXHIOD36.js");
+  const { envelopePayloadHash } = await import("./ledger-454SU3VE.js");
   await ledger.append({
     op: "put",
     collection,
@@ -198,4 +198,4 @@ export {
   purgeMarkersOn,
   withPeriods
 };
-//# sourceMappingURL=chunk-BERJ4AWW.js.map
+//# sourceMappingURL=chunk-VGXZT72I.js.map

package/dist/{chunk-2Z47NMFK.js → chunk-WZW37ZHL.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-GM4IM7TC.js";
 import {
   derivePersistedSchema
-} from "./chunk-URHRIAV6.js";
+} from "./chunk-REDOOY2Q.js";
 import {
   loadPersistedSchemaEntry,
   savePersistedSchema
@@ -257,4 +257,4 @@ export {
   persistClassifiedMarker,
   persistSatelliteMarker
 };
-//# sourceMappingURL=chunk-2Z47NMFK.js.map
+//# sourceMappingURL=chunk-WZW37ZHL.js.map

package/dist/{chunk-SWVNZQVR.js → chunk-YPXNAP72.js}

@@ -6,7 +6,6 @@ import {
   presentI18nForJoin
 } from "./chunk-TRGTKX5E.js";
 import {
-  PeriodClosedError,
   UnknownDictCodeError,
   ValidationError
 } from "./chunk-7O3Y4PPD.js";
@@ -304,164 +303,6 @@ function isLookupDescriptor(x) {
   return typeof x === "object" && x !== null && x._viaBrand === "lookup";
 }
 
-// src/kernel/via/dispatch.ts
-function touchFor(batch, collection) {
-  let t = batch.get(collection);
-  if (!t) {
-    t = { puts: /* @__PURE__ */ new Set(), deletes: /* @__PURE__ */ new Map() };
-    batch.set(collection, t);
-  }
-  return t;
-}
-function resolveRollupDeleteIntents(registry, collectionName, deleted) {
-  if (!registry) return [];
-  const intents = [];
-  for (const { spec } of registry.strategiesForSource(collectionName)) {
-    if (!spec.rollup || spec.rollup.from !== collectionName) continue;
-    const kv = deleted[spec.rollup.key];
-    if (typeof kv === "string" || typeof kv === "number") intents.push({ into: spec.source, parentId: String(kv), field: spec.rollup.field });
-  }
-  return intents;
-}
-function findRollupSpecForIntent(registry, collectionName, intent) {
-  return registry?.strategiesForSource(collectionName).find((s) => s.spec.source === intent.into && s.spec.rollup?.field === intent.field && s.spec.rollup?.from === collectionName)?.spec;
-}
-var WaveContext = class {
-  _seen = /* @__PURE__ */ new Set();
-  seen(targetKey) {
-    if (this._seen.has(targetKey)) return true;
-    this._seen.add(targetKey);
-    return false;
-  }
-};
-async function runGraphDispatchWave(vault, batch) {
-  const wave = new WaveContext();
-  for (const [collectionName, touch] of batch) {
-    if (vault.graph.dependentsOf(collectionName).length === 0) continue;
-    const coll = vault._getCollection(collectionName);
-    if (!coll) continue;
-    for (const id of touch.puts) {
-      try {
-        const stored = await coll._getStoredRecordForDispatch(id);
-        if (!stored) continue;
-        await coll.dispatchDerivations(id, stored.record, stored.version, wave);
-        await coll.dispatchMaterializedViews(id, stored.record, wave);
-      } catch (err) {
-        console.warn(`[via-dispatch] wave recompute failed for ${collectionName}/${id}:`, err);
-        vault._emit("derivation:wave-error", { collection: collectionName, id, error: err });
-      }
-    }
-    for (const [id, intents] of touch.deletes) {
-      try {
-        await coll._recomputeDeletedRollups(intents, wave);
-        await coll.dispatchMaterializedViewsOnDelete(id);
-        await coll.dispatchArrayDerivationsOnDelete(id);
-      } catch (err) {
-        console.warn(`[via-dispatch] wave delete-recompute failed for ${collectionName}/${id}:`, err);
-        vault._emit("derivation:wave-error", { collection: collectionName, id, error: err });
-      }
-    }
-  }
-}
-async function putDerivedOutput(outColl, id, value, ctx, options) {
-  try {
-    await outColl.put(id, value, options);
-    return "written";
-  } catch (err) {
-    if (!(err instanceof PeriodClosedError)) throw err;
-    const targetCollection = outColl.name;
-    const event = {
-      source: ctx.source,
-      target: { collection: targetCollection, id },
-      period: err.periodName,
-      endDate: err.endDate
-    };
-    ctx.emit("derivation:skipped-frozen", event);
-    if (ctx.audit) await ctx.audit(event);
-    return "skipped-frozen";
-  }
-}
-function ledgerAuditHook(ledger, actor) {
-  if (!ledger) return void 0;
-  return async (e) => {
-    await ledger.append({
-      op: "lifecycle",
-      collection: e.target.collection,
-      id: e.target.id,
-      version: 0,
-      actor,
-      payloadHash: "",
-      reason: JSON.stringify({ event: "derivation-skipped-frozen", ...e })
-    });
-  };
-}
-async function forgetDerivedFanout(vault, ref, envelope, stats, lookupCompareKeys) {
-  const coll = vault._getCollection(ref.collection);
-  if (coll) {
-    const mv = await coll.dispatchMaterializedViewsOnDelete(ref.id);
-    stats.recordsErased += mv.deleted;
-    stats.derivedResidueUndecodable.push(...mv.residueUndecodable);
-    stats.derivedResidueDeclined.push(...mv.residueDeclined);
-  }
-  const edges = vault.graph.derivedArtifactsOf(ref.collection);
-  if (edges.length === 0 || !coll) return;
-  if (edges.some((e) => e.kind === "ref")) {
-    const { cascaded, nullified, residue } = await applyLookupRefsFanout(vault, ref.collection, ref.id, lookupCompareKeys);
-    stats.lookupReferencesCascaded += cascaded;
-    stats.lookupReferencesNullified += nullified;
-    stats.lookupReferencesResidue.push(...residue);
-  }
-  if (edges.some((e) => e.kind === "derivation")) {
-    stats.recordsErased += await coll.dispatchArrayDerivationsOnDelete(ref.id, true);
-  }
-  if (envelope && edges.some((e) => e.kind === "rollup")) {
-    const priorRecord = await coll._decodeEnvelope(envelope, ref.id);
-    if (priorRecord) {
-      for (const r of await coll.dispatchRollupsOnDelete(ref.id, priorRecord)) {
-        if (r.outcome === "written") stats.aggregatesRecomputed += 1;
-        else if (r.outcome === "skipped-frozen") stats.residueFrozen.push(`${r.into}:${r.parentId}`);
-      }
-    }
-  }
-}
-async function applyLookupRefsFanout(vault, backing, key, compareKeys) {
-  let cascaded = 0;
-  let nullified = 0;
-  const residue = [];
-  for (const { referencing, onDelete, keyField } of vault.graph.referencingEdgesOf(backing)) {
-    if (onDelete === "restrict") continue;
-    const compareKey = keyField === "id" ? key : compareKeys.get(keyField);
-    if (compareKey === void 0) {
-      residue.push(`${backing}:${key}:${referencing.collection}.${referencing.field}`);
-      continue;
-    }
-    const coll = vault._getCollection(referencing.collection);
-    if (!coll) continue;
-    const matches = (await coll.list()).filter((rec) => matchesReferencingValue(rec, referencing.field, compareKey));
-    for (const rec of matches) {
-      const id = rec["id"];
-      if (id === void 0) continue;
-      if (onDelete === "cascade") {
-        await coll.delete(id);
-        cascaded++;
-      } else if (onDelete === "nullify") {
-        await coll.put(id, { ...rec, [referencing.field]: null });
-        nullified++;
-      }
-    }
-  }
-  return { cascaded, nullified, residue };
-}
-function selfWriteFieldEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch {
-    return false;
-  }
-}
-
 export {
   enforceStaticDictOnPut,
   resolveDictSource,
@@ -477,14 +318,6 @@ export {
   buildLookupSnapshotRows,
   buildLookupSnapshot,
   buildPresentForJoin,
-  isLookupDescriptor,
-  touchFor,
-  resolveRollupDeleteIntents,
-  findRollupSpecForIntent,
-  runGraphDispatchWave,
-  putDerivedOutput,
-  ledgerAuditHook,
-  forgetDerivedFanout,
-  selfWriteFieldEqual
+  isLookupDescriptor
 };
-//# sourceMappingURL=chunk-SWVNZQVR.js.map
+//# sourceMappingURL=chunk-YPXNAP72.js.map