@noy-db/hub 0.3.0-pre.9 → 0.4.0-pre.0

package/dist/bundle/index.js

@@ -1,18 +1,18 @@
 import {
   extractPartition,
   walkClosure
-} from "../chunk-RJ5522XX.js";
+} from "../chunk-THVIPWRF.js";
 import "../chunk-CHFZDSE4.js";
 import {
   adoptPartition,
   createOwnerOnAdoptedPartition,
   decryptExtractedPartition,
   unsealDeks
-} from "../chunk-M5I354EE.js";
-import "../chunk-KXKLKJW4.js";
-import "../chunk-CJEMA2Z6.js";
-import "../chunk-4ZSGSRBI.js";
-import "../chunk-S6AQXDN4.js";
+} from "../chunk-UDSR4X4L.js";
+import "../chunk-CJ5KKU6X.js";
+import "../chunk-RFI7GGFO.js";
+import "../chunk-UHNGNKLV.js";
+import "../chunk-YTGDPCPW.js";
 import {
   COMPRESSION_BROTLI,
   COMPRESSION_GZIP,
@@ -31,25 +31,27 @@ import {
   validateBundleHeader,
   writeNoydbBundle,
   writePod
-} from "../chunk-Q2KVKTC2.js";
-import "../chunk-KNXN47MO.js";
-import "../chunk-6CU3FN74.js";
-import "../chunk-E5AHO65E.js";
+} from "../chunk-FXZDAV62.js";
+import "../chunk-XUW3PXHU.js";
+import "../chunk-554KLAAN.js";
+import "../chunk-NCCBLYEB.js";
+import "../chunk-UC2ETWF3.js";
 import {
   generateULID,
   isULID
 } from "../chunk-ZJADGNYF.js";
-import "../chunk-WNA6T3MA.js";
+import "../chunk-VRBTNCM4.js";
 import "../chunk-I7FD46FF.js";
-import "../chunk-MSVY7ULZ.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+import "../chunk-DRWBEDYO.js";
+import "../chunk-WQIYTNJV.js";
+import "../chunk-W4TCUGQR.js";
+import "../chunk-A4FXFAKF.js";
+import "../chunk-IY23KFNZ.js";
+import "../chunk-N6WF5PKC.js";
+import "../chunk-6HY2X62D.js";
 import "../chunk-LP7BEXCT.js";
