@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/chunk-D26JB3LZ.js

@@ -0,0 +1,54 @@
+import {
+  QuiesceTimeoutError
+} from "./chunk-FH542DDY.js";
+
+// src/port/by/types.ts
+function isQuorum(writers, generation, excludeWriterId) {
+  return writers.filter((w) => w.writerId !== excludeWriterId).every((w) => w.quiescedAtVersion === generation);
+}
+async function runDrainBarrier(provider, o, run) {
+  await provider.setFence(o.vault, { currentSchemaVersion: o.generation, fenceState: "draining" });
+  await o.onFlush();
+  const deadline = o.now() + o.quiesceTimeoutMs;
+  const seeded = await provider.reachableWriters(o.vault, { staleMs: o.staleMs, now: o.now() });
+  if (!isQuorum(seeded, o.generation, o.writerId)) {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (fn) => {
+        if (!settled) {
+          settled = true;
+          unsub();
+          fn();
+        }
+      };
+      const unsub = provider.observePresence(o.vault, (writers) => {
+        if (isQuorum(writers, o.generation, o.writerId)) finish(resolve);
+      });
+      const tick = async () => {
+        if (settled) return;
+        if (o.now() >= deadline) {
+          finish(
+            () => reject(
+              new QuiesceTimeoutError(
+                `Cutover of vault "${o.vault}" to generation ${o.generation} timed out after ${o.quiesceTimeoutMs}ms waiting for active writers to quiesce.`
+              )
+            )
+          );
+          return;
+        }
+        if (o.onPoll) await o.onPoll();
+        const w = await provider.reachableWriters(o.vault, { staleMs: o.staleMs, now: o.now() });
+        if (isQuorum(w, o.generation, o.writerId)) finish(resolve);
+        else setTimeout(() => void tick(), 25);
+      };
+      void tick();
+    });
+  }
+  await run();
+}
+
+export {
+  isQuorum,
+  runDrainBarrier
+};
+//# sourceMappingURL=chunk-D26JB3LZ.js.map

package/dist/chunk-D3EFFFOL.js

@@ -0,0 +1,59 @@
+import {
+  openEnvelopeJson
+} from "./chunk-QQJXBZCO.js";
+import {
+  encrypt
+} from "./chunk-HUS3J5WM.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-CKZW6P5V.js";
+import {
+  ConflictError
+} from "./chunk-FH542DDY.js";
+
+// src/with-audit/attestation/signer.ts
+import { generateDocSigningKeyPair } from "@noy-db/attestation";
+var ATTESTATIONS_COLLECTION = "_attestations";
+var SIGNER_RECORD_ID = "_signer";
+var REVOKED_RECORD_ID = "_revoked";
+async function loadSigner(store, vault, getDEK) {
+  const existing = await store.get(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID);
+  if (!existing) return null;
+  const dek = await getDEK(ATTESTATIONS_COLLECTION);
+  const json = await openEnvelopeJson(existing, dek);
+  return JSON.parse(json);
+}
+async function loadOrCreateSigner(store, vault, getDEK) {
+  const existing = await loadSigner(store, vault, getDEK);
+  if (existing) return existing;
+  const dek = await getDEK(ATTESTATIONS_COLLECTION);
+  const signer = await generateDocSigningKeyPair();
+  const { iv, data } = await encrypt(JSON.stringify(signer), dek);
+  const env = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: iv,
+    _data: data
+  };
+  try {
+    await store.put(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID, env, 0);
+    return signer;
+  } catch (e) {
+    if (!(e instanceof ConflictError)) throw e;
+    const winner = await loadSigner(store, vault, getDEK);
+    if (!winner) {
+      throw new ConflictError(0, "loadOrCreateSigner: signer mint lost a concurrent race but the winning record could not be re-read.");
+    }
+    return winner;
+  }
+}
+
+export {
+  ATTESTATIONS_COLLECTION,
+  SIGNER_RECORD_ID,
+  REVOKED_RECORD_ID,
+  loadSigner,
+  loadOrCreateSigner
+};
+//# sourceMappingURL=chunk-D3EFFFOL.js.map

