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

package/dist/chunk-7BE7ZDVQ.js

@@ -1,722 +0,0 @@
-import {
-  jsonSchemaToFields
-} from "./chunk-VYYM3MEN.js";
-import {
-  derivePersistedSchema,
-  isZod4Schema
-} from "./chunk-URHRIAV6.js";
-import {
-  loadPersistedSchema
-} from "./chunk-WWNYSV7S.js";
-import {
-  isStaticDictDescriptor
-} from "./chunk-TRGTKX5E.js";
-import {
-  DerivationCycleError,
-  MaterializedViewCycleError
-} from "./chunk-7O3Y4PPD.js";
-
-// src/with-shape/introspection/field-meta.ts
-var FieldMetaUnknownFieldError = class extends Error {
-  constructor(collection, key) {
-    super(`fieldMeta for collection "${collection}" references unknown field "${key}". Declare it in the schema/config or remove the fieldMeta entry.`);
-    this.collection = collection;
-    this.key = key;
-    this.name = "FieldMetaUnknownFieldError";
-  }
-  collection;
-  key;
-};
-function validateFieldMetaKeys(collection, fieldMeta, knownFields) {
-  for (const key of Object.keys(fieldMeta)) {
-    if (!knownFields.has(key)) throw new FieldMetaUnknownFieldError(collection, key);
-  }
-}
-function humanizeFieldKey(key) {
-  return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function resolveFieldMeta(key, inputs) {
-  const { channel, zodMeta, inferred } = inputs;
-  const pick = (k) => channel?.[k] ?? zodMeta?.[k] ?? inferred?.[k];
-  const description = pick("description");
-  const semanticType = pick("semanticType");
-  const unit = pick("unit");
-  const sensitivity = pick("sensitivity");
-  const aggregate = pick("aggregate");
-  const aliases = pick("aliases");
-  const displayFor = pick("displayFor");
-  const widget = pick("widget");
-  const group = pick("group");
-  const order = pick("order");
-  return {
-    label: pick("label") ?? humanizeFieldKey(key),
-    ...description !== void 0 ? { description } : {},
-    ...semanticType !== void 0 ? { semanticType } : {},
-    ...unit !== void 0 ? { unit } : {},
-    ...sensitivity !== void 0 ? { sensitivity } : {},
-    ...aggregate !== void 0 ? { aggregate } : {},
-    ...aliases !== void 0 ? { aliases } : {},
-    ...displayFor !== void 0 ? { displayFor } : {},
-    ...widget !== void 0 ? { widget } : {},
-    ...group !== void 0 ? { group } : {},
-    ...order !== void 0 ? { order } : {}
-  };
-}
-
-// src/with-shape/introspection/describe.ts
-var ZOD_META_KEYS = /* @__PURE__ */ new Set([
-  "label",
-  "description",
-  "unit",
-  "semanticType",
-  "sensitivity",
-  "aggregate",
-  "aliases",
-  "displayFor",
-  "group",
-  "order"
-]);
-function schemaFieldKeys(schema) {
-  let s = schema;
-  for (let depth = 0; depth < 10; depth++) {
-    if (s === null || typeof s !== "object") return void 0;
-    const shape = s.shape;
-    if (shape !== null && typeof shape === "object") {
-      const keys = Object.keys(shape);
-      return keys.length > 0 ? keys : void 0;
-    }
-    const def = s._def;
-    if (def?.schema !== void 0 && def.effect?.type === "refinement") {
-      s = def.schema;
-      continue;
-    }
-    return void 0;
-  }
-  return void 0;
-}
-async function deriveZodFields(schema) {
-  const envelope = await derivePersistedSchema(schema);
-  if (!envelope.jsonSchema) return {};
-  const isZod4 = isZod4Schema(schema);
-  const jsonSchema = envelope.jsonSchema;
-  const fieldDescriptors = jsonSchemaToFields(jsonSchema, "live-validator");
-  const propertiesRaw = jsonSchema["properties"];
-  const result = {};
-  for (const [key, descriptor] of Object.entries(fieldDescriptors)) {
-    let meta;
-    if (isZod4 && propertiesRaw) {
-      const prop = propertiesRaw[key];
-      if (prop) {
-        const extracted = {};
-        let hasAny = false;
-        for (const mk of ZOD_META_KEYS) {
-          if (mk in prop) {
-            extracted[mk] = prop[mk];
-            hasAny = true;
-          }
-        }
-        if (hasAny) meta = extracted;
-      }
-    }
-    result[key] = {
-      type: descriptor.type,
-      optional: descriptor.optional === true,
-      ...descriptor.constraints !== void 0 ? { constraints: descriptor.constraints } : {},
-      ...meta !== void 0 ? { meta } : {}
-    };
-  }
-  return result;
-}
-async function resolveDescribeFieldIds(store, vaultName, collectionName, getDEK) {
-  let dek;
-  try {
-    dek = await getDEK(collectionName);
-  } catch {
-    return {};
-  }
-  const persisted = await loadPersistedSchema(store, vaultName, collectionName, dek);
-  return persisted?.fieldIds !== void 0 ? { fieldIds: persisted.fieldIds } : {};
-}
-function deriveWidget(opts) {
-  if (opts.resolvedWidget !== void 0) return opts.resolvedWidget;
-  switch (opts.semanticType) {
-    case "date":
-    case "datetime":
-      return "date";
-    case "currency":
-      return "money";
-    case "entity":
-      return "ref-select";
-    case "url":
-      return "url";
-    case "email":
-      return "email";
-    case "percent":
-      return "number";
-  }
-  if (opts.dict !== void 0 || opts.lookup !== void 0) return "select";
-  if (opts.blob !== void 0) return "file";
-  if (opts.type === "boolean") return "checkbox";
-  if (opts.type === "number") return "number";
-  return "text";
-}
-function buildDescription(input) {
-  const { collection, fieldMeta, moneyFields, dictKeyFields, lookupFields, computed, refs, zodFields, schema, dictLabels, meta, i18nFields, classified, taint, fieldIds } = input;
-  const lookupFragments = input.viaFragments?.["lookup"]?.lookupFields;
-  const blobFragments = input.viaFragments?.["blob"]?.blobFields;
-  const validatorKeys = zodFields !== void 0 && Object.keys(zodFields).length > 0 ? Object.keys(zodFields) : schemaFieldKeys(schema);
-  const canEnumerateFields = validatorKeys !== void 0;
-  if (canEnumerateFields && fieldMeta !== void 0) {
-    const knownFields = /* @__PURE__ */ new Set([
-      ...Object.keys(moneyFields ?? {}),
-      ...Object.keys(dictKeyFields ?? {}),
-      ...Object.keys(refs),
-      ...Object.keys(computed ?? {}),
-      ...validatorKeys ?? [],
-      ...Object.keys(i18nFields ?? {}),
-      ...Object.keys(lookupFields ?? {}),
-      ...Object.keys(blobFragments ?? {}),
-      ...Object.keys(classified ?? {})
-    ]);
-    validateFieldMetaKeys(collection, fieldMeta, knownFields);
-  }
-  const allKeys = /* @__PURE__ */ new Set([
-    ...Object.keys(moneyFields ?? {}),
-    ...Object.keys(dictKeyFields ?? {}),
-    ...Object.keys(lookupFields ?? {}),
-    ...Object.keys(refs),
-    ...Object.keys(computed ?? {}),
-    ...Object.keys(fieldMeta ?? {}),
-    ...Object.keys(zodFields ?? {}),
-    ...Object.keys(i18nFields ?? {}),
-    ...Object.keys(classified ?? {}),
-    ...Object.keys(blobFragments ?? {})
-  ]);
-  const fields = [];
-  for (const key of [...allKeys].sort()) {
-    const zod = zodFields?.[key];
-    const money = moneyFields?.[key];
-    const dict = dictKeyFields?.[key];
-    const lookupDesc = lookupFields?.[key];
-    const refDesc = refs[key];
-    const isComputed = computed !== void 0 && key in computed;
-    const i18nDesc = i18nFields?.[key];
-    const cls = classified?.[key];
-    const blobFragmentEntry = blobFragments?.[key];
-    const taintPosture = taint?.postures.get(key);
-    let type = zod?.type ?? "unknown";
-    const inferred = {};
-    let moneyBlock;
-    let dictBlock;
-    let refBlock;
-    let lookupBlock;
-    let blobBlock;
-    if (money) {
-      type = "number";
-      inferred.semanticType = "currency";
-      inferred.aggregate = "sum";
-      const currency = money.soleCurrency();
-      const scale = currency !== void 0 ? money.scaleFor(currency) : void 0;
-      moneyBlock = {
-        mode: money.mode,
-        ...currency !== void 0 ? { currency } : {},
-        ...scale !== void 0 ? { scale } : {},
-        ...money.rounding !== void 0 ? { rounding: money.rounding } : {}
-      };
-    } else if (refDesc) {
-      type = refDesc.isArray ? "array" : "string";
-      inferred.semanticType = "entity";
-      refBlock = {
-        target: refDesc.target,
-        mode: refDesc.mode,
-        ...refDesc.isArray ? { isArray: true } : {}
-      };
-    } else if (dict) {
-      type = "enum";
-      if (isStaticDictDescriptor(dict)) {
-        const displayLocale = dict.displayLocale;
-        const values = dict.keys.map((k) => {
-          const localeMap = dict.table[k];
-          const label = displayLocale !== void 0 ? localeMap?.[displayLocale] ?? void 0 : void 0;
-          return label !== void 0 ? { value: k, label } : { value: k };
-        });
-        dictBlock = { name: dict.name, static: true, values };
-      } else {
-        const labelMap = dictLabels?.[dict.name];
-        const labelMapHasEntries = labelMap !== void 0 && Object.keys(labelMap).length > 0;
-        if (labelMapHasEntries) {
-          const values = Object.entries(labelMap).map(([value, label]) => ({ value, label }));
-          dictBlock = { name: dict.name, static: false, values };
-        } else if (dict.keys !== void 0) {
-          const values = dict.keys.map((k) => {
-            const label = dict.labels?.[k];
-            return label !== void 0 ? { value: k, label } : { value: k };
-          });
-          dictBlock = { name: dict.name, static: false, values };
-        } else {
-          dictBlock = { name: dict.name, static: false };
-        }
-      }
-    } else if (lookupDesc) {
-      type = "enum";
-      const lookupLabelMap = dictLabels?.[lookupDesc.dimension];
-      const lookupLabelMapHasEntries = lookupLabelMap !== void 0 && Object.keys(lookupLabelMap).length > 0;
-      if (lookupDesc.table !== void 0) {
-        const displayLocale = lookupDesc.displayLocale;
-        const table = lookupDesc.table;
-        const values = (lookupDesc.keys ?? Object.keys(table)).map((k) => {
-          const localeMap = table[k];
-          const label = displayLocale !== void 0 ? localeMap?.[displayLocale] ?? void 0 : void 0;
-          return label !== void 0 ? { value: k, label } : { value: k };
-        });
-        dictBlock = { name: lookupDesc.dimension, static: true, values };
-      } else if (lookupLabelMapHasEntries) {
-        const values = Object.entries(lookupLabelMap).map(([value, label]) => ({ value, label }));
-        dictBlock = { name: lookupDesc.dimension, static: false, values };
-      } else if (lookupDesc.keys !== void 0) {
-        const values = lookupDesc.keys.map((k) => {
-          const label = lookupDesc.labels?.[k];
-          return label !== void 0 ? { value: k, label } : { value: k };
-        });
-        dictBlock = { name: lookupDesc.dimension, static: false, values };
-      } else {
-        dictBlock = { name: lookupDesc.dimension, static: false };
-      }
-    } else if (i18nDesc) {
-      type = "string";
-    } else if (isComputed) {
-    } else if (blobFragmentEntry !== void 0) {
-      type = "blob";
-      blobBlock = { ...blobFragmentEntry, queryable: "none" };
-    }
-    const lookupFragmentEntry = lookupFragments?.[key];
-    if (lookupFragmentEntry !== void 0) {
-      lookupBlock = {
-        ...lookupFragmentEntry.dimension !== void 0 ? { dimension: lookupFragmentEntry.dimension } : {},
-        backing: lookupFragmentEntry.backing,
-        vocabulary: lookupFragmentEntry.vocabulary,
-        key: lookupFragmentEntry.key,
-        onDelete: lookupFragmentEntry.onDelete,
-        ...lookupFragmentEntry.altKeys !== void 0 ? { altKeys: lookupFragmentEntry.altKeys } : {},
-        ...lookupFragmentEntry.present !== void 0 ? { present: lookupFragmentEntry.present } : {},
-        ...lookupFragmentEntry.sortBy !== void 0 ? { sortBy: lookupFragmentEntry.sortBy } : {},
-        ...lookupFragmentEntry.keys !== void 0 ? { keys: lookupFragmentEntry.keys } : {}
-      };
-    }
-    if (cls !== void 0) inferred.sensitivity = cls.sensitivity;
-    const channelEntry = fieldMeta?.[key];
-    const zodMeta = zod?.meta;
-    const resolved = resolveFieldMeta(key, {
-      ...channelEntry !== void 0 ? { channel: channelEntry } : {},
-      ...zodMeta !== void 0 ? { zodMeta } : {},
-      inferred
-    });
-    let i18nBlock;
-    if (i18nDesc !== void 0) {
-      const locales = i18nDesc.options.languages;
-      const densify = i18nDesc.options.densifyOnWrite;
-      i18nBlock = {
-        ...locales !== void 0 ? { locales } : {},
-        ...densify !== void 0 ? { densify } : {}
-      };
-    }
-    const widget = deriveWidget({
-      type,
-      ...resolved.semanticType !== void 0 ? { semanticType: resolved.semanticType } : {},
-      ...dictBlock !== void 0 ? { dict: dictBlock } : {},
-      ...lookupBlock !== void 0 ? { lookup: lookupBlock } : {},
-      ...blobBlock !== void 0 ? { blob: blobBlock } : {},
-      ...resolved.widget !== void 0 ? { resolvedWidget: resolved.widget } : {}
-    });
-    const editable = !isComputed && key !== "id" && blobBlock === void 0;
-    const field = {
-      key,
-      ...fieldIds?.[key] !== void 0 ? { id: fieldIds[key] } : {},
-      type,
-      optional: zod?.optional ?? false,
-      ...zod?.constraints !== void 0 ? { constraints: zod.constraints } : {},
-      label: resolved.label,
-      ...resolved.description !== void 0 ? { description: resolved.description } : {},
-      ...resolved.group !== void 0 ? { group: resolved.group } : {},
-      ...resolved.order !== void 0 ? { order: resolved.order } : {},
-      ...resolved.semanticType !== void 0 ? { semanticType: resolved.semanticType } : {},
-      ...resolved.unit !== void 0 ? { unit: resolved.unit } : {},
-      ...resolved.sensitivity !== void 0 ? { sensitivity: resolved.sensitivity } : {},
-      ...resolved.aggregate !== void 0 ? { aggregate: resolved.aggregate } : {},
-      ...resolved.aliases !== void 0 ? { aliases: resolved.aliases } : {},
-      ...resolved.displayFor !== void 0 ? { displayFor: resolved.displayFor } : {},
-      ...refBlock !== void 0 ? { ref: refBlock } : {},
-      ...moneyBlock !== void 0 ? { money: moneyBlock } : {},
-      ...dictBlock !== void 0 ? { dict: dictBlock } : {},
-      ...lookupBlock !== void 0 ? { lookup: lookupBlock } : {},
-      ...blobBlock !== void 0 ? { blob: blobBlock } : {},
-      ...isComputed ? { computed: true } : {},
-      ...i18nBlock !== void 0 ? { i18n: i18nBlock } : {},
-      widget,
-      editable,
-      ...cls !== void 0 ? {
-        classified: {
-          preset: cls.preset,
-          storage: cls.storage,
-          list: cls.list.kind === "omit" ? "omit" : cls.list.kind === "mask" ? { mask: cls.list.pattern } : { rider: cls.list.rider },
-          ...cls.equatable === true ? { equatable: true } : {}
-        }
-      } : {},
-      ...taintPosture !== void 0 ? { taint: { posture: taintPosture, forcedBy: taint?.provenance?.get(key) ?? [] } } : {}
-    };
-    fields.push(field);
-  }
-  const collectionMeta = {
-    ...meta,
-    label: meta?.label ?? humanizeFieldKey(collection)
-  };
-  return {
-    collection,
-    fields,
-    meta: collectionMeta
-  };
-}
-
-// 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 {
-  schemaFieldKeys,
-  deriveZodFields,
-  resolveDescribeFieldIds,
-  buildDescription,
-  DEFAULT_POSTURE,
-  ViaGraph
-};
-//# sourceMappingURL=chunk-7BE7ZDVQ.js.map