-import "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
+import "../chunk-HOONYZY2.js";
+import "../chunk-VCTXU4AT.js";
 import {
   AdoptionStateError,
   BackupCorruptedError,
@@ -60,12 +62,12 @@ import {
   PartitionExtractionError,
   PodVersionConflictError,
   TransferSealError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/with-cargo/describe-extraction.ts
 async function describeExtraction(vault, opts) {
-  const { closure, graph } = await walkClosure(vault, opts);
+  const { closure, graph, danglingRefs } = await walkClosure(vault, opts);
   const { name: vaultName, adapter } = vault._introspectState();
   const encoder = new TextEncoder();
   const byCollection = [];
@@ -107,7 +109,8 @@ async function describeExtraction(vault, opts) {
     totalBytes,
     byCollection,
     graph,
-    inaccessible
+    inaccessible,
+    danglingRefs
   });
 }
 export {

package/dist/bundle/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/with-cargo/describe-extraction.ts"],"sourcesContent":["/**\n * Partition-extraction dry-run. Read-only preview of what an\n * `extractPartition` would move: record counts, byte totals, and the\n * timestamp span per collection — computed from raw encrypted\n * envelopes WITHOUT decrypting them. Writes nothing, mutates nothing.\n *\n * @module\n */\nimport type { Vault } from '../kernel/vault.js'\nimport { walkClosure, type WalkClosureOptions } from './walk-closure.js'\n\nexport interface ExtractionPreview {\n  readonly totalRecords: number\n  /** Sum of serialized encrypted-envelope sizes (bytes). */\n  readonly totalBytes: number\n  readonly byCollection: ReadonlyArray<{\n    readonly name: string\n    readonly recordCount: number\n    readonly bytes: number\n    /** Earliest envelope `_ts` in this collection (lexicographic). */\n    readonly oldestTs?: string\n    readonly newestTs?: string\n  }>\n  readonly graph: { readonly depth: number; readonly cyclesDetected: boolean }\n  /** Records the walk reached but whose envelope couldn't be read. */\n  readonly inaccessible: ReadonlyArray<{ readonly collection: string; readonly id: string }>\n}\n\nexport async function describeExtraction(\n  vault: Vault,\n  opts: WalkClosureOptions,\n): Promise<ExtractionPreview> {\n  const { closure, graph } = await walkClosure(vault, opts)\n\n  const { name: vaultName, adapter } = vault._introspectState()\n  const encoder = new TextEncoder()\n\n  const byCollection: Array<{\n    name: string; recordCount: number; bytes: number; oldestTs?: string; newestTs?: string\n  }> = []\n  const inaccessible: Array<{ collection: string; id: string }> = []\n  let totalBytes = 0\n  let totalRecords = 0\n\n  for (const [collectionName, ids] of closure) {\n    let bytes = 0\n    let oldestTs: string | undefined\n    let newestTs: string | undefined\n    let recordCount = 0\n\n    for (const id of ids) {\n      const env = await adapter.get(vaultName, collectionName, id)\n      if (!env) {\n        // Walk reached it (via decrypted list) but the raw store read\n        // returned nothing — surface rather than miscount.\n        inaccessible.push({ collection: collectionName, id })\n        continue\n      }\n      recordCount++\n      bytes += encoder.encode(JSON.stringify(env)).length\n      const ts = env._ts\n      if (oldestTs === undefined || ts < oldestTs) oldestTs = ts\n      if (newestTs === undefined || ts > newestTs) newestTs = ts\n    }\n\n    byCollection.push({\n      name: collectionName,\n      recordCount,\n      bytes,\n      // Spread conditionally — exactOptionalPropertyTypes forbids an\n      // explicit `undefined` on an optional property.\n      ...(oldestTs !== undefined ? { oldestTs } : {}),\n      ...(newestTs !== undefined ? { newestTs } : {}),\n    })\n    totalBytes += bytes\n    totalRecords += recordCount\n  }\n\n  byCollection.sort((a, b) => a.name.localeCompare(b.name))\n\n  return Object.freeze({\n    totalRecords,\n    totalBytes,\n    byCollection,\n    graph,\n    inaccessible,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,eAAsB,mBACpB,OACA,MAC4B;AAC5B,QAAM,EAAE,SAAS,MAAM,IAAI,MAAM,YAAY,OAAO,IAAI;AAExD,QAAM,EAAE,MAAM,WAAW,QAAQ,IAAI,MAAM,iBAAiB;AAC5D,QAAM,UAAU,IAAI,YAAY;AAEhC,QAAM,eAED,CAAC;AACN,QAAM,eAA0D,CAAC;AACjE,MAAI,aAAa;AACjB,MAAI,eAAe;AAEnB,aAAW,CAAC,gBAAgB,GAAG,KAAK,SAAS;AAC3C,QAAI,QAAQ;AACZ,QAAI;AACJ,QAAI;AACJ,QAAI,cAAc;AAElB,eAAW,MAAM,KAAK;AACpB,YAAM,MAAM,MAAM,QAAQ,IAAI,WAAW,gBAAgB,EAAE;AAC3D,UAAI,CAAC,KAAK;AAGR,qBAAa,KAAK,EAAE,YAAY,gBAAgB,GAAG,CAAC;AACpD;AAAA,MACF;AACA;AACA,eAAS,QAAQ,OAAO,KAAK,UAAU,GAAG,CAAC,EAAE;AAC7C,YAAM,KAAK,IAAI;AACf,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AACxD,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AAAA,IAC1D;AAEA,iBAAa,KAAK;AAAA,MAChB,MAAM;AAAA,MACN;AAAA,MACA;AAAA;AAAA;AAAA,MAGA,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,MAC7C,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,IAC/C,CAAC;AACD,kBAAc;AACd,oBAAgB;AAAA,EAClB;AAEA,eAAa,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAExD,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../../src/with-cargo/describe-extraction.ts"],"sourcesContent":["/**\n * Partition-extraction dry-run. Read-only preview of what an\n * `extractPartition` would move: record counts, byte totals, and the\n * timestamp span per collection — computed from raw encrypted\n * envelopes WITHOUT decrypting them. Writes nothing, mutates nothing.\n *\n * @module\n */\nimport type { Vault } from '../kernel/vault.js'\nimport { walkClosure, type WalkClosureOptions, type DanglingRefNotice } from './walk-closure.js'\n\nexport interface ExtractionPreview {\n  readonly totalRecords: number\n  /** Sum of serialized encrypted-envelope sizes (bytes). */\n  readonly totalBytes: number\n  readonly byCollection: ReadonlyArray<{\n    readonly name: string\n    readonly recordCount: number\n    readonly bytes: number\n    /** Earliest envelope `_ts` in this collection (lexicographic). */\n    readonly oldestTs?: string\n    readonly newestTs?: string\n  }>\n  readonly graph: { readonly depth: number; readonly cyclesDetected: boolean }\n  /** Records the walk reached but whose envelope couldn't be read. */\n  readonly inaccessible: ReadonlyArray<{ readonly collection: string; readonly id: string }>\n  /**\n   * #772: outbound FK edges whose referenced parent was excluded from the\n   * closure (missing, or tier-elevated and therefore invisible) — mirrors\n   * `ExtractPartitionResult.danglingRefs` (#759) so a preview/extract pair\n   * gives the SAME signal. A parent excluded this way never appears in\n   * `byCollection` at all; this is the only preview-time indicator.\n   */\n  readonly danglingRefs: ReadonlyArray<DanglingRefNotice>\n}\n\nexport async function describeExtraction(\n  vault: Vault,\n  opts: WalkClosureOptions,\n): Promise<ExtractionPreview> {\n  const { closure, graph, danglingRefs } = await walkClosure(vault, opts)\n\n  const { name: vaultName, adapter } = vault._introspectState()\n  const encoder = new TextEncoder()\n\n  const byCollection: Array<{\n    name: string; recordCount: number; bytes: number; oldestTs?: string; newestTs?: string\n  }> = []\n  const inaccessible: Array<{ collection: string; id: string }> = []\n  let totalBytes = 0\n  let totalRecords = 0\n\n  for (const [collectionName, ids] of closure) {\n    let bytes = 0\n    let oldestTs: string | undefined\n    let newestTs: string | undefined\n    let recordCount = 0\n\n    for (const id of ids) {\n      const env = await adapter.get(vaultName, collectionName, id)\n      if (!env) {\n        // Walk reached it (via decrypted list) but the raw store read\n        // returned nothing — surface rather than miscount.\n        inaccessible.push({ collection: collectionName, id })\n        continue\n      }\n      recordCount++\n      bytes += encoder.encode(JSON.stringify(env)).length\n      const ts = env._ts\n      if (oldestTs === undefined || ts < oldestTs) oldestTs = ts\n      if (newestTs === undefined || ts > newestTs) newestTs = ts\n    }\n\n    byCollection.push({\n      name: collectionName,\n      recordCount,\n      bytes,\n      // Spread conditionally — exactOptionalPropertyTypes forbids an\n      // explicit `undefined` on an optional property.\n      ...(oldestTs !== undefined ? { oldestTs } : {}),\n      ...(newestTs !== undefined ? { newestTs } : {}),\n    })\n    totalBytes += bytes\n    totalRecords += recordCount\n  }\n\n  byCollection.sort((a, b) => a.name.localeCompare(b.name))\n\n  return Object.freeze({\n    totalRecords,\n    totalBytes,\n    byCollection,\n    graph,\n    inaccessible,\n    danglingRefs,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,eAAsB,mBACpB,OACA,MAC4B;AAC5B,QAAM,EAAE,SAAS,OAAO,aAAa,IAAI,MAAM,YAAY,OAAO,IAAI;AAEtE,QAAM,EAAE,MAAM,WAAW,QAAQ,IAAI,MAAM,iBAAiB;AAC5D,QAAM,UAAU,IAAI,YAAY;AAEhC,QAAM,eAED,CAAC;AACN,QAAM,eAA0D,CAAC;AACjE,MAAI,aAAa;AACjB,MAAI,eAAe;AAEnB,aAAW,CAAC,gBAAgB,GAAG,KAAK,SAAS;AAC3C,QAAI,QAAQ;AACZ,QAAI;AACJ,QAAI;AACJ,QAAI,cAAc;AAElB,eAAW,MAAM,KAAK;AACpB,YAAM,MAAM,MAAM,QAAQ,IAAI,WAAW,gBAAgB,EAAE;AAC3D,UAAI,CAAC,KAAK;AAGR,qBAAa,KAAK,EAAE,YAAY,gBAAgB,GAAG,CAAC;AACpD;AAAA,MACF;AACA;AACA,eAAS,QAAQ,OAAO,KAAK,UAAU,GAAG,CAAC,EAAE;AAC7C,YAAM,KAAK,IAAI;AACf,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AACxD,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AAAA,IAC1D;AAEA,iBAAa,KAAK;AAAA,MAChB,MAAM;AAAA,MACN;AAAA,MACA;AAAA;AAAA;AAAA,MAGA,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,MAC7C,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,IAC/C,CAAC;AACD,kBAAc;AACd,oBAAgB;AAAA,EAClB;AAEA,eAAa,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAExD,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/by/index.js

@@ -1,8 +1,8 @@
 import {
   isQuorum,
   runDrainBarrier
-} from "../chunk-ZWQFOXBR.js";
-import "../chunk-CU62BBRB.js";
+} from "../chunk-ISMV2QVG.js";
+import "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   isQuorum,

package/dist/cargo/index.js

@@ -1,57 +1,56 @@
 import {
   withCargo
-} from "../chunk-KBBWY46Y.js";
+} from "../chunk-TIGPQDYP.js";
 import {
   CustodyApi,
   NO_CARGO
-} from "../chunk-42KVY3OC.js";
+} from "../chunk-SV6EAJEP.js";
 import {
   createDeedOwner,
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "../chunk-NNWK3PSY.js";
-import "../chunk-GX2BYNCT.js";
-import {
-  diffVault
-} from "../chunk-LB7FD65R.js";
-import "../chunk-OQAODTYR.js";
-import "../chunk-BGIZAFY7.js";
+} from "../chunk-5PFOMHTB.js";
 import {
   fuseRetrieval
 } from "../chunk-AURFOK3D.js";
+import {
+  diffVault
+} from "../chunk-LB7FD65R.js";
+import "../chunk-JFCV5QIK.js";
+import "../chunk-WKGF2TJR.js";
 import {
   isQuorum,
   runDrainBarrier
-} from "../chunk-ZWQFOXBR.js";
-import "../chunk-CJEMA2Z6.js";
-import "../chunk-Q2KVKTC2.js";
-import "../chunk-KNXN47MO.js";
-import "../chunk-6CU3FN74.js";
-import "../chunk-E5AHO65E.js";
+} from "../chunk-ISMV2QVG.js";
+import {
+  groupAndReduce,
+  reduceRecords
+} from "../chunk-TAGR72IR.js";
+import {
+  readPath
+} from "../chunk-IGJCYUT5.js";
+import "../chunk-RFI7GGFO.js";
+import "../chunk-FXZDAV62.js";
+import "../chunk-XUW3PXHU.js";
+import "../chunk-GULTLPFB.js";
+import "../chunk-JVBO4SZL.js";
+import "../chunk-554KLAAN.js";
+import "../chunk-NCCBLYEB.js";
 import {
   generateULID
 } from "../chunk-ZJADGNYF.js";
 import "../chunk-SVLR4POP.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+import "../chunk-W4TCUGQR.js";
+import "../chunk-A4FXFAKF.js";
+import "../chunk-IY23KFNZ.js";
+import "../chunk-N6WF5PKC.js";
+import "../chunk-6HY2X62D.js";
 import "../chunk-LP7BEXCT.js";
 import {
   sha256Hex
-} from "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
-import {
-  groupAndReduce,
-  reduceRecords
-} from "../chunk-2XE6LIXT.js";
-import {
-  readPath
-} from "../chunk-KCG3BHFG.js";
-import "../chunk-3C5CKXFI.js";
-import "../chunk-6G2SCQYS.js";
+} from "../chunk-HOONYZY2.js";
+import "../chunk-VCTXU4AT.js";
 import {
   CargoNotEnabledError,
   CrossShardJoinError,
@@ -63,7 +62,7 @@ import {
   UnknownShardError,
   ValidationError,
   VaultTemplateNotFoundError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   CargoNotEnabledError,

package/dist/chunk-2PCAVW2I.js

@@ -0,0 +1,50 @@
+import {
+  SatelliteConfigError
+} from "./chunk-W2OG6JOL.js";
+
+// src/with-shape/satellites/validate.ts
+function validateSatelliteDeclaration(input) {
+  if (input.baseIsSatellite) {
+    throw new SatelliteConfigError(
+      `R-S3: "${input.satellite}" declares satelliteOf "${input.satelliteOf}", which is itself a satellite \u2014 no satellite-of-satellite chains.`
+    );
+  }
+  if (input.crdtMode) {
+    throw new SatelliteConfigError(
+      `R-S8: crdtMode is refused on either member of a satellite pair in v1 (revert cannot compensate a merge).`
+    );
+  }
+  if (!input.fields || input.fields.length === 0) {
+    throw new SatelliteConfigError(`R-S5: satellite "${input.satellite}" must declare a non-empty fields list.`);
+  }
+  if (input.fields.includes("id")) {
+    throw new SatelliteConfigError(`R-S5: fields must not contain the shared key "id".`);
+  }
+  if (input.joined !== void 0 && (input.joined === input.satellite || input.joined === input.satelliteOf)) {
+    throw new SatelliteConfigError(`R-S5: joined name "${input.joined}" collides with a pair member.`);
+  }
+  if (input.joinedCollidesWithCollection) {
+    throw new SatelliteConfigError(`R-S5: joined name "${input.joined}" collides with an already-declared collection.`);
+  }
+  return Object.freeze({
+    base: input.satelliteOf,
+    satellite: input.satellite,
+    fields: Object.freeze([...input.fields]),
+    joined: input.joined
+  });
+}
+function hashFields(fields) {
+  const s = [...fields].sort().join("");
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16);
+}
+
+export {
+  validateSatelliteDeclaration,
+  hashFields
+};
+//# sourceMappingURL=chunk-2PCAVW2I.js.map

package/dist/chunk-3ELCWU56.js

@@ -0,0 +1,344 @@
+import {
+  DerivationCycleError,
+  MaterializedViewCycleError
+} from "./chunk-W2OG6JOL.js";
+
+// src/kernel/via/graph.ts
+var DEFAULT_POSTURE = { encryptedAtRest: "envelope", queryable: "full", exportable: true, forgettable: false };
+var QUERYABLE_RANK = {
+  none: 0,
+  "det-exact": 1,
+  ordered: 2,
+  full: 3
+};
+function foldPosture(a, b) {
+  return {
+    encryptedAtRest: a.encryptedAtRest === "sealed" || b.encryptedAtRest === "sealed" ? "sealed" : "envelope",
+    queryable: QUERYABLE_RANK[a.queryable] <= QUERYABLE_RANK[b.queryable] ? a.queryable : b.queryable,
+    exportable: a.exportable && b.exportable,
+    forgettable: a.forgettable || b.forgettable
+  };
+}
+function foldWildcardSecurity(base, contributor) {
+  return {
+    encryptedAtRest: base.encryptedAtRest === "sealed" || contributor.encryptedAtRest === "sealed" ? "sealed" : "envelope",
+    queryable: base.queryable,
+    exportable: base.exportable && contributor.exportable,
+    forgettable: base.forgettable || contributor.forgettable
+  };
+}
+var FOLDED_KINDS = /* @__PURE__ */ new Set(["derivation", "rollup", "mv", "overlay"]);
+function isDefaultPosture(p) {
+  return p.encryptedAtRest === DEFAULT_POSTURE.encryptedAtRest && p.queryable === DEFAULT_POSTURE.queryable && p.exportable === DEFAULT_POSTURE.exportable && p.forgettable === DEFAULT_POSTURE.forgettable;
+}
+var SEP = "\0";
+var EMPTY_SET = /* @__PURE__ */ new Set();
+function nodeId(ref) {
+  return `${ref.collection}${SEP}${ref.field}`;
+}
+function displayNodeId(id) {
+  const sep = id.indexOf(SEP);
+  return `${id.slice(0, sep)}.${id.slice(sep + 1)}`;
+}
+var ViaGraph = class {
+  /** Declared source-field postures (registerField), keyed by node id. */
+  _posture = /* @__PURE__ */ new Map();
+  /** Every derived target's registration, keyed by the target's node id. */
+  _in = /* @__PURE__ */ new Map();
+  /** source node id -> derived edges that depend on it (dispatch/erasure), each carrying
+   *  its own registration's `kind` (#678 — see {@link OutEdge}). */
+  _out = /* @__PURE__ */ new Map();
+  /** Memoized effective posture per derived target node id. */
+  _effectiveCache = /* @__PURE__ */ new Map();
+  /** Memoized whole-collection security-axes fold for `'*'` wildcard LEAF nodes (#642),
+   *  keyed by collection name — see {@link _wildcardContribution}. Cleared alongside
+   *  `_effectiveCache` on every `registerField`/`registerDerived` (a later-registered
+   *  field must re-fold on the next read — registration ordering is free). */
+  _wildcardCache = /* @__PURE__ */ new Map();
+  /** Collections with at least one classified field (#638 Task 2 fix wave 2,
+   *  Finding I1 — the reconcile path's combined-state leak guard memory). */
+  _classifiedCollections = /* @__PURE__ */ new Set();
+  /** Computed field names declared with no `deps` entry, per collection
+   *  (Finding I1 — such a field registers no edge when no classified field is
+   *  present yet, so a LATER, separate reconcile call attaching classifiedFields
+   *  still needs to see it regardless of declaration order). */
+  _depslessComputed = /* @__PURE__ */ new Map();
+  /** Declare a source field's posture (money/i18n/classified/plain). Plain fields
+   *  default to `DEFAULT_POSTURE`; a later declaration for the same node wins-first (idempotent). */
+  registerField(collection, field, posture) {
+    const id = nodeId({ collection, field });
+    if (this._posture.has(id)) return;
+    this._posture.set(id, posture);
+    this._effectiveCache.clear();
+    this._wildcardCache.clear();
+  }
+  /** A derived target depends on `sources` (may be cross-collection). `kind`/`grain`
+   *  drive dispatch + erasure semantics; sources drive taint. Re-registering the same
+   *  target replaces `_in` but does not prune stale `_out` edges — callers must
+   *  register each target at most once per graph lifetime. `onDelete`/`keyField` (#650 Task 5)
+   *  are meaningful only for `kind === 'ref'` edges — {@link referencingEdgesOf} reads them back. */
+  registerDerived(target, sources, kind, grain, onDelete, keyField) {
+    const id = nodeId(target);
+    this._in.set(id, {
+      target,
+      sources,
+      kind,
+      grain,
+      ...onDelete !== void 0 ? { onDelete } : {},
+      ...keyField !== void 0 ? { keyField } : {}
+    });
+    for (const source of sources) {
+      const sourceId = nodeId(source);
+      const outEdge = { target, kind };
+      const dependents = this._out.get(sourceId);
+      if (dependents) dependents.push(outEdge);
+      else this._out.set(sourceId, [outEdge]);
+    }
+    this._effectiveCache.clear();
+    this._wildcardCache.clear();
+  }
+  /** Whether `target` already has a registered in-edge — lets a caller skip
+   *  re-registering the same target (#638 Task 2 fix wave 2, Finding I2i:
+   *  `registerDerived`'s at-most-once contract must hold across repeated
+   *  identical `vault.collection()` calls, not just within a single one). */
+  hasDerived(target) {
+    return this._in.has(nodeId(target));
+  }
+  /** Mark/query a collection as having declared at least one classified field. */
+  markClassified(collection) {
+    this._classifiedCollections.add(collection);
+  }
+  isClassified(collection) {
+    return this._classifiedCollections.has(collection);
+  }
+  /** Mark/query a collection's depsless (no declared `deps`) computed
+   *  field names — see `_depslessComputed`'s doc comment above. */
+  markDepslessComputed(collection, field) {
+    let set = this._depslessComputed.get(collection);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._depslessComputed.set(collection, set);
+    }
+    set.add(field);
+  }
+  depslessComputedFields(collection) {
+    return this._depslessComputed.get(collection) ?? EMPTY_SET;
+  }
+  /** Every field name the graph already has memory of for `collection` — from an
+   *  EARLIER, separate `vault.collection()` call (registered postures, derived
+   *  targets, depsless-computed names) — regardless of which via feature declared
+   *  it. #645 — `via/graph-wiring.ts`'s reconcile-path `knownFields` universe
+   *  (`collectKnownFieldNames`) is scoped to THIS call's own options only, so a
+   *  computed field attached in a LATER call whose `deps` correctly names a field
+   *  declared in an EARLIER call was spuriously refused as "unknown"; this method
+   *  lets that call site union in the graph's cross-call memory. Excludes the `'*'`
+   *  wildcard target (an overlay/derivation whole-record fold node, never a real
+   *  record field — see {@link registerDerived}'s doc comment). */
+  knownFieldNames(collection) {
+    const out = /* @__PURE__ */ new Set();
+    const prefix = `${collection}${SEP}`;
+    for (const id of this._posture.keys()) {
+      if (id.startsWith(prefix)) out.add(id.slice(prefix.length));
+    }
+    for (const edge of this._in.values()) {
+      if (edge.target.collection === collection && edge.target.field !== "*") out.add(edge.target.field);
+    }
+    const depsless = this._depslessComputed.get(collection);
+    if (depsless) for (const field of depsless) out.add(field);
+    return out;
+  }
+  /** Reject cycles at declare time (vault open). Throws `DerivationCycleError` for a
+   *  derivation/rollup/computed cycle, `MaterializedViewCycleError` for an MV cycle —
+   *  same classes + message shape the registries throw today (behavior lock). */
+  assertAcyclic() {
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [];
+    const notRefEdge = (entry) => entry.kind !== "ref";
+    const neighboursOf = (id) => {
+      const own = (this._out.get(id) ?? []).filter(notRefEdge).map((entry) => entry.target);
+      const sep = id.indexOf(SEP);
+      if (id.slice(sep + 1) === "*") return own;
+      const wildcard = (this._out.get(`${id.slice(0, sep)}${SEP}*`) ?? []).filter(notRefEdge).map((entry) => entry.target);
+      if (wildcard.length === 0) return own;
+      return [...own, ...wildcard];
+    };
+    const visit = (id) => {
+      const idx = stack.indexOf(id);
+      if (idx !== -1) {
+        const cycle = stack.slice(idx).concat(id);
+        const isMv = cycle.some((cycleId) => this._in.get(cycleId)?.kind === "mv");
+        const path = cycle.map(displayNodeId);
+        if (isMv) throw new MaterializedViewCycleError(path);
+        throw new DerivationCycleError(path);
+      }
+      if (visited.has(id)) return;
+      stack.push(id);
+      for (const dependent of neighboursOf(id)) visit(nodeId(dependent));
+      stack.pop();
+      visited.add(id);
+    };
+    for (const id of this._out.keys()) visit(id);
+  }
+  /** A leaf (non-derived) node's own posture contribution: its declared posture,
+   *  or `DEFAULT_POSTURE` if never declared via `registerField`. */
+  _declaredPosture(id) {
+    return this._posture.get(id) ?? DEFAULT_POSTURE;
+  }
+  /** A node's posture contribution when folded into a dependent: recurse if it is itself
+   *  derived; else its declared/default posture — UNLESS it is a `'*'` LEAF node consumed
+   *  by a folded formula kind (#642, `derivation|rollup|mv|overlay`), in which case it
+   *  contributes its collection's whole-record security fold ({@link _wildcardContribution}).
+   *  `kind` is the CONSUMING edge's kind, threaded from {@link _computeEffective}. `'ref'`
+   *  edges (and the provenance-only untyped call, `kind` left `undefined`) keep `'*'` =
+   *  identity — the phase-D lookup reliance (`via/lookup/registry.ts:392-397`) that a
+   *  referencing field must not seal just because its dimension collection has a classified
+   *  column. */
+  _contribution(id, kind) {
+    const edge = this._in.get(id);
+    if (edge) return this._computeEffective(id, edge);
+    if (kind !== void 0 && FOLDED_KINDS.has(kind) && id.endsWith(`${SEP}*`)) {
+      return this._wildcardContribution(id.slice(0, -2));
+    }
+    return this._declaredPosture(id);
+  }
+  /** Lazy fold (#642) of a collection's REGISTERED field postures on the security axes only
+   *  ({@link foldWildcardSecurity} — sealed-wins encryptedAtRest, AND exportable, OR
+   *  forgettable; queryable stays at DEFAULT_POSTURE's 'full', never folded), seeded at
+   *  DEFAULT_POSTURE. This is the collection-level posture a `'*'` LEAF node contributes to a
+   *  folded-kind formula edge (derivation/rollup/mv/overlay) — see {@link _contribution}. A
+   *  plain (unregistered) field contributes nothing (the identity), so the fold is strictly
+   *  more conservative than deps-based taint and never hits the KNOWN-LIMIT wall (it names no
+   *  fields — seam map §1d). Memoized per collection in `_wildcardCache`. */
+  _wildcardContribution(collection) {
+    const cached = this._wildcardCache.get(collection);
+    if (cached) return cached;
+    let result = DEFAULT_POSTURE;
+    const prefix = `${collection}${SEP}`;
+    for (const [id, posture] of this._posture) {
+      if (!id.startsWith(prefix) || id === `${prefix}*`) continue;
+      result = foldWildcardSecurity(result, posture);
+    }
+    this._wildcardCache.set(collection, result);
+    return result;
+  }
+  _computeEffective(id, edge) {
+    const cached = this._effectiveCache.get(id);
+    if (cached) return cached;
+    let result = DEFAULT_POSTURE;
+    for (const source of edge.sources) {
+      result = foldPosture(result, this._contribution(nodeId(source), edge.kind));
+    }
+    if (edge.grain === "virtual" && result.queryable !== "none") {
+      result = { ...result, queryable: "none" };
+    }
+    this._effectiveCache.set(id, result);
+    return result;
+  }
+  /** Strictest source posture on every axis, per §2. `undefined` when `target` has no
+   *  in-edges (not a derived field). Transitive: folds through chained derivations. */
+  effectivePosture(target) {
+    const id = nodeId(target);
+    const edge = this._in.get(id);
+    if (!edge) return void 0;
+    return this._computeEffective(id, edge);
+  }
+  /** Per-collection { field → effectivePosture } overlay the pipeline consumes (Task 3). */
+  taintedPostures(collection) {
+    const out = /* @__PURE__ */ new Map();
+    for (const edge of this._in.values()) {
+      if (edge.target.collection !== collection) continue;
+      out.set(edge.target.field, this._computeEffective(nodeId(edge.target), edge));
+    }
+    return out;
+  }
+  /** Materialized (`grain !== 'virtual'`) derived fields on `collection` whose effective
+   *  encryptedAtRest resolves to 'sealed' — the taint-seal set (Task 3). #638 Task 7
+   *  makes the `grain !== 'virtual'` filter meaningful: a `computed(fn, { mode: 'virtual' })`
+   *  field is never stored (rides the `present` phase, seam map Part 4's money-Formatted/
+   *  i18n-Label precedent), so it is EXCLUDED here even when its effective `encryptedAtRest`
+   *  folds to `'sealed'` — there is no envelope slot to seal. It still surfaces in
+   *  {@link taintedPostures} (query refusal via `postureFor`'s `queryable` clamp above, and
+   *  export refusal via `exportable`) — only the AT-REST SEALING ACTION is skipped. */
+  taintSealedFields(collection) {
+    const out = /* @__PURE__ */ new Set();
+    for (const edge of this._in.values()) {
+      if (edge.target.collection !== collection || edge.grain === "virtual") continue;
+      const posture = this._computeEffective(nodeId(edge.target), edge);
+      if (posture.encryptedAtRest === "sealed") out.add(edge.target.field);
+    }
+    return out;
+  }
+  /** Fields on `collection` whose registered edge is `grain === 'virtual'` (#638 Task 7) —
+   *  `via/graph-wiring.ts#applyTaintOverlay` intersects this with `exportable === false`
+   *  postures to know which virtual fields need PRESENT-TIME (not just export-time)
+   *  redaction, since a virtual field's value is only ever materialized inside `present()`. */
+  virtualFields(collection) {
+    const out = /* @__PURE__ */ new Set();
+    for (const edge of this._in.values()) {
+      if (edge.target.collection === collection && edge.grain === "virtual") out.add(edge.target.field);
+    }
+    return out;
+  }
+  /** Per-collection { field → immediate source field names that forced its
+   *  effective posture away from `DEFAULT_POSTURE` } — `describe()`'s
+   *  provenance (Task 3). Only the DIRECT declared sources are named (not the
+   *  ultimate origin several hops up a transitive chain); a source absent
+   *  from the result contributed nothing restrictive. */
+  taintProvenance(collection) {
+    const out = /* @__PURE__ */ new Map();
+    for (const edge of this._in.values()) {
+      if (edge.target.collection !== collection) continue;
+      const forcedBy = edge.sources.filter((source) => !isDefaultPosture(this._contribution(nodeId(source)))).map((source) => source.field);
+      if (forcedBy.length > 0) out.set(edge.target.field, forcedBy);
+    }
+    return out;
+  }
+  _targetsDependingOn(collection) {
+    const out = [];
+    for (const edge of this._in.values()) {
+      if (edge.sources.some((source) => source.collection === collection)) {
+        out.push({ target: edge.target, kind: edge.kind, grain: edge.grain });
+      }
+    }
+    return out;
+  }
+  /** Dispatch (Task 4): every derived target triggered by a write to `collection`. Excludes
+   *  `'ref'` edges (#650 Task 5 review, folded Minor) — a `'ref'` edge is consulted only by the
+   *  delete/forget-time restrict/cascade/nullify path ({@link referencingEdgesOf}), never by the
+   *  sync/cutover/restore dispatch wave (`runGraphDispatchWave`); counting it here defeated that
+   *  wave's zero-cost early-continue, costing every write to a referenced backing collection an
+   *  unconditional decrypt + two no-op dispatch passes. {@link derivedArtifactsOf} (erasure
+   *  fanout) still includes `'ref'` edges — the forget path genuinely needs them. */
+  dependentsOf(collection) {
+    return this._targetsDependingOn(collection).filter((edge) => edge.kind !== "ref");
+  }
+  /** Erasure (Task 6): derived artifacts of a forgotten record whose source is `collection`. */
+  derivedArtifactsOf(collection) {
+    return this._targetsDependingOn(collection);
+  }
+  /** Referencing edges pointing AT a backing dimension (delete/forget-time restrict/cascade/
+   *  nullify, #650 Task 5) — an O(1) reverse lookup via the existing `_out` map (keyed at the
+   *  dimension's wildcard `field:'*'` node, the same convention every whole-collection source
+   *  already uses), NEVER a scan across collections or records. `backing` is the collection name
+   *  a lookup field's edge was registered against (a reserved dimension's `_dict_<name>`/
+   *  `_lookup_<name>` collection name, or a matrix dimension's own collection name). */
+  referencingEdgesOf(backing) {
+    const targets = this._out.get(nodeId({ collection: backing, field: "*" }));
+    if (!targets) return [];
+    const out = [];
+    for (const entry of targets) {
+      if (entry.kind !== "ref") continue;
+      const edge = this._in.get(nodeId(entry.target));
+      if (edge?.onDelete !== void 0) {
+        out.push({ referencing: entry.target, onDelete: edge.onDelete, keyField: edge.keyField ?? "id" });
+      }
+    }
+    return out;
+  }
+};
+
+export {
+  DEFAULT_POSTURE,
+  ViaGraph
+};
+//# sourceMappingURL=chunk-3ELCWU56.js.map