package/dist/chunk-D3EFFFOL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-audit/attestation/signer.ts"],"sourcesContent":["import type { NoydbStore, EncryptedEnvelope } from '../../kernel/types.js'\nimport { NOYDB_FORMAT_VERSION } from '../../kernel/types.js'\nimport { encrypt, openEnvelopeJson, type EnclaveKey } from '../../kernel/enclave/index.js'\nimport { ConflictError } from '../../kernel/errors.js'\nimport { generateDocSigningKeyPair } from '@noy-db/attestation'\n\nexport const ATTESTATIONS_COLLECTION = '_attestations'\nexport const SIGNER_RECORD_ID = '_signer'\nexport const REVOKED_RECORD_ID = '_revoked'\n\nexport interface DocSigner {\n  readonly keyId: string\n  readonly publicKeyB64: string\n  readonly privateKeyPkcs8B64: string\n}\n\n/**\n * Pure read: return the firm's persisted document-signing keypair, or `null`\n * if none has been minted yet. Never writes — callers that must NOT mint\n * (e.g. an ungated public-key getter) use this instead of `loadOrCreateSigner`.\n *\n * Stored as an encrypted record `_attestations/_signer` under the\n * `_attestations` collection DEK (resolved via `getDEK`, which is\n * AES-KW-wrapped under the owner KEK + persisted by the keyring). The KEK\n * itself is AES-KW-only and cannot AES-GCM-encrypt these bytes — hence\n * storage under a normal collection DEK.\n */\nexport async function loadSigner(\n  store: NoydbStore,\n  vault: string,\n  getDEK: (collection: string) => Promise<EnclaveKey>,\n): Promise<DocSigner | null> {\n  const existing = await store.get(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID)\n  if (!existing) return null\n  const dek = await getDEK(ATTESTATIONS_COLLECTION)\n  const json = await openEnvelopeJson(existing, dek)\n  return JSON.parse(json) as DocSigner\n}\n\n/**\n * Lazily mint (or load) the firm's Ed25519 document-signing keypair.\n *\n * On a concurrent first-mint, two callers can both read `null` and both mint\n * distinct keypairs. The `put(…, expectedVersion: 0)` (\"must not already\n * exist\") lets exactly one win; the loser catches `ConflictError`, re-reads,\n * and returns the winner's signer — converging on a single keypair rather than\n * clobbering it or surfacing a raw conflict. (All real stores treat a missing\n * record + `ev: 0` as a no-conflict write, so the catch fires on lost-race only.)\n */\nexport async function loadOrCreateSigner(\n  store: NoydbStore,\n  vault: string,\n  getDEK: (collection: string) => Promise<EnclaveKey>,\n): Promise<DocSigner> {\n  const existing = await loadSigner(store, vault, getDEK)\n  if (existing) return existing\n\n  const dek = await getDEK(ATTESTATIONS_COLLECTION)\n  const signer = await generateDocSigningKeyPair()\n  const { iv, data } = await encrypt(JSON.stringify(signer), dek)\n  const env: EncryptedEnvelope = {\n    _noydb: NOYDB_FORMAT_VERSION, _v: 1, _ts: new Date().toISOString(), _iv: iv, _data: data,\n  }\n  try {\n    await store.put(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID, env, 0)\n    return signer\n  } catch (e) {\n    if (!(e instanceof ConflictError)) throw e\n    // Lost the race — another writer minted first. Adopt the winner.\n    const winner = await loadSigner(store, vault, getDEK)\n    if (!winner) {\n      throw new ConflictError(0, 'loadOrCreateSigner: signer mint lost a concurrent race but the winning record could not be re-read.')\n    }\n    return winner\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAIA,SAAS,iCAAiC;AAEnC,IAAM,0BAA0B;AAChC,IAAM,mBAAmB;AACzB,IAAM,oBAAoB;AAmBjC,eAAsB,WACpB,OACA,OACA,QAC2B;AAC3B,QAAM,WAAW,MAAM,MAAM,IAAI,OAAO,yBAAyB,gBAAgB;AACjF,MAAI,CAAC,SAAU,QAAO;AACtB,QAAM,MAAM,MAAM,OAAO,uBAAuB;AAChD,QAAM,OAAO,MAAM,iBAAiB,UAAU,GAAG;AACjD,SAAO,KAAK,MAAM,IAAI;AACxB;AAYA,eAAsB,mBACpB,OACA,OACA,QACoB;AACpB,QAAM,WAAW,MAAM,WAAW,OAAO,OAAO,MAAM;AACtD,MAAI,SAAU,QAAO;AAErB,QAAM,MAAM,MAAM,OAAO,uBAAuB;AAChD,QAAM,SAAS,MAAM,0BAA0B;AAC/C,QAAM,EAAE,IAAI,KAAK,IAAI,MAAM,QAAQ,KAAK,UAAU,MAAM,GAAG,GAAG;AAC9D,QAAM,MAAyB;AAAA,IAC7B,QAAQ;AAAA,IAAsB,IAAI;AAAA,IAAG,MAAK,oBAAI,KAAK,GAAE,YAAY;AAAA,IAAG,KAAK;AAAA,IAAI,OAAO;AAAA,EACtF;AACA,MAAI;AACF,UAAM,MAAM,IAAI,OAAO,yBAAyB,kBAAkB,KAAK,CAAC;AACxE,WAAO;AAAA,EACT,SAAS,GAAG;AACV,QAAI,EAAE,aAAa,eAAgB,OAAM;AAEzC,UAAM,SAAS,MAAM,WAAW,OAAO,OAAO,MAAM;AACpD,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,cAAc,GAAG,qGAAqG;AAAA,IAClI;AACA,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-DGH65E7Q.js

@@ -0,0 +1,466 @@
+import {
+  dictCollectionName
+} from "./chunk-ELNBMFOS.js";
+import {
+  getAtPath,
+  presentI18nForJoin
+} from "./chunk-BE7N3AXA.js";
+import {
+  PeriodClosedError,
+  UnknownDictCodeError,
+  ValidationError
+} from "./chunk-FH542DDY.js";
+
+// src/via/lookup/registry.ts
+function enforceStaticDictOnPut(staticFields, record) {
+  if (!staticFields || Object.keys(staticFields).length === 0) return;
+  if (!record || typeof record !== "object") return;
+  const obj = record;
+  for (const [field, desc] of Object.entries(staticFields)) {
+    if (desc.validateCodes === false) continue;
+    const known = new Set(desc.keys);
+    const values = getAtPath(obj, field);
+    for (const value of values) {
+      if (value === void 0 || value === null) continue;
+      const codes = Array.isArray(value) ? value : [value];
+      for (const code of codes) {
+        if (typeof code !== "string") continue;
+        if (!known.has(code)) {
+          throw new UnknownDictCodeError(desc.name, field, code);
+        }
+      }
+    }
+  }
+}
+function resolveDictSource(leftCollection, field, staticDescriptorByField, dictKeyFieldRegistry, getDictionaryHandle) {
+  const staticFields = staticDescriptorByField.get(leftCollection);
+  if (staticFields && field in staticFields) {
+    const desc = staticFields[field];
+    const rows = Object.entries(desc.table).map(
+      ([key, labels]) => ({ key, labels, ...labels })
+    );
+    const source = {
+      snapshot() {
+        return rows;
+      },
+      lookupById(id) {
+        return rows.find((e) => e["key"] === id);
+      }
+    };
+    if (desc.displayLocale !== void 0) {
+      ;
+      source.displayLocale = desc.displayLocale;
+    }
+    return source;
+  }
+  const dictFields = dictKeyFieldRegistry.get(leftCollection);
+  if (!dictFields || !(field in dictFields)) return null;
+  const dictName = dictFields[field];
+  if (!dictName) return null;
+  const handle = getDictionaryHandle(dictName);
+  return {
+    snapshot() {
+      return handle.snapshotEntries();
+    },
+    lookupById(id) {
+      const entries = handle.snapshotEntries();
+      return entries.find((e) => e["key"] === id);
+    }
+  };
+}
+async function updateReferencingRecords(registry, getCollection, name, oldKey, newKey) {
+  for (const [collectionName, dictFields] of registry) {
+    const fields = Object.entries(dictFields).filter(([, dn]) => dn === name).map(([field]) => field);
+    if (fields.length === 0) continue;
+    const coll = getCollection(collectionName);
+    const records = await coll.list();
+    for (const record of records) {
+      let changed = false;
+      const updated = { ...record };
+      for (const field of fields) {
+        if (updated[field] === oldKey) {
+          updated[field] = newKey;
+          changed = true;
+        }
+      }
+      if (changed) {
+        const id = record["id"];
+        if (id !== void 0) {
+          await coll.put(id, updated);
+        }
+      }
+    }
+  }
+}
+function resolveLabelFromMap(labels, locale, fallback) {
+  if (labels[locale] !== void 0) return labels[locale];
+  const chain = Array.isArray(fallback) ? fallback : fallback ? [fallback] : [];
+  for (const fb of chain) {
+    if (fb === "any") {
+      const any = Object.values(labels)[0];
+      if (any !== void 0) return any;
+    } else if (labels[fb] !== void 0) {
+      return labels[fb];
+    }
+  }
+  return void 0;
+}
+function lookupToStaticDictCompat(desc) {
+  if (desc.backing !== "static" || desc.table === void 0) return void 0;
+  return {
+    _noydbStaticDict: true,
+    _viaBrand: "i18n",
+    name: desc.dimension,
+    table: desc.table,
+    keys: desc.keys ?? Object.keys(desc.table),
+    ...desc.displayLocale !== void 0 ? { displayLocale: desc.displayLocale } : {},
+    ...desc.onMissing !== void 0 ? { onMissing: desc.onMissing } : {},
+    ...desc.substitute !== void 0 ? { substitute: desc.substitute } : {},
+    validateCodes: desc.vocabulary === "closed"
+  };
+}
+function collectLookupDictCompat(lookupFields) {
+  const dictFieldMap = {};
+  const staticEntries = [];
+  for (const [field, desc] of Object.entries(lookupFields ?? {})) {
+    if (desc.backing === "reserved") {
+      dictFieldMap[field] = desc.dimension;
+    } else {
+      const compat = lookupToStaticDictCompat(desc);
+      if (compat) staticEntries.push([field, compat]);
+    }
+  }
+  return { dictFieldMap, staticEntries };
+}
+function materializeBackingTable(descriptor, rows) {
+  const keys = new Set(rows.keys());
+  const owner = /* @__PURE__ */ new Map();
+  for (const key of keys) owner.set(key, key);
+  const altIndex = /* @__PURE__ */ new Map();
+  const altFields = descriptor.altKeys ?? [];
+  for (const [canonicalKey, row] of rows) {
+    for (const altField of altFields) {
+      const value = coerceLookupKey(row[altField]);
+      if (value === void 0 || value === "") continue;
+      const existingOwner = owner.get(value);
+      if (existingOwner !== void 0 && existingOwner !== canonicalKey) {
+        throw new ValidationError(
+          `lookup "${descriptor.dimension}": altKey field "${altField}" value "${value}" is claimed by both "${existingOwner}" and "${canonicalKey}" \u2014 key/altKey values must be unique across the dimension.`
+        );
+      }
+      owner.set(value, canonicalKey);
+      altIndex.set(value, canonicalKey);
+    }
+  }
+  return { keys, altIndex };
+}
+function checkLookupMembership(descriptor, key, getDictionary, getCollection) {
+  if (descriptor.backing === "static") {
+    const known = descriptor.keys ?? (descriptor.table ? Object.keys(descriptor.table) : []);
+    return known.includes(key);
+  }
+  if (descriptor.backing === "reserved") {
+    if ((descriptor.keys ?? []).includes(key)) return true;
+    return getDictionary(descriptor.dimension).snapshotEntries().some((e) => e["key"] === key);
+  }
+  return buildLookupAltIndex(descriptor, getDictionary, getCollection).keys.has(key);
+}
+function coerceLookupKey(raw) {
+  return typeof raw === "string" || typeof raw === "number" ? String(raw) : void 0;
+}
+function resolveBackingRowKey(descriptor, row) {
+  return coerceLookupKey(row[descriptor.key]);
+}
+function matchesReferencingValue(rec, field, compareKey) {
+  return coerceLookupKey(rec[field]) === compareKey;
+}
+function buildLookupAltIndex(descriptor, getDictionary, getCollection) {
+  if (descriptor.backing === "static") {
+    return materializeBackingTable(descriptor, new Map(Object.entries(descriptor.table ?? {})));
+  }
+  if (descriptor.backing === "reserved") {
+    const entries = getDictionary(descriptor.dimension).snapshotEntries();
+    return materializeBackingTable(descriptor, new Map(entries.map((e) => [String(e["key"]), e])));
+  }
+  const rows = getCollection(descriptor.dimension).querySourceForJoin().snapshot();
+  const keyed = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = r;
+    const key = resolveBackingRowKey(descriptor, row);
+    if (key !== void 0) keyed.set(key, row);
+  }
+  return materializeBackingTable(descriptor, keyed);
+}
+function collectLookupRefEdges(collectionName, lookupFields) {
+  const edges = [];
+  for (const [field, desc] of Object.entries(lookupFields ?? {})) {
+    if (desc.backing === "static") continue;
+    const backing = desc.backing === "reserved" ? dictCollectionName(desc.dimension) : desc.dimension;
+    edges.push({
+      referencing: { collection: collectionName, field },
+      sources: [
+        { collection: backing, field: "*" },
+        ...desc.present?.label !== void 0 ? [{ collection: backing, field: desc.present.label }] : []
+      ],
+      onDelete: desc.onDelete,
+      keyField: desc.key
+    });
+  }
+  return edges;
+}
+function registerLookupRefEdges(graph, collectionName, lookupFields) {
+  for (const e of collectLookupRefEdges(collectionName, lookupFields)) {
+    graph.registerDerived(e.referencing, e.sources, "ref", "record", e.onDelete, e.keyField);
+  }
+}
+function buildLookupSnapshotRows(descriptor, isReservedDimension, getDictionary, getCollection) {
+  const dimension = descriptor.dimension;
+  if (isReservedDimension(dimension)) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const entry of getDictionary(dimension).snapshotEntries()) {
+      const key = entry["key"];
+      if (typeof key === "string") rows.set(key, entry);
+    }
+    return rows;
+  }
+  if (descriptor.backing === "collection") {
+    const rawRows = getCollection(dimension).querySourceForJoin().snapshot();
+    const rows = /* @__PURE__ */ new Map();
+    for (const r of rawRows) {
+      const row = r;
+      const key = resolveBackingRowKey(descriptor, row);
+      if (key !== void 0) rows.set(key, row);
+    }
+    return rows;
+  }
+  return void 0;
+}
+
+// src/via/lookup/snapshot.ts
+function readRowField(row, field, by, locale, fallback) {
+  if (!row || field === void 0) return void 0;
+  const raw = row[field];
+  if (by === void 0) return typeof raw === "string" ? raw : void 0;
+  if (!raw || typeof raw !== "object") return void 0;
+  const map = raw;
+  const val = map[locale];
+  if (typeof val === "string") return val;
+  if (typeof fallback === "string" && typeof map[fallback] === "string") return map[fallback];
+  return void 0;
+}
+function buildLookupSnapshot(dimension, rows, descriptor) {
+  void dimension;
+  return {
+    row: (key) => rows.get(key),
+    label: (key, locale, fallback) => readRowField(rows.get(key), descriptor.present?.label, descriptor.present?.by, locale, fallback),
+    compareKeys: (a, b, locale) => {
+      const sortField = descriptor.sortBy ?? descriptor.present?.label;
+      const av = readRowField(rows.get(a), sortField, descriptor.present?.by, locale) ?? a;
+      const bv = readRowField(rows.get(b), sortField, descriptor.present?.by, locale) ?? b;
+      return av < bv ? -1 : av > bv ? 1 : 0;
+    }
+  };
+}
+function presentLookupForJoin(record, locale, lookupFields, getSnapshotRows) {
+  let result = record;
+  for (const [field, desc] of Object.entries(lookupFields)) {
+    if (desc.present === void 0) continue;
+    const raw = record[field];
+    if (typeof raw !== "string") continue;
+    const rows = desc.backing === "static" ? desc.table ? new Map(Object.entries(desc.table)) : void 0 : getSnapshotRows(desc);
+    if (!rows) continue;
+    const label = buildLookupSnapshot(desc.dimension, rows, desc).label(raw, locale);
+    if (label === void 0) continue;
+    if (result === record) result = { ...record };
+    result[`${field}Label`] = label;
+  }
+  return result;
+}
+function buildPresentForJoin(i18nFields, lookupFields, getSnapshotRows) {
+  const hasI18n = i18nFields !== void 0 && Object.keys(i18nFields).length > 0;
+  const hasLookup = lookupFields !== void 0 && Object.keys(lookupFields).length > 0;
+  if (!hasI18n && !hasLookup) return void 0;
+  const resolveRows = getSnapshotRows ?? (() => void 0);
+  return (record, locale) => {
+    if (record === null || typeof record !== "object") return record;
+    let result = record;
+    if (hasI18n) result = presentI18nForJoin(result, i18nFields, locale);
+    if (hasLookup) result = presentLookupForJoin(result, locale, lookupFields, resolveRows);
+    return result;
+  };
+}
+
+// src/port/with/lookup-strategy.ts
+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);
+      } 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 edges = vault.graph.derivedArtifactsOf(ref.collection);
+  if (edges.length === 0) return;
+  const coll = vault._getCollection(ref.collection);
+  if (!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 === "mv")) {
+    stats.recordsErased += await coll.dispatchMaterializedViewsOnDelete(ref.id);
+  }
+  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 };
+}
+
+export {
+  enforceStaticDictOnPut,
+  resolveDictSource,
+  updateReferencingRecords,
+  resolveLabelFromMap,
+  collectLookupDictCompat,
+  checkLookupMembership,
+  coerceLookupKey,
+  matchesReferencingValue,
+  buildLookupAltIndex,
+  registerLookupRefEdges,
+  buildLookupSnapshotRows,
+  buildLookupSnapshot,
+  buildPresentForJoin,
+  isLookupDescriptor,
+  touchFor,
+  resolveRollupDeleteIntents,
+  findRollupSpecForIntent,
+  runGraphDispatchWave,
+  putDerivedOutput,
+  ledgerAuditHook,
+  forgetDerivedFanout
+};
+//# sourceMappingURL=chunk-DGH65E7Q.js.map