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

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

package/dist/chunk-DIRRS7WP.js

@@ -0,0 +1,42 @@
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-CKZW6P5V.js";
+
+// src/with-party/policy/storage.ts
+var META_COLLECTION = "_meta";
+var POLICY_RECORD_ID = "policy";
+async function loadVaultPolicy(store, vault) {
+  const envelope = await store.get(vault, META_COLLECTION, POLICY_RECORD_ID);
+  if (!envelope) return void 0;
+  try {
+    const parsed = JSON.parse(envelope._data);
+    if (!isVaultPolicy(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+async function saveVaultPolicy(store, vault, policy) {
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(policy)
+  };
+  await store.put(vault, META_COLLECTION, POLICY_RECORD_ID, envelope);
+}
+function isVaultPolicy(x) {
+  if (x === null || typeof x !== "object") return false;
+  if (!("gates" in x)) return false;
+  const gates = x.gates;
+  return gates !== null && typeof gates === "object";
+}
+
+export {
+  META_COLLECTION,
+  POLICY_RECORD_ID,
+  loadVaultPolicy,
+  saveVaultPolicy
+};
+//# sourceMappingURL=chunk-DIRRS7WP.js.map

package/dist/chunk-DJ3VKYFA.js

@@ -0,0 +1,150 @@
+import {
+  openEnvelopeJson
+} from "./chunk-QQJXBZCO.js";
+import {
+  encrypt,
+  hmacSha256Hex,
+  sha256Hex
+} from "./chunk-HUS3J5WM.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-CKZW6P5V.js";
+
+// src/with-audit/forget/strategy.ts
+var NO_FORGET = { subjects: {} };
+
+// src/with-audit/forget/subject-index.ts
+var SUBJECT_INDEX_COLLECTION = "_subject_index";
+var REF_LIST_BUCKET = 256;
+async function sha256HexString(input) {
+  return sha256Hex(new TextEncoder().encode(input));
+}
+async function subjectKeys(getDEK, encrypted, subjectId) {
+  const legacy = await sha256HexString(subjectId);
+  if (!encrypted) return [legacy];
+  const dek = await getDEK(SUBJECT_INDEX_COLLECTION);
+  const keyed = await hmacSha256Hex(dek, new TextEncoder().encode(subjectId));
+  return keyed === legacy ? [keyed] : [keyed, legacy];
+}
+async function primarySubjectKey(getDEK, encrypted, subjectId) {
+  return (await subjectKeys(getDEK, encrypted, subjectId))[0];
+}
+function parseRefs(json) {
+  const parsed = JSON.parse(json);
+  return Array.isArray(parsed) ? parsed : parsed.r;
+}
+function serializeRefs(refs) {
+  const base = JSON.stringify({ r: refs, p: "" });
+  const pad = Math.ceil(base.length / REF_LIST_BUCKET) * REF_LIST_BUCKET - base.length;
+  return JSON.stringify({ r: refs, p: " ".repeat(pad) });
+}
+async function readRefs(adapter, vault, getDEK, encrypted, key) {
+  const env = await adapter.get(vault, SUBJECT_INDEX_COLLECTION, key);
+  if (!env || !env._data) return [];
+  if (!encrypted) return parseRefs(env._data);
+  const dek = await getDEK(SUBJECT_INDEX_COLLECTION);
+  const json = await openEnvelopeJson(env, dek);
+  return parseRefs(json);
+}
+async function writeRefs(adapter, vault, getDEK, encrypted, key, refs) {
+  let env;
+  if (!encrypted) {
+    env = { _noydb: NOYDB_FORMAT_VERSION, _v: 1, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: "", _data: JSON.stringify(refs) };
+  } else {
+    const dek = await getDEK(SUBJECT_INDEX_COLLECTION);
+    const { iv, data } = await encrypt(serializeRefs(refs), dek);
+    env = { _noydb: NOYDB_FORMAT_VERSION, _v: 1, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: iv, _data: data };
+  }
+  await adapter.put(vault, SUBJECT_INDEX_COLLECTION, key, env);
+}
+async function addSubjectRef(adapter, vault, getDEK, encrypted, subjectId, ref) {
+  const key = await primarySubjectKey(getDEK, encrypted, subjectId);
+  const refs = await readRefs(adapter, vault, getDEK, encrypted, key);
+  if (refs.some((r) => r.collection === ref.collection && r.id === ref.id)) return;
+  refs.push(ref);
+  await writeRefs(adapter, vault, getDEK, encrypted, key, refs);
+}
+async function removeSubjectRef(adapter, vault, getDEK, encrypted, subjectId, ref) {
+  for (const key of await subjectKeys(getDEK, encrypted, subjectId)) {
+    const refs = await readRefs(adapter, vault, getDEK, encrypted, key);
+    const next = refs.filter((r) => !(r.collection === ref.collection && r.id === ref.id));
+    if (next.length === refs.length) continue;
+    if (next.length === 0) {
+      await adapter.delete(vault, SUBJECT_INDEX_COLLECTION, key);
+    } else {
+      await writeRefs(adapter, vault, getDEK, encrypted, key, next);
+    }
+  }
+}
+async function lookupSubject(adapter, vault, getDEK, encrypted, subjectId) {
+  const keys = await subjectKeys(getDEK, encrypted, subjectId);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const key of keys) {
+    for (const ref of await readRefs(adapter, vault, getDEK, encrypted, key)) {
+      const dedup = `${ref.collection}\0${ref.id}`;
+      if (seen.has(dedup)) continue;
+      seen.add(dedup);
+      out.push(ref);
+    }
+  }
+  return out;
+}
+async function rebuildSubjectIndex(adapter, vault, getDEK, encrypted, subjects, decodeRecord) {
+  const existing = await adapter.list(vault, SUBJECT_INDEX_COLLECTION);
+  for (const k of existing) {
+    await adapter.delete(vault, SUBJECT_INDEX_COLLECTION, k);
+  }
+  const bySubject = /* @__PURE__ */ new Map();
+  for (const [collection, field] of Object.entries(subjects)) {
+    const ids = await adapter.list(vault, collection);
+    for (const id of ids) {
+      if (id.startsWith("_")) continue;
+      const env = await adapter.get(vault, collection, id);
+      if (!env || !env._data) continue;
+      const record = await decodeRecord(collection, id, env);
+      if (record === null) continue;
+      const subjectValue = readDottedPath(record, field);
+      if (subjectValue === void 0 || subjectValue === null) continue;
+      const subjectId = coerceSubjectId(subjectValue);
+      const list = bySubject.get(subjectId) ?? [];
+      list.push({ collection, id });
+      bySubject.set(subjectId, list);
+    }
+  }
+  let entries = 0;
+  for (const [subjectId, refs] of bySubject) {
+    const key = await primarySubjectKey(getDEK, encrypted, subjectId);
+    await writeRefs(adapter, vault, getDEK, encrypted, key, refs);
+    entries++;
+  }
+  return entries;
+}
+function coerceSubjectId(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function readDottedPath(record, field) {
+  if (!field.includes(".")) return record[field];
+  let cursor = record;
+  for (const segment of field.split(".")) {
+    if (cursor === null || cursor === void 0) return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+}
+
+export {
+  NO_FORGET,
+  SUBJECT_INDEX_COLLECTION,
+  addSubjectRef,
+  removeSubjectRef,
+  lookupSubject,
+  rebuildSubjectIndex,
+  coerceSubjectId,
+  readDottedPath
+};
+//# sourceMappingURL=chunk-DJ3VKYFA.js.map