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

package/dist/chunk-KHKKD62N.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/with-shape/introspection/fields.ts","../src/with-shape/introspection/derivation-key.ts"],"sourcesContent":["/**\n * Map a JSON Schema (Draft 2020-12 produced by `zod-to-json-schema`) into\n * the {@link FieldDescriptor} map consumed by {@link VaultSchemaSnapshot}.\n *\n * Used by both the persisted-schema path (decrypted envelope body) and the\n * live-validator path (in-process derivation).\n *\n * @module\n */\n\nimport type { FieldDescriptor, FieldSource } from './types.js'\n\ninterface JsonSchemaShape {\n  type?: string | string[]\n  properties?: Record<string, JsonSchemaShape>\n  required?: string[]\n  enum?: unknown[]\n  const?: unknown\n  minLength?: number\n  maxLength?: number\n  pattern?: string\n  minimum?: number\n  maximum?: number\n  exclusiveMinimum?: number\n  exclusiveMaximum?: number\n  format?: string\n  items?: JsonSchemaShape\n  oneOf?: JsonSchemaShape[]\n  anyOf?: JsonSchemaShape[]\n}\n\nfunction jsonSchemaType(node: JsonSchemaShape): string {\n  if (Array.isArray(node.type)) {\n    const non = node.type.filter((t) => t !== 'null')\n    return non[0] ?? 'opaque'\n  }\n  if (node.enum && Array.isArray(node.enum)) return 'enum'\n  // JSON Schema `const` is used by zod-to-json-schema for z.literal(...)\n  if (node.const !== undefined) return 'enum'\n  if (typeof node.type === 'string') return node.type\n  return 'opaque'\n}\n\n// #657 — zod v4's native `toJSONSchema()` injects a ±Number.MAX_SAFE_INTEGER\n// bound on every `.int()` field (a JS-safe-integer representability fact,\n// not authored validation intent — `type: 'integer'` already carries it).\n// Empirically verified: `z.number().int()` → `{type:'integer', minimum:\n// -9007199254740991, maximum:9007199254740991}`, and — critically — zod\n// emits NO metadata distinguishing that derived bound from an authored one\n// at the exact same value (`z.number().min(-9007199254740991)\n// .max(9007199254740991)` on a plain, non-int number produces a\n// byte-identical minimum/maximum). Without that distinguishing signal, a\n// value-based filter gated on `type === 'integer'` is the pragmatic call:\n// it never touches a non-int field's authored bound (whatever its value),\n// and an authored `.int().min(Number.MAX_SAFE_INTEGER)` is pathological\n// either way, so folding it into the same omission is an acceptable trade.\nfunction isIntSentinel(node: JsonSchemaShape, value: number): boolean {\n  return node.type === 'integer' && Math.abs(value) === Number.MAX_SAFE_INTEGER\n}\n\nfunction constraintsFor(node: JsonSchemaShape): Record<string, unknown> | undefined {\n  const out: Record<string, unknown> = {}\n  if (node.enum) out.values = node.enum\n  // JSON Schema `const` (used by zod-to-json-schema for z.literal) — treat like a single-value enum\n  if (node.const !== undefined) out.values = [node.const]\n  if (node.minLength !== undefined) out.minLength = node.minLength\n  if (node.maxLength !== undefined) out.maxLength = node.maxLength\n  if (node.pattern !== undefined) out.pattern = node.pattern\n  if (node.format !== undefined) out.format = node.format\n  if (node.minimum !== undefined && !isIntSentinel(node, node.minimum)) out.minimum = node.minimum\n  if (node.maximum !== undefined && !isIntSentinel(node, node.maximum)) out.maximum = node.maximum\n  if (node.exclusiveMinimum !== undefined) out.gt = node.exclusiveMinimum\n  if (node.exclusiveMaximum !== undefined) out.lt = node.exclusiveMaximum\n  return Object.keys(out).length === 0 ? undefined : out\n}\n\n/**\n * Extract fields from a single JSON Schema object node (must have `properties`).\n * Used by both the plain-object path and the per-member extraction in the union path.\n */\nfunction extractObjectFields(\n  obj: JsonSchemaShape,\n  source: FieldSource,\n  refs?: Record<string, { target: string; mode: string }>,\n): { fields: Record<string, FieldDescriptor>; required: Set<string> } {\n  const required = new Set(Array.isArray(obj.required) ? obj.required : [])\n  const fields: Record<string, FieldDescriptor> = {}\n  if (!obj.properties || typeof obj.properties !== 'object') return { fields, required }\n\n  for (const [name, node] of Object.entries(obj.properties)) {\n    const descriptor: FieldDescriptor = {\n      type: jsonSchemaType(node),\n      source,\n      ...(required.has(name) ? {} : { optional: true }),\n      ...(refs?.[name] ? { references: `${refs[name].target}.id` } : {}),\n    }\n    const constraints = constraintsFor(node)\n    if (constraints) (descriptor as { constraints?: Record<string, unknown> }).constraints = constraints\n    fields[name] = descriptor\n  }\n\n  return { fields, required }\n}\n\n/**\n * Merge field descriptors from multiple union members.\n *\n * Merge rules:\n * - Emit the UNION of all field names so no member's fields are hidden.\n * - A field is required (optional=false/absent) only when it is required in\n *   EVERY member; otherwise it is marked optional=true.\n * - For the discriminator field (appears in every member with a `const` value),\n *   collect the const values from all members and surface them as constraints.values\n *   so the caller can see the full literal set.\n * - For conflicting types across members, first-seen wins.\n */\nfunction mergeUnionMembers(\n  members: JsonSchemaShape[],\n  source: FieldSource,\n  refs?: Record<string, { target: string; mode: string }>,\n): Record<string, FieldDescriptor> {\n  if (members.length === 0) return {}\n\n  // Extract per-member fields + required sets\n  const extracted = members\n    .filter((m) => m.properties && typeof m.properties === 'object')\n    .map((m) => extractObjectFields(m, source, refs))\n\n  if (extracted.length === 0) return {}\n\n  // Collect all field names across all members\n  const allNames = new Set<string>()\n  for (const { fields } of extracted) {\n    for (const name of Object.keys(fields)) allNames.add(name)\n  }\n\n  const memberCount = extracted.length\n  const out: Record<string, FieldDescriptor> = {}\n\n  for (const name of allNames) {\n    // Which members contain this field?\n    const presentIn = extracted.filter(({ fields }) => name in fields)\n    const requiredInAll = presentIn.length === memberCount\n      && presentIn.every(({ required }) => required.has(name))\n\n    // Use first-seen descriptor as the base (presentIn is always non-empty here since\n    // we iterate names that appeared in at least one member's fields)\n    const base = presentIn[0]!.fields[name]!\n\n    // For discriminator-like fields: collect const/enum values across all members\n    // to surface the full literal set in constraints.values\n    const allValues: unknown[] = []\n    for (const { fields } of presentIn) {\n      const fd = fields[name]\n      if (fd?.constraints?.values && Array.isArray(fd.constraints.values)) {\n        for (const v of fd.constraints.values) {\n          if (!allValues.includes(v)) allValues.push(v)\n        }\n      }\n    }\n\n    const mergedConstraints: Record<string, unknown> | undefined =\n      allValues.length > 0\n        ? { ...(base.constraints ?? {}), values: allValues }\n        : base.constraints\n\n    const descriptor: FieldDescriptor = {\n      type: base.type,\n      source,\n      ...(requiredInAll ? {} : { optional: true }),\n      ...(base.references ? { references: base.references } : {}),\n    }\n    if (mergedConstraints) {\n      (descriptor as { constraints?: Record<string, unknown> }).constraints = mergedConstraints\n    }\n    out[name] = descriptor\n  }\n\n  return out\n}\n\nexport function jsonSchemaToFields(\n  jsonSchema: unknown,\n  source: FieldSource,\n  refs?: Record<string, { target: string; mode: string }>,\n): Record<string, FieldDescriptor> {\n  if (!jsonSchema || typeof jsonSchema !== 'object') return {}\n  const root = jsonSchema as JsonSchemaShape\n\n  // Handle discriminated unions: zod-to-json-schema emits anyOf/oneOf for z.discriminatedUnion\n  const unionMembers = root.anyOf ?? root.oneOf\n  if (Array.isArray(unionMembers) && unionMembers.length > 0) {\n    return mergeUnionMembers(unionMembers, source, refs)\n  }\n\n  if (!root.properties || typeof root.properties !== 'object') return {}\n\n  const { fields } = extractObjectFields(root, source, refs)\n  return fields\n}\n","/**\n * The deterministic fallback key for an UNNAMED derivation, shared by\n * `dumpSchema`'s `describeDerivations` (walk.ts) and `listBehaviors`'s\n * `buildDerivationEntries` (behaviors.ts) so the two surfaces always key the\n * same unnamed derivation identically.\n *\n * Base key = the derivation's output-collection names, sorted and joined by\n * `+` (or `source` when it has no outputs). On collision with any key already\n * assigned in this enumeration (named or fallback, passed in `used`), a\n * deterministic `#occurrence` suffix is appended (`base`, `base#1`, `base#2`, …)\n * so two derivations with the same output set both appear.\n *\n * Takes the already-extracted output-collection list + source (rather than a\n * `DerivationSpec`) so both the typed builder and walk.ts's duck-typed registry\n * walk can call it without a shared concrete type.\n */\nexport function fallbackDerivationName(\n  outputCollections: readonly string[],\n  source: string,\n  used: ReadonlySet<string>,\n): string {\n  const base = outputCollections.length > 0 ? [...outputCollections].sort().join('+') : source\n  if (!used.has(base)) return base\n  let occurrence = 1\n  let candidate = `${base}#${occurrence}`\n  while (used.has(candidate)) {\n    occurrence++\n    candidate = `${base}#${occurrence}`\n  }\n  return candidate\n}\n"],"mappings":";AA+BA,SAAS,eAAe,MAA+B;AACrD,MAAI,MAAM,QAAQ,KAAK,IAAI,GAAG;AAC5B,UAAM,MAAM,KAAK,KAAK,OAAO,CAAC,MAAM,MAAM,MAAM;AAChD,WAAO,IAAI,CAAC,KAAK;AAAA,EACnB;AACA,MAAI,KAAK,QAAQ,MAAM,QAAQ,KAAK,IAAI,EAAG,QAAO;AAElD,MAAI,KAAK,UAAU,OAAW,QAAO;AACrC,MAAI,OAAO,KAAK,SAAS,SAAU,QAAO,KAAK;AAC/C,SAAO;AACT;AAeA,SAAS,cAAc,MAAuB,OAAwB;AACpE,SAAO,KAAK,SAAS,aAAa,KAAK,IAAI,KAAK,MAAM,OAAO;AAC/D;AAEA,SAAS,eAAe,MAA4D;AAClF,QAAM,MAA+B,CAAC;AACtC,MAAI,KAAK,KAAM,KAAI,SAAS,KAAK;AAEjC,MAAI,KAAK,UAAU,OAAW,KAAI,SAAS,CAAC,KAAK,KAAK;AACtD,MAAI,KAAK,cAAc,OAAW,KAAI,YAAY,KAAK;AACvD,MAAI,KAAK,cAAc,OAAW,KAAI,YAAY,KAAK;AACvD,MAAI,KAAK,YAAY,OAAW,KAAI,UAAU,KAAK;AACnD,MAAI,KAAK,WAAW,OAAW,KAAI,SAAS,KAAK;AACjD,MAAI,KAAK,YAAY,UAAa,CAAC,cAAc,MAAM,KAAK,OAAO,EAAG,KAAI,UAAU,KAAK;AACzF,MAAI,KAAK,YAAY,UAAa,CAAC,cAAc,MAAM,KAAK,OAAO,EAAG,KAAI,UAAU,KAAK;AACzF,MAAI,KAAK,qBAAqB,OAAW,KAAI,KAAK,KAAK;AACvD,MAAI,KAAK,qBAAqB,OAAW,KAAI,KAAK,KAAK;AACvD,SAAO,OAAO,KAAK,GAAG,EAAE,WAAW,IAAI,SAAY;AACrD;AAMA,SAAS,oBACP,KACA,QACA,MACoE;AACpE,QAAM,WAAW,IAAI,IAAI,MAAM,QAAQ,IAAI,QAAQ,IAAI,IAAI,WAAW,CAAC,CAAC;AACxE,QAAM,SAA0C,CAAC;AACjD,MAAI,CAAC,IAAI,cAAc,OAAO,IAAI,eAAe,SAAU,QAAO,EAAE,QAAQ,SAAS;AAErF,aAAW,CAAC,MAAM,IAAI,KAAK,OAAO,QAAQ,IAAI,UAAU,GAAG;AACzD,UAAM,aAA8B;AAAA,MAClC,MAAM,eAAe,IAAI;AAAA,MACzB;AAAA,MACA,GAAI,SAAS,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,UAAU,KAAK;AAAA,MAC/C,GAAI,OAAO,IAAI,IAAI,EAAE,YAAY,GAAG,KAAK,IAAI,EAAE,MAAM,MAAM,IAAI,CAAC;AAAA,IAClE;AACA,UAAM,cAAc,eAAe,IAAI;AACvC,QAAI,YAAa,CAAC,WAAyD,cAAc;AACzF,WAAO,IAAI,IAAI;AAAA,EACjB;AAEA,SAAO,EAAE,QAAQ,SAAS;AAC5B;AAcA,SAAS,kBACP,SACA,QACA,MACiC;AACjC,MAAI,QAAQ,WAAW,EAAG,QAAO,CAAC;AAGlC,QAAM,YAAY,QACf,OAAO,CAAC,MAAM,EAAE,cAAc,OAAO,EAAE,eAAe,QAAQ,EAC9D,IAAI,CAAC,MAAM,oBAAoB,GAAG,QAAQ,IAAI,CAAC;AAElD,MAAI,UAAU,WAAW,EAAG,QAAO,CAAC;AAGpC,QAAM,WAAW,oBAAI,IAAY;AACjC,aAAW,EAAE,OAAO,KAAK,WAAW;AAClC,eAAW,QAAQ,OAAO,KAAK,MAAM,EAAG,UAAS,IAAI,IAAI;AAAA,EAC3D;AAEA,QAAM,cAAc,UAAU;AAC9B,QAAM,MAAuC,CAAC;AAE9C,aAAW,QAAQ,UAAU;AAE3B,UAAM,YAAY,UAAU,OAAO,CAAC,EAAE,OAAO,MAAM,QAAQ,MAAM;AACjE,UAAM,gBAAgB,UAAU,WAAW,eACtC,UAAU,MAAM,CAAC,EAAE,SAAS,MAAM,SAAS,IAAI,IAAI,CAAC;AAIzD,UAAM,OAAO,UAAU,CAAC,EAAG,OAAO,IAAI;AAItC,UAAM,YAAuB,CAAC;AAC9B,eAAW,EAAE,OAAO,KAAK,WAAW;AAClC,YAAM,KAAK,OAAO,IAAI;AACtB,UAAI,IAAI,aAAa,UAAU,MAAM,QAAQ,GAAG,YAAY,MAAM,GAAG;AACnE,mBAAW,KAAK,GAAG,YAAY,QAAQ;AACrC,cAAI,CAAC,UAAU,SAAS,CAAC,EAAG,WAAU,KAAK,CAAC;AAAA,QAC9C;AAAA,MACF;AAAA,IACF;AAEA,UAAM,oBACJ,UAAU,SAAS,IACf,EAAE,GAAI,KAAK,eAAe,CAAC,GAAI,QAAQ,UAAU,IACjD,KAAK;AAEX,UAAM,aAA8B;AAAA,MAClC,MAAM,KAAK;AAAA,MACX;AAAA,MACA,GAAI,gBAAgB,CAAC,IAAI,EAAE,UAAU,KAAK;AAAA,MAC1C,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,IAC3D;AACA,QAAI,mBAAmB;AACrB,MAAC,WAAyD,cAAc;AAAA,IAC1E;AACA,QAAI,IAAI,IAAI;AAAA,EACd;AAEA,SAAO;AACT;AAEO,SAAS,mBACd,YACA,QACA,MACiC;AACjC,MAAI,CAAC,cAAc,OAAO,eAAe,SAAU,QAAO,CAAC;AAC3D,QAAM,OAAO;AAGb,QAAM,eAAe,KAAK,SAAS,KAAK;AACxC,MAAI,MAAM,QAAQ,YAAY,KAAK,aAAa,SAAS,GAAG;AAC1D,WAAO,kBAAkB,cAAc,QAAQ,IAAI;AAAA,EACrD;AAEA,MAAI,CAAC,KAAK,cAAc,OAAO,KAAK,eAAe,SAAU,QAAO,CAAC;AAErE,QAAM,EAAE,OAAO,IAAI,oBAAoB,MAAM,QAAQ,IAAI;AACzD,SAAO;AACT;;;ACvLO,SAAS,uBACd,mBACA,QACA,MACQ;AACR,QAAM,OAAO,kBAAkB,SAAS,IAAI,CAAC,GAAG,iBAAiB,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;AACtF,MAAI,CAAC,KAAK,IAAI,IAAI,EAAG,QAAO;AAC5B,MAAI,aAAa;AACjB,MAAI,YAAY,GAAG,IAAI,IAAI,UAAU;AACrC,SAAO,KAAK,IAAI,SAAS,GAAG;AAC1B;AACA,gBAAY,GAAG,IAAI,IAAI,UAAU;AAAA,EACnC;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-OEA5NVSU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/with-formula/derivations/strategy-hash.ts","../src/with-formula/derivations/registry.ts"],"sourcesContent":["/**\n * Deterministic hash of a derivation strategy's \"shape\": source\n * collection, declared sibling sources, output keys, derive function\n * source. Used to detect\n * strategy drift: a record whose `_derivedFrom.strategyHash` doesn't\n * match the current strategy is considered stale.\n *\n * Web Crypto SHA-256 — no extra deps.\n */\nimport { sha256Hex } from '../../kernel/enclave/index.js'\n\nexport async function computeStrategyHash(\n  source: string,\n  outputKeys: readonly string[],\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  derive: (...args: any[]) => any,\n  sources?: ReadonlyArray<string>,\n): Promise<string> {\n  const canonical = JSON.stringify({\n    source,\n    outputs: [...outputKeys].sort(),\n    derive: derive.toString(),\n    // Declared sibling sources — adding/removing a trigger\n    // collection invalidates cached derived records. Omitted when empty\n    // so strategies without siblings keep their existing hash.\n    ...(sources?.length ? { sources: [...sources].sort() } : {}),\n  })\n  const bytes = new TextEncoder().encode(canonical)\n  return sha256Hex(bytes)\n}\n","import { DerivationCycleError, DuplicateBehaviorNameError } from '../../kernel/errors.js'\nimport { ViaGraph, type FieldRef, type EdgeKind, type Grain } from '../../kernel/via/graph.js'\nimport { computeStrategyHash } from './strategy-hash.js'\nimport type { DerivationSpec } from './types.js'\n\n/**\n * Whole-record artifact-grain field marker (#638 Task 2). A derivation's\n * `derive()`/a rollup's `compute()` reads the WHOLE source record — there is\n * no single declared field to point at — so a trigger/output collection is\n * modelled as one artifact node per collection (`kernel/via/graph.ts`'s\n * \"Artifact-grain targets... modelled as a field node whose field is the\n * artifact key\" convention). MUST match `materialized-views/registry.ts`'s\n * and `vault.ts`'s overlay-edge marker so cross-registry edges (a derivation\n * feeding into / out of an MV or overlay collection) resolve to the SAME\n * graph node.\n */\nconst WHOLE_RECORD = '*'\n\n/** Strip this registry's `.${WHOLE_RECORD}` artifact suffix off a graph cycle\n *  path entry, recovering the bare collection name — preserves the exact\n *  pre-#638 `DerivationCycleError` message shape (behavior lock) for a pure\n *  record-shape derivation cycle. A rollup's real-field target (not suffixed\n *  `.${WHOLE_RECORD}`) is left untouched. */\nfunction stripArtifactSuffix(displayId: string): string {\n  const suffix = `.${WHOLE_RECORD}`\n  return displayId.endsWith(suffix) ? displayId.slice(0, -suffix.length) : displayId\n}\n\ninterface RegisteredStrategy {\n  // Type-erased to allow the registry to hold heterogeneous strategies.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  spec: DerivationSpec<any, any>\n  strategyHash: string\n}\n\n/**\n * Vault-internal registry of derivation strategies. Owned by `Vault`;\n * not exported.\n *\n * @internal\n */\nexport class DerivationRegistry {\n  private readonly _bySource = new Map<string, RegisteredStrategy[]>()\n  private readonly _byOutput = new Map<string, RegisteredStrategy[]>()\n  private readonly _byName = new Map<string, RegisteredStrategy>()\n\n  /**\n   * Register a derivation strategy. If `spec.name` is given and already\n   * registered by another derivation in this vault, throws\n   * {@link DuplicateBehaviorNameError} before indexing.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  async register(spec: DerivationSpec<any, any>): Promise<void> {\n    if (spec.name !== undefined && this._byName.has(spec.name)) {\n      throw new DuplicateBehaviorNameError(spec.name, 'derivation')\n    }\n\n    const outputKeys = Object.keys(spec.outputs)\n    const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources)\n    const reg: RegisteredStrategy = { spec, strategyHash }\n\n    if (spec.name !== undefined) this._byName.set(spec.name, reg)\n\n    const fromSource = this._bySource.get(spec.source)\n    if (fromSource) fromSource.push(reg)\n    else this._bySource.set(spec.source, [reg])\n\n    // Declared sibling sources index the SAME `reg` under each\n    // extra collection so `strategiesForSource(extra)` returns it and a\n    // sibling write re-fires the derivation. Sibling keys also enter\n    // `_bySource`, so `validate()`'s cycle DFS walks them automatically.\n    for (const extra of spec.sources ?? []) {\n      const fromExtra = this._bySource.get(extra)\n      if (fromExtra) fromExtra.push(reg)\n      else this._bySource.set(extra, [reg])\n    }\n\n    // FK triggers index the SAME `reg` under each parent collection so\n    // a parent write re-fires the derivation (fanned out to matching source\n    // records in `dispatchDerivations`). Like sources[], these keys enter\n    // `_bySource` so the cycle DFS walks the trigger→output edge.\n    for (const t of spec.triggerBy ?? []) {\n      const fromTrigger = this._bySource.get(t.collection)\n      if (fromTrigger) fromTrigger.push(reg)\n      else this._bySource.set(t.collection, [reg])\n    }\n\n    // Rollup: a write to the child `from` collection recomputes\n    // the parent (= spec.source = into) at id child[key]. Index under `from`\n    // so a child write fires it; spec.source (into) is already indexed above,\n    // so a parent write also recomputes its own aggregate (covers the\n    // parent-created-after-children case). The from→into edge enters the cycle\n    // DFS automatically.\n    if (spec.rollup) {\n      const fromRollup = this._bySource.get(spec.rollup.from)\n      if (fromRollup) fromRollup.push(reg)\n      else this._bySource.set(spec.rollup.from, [reg])\n    }\n\n    for (const key of outputKeys) {\n      const output = spec.outputs[key]\n      if (!output) continue\n      const outputCollection = output.collection\n      const arr = this._byOutput.get(outputCollection)\n      if (arr) arr.push(reg)\n      else this._byOutput.set(outputCollection, [reg])\n    }\n  }\n\n  strategiesForSource(source: string): ReadonlyArray<RegisteredStrategy> {\n    return this._bySource.get(source) ?? []\n  }\n\n  strategiesProducingOutput(collection: string): ReadonlyArray<RegisteredStrategy> {\n    return this._byOutput.get(collection) ?? []\n  }\n\n  /**\n   * All registered strategies as a flat, deduplicated array.\n   * Each strategy is indexed once per source (not once per output key),\n   * so iterating `_bySource.values()` naturally yields each strategy\n   * exactly once per source — deduplication is handled by flattening\n   * the per-source arrays and collecting into a Set by identity.\n   *\n   * Used by `dumpSchema()` / `describeDerivations()` in the introspection\n   * walker to populate the derivations map.\n   */\n  all(): ReadonlyArray<RegisteredStrategy> {\n    const seen = new Set<RegisteredStrategy>()\n    for (const strategies of this._bySource.values()) {\n      for (const s of strategies) seen.add(s)\n    }\n    return [...seen]\n  }\n\n  /**\n   * Graph edges for #638 Task 2: one `'derivation'`/`'record'` edge per\n   * (non-self-write) output key — target = the output collection (a\n   * `WHOLE_RECORD` artifact node), sources = every collection that can\n   * trigger this strategy (`source`, `sources[]`, `triggerBy[].collection`,\n   * and — for a rollup — `rollup.from`), mirroring EXACTLY the trigger keys\n   * `register()` indexes under `_bySource`. The self-write reverse-denorm\n   * output (`output.collection === source` with `denorm` declared) is\n   * skipped — the SAME condition the old local DFS used; it is not a cycle\n   * (see the comment `validate()` used to carry, now on this skip).\n   * Rollups ADDITIONALLY get a dedicated `'rollup'`/`'aggregate'` edge\n   * targeting the real `rollup.field` on the parent (`source`) — the\n   * self-write output above only covers the cycle-DFS skip, not\n   * dispatch/taint (Tasks 3/4/6), which need the real field.\n   */\n  edges(): ReadonlyArray<{ readonly target: FieldRef; readonly sources: readonly FieldRef[]; readonly kind: EdgeKind; readonly grain: Grain }> {\n    const out: Array<{ target: FieldRef; sources: FieldRef[]; kind: EdgeKind; grain: Grain }> = []\n    for (const reg of this.all()) {\n      const spec = reg.spec\n      const triggerCollections = [\n        spec.source,\n        ...(spec.sources ?? []),\n        ...(spec.triggerBy ?? []).map((t) => t.collection),\n        ...(spec.rollup ? [spec.rollup.from] : []),\n      ]\n      const sources: FieldRef[] = triggerCollections.map((c) => ({ collection: c, field: WHOLE_RECORD }))\n      for (const key of Object.keys(spec.outputs)) {\n        const output = spec.outputs[key]\n        if (!output) continue\n        if (output.shape === 'record' && output.collection === spec.source && output.denorm !== undefined) continue\n        out.push({ target: { collection: output.collection, field: WHOLE_RECORD }, sources, kind: 'derivation', grain: 'record' })\n      }\n      if (spec.rollup) {\n        out.push({\n          target: { collection: spec.source, field: spec.rollup.field },\n          sources: [{ collection: spec.rollup.from, field: WHOLE_RECORD }],\n          kind: 'rollup',\n          grain: 'aggregate',\n        })\n      }\n    }\n    return out\n  }\n\n  /**\n   * Cycle detection, delegated to `ViaGraph.assertAcyclic()` (#638 Task 2 —\n   * retires the local DFS). Call after all `register()` calls complete (i.e.\n   * at vault open). Throws `DerivationCycleError` on the first cycle found —\n   * SAME class/timing as before; the message/path is byte-identical to the\n   * pre-#638 shape for a pure record-shape derivation cycle (the\n   * `WHOLE_RECORD` artifact suffix is stripped back to a bare collection\n   * name before re-throwing).\n   *\n   * `graph` is the caller's shared per-vault graph, ALREADY carrying this\n   * registry's `edges()` (the caller registers them — see `Vault._initDerivations`)\n   * — omit it (e.g. this registry's own unit tests) to validate this\n   * registry's edges in isolation against a throwaway graph.\n   */\n  validate(graph?: ViaGraph): void {\n    const g = graph ?? new ViaGraph()\n    if (!graph) {\n      for (const edge of this.edges()) g.registerDerived(edge.target, edge.sources, edge.kind, edge.grain)\n    }\n    try {\n      g.assertAcyclic()\n    } catch (e) {\n      if (e instanceof DerivationCycleError) throw new DerivationCycleError(e.path.map(stripArtifactSuffix))\n      throw e\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-T6PSWLAR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/with-formula/derivations/with-derivation.ts","../src/with-formula/derivations/with-rollup.ts"],"sourcesContent":["import { ValidationError } from '../../kernel/errors.js'\nimport type { DerivationSpec, DerivationStrategy } from './types.js'\n\n/**\n * Register a deterministic derivation: one source collection → one or\n * more typed outputs, computed by the user's `derive` function on\n * plaintext after DEK unwrap. Outputs are encrypted with the same DEK\n * as the source and written via the standard `Collection.put` path.\n *\n * See design-history/2026-05-01-dim14-derivation-v1-design.md.\n */\nexport function withDerivation<\n  TSource extends Record<string, unknown>,\n  TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>,\n>(spec: DerivationSpec<TSource, TOutputs>): DerivationStrategy {\n  if (!spec.source || spec.source.length === 0) {\n    throw new ValidationError('withDerivation: source collection name is required')\n  }\n  if (!spec.outputs || Object.keys(spec.outputs).length === 0) {\n    throw new ValidationError('withDerivation: outputs map must declare at least one output')\n  }\n  if (spec.deterministic !== true) {\n    throw new ValidationError('withDerivation: v1 only supports deterministic derivations')\n  }\n  if (typeof spec.derive !== 'function') {\n    throw new ValidationError('withDerivation: derive must be a function')\n  }\n\n  // Validate declared sibling sources. Each must be a non-empty\n  // string and must differ from the primary source — a self-reference\n  // would double-register the strategy under the same `_bySource` key.\n  if (spec.sources !== undefined) {\n    for (const extra of spec.sources) {\n      if (typeof extra !== 'string' || extra.length === 0) {\n        throw new ValidationError('withDerivation: each entry in sources[] must be a non-empty string')\n      }\n      if (extra === spec.source) {\n        throw new ValidationError(\n          `withDerivation: sources[] must not contain the primary source \"${spec.source}\"`,\n        )\n      }\n    }\n  }\n\n  // Validate FK triggers. Each `collection` must be a non-empty\n  // string differing from the primary source, and `on` a non-empty field.\n  if (spec.triggerBy !== undefined) {\n    for (const t of spec.triggerBy) {\n      if (typeof t?.collection !== 'string' || t.collection.length === 0) {\n        throw new ValidationError('withDerivation: each triggerBy entry needs a non-empty `collection`')\n      }\n      if (t.collection === spec.source) {\n        throw new ValidationError(\n          `withDerivation: triggerBy.collection must not equal the source \"${spec.source}\" (use sources[] for same-id triggers)`,\n        )\n      }\n      if (typeof t.on !== 'string' || t.on.length === 0) {\n        throw new ValidationError(\n          `withDerivation: triggerBy on \"${t.collection}\" needs a non-empty \\`on\\` (the FK field on the source)`,\n        )\n      }\n      if (t.maxFanout !== undefined && (!Number.isInteger(t.maxFanout) || t.maxFanout < 1)) {\n        throw new ValidationError(\n          `withDerivation: triggerBy maxFanout on \"${t.collection}\" must be a positive integer (got ${String(t.maxFanout)}).`,\n        )\n      }\n    }\n  }\n\n  // Validate array-shape outputs.\n  const lifecycleMode = typeof spec.lifecycle === 'string' ? spec.lifecycle : spec.lifecycle.mode\n  for (const [outputKey, outputSpec] of Object.entries(spec.outputs)) {\n    // Self-write output (collection === source): reverse-denorm must declare\n    // `denorm` (the fields it owns) — field-level provenance.\n    if (outputSpec.shape === 'record' && outputSpec.collection === spec.source) {\n      if (!outputSpec.denorm || outputSpec.denorm.length === 0) {\n        throw new ValidationError(\n          `withDerivation: self-write output \"${outputKey}\" (collection === source \"${spec.source}\") `\n          + 'must declare `denorm: [...]` naming the fields it maintains.',\n        )\n      }\n    }\n    if (outputSpec.shape === 'array') {\n      if (lifecycleMode !== 'eager') {\n        throw new ValidationError(\n          `withDerivation: shape 'array' supports lifecycle 'eager' only in this release `\n          + `Output \"${outputKey}\" declared lifecycle '${lifecycleMode}'. `\n          + 'Switch to `lifecycle: \"eager\"` or use shape: \"record\".',\n        )\n      }\n      if (typeof outputSpec.key !== 'function') {\n        throw new ValidationError(\n          `withDerivation: shape 'array' output \"${outputKey}\" requires \\`key: (out) => string\\`.`,\n        )\n      }\n      if (outputSpec.maxFanout !== undefined) {\n        if (!Number.isInteger(outputSpec.maxFanout) || outputSpec.maxFanout < 1) {\n          throw new ValidationError(\n            `withDerivation: maxFanout for output \"${outputKey}\" must be a positive integer `\n            + `(got ${String(outputSpec.maxFanout)}).`,\n          )\n        }\n      }\n    }\n  }\n\n  return {\n    __noydb_strategy: 'derivation',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    spec: spec as DerivationSpec<any, any>,\n  }\n}\n","import { ValidationError } from '../../kernel/errors.js'\nimport type { DerivationSpec, DerivationStrategy } from './types.js'\n\n/** Options for {@link withRollup} (#844b — was an inline literal, so unnameable). */\nexport interface WithRollupOptions<\n  TChild extends Record<string, unknown> = Record<string, unknown>,\n  TParent extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Child collection — the trigger. */\n  readonly from: string\n  /** FK field on the child pointing at the parent id. */\n  readonly key: keyof TChild & string\n  /** Parent collection carrying the maintained summary. */\n  readonly into: string\n  /** Field on the parent to maintain. */\n  readonly field: keyof TParent & string\n  /** Reduces the matching children to the value written at `field`. */\n  readonly compute: (children: TChild[]) => unknown\n}\n\n/**\n * `withRollup` — aggregate many child records onto a single field of their\n * parent. The reverse of a join: instead of reading children\n * on demand, the parent carries a maintained summary.\n *\n * ```ts\n * withRollup<Sale, Buyer>({\n *   from: 'sales',          // child collection (the trigger)\n *   key: 'buyerId',         // FK on the child → parent id\n *   into: 'buyers',         // parent collection\n *   field: 'revenueByYear', // field on the parent to maintain\n *   compute: (sales) => groupSumByYear(sales, 'total'),\n * })\n * ```\n *\n * On every write OR delete of a `from` record, the parent at id `child[key]`\n * is recomputed: `compute(allChildren where child[key] === parentId)` is\n * patched onto `parent[field]`. A parent write also recomputes its own\n * aggregate (so a parent created after its children still fills in). Only the\n * `field` is touched — the rest of the parent record is never clobbered — and\n * a value-equality guard suppresses no-op writes. The aggregate is gap-free\n * with respect to child inserts, updates, and deletes.\n *\n * Desugars to a `withDerivation` strategy carrying a `rollup` marker; dispatch\n * handles it without invoking the executor. Eager-only in this slice.\n */\nexport function withRollup<\n  TChild extends Record<string, unknown> = Record<string, unknown>,\n  TParent extends Record<string, unknown> = Record<string, unknown>,\n>(opts: WithRollupOptions<TChild, TParent>): DerivationStrategy {\n  const { from, key, into, field, compute } = opts\n  if (!from || from.length === 0) {\n    throw new ValidationError('withRollup: `from` (child collection) is required')\n  }\n  if (!into || into.length === 0) {\n    throw new ValidationError('withRollup: `into` (parent collection) is required')\n  }\n  if (from === into) {\n    throw new ValidationError('withRollup: `from` and `into` must be different collections')\n  }\n  if (!key || key.length === 0) {\n    throw new ValidationError('withRollup: `key` (FK field on the child) is required')\n  }\n  if (!field || field.length === 0) {\n    throw new ValidationError('withRollup: `field` (target field on the parent) is required')\n  }\n  if (typeof compute !== 'function') {\n    throw new ValidationError('withRollup: `compute` must be a function')\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const spec: DerivationSpec<any, any> = {\n    source: into, // the parent record is what carries the rolled-up field\n    deterministic: true,\n    rollup: { from, key, field, compute: compute as (children: unknown[]) => unknown },\n    // Synthetic self-write output for registry / cycle bookkeeping. Dispatch\n    // patches `field` directly (value-equality guarded); the executor is not run.\n    outputs: { value: { shape: 'record', collection: into, denorm: [field] } },\n    derive: () => ({ value: {} }), // never invoked for a rollup strategy\n    lifecycle: 'eager',\n  }\n\n  return { __noydb_strategy: 'derivation', spec }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-UB5CRTFF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/kernel/via/graph.ts"],"sourcesContent":["// kernel/via/graph.ts — the per-vault ViaGraph dependency model (Via port phase C, #638).\n//\n// Metadata-only dependency graph over (collection, field) nodes: source-field\n// postures, derived-field edges, and the taint (effective-posture) algebra.\n// NEVER stores record values or key material — see\n// design-history/2026-07-11-via-phase-c-design.md §1/§2.\n\nimport { DerivationCycleError, MaterializedViewCycleError } from '../errors.js'\nimport type { ViaPosture } from './index.js'\n\n/** A (collection, field) node. Artifact-grain targets (rollup field, MV row-class,\n *  overlay output) are modelled as a field node whose `field` is the artifact key. */\nexport interface FieldRef { readonly collection: string; readonly field: string }\n\nexport type EdgeKind = 'computed' | 'derivation' | 'rollup' | 'mv' | 'overlay' | 'ref'\n/** `'virtual'` (#638 Task 7) marks a `computed(fn, { mode: 'virtual' })` field's edge —\n *  never stored (rides the `present` phase), so it can never be sealed at rest\n *  ({@link ViaGraph.taintSealedFields} excludes it) and is always non-queryable\n *  regardless of source posture ({@link ViaGraph.effectivePosture} clamps it). */\nexport type Grain = 'record' | 'aggregate' | 'virtual'\n\n/** Delete/forget-time referential policy for a `'ref'` edge (#650 Task 5, spec §4) — duplicated\n *  (not imported) from `via/lookup/descriptor.ts`'s `OnDelete`: the kernel spine may not\n *  statically import `via/**` (Check 14, `via-layering`). Keep the two in sync by hand. */\nexport type OnDelete = 'restrict' | 'cascade' | 'nullify'\n\n/** Plain (non-via) field baseline — max-permissive; taint only ever tightens. */\nexport const DEFAULT_POSTURE: ViaPosture =\n  { encryptedAtRest: 'envelope', queryable: 'full', exportable: true, forgettable: false }\n\nconst QUERYABLE_RANK: Record<ViaPosture['queryable'], number> = {\n  none: 0,\n  'det-exact': 1,\n  ordered: 2,\n  full: 3,\n}\n\n/** The per-axis \"most restrictive\" fold — pure, exported for direct unit testing. */\nexport function foldPosture(a: ViaPosture, b: ViaPosture): ViaPosture {\n  return {\n    encryptedAtRest: a.encryptedAtRest === 'sealed' || b.encryptedAtRest === 'sealed' ? 'sealed' : 'envelope',\n    queryable: QUERYABLE_RANK[a.queryable] <= QUERYABLE_RANK[b.queryable] ? a.queryable : b.queryable,\n    exportable: a.exportable && b.exportable,\n    forgettable: a.forgettable || b.forgettable,\n  }\n}\n\n/** Security-axes-only fold for a wildcard collection node (#642): sealed-wins encryptedAtRest,\n *  AND exportable, OR forgettable — queryable is NOT folded (stays base.queryable; the sealed\n *  clamp to 'none' is buildTaintOverlay's job, so inheriting `sealed` never over-restricts a\n *  blob-adjacent output to unqueryable). Pure; exported for unit testing. Distinct from\n *  {@link foldPosture} (which folds all four axes) — do NOT reuse foldPosture here. */\nexport function foldWildcardSecurity(base: ViaPosture, contributor: ViaPosture): ViaPosture {\n  return {\n    encryptedAtRest: base.encryptedAtRest === 'sealed' || contributor.encryptedAtRest === 'sealed' ? 'sealed' : 'envelope',\n    queryable: base.queryable,\n    exportable: base.exportable && contributor.exportable,\n    forgettable: base.forgettable || contributor.forgettable,\n  }\n}\n\n// the folded formula kinds a '*' source contributes its collection-fold to (ref keeps identity):\ntype FoldedKind = 'derivation' | 'rollup' | 'mv' | 'overlay'\nconst FOLDED_KINDS: ReadonlySet<EdgeKind> = new Set<FoldedKind>(['derivation', 'rollup', 'mv', 'overlay'])\n\n/** Whether `p` is exactly the plain, non-taint baseline (Task 3 — `taintProvenance`). */\nfunction isDefaultPosture(p: ViaPosture): boolean {\n  return p.encryptedAtRest === DEFAULT_POSTURE.encryptedAtRest && p.queryable === DEFAULT_POSTURE.queryable &&\n    p.exportable === DEFAULT_POSTURE.exportable && p.forgettable === DEFAULT_POSTURE.forgettable\n}\n\n/** One `_out` entry — a `source -> target` derived edge, carrying its OWN registration's\n *  `kind` (#678). `kind` must be edge-local, not re-derived from `_in`: `_in` is single-slot\n *  per target and can be overwritten by a LATER `registerDerived` call on the SAME target\n *  (a dual-role target, e.g. #631's exempt {computed, lookup} field composition) — asking\n *  `_in` for \"this target's current kind\" answers the wrong question for a specific edge. */\ninterface OutEdge { readonly target: FieldRef; readonly kind: EdgeKind }\n\n/** One registered `registerDerived` call — a target's whole in-edge set. */\ninterface DerivedEdge {\n  readonly target: FieldRef\n  readonly sources: readonly FieldRef[]\n  readonly kind: EdgeKind\n  readonly grain: Grain\n  /** `'ref'` edges only — the referencing field's delete/forget policy (#650 Task 5). */\n  readonly onDelete?: OnDelete\n  /** `'ref'` edges only — the backing dimension's canonical-key FIELD NAME on its own row (matrix\n   *  tier's `lookup(dim, {key})`; always `'id'` for reserved/static tiers). Defaults to `'id'`\n   *  when absent — a referencing field always stores this field's VALUE, never the backing row's\n   *  PUT-id when the two differ (#650 Task 5, mirrors Task 3's membership review fix). */\n  readonly keyField?: string\n}\n\nconst SEP = '\\0'\nconst EMPTY_SET: ReadonlySet<string> = new Set()\n\nfunction nodeId(ref: FieldRef): string {\n  return `${ref.collection}${SEP}${ref.field}`\n}\n\n/** Inverse of `nodeId`, for building a human-readable cycle path. */\nfunction displayNodeId(id: string): string {\n  const sep = id.indexOf(SEP)\n  return `${id.slice(0, sep)}.${id.slice(sep + 1)}`\n}\n\n/** Metadata-only dependency graph, ONE per vault. Never stores values or key material. */\nexport class ViaGraph {\n  /** Declared source-field postures (registerField), keyed by node id. */\n  private readonly _posture = new Map<string, ViaPosture>()\n  /** Every derived target's registration, keyed by the target's node id. */\n  private readonly _in = new Map<string, DerivedEdge>()\n  /** source node id -> derived edges that depend on it (dispatch/erasure), each carrying\n   *  its own registration's `kind` (#678 — see {@link OutEdge}). */\n  private readonly _out = new Map<string, OutEdge[]>()\n  /** Memoized effective posture per derived target node id. */\n  private readonly _effectiveCache = new Map<string, ViaPosture>()\n  /** Memoized whole-collection security-axes fold for `'*'` wildcard LEAF nodes (#642),\n   *  keyed by collection name — see {@link _wildcardContribution}. Cleared alongside\n   *  `_effectiveCache` on every `registerField`/`registerDerived` (a later-registered\n   *  field must re-fold on the next read — registration ordering is free). */\n  private readonly _wildcardCache = new Map<string, ViaPosture>()\n  /** Collections with at least one classified field (#638 Task 2 fix wave 2,\n   *  Finding I1 — the reconcile path's combined-state leak guard memory). */\n  private readonly _classifiedCollections = new Set<string>()\n  /** Computed field names declared with no `deps` entry, per collection\n   *  (Finding I1 — such a field registers no edge when no classified field is\n   *  present yet, so a LATER, separate reconcile call attaching classifiedFields\n   *  still needs to see it regardless of declaration order). */\n  private readonly _depslessComputed = new Map<string, Set<string>>()\n\n  /** Declare a source field's posture (money/i18n/classified/plain). Plain fields\n   *  default to `DEFAULT_POSTURE`; a later declaration for the same node wins-first (idempotent). */\n  registerField(collection: string, field: string, posture: ViaPosture): void {\n    const id = nodeId({ collection, field })\n    if (this._posture.has(id)) return\n    this._posture.set(id, posture)\n    this._effectiveCache.clear()\n    this._wildcardCache.clear()\n  }\n\n  /** A derived target depends on `sources` (may be cross-collection). `kind`/`grain`\n   *  drive dispatch + erasure semantics; sources drive taint. Re-registering the same\n   *  target replaces `_in` but does not prune stale `_out` edges — callers must\n   *  register each target at most once per graph lifetime. `onDelete`/`keyField` (#650 Task 5)\n   *  are meaningful only for `kind === 'ref'` edges — {@link referencingEdgesOf} reads them back. */\n  registerDerived(target: FieldRef, sources: readonly FieldRef[], kind: EdgeKind, grain: Grain, onDelete?: OnDelete, keyField?: string): void {\n    const id = nodeId(target)\n    this._in.set(id, {\n      target, sources, kind, grain,\n      ...(onDelete !== undefined ? { onDelete } : {}),\n      ...(keyField !== undefined ? { keyField } : {}),\n    })\n    for (const source of sources) {\n      const sourceId = nodeId(source)\n      const outEdge: OutEdge = { target, kind }\n      const dependents = this._out.get(sourceId)\n      if (dependents) dependents.push(outEdge)\n      else this._out.set(sourceId, [outEdge])\n    }\n    this._effectiveCache.clear()\n    this._wildcardCache.clear()\n  }\n\n  /** Whether `target` already has a registered in-edge — lets a caller skip\n   *  re-registering the same target (#638 Task 2 fix wave 2, Finding I2i:\n   *  `registerDerived`'s at-most-once contract must hold across repeated\n   *  identical `vault.collection()` calls, not just within a single one). */\n  hasDerived(target: FieldRef): boolean {\n    return this._in.has(nodeId(target))\n  }\n\n  /** Mark/query a collection as having declared at least one classified field. */\n  markClassified(collection: string): void {\n    this._classifiedCollections.add(collection)\n  }\n\n  isClassified(collection: string): boolean {\n    return this._classifiedCollections.has(collection)\n  }\n\n  /** Mark/query a collection's depsless (no declared `deps`) computed\n   *  field names — see `_depslessComputed`'s doc comment above. */\n  markDepslessComputed(collection: string, field: string): void {\n    let set = this._depslessComputed.get(collection)\n    if (!set) { set = new Set(); this._depslessComputed.set(collection, set) }\n    set.add(field)\n  }\n\n  depslessComputedFields(collection: string): ReadonlySet<string> {\n    return this._depslessComputed.get(collection) ?? EMPTY_SET\n  }\n\n  /** Every field name the graph already has memory of for `collection` — from an\n   *  EARLIER, separate `vault.collection()` call (registered postures, derived\n   *  targets, depsless-computed names) — regardless of which via feature declared\n   *  it. #645 — `via/graph-wiring.ts`'s reconcile-path `knownFields` universe\n   *  (`collectKnownFieldNames`) is scoped to THIS call's own options only, so a\n   *  computed field attached in a LATER call whose `deps` correctly names a field\n   *  declared in an EARLIER call was spuriously refused as \"unknown\"; this method\n   *  lets that call site union in the graph's cross-call memory. Excludes the `'*'`\n   *  wildcard target (an overlay/derivation whole-record fold node, never a real\n   *  record field — see {@link registerDerived}'s doc comment). */\n  knownFieldNames(collection: string): ReadonlySet<string> {\n    const out = new Set<string>()\n    const prefix = `${collection}${SEP}`\n    for (const id of this._posture.keys()) {\n      if (id.startsWith(prefix)) out.add(id.slice(prefix.length))\n    }\n    for (const edge of this._in.values()) {\n      if (edge.target.collection === collection && edge.target.field !== '*') out.add(edge.target.field)\n    }\n    const depsless = this._depslessComputed.get(collection)\n    if (depsless) for (const field of depsless) out.add(field)\n    return out\n  }\n\n  /** Reject cycles at declare time (vault open). Throws `DerivationCycleError` for a\n   *  derivation/rollup/computed cycle, `MaterializedViewCycleError` for an MV cycle —\n   *  same classes + message shape the registries throw today (behavior lock). */\n  assertAcyclic(): void {\n    const visited = new Set<string>()\n    const stack: string[] = []\n\n    /** #639 — containment expansion: writing a real field `f` on collection `C` is\n     *  a write to `C`, so it must ALSO reach every whole-record (`'*'`) dependent of\n     *  `C` — the missing reachability step that made mutual/rotating rollup cycles\n     *  invisible (a rollup target is always a real field node and never itself a\n     *  graph SOURCE, so the old `_out.get(id)`-only walk dead-ended on it).\n     *\n     *  TRAVERSAL-LOCAL ONLY (law, #642): this is a virtual adjacency computed\n     *  during the DFS walk, reading `_out` only. It must NEVER be materialized via\n     *  `registerDerived` (no new `(C,f)→(C,'*')` edge) and must NEVER touch `_in` —\n     *  putting `(C,'*')` into `_in` would flip `_contribution('C\\0*')` from the\n     *  `_wildcardContribution` fold (`#642`) onto the `_computeEffective` path,\n     *  bleeding cycle-reachability taint into `foldWildcardSecurity`'s posture\n     *  fold. Posture folding (`_contribution`/`_computeEffective`/\n     *  `_wildcardContribution`) never reads `_out`, so an expansion that reads\n     *  `_out` only is provably unable to perturb it. */\n    // #671 item 5 — exclude `kind:'ref'` consuming edges: mutual FK lookups (two\n    // collections each referencing the other) are legal and must not be treated as a\n    // derivation cycle. Ref edges exist for cascade/rename machinery\n    // (`referencingEdgesOf`/delete-time restrict/cascade/nullify), never derivation\n    // ordering, so they carry no ordering constraint here. #678 — `kind` is read off\n    // THIS `_out` entry (edge-local), NOT re-derefed from `_in`: a dual-role target\n    // (e.g. #631's exempt {computed, lookup} composition) can have its `_in` entry's\n    // `kind` overwritten by a LATER `registerDerived` call for the SAME target, so\n    // asking `_in` \"what kind is `t` registered as NOW\" wrongly excluded a real\n    // computed edge from the DFS as if it were a ref edge, hiding a genuine\n    // derivation cycle. Asking \"what kind is THIS specific edge\" is correct\n    // regardless of what else was later registered for the target.\n    const notRefEdge = (entry: OutEdge): boolean => entry.kind !== 'ref'\n    const neighboursOf = (id: string): readonly FieldRef[] => {\n      const own = (this._out.get(id) ?? []).filter(notRefEdge).map((entry) => entry.target)\n      const sep = id.indexOf(SEP)\n      if (id.slice(sep + 1) === '*') return own\n      const wildcard = (this._out.get(`${id.slice(0, sep)}${SEP}*`) ?? []).filter(notRefEdge).map((entry) => entry.target)\n      if (wildcard.length === 0) return own\n      return [...own, ...wildcard]\n    }\n\n    const visit = (id: string): void => {\n      const idx = stack.indexOf(id)\n      if (idx !== -1) {\n        const cycle = stack.slice(idx).concat(id)\n        const isMv = cycle.some(cycleId => this._in.get(cycleId)?.kind === 'mv')\n        const path = cycle.map(displayNodeId)\n        if (isMv) throw new MaterializedViewCycleError(path)\n        throw new DerivationCycleError(path)\n      }\n      if (visited.has(id)) return\n      stack.push(id)\n      for (const dependent of neighboursOf(id)) visit(nodeId(dependent))\n      stack.pop()\n      visited.add(id)\n    }\n\n    for (const id of this._out.keys()) visit(id)\n  }\n\n  /** A leaf (non-derived) node's own posture contribution: its declared posture,\n   *  or `DEFAULT_POSTURE` if never declared via `registerField`. */\n  private _declaredPosture(id: string): ViaPosture {\n    return this._posture.get(id) ?? DEFAULT_POSTURE\n  }\n\n  /** A node's posture contribution when folded into a dependent: recurse if it is itself\n   *  derived; else its declared/default posture — UNLESS it is a `'*'` LEAF node consumed\n   *  by a folded formula kind (#642, `derivation|rollup|mv|overlay`), in which case it\n   *  contributes its collection's whole-record security fold ({@link _wildcardContribution}).\n   *  `kind` is the CONSUMING edge's kind, threaded from {@link _computeEffective}. `'ref'`\n   *  edges (and the provenance-only untyped call, `kind` left `undefined`) keep `'*'` =\n   *  identity — the phase-D lookup reliance (`via/lookup/registry.ts:392-397`) that a\n   *  referencing field must not seal just because its dimension collection has a classified\n   *  column. */\n  private _contribution(id: string, kind?: EdgeKind): ViaPosture {\n    const edge = this._in.get(id)\n    if (edge) return this._computeEffective(id, edge)\n    if (kind !== undefined && FOLDED_KINDS.has(kind) && id.endsWith(`${SEP}*`)) {\n      return this._wildcardContribution(id.slice(0, -2))\n    }\n    return this._declaredPosture(id)\n  }\n\n  /** Lazy fold (#642) of a collection's REGISTERED field postures on the security axes only\n   *  ({@link foldWildcardSecurity} — sealed-wins encryptedAtRest, AND exportable, OR\n   *  forgettable; queryable stays at DEFAULT_POSTURE's 'full', never folded), seeded at\n   *  DEFAULT_POSTURE. This is the collection-level posture a `'*'` LEAF node contributes to a\n   *  folded-kind formula edge (derivation/rollup/mv/overlay) — see {@link _contribution}. A\n   *  plain (unregistered) field contributes nothing (the identity), so the fold is strictly\n   *  more conservative than deps-based taint and never hits the KNOWN-LIMIT wall (it names no\n   *  fields — seam map §1d). Memoized per collection in `_wildcardCache`. */\n  private _wildcardContribution(collection: string): ViaPosture {\n    const cached = this._wildcardCache.get(collection)\n    if (cached) return cached\n    let result = DEFAULT_POSTURE\n    const prefix = `${collection}${SEP}`\n    for (const [id, posture] of this._posture) {\n      if (!id.startsWith(prefix) || id === `${prefix}*`) continue\n      result = foldWildcardSecurity(result, posture)\n    }\n    this._wildcardCache.set(collection, result)\n    return result\n  }\n\n  private _computeEffective(id: string, edge: DerivedEdge): ViaPosture {\n    const cached = this._effectiveCache.get(id)\n    if (cached) return cached\n    let result = DEFAULT_POSTURE\n    for (const source of edge.sources) {\n      result = foldPosture(result, this._contribution(nodeId(source), edge.kind))\n    }\n    // #638 Task 7 — a virtual field is computed fresh on every read and never\n    // stored, so it is structurally unqueryable regardless of what its\n    // sources' fold would otherwise permit (e.g. a money-sourced virtual\n    // field must NOT inherit money's 'ordered' queryability — there is no\n    // stored/indexed form to query against). Every OTHER axis (exportable/\n    // forgettable/encryptedAtRest) still folds normally — the taint rule is\n    // identical to a materialized field; only queryability is a fixed,\n    // grain-level property, not a source-derived one.\n    if (edge.grain === 'virtual' && result.queryable !== 'none') {\n      result = { ...result, queryable: 'none' }\n    }\n    this._effectiveCache.set(id, result)\n    return result\n  }\n\n  /** Strictest source posture on every axis, per §2. `undefined` when `target` has no\n   *  in-edges (not a derived field). Transitive: folds through chained derivations. */\n  effectivePosture(target: FieldRef): ViaPosture | undefined {\n    const id = nodeId(target)\n    const edge = this._in.get(id)\n    if (!edge) return undefined\n    return this._computeEffective(id, edge)\n  }\n\n  /** Per-collection { field → effectivePosture } overlay the pipeline consumes (Task 3). */\n  taintedPostures(collection: string): ReadonlyMap<string, ViaPosture> {\n    const out = new Map<string, ViaPosture>()\n    for (const edge of this._in.values()) {\n      if (edge.target.collection !== collection) continue\n      out.set(edge.target.field, this._computeEffective(nodeId(edge.target), edge))\n    }\n    return out\n  }\n\n  /** Materialized (`grain !== 'virtual'`) derived fields on `collection` whose effective\n   *  encryptedAtRest resolves to 'sealed' — the taint-seal set (Task 3). #638 Task 7\n   *  makes the `grain !== 'virtual'` filter meaningful: a `computed(fn, { mode: 'virtual' })`\n   *  field is never stored (rides the `present` phase, seam map Part 4's money-Formatted/\n   *  i18n-Label precedent), so it is EXCLUDED here even when its effective `encryptedAtRest`\n   *  folds to `'sealed'` — there is no envelope slot to seal. It still surfaces in\n   *  {@link taintedPostures} (query refusal via `postureFor`'s `queryable` clamp above, and\n   *  export refusal via `exportable`) — only the AT-REST SEALING ACTION is skipped. */\n  taintSealedFields(collection: string): ReadonlySet<string> {\n    const out = new Set<string>()\n    for (const edge of this._in.values()) {\n      if (edge.target.collection !== collection || edge.grain === 'virtual') continue\n      const posture = this._computeEffective(nodeId(edge.target), edge)\n      if (posture.encryptedAtRest === 'sealed') out.add(edge.target.field)\n    }\n    return out\n  }\n\n  /** Fields on `collection` whose registered edge is `grain === 'virtual'` (#638 Task 7) —\n   *  `via/graph-wiring.ts#applyTaintOverlay` intersects this with `exportable === false`\n   *  postures to know which virtual fields need PRESENT-TIME (not just export-time)\n   *  redaction, since a virtual field's value is only ever materialized inside `present()`. */\n  virtualFields(collection: string): ReadonlySet<string> {\n    const out = new Set<string>()\n    for (const edge of this._in.values()) {\n      if (edge.target.collection === collection && edge.grain === 'virtual') out.add(edge.target.field)\n    }\n    return out\n  }\n\n  /** Per-collection { field → immediate source field names that forced its\n   *  effective posture away from `DEFAULT_POSTURE` } — `describe()`'s\n   *  provenance (Task 3). Only the DIRECT declared sources are named (not the\n   *  ultimate origin several hops up a transitive chain); a source absent\n   *  from the result contributed nothing restrictive. */\n  taintProvenance(collection: string): ReadonlyMap<string, readonly string[]> {\n    const out = new Map<string, readonly string[]>()\n    for (const edge of this._in.values()) {\n      if (edge.target.collection !== collection) continue\n      const forcedBy = edge.sources\n        .filter((source) => !isDefaultPosture(this._contribution(nodeId(source))))\n        .map((source) => source.field)\n      if (forcedBy.length > 0) out.set(edge.target.field, forcedBy)\n    }\n    return out\n  }\n\n  private _targetsDependingOn(collection: string): ReadonlyArray<{ readonly target: FieldRef; readonly kind: EdgeKind; readonly grain: Grain }> {\n    const out: Array<{ target: FieldRef; kind: EdgeKind; grain: Grain }> = []\n    for (const edge of this._in.values()) {\n      if (edge.sources.some(source => source.collection === collection)) {\n        out.push({ target: edge.target, kind: edge.kind, grain: edge.grain })\n      }\n    }\n    return out\n  }\n\n  /** Dispatch (Task 4): every derived target triggered by a write to `collection`. Excludes\n   *  `'ref'` edges (#650 Task 5 review, folded Minor) — a `'ref'` edge is consulted only by the\n   *  delete/forget-time restrict/cascade/nullify path ({@link referencingEdgesOf}), never by the\n   *  sync/cutover/restore dispatch wave (`runGraphDispatchWave`); counting it here defeated that\n   *  wave's zero-cost early-continue, costing every write to a referenced backing collection an\n   *  unconditional decrypt + two no-op dispatch passes. {@link derivedArtifactsOf} (erasure\n   *  fanout) still includes `'ref'` edges — the forget path genuinely needs them. */\n  dependentsOf(collection: string): ReadonlyArray<{ readonly target: FieldRef; readonly kind: EdgeKind; readonly grain: Grain }> {\n    return this._targetsDependingOn(collection).filter((edge) => edge.kind !== 'ref')\n  }\n\n  /** Erasure (Task 6): derived artifacts of a forgotten record whose source is `collection`. */\n  derivedArtifactsOf(collection: string): ReadonlyArray<{ readonly target: FieldRef; readonly kind: EdgeKind; readonly grain: Grain }> {\n    return this._targetsDependingOn(collection)\n  }\n\n  /** Referencing edges pointing AT a backing dimension (delete/forget-time restrict/cascade/\n   *  nullify, #650 Task 5) — an O(1) reverse lookup via the existing `_out` map (keyed at the\n   *  dimension's wildcard `field:'*'` node, the same convention every whole-collection source\n   *  already uses), NEVER a scan across collections or records. `backing` is the collection name\n   *  a lookup field's edge was registered against (a reserved dimension's `_dict_<name>`/\n   *  `_lookup_<name>` collection name, or a matrix dimension's own collection name). */\n  referencingEdgesOf(backing: string): ReadonlyArray<{ readonly referencing: FieldRef; readonly onDelete: OnDelete; readonly keyField: string }> {\n    const targets = this._out.get(nodeId({ collection: backing, field: '*' }))\n    if (!targets) return []\n    const out: Array<{ referencing: FieldRef; onDelete: OnDelete; keyField: string }> = []\n    for (const entry of targets) {\n      // #678 — `kind` is read directly off THIS `_out` entry (edge-local) instead of\n      // re-derefing `_in`. This also fixes the symmetric ref-vanishes hazard: under a\n      // registration order where a LATER `registerDerived` call for the same target\n      // overwrites `_in`'s kind away from `'ref'`, the old `_in`-derefing check would\n      // silently drop a genuine referencing edge from cascade/nullify delete machinery\n      // even though this specific edge was truly registered as `'ref'`.\n      if (entry.kind !== 'ref') continue\n      const edge = this._in.get(nodeId(entry.target))\n      if (edge?.onDelete !== undefined) {\n        out.push({ referencing: entry.target, onDelete: edge.onDelete, keyField: edge.keyField ?? 'id' })\n      }\n    }\n    return out\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-YPMW26SL.js

@@ -1,81 +0,0 @@
-import {
-  lazy
-} from "./chunk-5D2ALSM5.js";
-
-// src/with-formula/derivations/stale.ts
-var loadDerivationExecutor = lazy(() => import("./executor-TOLPBHOC.js"));
-var _staleByRegistry = /* @__PURE__ */ new WeakMap();
-var keyFor = (source, sourceId) => `${source}/${sourceId}`;
-async function markStale(registry, strategy, sourceId) {
-  let map = _staleByRegistry.get(registry);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    _staleByRegistry.set(registry, map);
-  }
-  const k = keyFor(strategy.source, sourceId);
-  let set = map.get(k);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    map.set(k, set);
-  }
-  set.add(strategy);
-}
-async function resolveStaleOnRead(accessor, outputCollection, id) {
-  const registry = accessor.registry();
-  const producers = registry.strategiesProducingOutput(outputCollection);
-  if (producers.length === 0) return;
-  const map = _staleByRegistry.get(registry);
-  if (!map) return;
-  let DerivationExecutor = null;
-  for (const { spec, strategyHash } of producers) {
-    const k = keyFor(spec.source, id);
-    const pending = map.get(k);
-    if (!pending || !pending.has(spec)) continue;
-    const sourceColl = accessor.getCollection(spec.source);
-    const source = await sourceColl.get(id);
-    if (!source) {
-      pending.delete(spec);
-      continue;
-    }
-    const sourceWithId = { ...source, id };
-    DerivationExecutor ??= (await loadDerivationExecutor()).DerivationExecutor;
-    const ctx = { vault: accessor.getReadOnlyFacade() };
-    const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx);
-    for (const key of Object.keys(spec.outputs)) {
-      const out = result.outputs[key];
-      if (!out) continue;
-      if (out.kind === "failed") {
-        const err = out.error;
-        if (spec.strict) {
-          throw err;
-        }
-        console.warn(
-          `[derivation] lazy output "${key}" for source "${spec.source}" id="${id}" failed:`,
-          err
-        );
-        continue;
-      }
-      if (out.kind === "array") {
-        console.warn(
-          `[derivation] unexpected array-shape output "${key}" in lazy resolve path; array-shape derivations require lifecycle: "eager".`
-        );
-        continue;
-      }
-      const outSpec = spec.outputs[key];
-      if (!outSpec) continue;
-      const outputColl = accessor.getCollection(outSpec.collection);
-      if (out.skipped === true) {
-        await outputColl._internalDelete(id, accessor.getActiveTxContext());
-        continue;
-      }
-      await outputColl.put(id, out.value);
-    }
-    pending.delete(spec);
-  }
-}
-
-export {
-  markStale,
-  resolveStaleOnRead
-};
-//# sourceMappingURL=chunk-YPMW26SL.js.map

package/dist/chunk-YPMW26SL.js.map

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

package/dist/dispatch-IM52HDXT.js

@@ -1,194 +0,0 @@
-import {
-  markStale
-} from "./chunk-YPMW26SL.js";
-import {
-  putDerivedOutput,
-  selfWriteFieldEqual
-} from "./chunk-SWVNZQVR.js";
-import "./chunk-5D2ALSM5.js";
-import "./chunk-RDZZHYMV.js";
-import "./chunk-TRGTKX5E.js";
-import "./chunk-UXVWEX5L.js";
-import "./chunk-IPFE6MVM.js";
-import "./chunk-CIGAQBJR.js";
-import "./chunk-4RUFYGWG.js";
-import "./chunk-BOWNCWZT.js";
-import "./chunk-YSRUYAVU.js";
-import "./chunk-RMF67KCG.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-SL3JAAKN.js";
-import "./chunk-N4CHCXDL.js";
-import {
-  DerivationCapExceededError
-} from "./chunk-7O3Y4PPD.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/with-formula/derivations/dispatch.ts
-async function dispatchArrayDerivationsOnDelete(ctx, id, eraseRecordShapeToo = false) {
-  const { derivationSource, collectionName, adapter, vault, getDEK, storeCiphertext } = ctx;
-  const strategies = derivationSource.registry().strategiesForSource(collectionName);
-  if (strategies.length === 0) return 0;
-  const { loadFanoutSidecar, deleteFanoutSidecar } = await import("./fanout-sidecar-TSFPXY5C.js");
-  const txCtx = derivationSource.getActiveTxContext();
-  let erased = 0;
-  for (const { spec } of strategies) {
-    for (const [outputKey, outSpec] of Object.entries(spec.outputs)) {
-      if (outSpec.shape === "record") {
-        if (eraseRecordShapeToo && spec.source === collectionName && outSpec.collection !== collectionName) {
-          if (await derivationSource.getCollection(outSpec.collection)._internalDelete(id, txCtx)) erased += 1;
-        }
-        continue;
-      }
-      const sidecar = await loadFanoutSidecar(adapter, vault, spec.source, id, outputKey, getDEK, storeCiphertext);
-      if (!sidecar) continue;
-      const outputCollection = derivationSource.getCollection(outSpec.collection);
-      for (const derivedId of sidecar.keys) {
-        if (await outputCollection._internalDelete(derivedId, txCtx)) erased += 1;
-      }
-      await deleteFanoutSidecar(adapter, vault, spec.source, id, outputKey);
-    }
-  }
-  return erased;
-}
-async function dispatchDerivations(ctx, id, record, version, wave) {
-  const {
-    derivationSource,
-    collectionName,
-    adapter,
-    vault,
-    getDEK,
-    storeCiphertext,
-    via,
-    recomputeRollup,
-    dispatchCtx,
-    trackPut
-  } = ctx;
-  const incoming = via ? via.canonicalizeStored(record) : record;
-  if (incoming && typeof incoming === "object" && "_derivedFrom" in incoming) return;
-  const registry = derivationSource.registry();
-  const strategies = registry.strategiesForSource(collectionName);
-  if (strategies.length === 0) return;
-  let executorClass = null;
-  for (const { spec, strategyHash } of strategies) {
-    const mode = typeof spec.lifecycle === "string" ? spec.lifecycle : spec.lifecycle.mode;
-    if (spec.rollup) {
-      if (mode !== "eager") continue;
-      let parentId;
-      if (collectionName === spec.rollup.from) {
-        const kv = incoming[spec.rollup.key];
-        parentId = typeof kv === "string" || typeof kv === "number" ? String(kv) : null;
-      } else {
-        parentId = id;
-      }
-      if (parentId !== null) await recomputeRollup(spec, parentId, { collection: collectionName, id }, wave);
-      continue;
-    }
-    const isSource = spec.source === collectionName;
-    const isSibling = !isSource && (spec.sources?.includes(collectionName) ?? false);
-    const trigger = !isSource && !isSibling ? spec.triggerBy?.find((t) => t.collection === collectionName) : void 0;
-    const runs = [];
-    if (isSource) {
-      runs.push({ input: { ...incoming, id }, base: incoming, runId: id, version });
-    } else if (isSibling) {
-      const p = await derivationSource.getCollection(spec.source).get(id);
-      if (p !== null && p !== void 0) {
-        const raw = await derivationSource.getCollection(spec.source)._getStoredRecord(id);
-        runs.push({ input: { ...p, id }, base: raw ?? p, runId: id, version: 0 });
-      }
-    } else if (trigger) {
-      const srcColl = derivationSource.getCollection(spec.source);
-      const ids = await srcColl._findMatchingIds(trigger.on, id);
-      if (trigger.maxFanout !== void 0 && ids.length > trigger.maxFanout) {
-        throw new DerivationCapExceededError(`triggerBy ${collectionName}\u2192${spec.source}`, ids.length, trigger.maxFanout);
-      }
-      for (const sid of ids) {
-        const raw = await srcColl._getStoredRecord(sid);
-        if (raw === null) continue;
-        runs.push({ input: { ...raw, id: sid }, base: raw, runId: sid, version: 0 });
-      }
-    }
-    if (runs.length === 0) continue;
-    if (mode !== "eager") {
-      for (const run of runs) await markStale(registry, spec, run.runId);
-      continue;
-    }
-    if (executorClass === null) {
-      ;
-      ({ DerivationExecutor: executorClass } = await import("./executor-TOLPBHOC.js"));
-    }
-    for (const run of runs) {
-      const ctx2 = { vault: derivationSource.getReadOnlyFacade() };
-      const outCtx = dispatchCtx({ collection: spec.source, id: run.runId });
-      const result = await executorClass.run(spec, run.input, run.version, strategyHash, ctx2);
-      for (const key of Object.keys(spec.outputs)) {
-        const out = result.outputs[key];
-        if (!out) continue;
-        if (out.kind === "failed") {
-          const err = out.error;
-          if (spec.strict) throw err;
-          console.warn(`[derivation] output "${key}" for source "${spec.source}" id="${run.runId}" failed:`, err);
-          continue;
-        }
-        const outSpec = spec.outputs[key];
-        if (!outSpec) continue;
-        const outputCollection = derivationSource.getCollection(outSpec.collection);
-        const txCtx = derivationSource.getActiveTxContext();
-        if (out.kind === "array") {
-          const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-TSFPXY5C.js");
-          const prior = await loadFanoutSidecar(adapter, vault, spec.source, run.runId, key, getDEK, storeCiphertext);
-          const prevKeys = new Set(prior?.keys ?? []);
-          const newKeysList = out.entries.map((e) => e.key);
-          const newKeysSet = new Set(newKeysList);
-          for (const k of prevKeys) {
-            if (newKeysSet.has(k)) continue;
-            await outputCollection._internalDelete(k, txCtx);
-          }
-          for (const entry of out.entries) {
-            if (txCtx !== null) {
-              trackPut(txCtx, outSpec.collection, entry.key, await adapter.get(vault, outSpec.collection, entry.key));
-            }
-            await putDerivedOutput(outputCollection, entry.key, entry.value, outCtx, { source: "derived" });
-          }
-          await saveFanoutSidecar(adapter, vault, {
-            source: spec.source,
-            sourceId: run.runId,
-            outputKey: key,
-            outputCollection: outSpec.collection,
-            keys: newKeysList
-          }, getDEK, storeCiphertext);
-          continue;
-        }
-        if (out.skipped === true) {
-          await outputCollection._internalDelete(run.runId, txCtx);
-          continue;
-        }
-        if (outSpec.shape === "record" && outSpec.denorm !== void 0 && outSpec.collection === spec.source) {
-          const value = out.value;
-          const patched = { ...run.base };
-          let changed = false;
-          for (const f of outSpec.denorm) {
-            if (!selfWriteFieldEqual(run.base[f], value[f])) {
-              patched[f] = value[f];
-              changed = true;
-            }
-          }
-          if (!changed) continue;
-          if (txCtx !== null) {
-            trackPut(txCtx, outSpec.collection, run.runId, await adapter.get(vault, outSpec.collection, run.runId));
-          }
-          await putDerivedOutput(outputCollection, run.runId, patched, outCtx, { source: "derived" });
-          continue;
-        }
-        if (txCtx !== null) {
-          trackPut(txCtx, outSpec.collection, run.runId, await adapter.get(vault, outSpec.collection, run.runId));
-        }
-        await putDerivedOutput(outputCollection, run.runId, out.value, outCtx, { source: "derived" });
-      }
-    }
-  }
-}
-export {
-  dispatchArrayDerivationsOnDelete,
-  dispatchDerivations
-};
-//# sourceMappingURL=dispatch-IM52HDXT.js.map

package/dist/dispatch-IM52HDXT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/with-formula/derivations/dispatch.ts"],"sourcesContent":["/**\n * Derivation dispatch, lifted out of the kernel spine (#842 part b).\n *\n * `Collection` carried ~380 lines of dispatch logic that belongs to the\n * derivation service, not to the always-on kernel. These are free functions\n * taking an explicit context so the spine keeps only a thin delegator.\n *\n * ## How the spine reaches this module\n *\n * By dynamic `import()`, never a static one. `check-architecture.mjs`'s\n * `port-layering` check forbids the spine from statically importing a\n * `with-*` service; `collection.ts` is grandfathered for ten\n * `with-formula/*` specifiers, but that list is frozen per file and a new\n * one is a violation. A dynamic import is the sanctioned S4 gate recipe, and\n * it keeps this chunk out of the floor bundle for consumers who never fire a\n * derivation.\n *\n * The `Collection` type reference below points back at the spine. That is\n * inward (service → kernel) and so allowed, and it is TYPE-ONLY — erased at\n * build, so no runtime cycle exists.\n *\n * @internal\n */\n\nimport type { NoydbStore } from '../../kernel/types.js'\nimport type { TxContext } from '../../with-commit/tx/transaction.js'\nimport type { DerivationRegistry } from './registry.js'\nimport type { ReadOnlyVaultFacade } from '../../with-audit/guards/types.js'\nimport type { Collection } from '../../kernel/collection.js'\nimport type { EnclaveKey } from '../../kernel/enclave/index.js'\nimport type { EncryptedEnvelope } from '../../kernel/types.js'\nimport type { ledgerAuditHook, WaveContext } from '../../kernel/via/dispatch.js'\nimport { putDerivedOutput, selfWriteFieldEqual } from '../../kernel/via/dispatch.js'\nimport { DerivationCapExceededError } from '../../kernel/errors.js'\nimport { markStale } from './stale.js'\nimport type { DerivationExecutor } from './executor.js'\n\n/** The per-write dispatch context threaded into `putDerivedOutput`. */\ninterface DispatchCtx {\n  emit: (e: string, p: unknown) => void\n  source: { readonly collection: string; readonly id: string }\n  audit: ReturnType<typeof ledgerAuditHook>\n}\n\n/**\n * What the dispatchers need from the collection that owns them. Passing this\n * explicitly is what lets the logic live outside the class.\n */\nexport interface DerivationDeleteCtx {\n  readonly derivationSource: {\n    registry(): DerivationRegistry\n    getCollection(name: string): Collection<Record<string, unknown>>\n    getActiveTxContext(): TxContext | null\n    getReadOnlyFacade(): ReadOnlyVaultFacade\n  }\n  /** The collection the delete happened in. */\n  readonly collectionName: string\n  readonly adapter: NoydbStore\n  readonly vault: string\n  readonly getDEK: (collectionName: string) => Promise<EnclaveKey>\n  readonly storeCiphertext: boolean\n}\n\n/**\n * Erase the derived rows a deleted source record fanned out to, and drop the\n * fan-out sidecars that recorded them.\n *\n * @param eraseRecordShapeToo also erase same-id `shape: 'record'` outputs.\n *   Restricted to a source-triggered strategy writing into a DIFFERENT\n *   collection — the self-denorm case would re-delete the record just\n *   tombstoned, and triggerBy/sibling strategies derive under a different id.\n * @returns rows ACTUALLY deleted, not edges visited (#622).\n */\nexport async function dispatchArrayDerivationsOnDelete(\n  ctx: DerivationDeleteCtx,\n  id: string,\n  eraseRecordShapeToo = false,\n): Promise<number> {\n  const { derivationSource, collectionName, adapter, vault, getDEK, storeCiphertext } = ctx\n\n  const strategies = derivationSource.registry().strategiesForSource(collectionName)\n  if (strategies.length === 0) return 0\n\n  const { loadFanoutSidecar, deleteFanoutSidecar } = await import('./fanout-sidecar.js')\n  const txCtx = derivationSource.getActiveTxContext()\n  let erased = 0\n\n  for (const { spec } of strategies) {\n    for (const [outputKey, outSpec] of Object.entries(spec.outputs)) {\n      if (outSpec.shape === 'record') {\n        if (eraseRecordShapeToo && spec.source === collectionName && outSpec.collection !== collectionName) {\n          if (await derivationSource.getCollection(outSpec.collection)._internalDelete(id, txCtx)) erased += 1\n        }\n        continue\n      }\n\n      const sidecar = await loadFanoutSidecar(adapter, vault, spec.source, id, outputKey, getDEK, storeCiphertext)\n      if (!sidecar) continue\n\n      const outputCollection = derivationSource.getCollection(outSpec.collection)\n      for (const derivedId of sidecar.keys) {\n        if (await outputCollection._internalDelete(derivedId, txCtx)) erased += 1\n      }\n      await deleteFanoutSidecar(adapter, vault, spec.source, id, outputKey)\n    }\n  }\n\n  return erased\n}\n\n/** Adds what the on-write derivation dispatch needs beyond the delete path. */\nexport interface DerivationDispatchCtx extends DerivationDeleteCtx {\n  /** Via pipeline, for decoding the stored form back to canonical money shape. */\n  readonly via: { canonicalizeStored(r: Record<string, unknown>): Record<string, unknown> } | undefined\n  /** Recompute a rollup aggregate onto a parent. Stays on the spine — it walks collections. */\n  readonly recomputeRollup: (\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    spec: any,\n    parentId: string,\n    source: { readonly collection: string; readonly id: string },\n    wave?: WaveContext,\n  ) => Promise<unknown>\n  /** Builds the per-write dispatch context threaded into `putDerivedOutput`. */\n  readonly dispatchCtx: (source: { readonly collection: string; readonly id: string }) => DispatchCtx\n  /** Registers a write on the active transaction for rollback. */\n  readonly trackPut: (txCtx: TxContext, collectionName: string, id: string, priorEnvelope: EncryptedEnvelope | null) => void\n}\n\n/**\n * Fire registered derivation strategies for this source collection.\n *\n * Eager mode runs `derive` inline and writes each output; lazy mode records a\n * stale mark for cold-session recompute. Rollups are handled here rather than\n * by the executor — a write to the child recomputes the parent aggregate, and\n * a write to the parent recomputes its own.\n */\nexport async function dispatchDerivations(\n  ctx: DerivationDispatchCtx,\n  id: string,\n  record: Record<string, unknown>,\n  version: number,\n  wave?: WaveContext,\n): Promise<void> {\n  const {\n    derivationSource, collectionName, adapter, vault, getDEK, storeCiphertext,\n    via, recomputeRollup, dispatchCtx, trackPut,\n  } = ctx\n\n  // `record` is the stored form here (post-quantize) — decode so\n  // derive(source, ctx) sees the canonical money shape.\n  const incoming = (via ? via.canonicalizeStored(record) : record)\n  if (incoming && typeof incoming === 'object' && '_derivedFrom' in incoming) return\n  const registry = derivationSource.registry()\n  const strategies = registry.strategiesForSource(collectionName)\n  if (strategies.length === 0) return\n  // Dynamic-import the executor only on the first eager-mode\n  // dispatch. Lazy-mode dispatches use `markStale` (a pure helper)\n  // which doesn't reach into the executor at all. Keeps the\n  // derivation executor chunk out of the floor bundle for any\n  // consumer that doesn't fire an eager derivation.\n  let executorClass: typeof DerivationExecutor | null = null\n  for (const { spec, strategyHash } of strategies) {\n    const mode = typeof spec.lifecycle === 'string' ? spec.lifecycle : spec.lifecycle.mode\n\n    // Rollup: a write to the child `from` recomputes the\n    // parent at id child[key]; a write to the parent (source = into)\n    // recomputes its own aggregate. Handled here (the executor is not run).\n    if (spec.rollup) {\n      if (mode !== 'eager') continue\n      let parentId: string | null\n      if (collectionName === spec.rollup.from) {\n        const kv = incoming[spec.rollup.key]\n        parentId = (typeof kv === 'string' || typeof kv === 'number') ? String(kv) : null\n      } else {\n        parentId = id // a write to the parent recomputes its own aggregate\n      }\n      if (parentId !== null) await recomputeRollup(spec, parentId, { collection: collectionName, id }, wave)\n      continue\n    }\n\n    // Determine how `collectionName` triggers this strategy, and build the list\n    // of source records to (re-)derive:\n    //   • source     — re-derive the written record itself (same-id).\n    //   • sources[]  — re-derive the PRIMARY source at the same id.\n    //   • triggerBy  — FK fan-out: re-derive every source record\n    //                  whose `on` field equals the written parent's id.\n    // `input` is passed to derive(); `base` is the raw stored source record\n    // used as the patch base for a self-write reverse-denorm output.\n    const isSource = spec.source === collectionName\n    const isSibling = !isSource && (spec.sources?.includes(collectionName) ?? false)\n    const trigger = !isSource && !isSibling\n      ? spec.triggerBy?.find(t => t.collection === collectionName)\n      : undefined\n\n    const runs: Array<{\n      input: Record<string, unknown> & { id: string }\n      base: Record<string, unknown>\n      runId: string\n      version: number\n    }> = []\n\n    if (isSource) {\n      runs.push({ input: { ...incoming, id }, base: incoming, runId: id, version })\n    } else if (isSibling) {\n      const p = await derivationSource.getCollection(spec.source).get(id)\n      if (p !== null && p !== undefined) {\n        // Raw base for a (rare) sibling self-write; falls back to the\n        // resolved primary if the raw read misses.\n        const raw = await derivationSource.getCollection(spec.source)._getStoredRecord(id)\n        runs.push({ input: { ...p, id }, base: raw ?? p, runId: id, version: 0 })\n      }\n    } else if (trigger) {\n      const srcColl = derivationSource.getCollection(spec.source)\n      const ids = await srcColl._findMatchingIds(trigger.on, id)\n      if (trigger.maxFanout !== undefined && ids.length > trigger.maxFanout) {\n        throw new DerivationCapExceededError(`triggerBy ${collectionName}→${spec.source}`, ids.length, trigger.maxFanout)\n      }\n      for (const sid of ids) {\n        const raw = await srcColl._getStoredRecord(sid)\n        if (raw === null) continue\n        runs.push({ input: { ...raw, id: sid }, base: raw, runId: sid, version: 0 })\n      }\n    }\n\n    if (runs.length === 0) continue\n\n    if (mode !== 'eager') {\n      for (const run of runs) await markStale(registry, spec, run.runId)\n      continue\n    }\n\n    if (executorClass === null) {\n      ;({ DerivationExecutor: executorClass } = await import('./executor.js'))\n    }\n\n    for (const run of runs) {\n      const ctx = { vault: derivationSource.getReadOnlyFacade() }\n      const outCtx = dispatchCtx({ collection: spec.source, id: run.runId })\n      const result = await executorClass.run(spec, run.input, run.version, strategyHash, ctx)\n      for (const key of Object.keys(spec.outputs)) {\n        const out = result.outputs[key]\n        if (!out) continue\n        if (out.kind === 'failed') {\n          const err = out.error\n          if (spec.strict) throw err\n          console.warn(`[derivation] output \"${key}\" for source \"${spec.source}\" id=\"${run.runId}\" failed:`, err)\n          continue\n        }\n        const outSpec = spec.outputs[key]\n        if (!outSpec) continue\n        const outputCollection = derivationSource.getCollection(outSpec.collection)\n        // If we're inside a multi-record transaction, register\n        // derived writes as side-effect ops on the active ctx\n        // BEFORE they fire. `revertExecuted` walks `_executed` in\n        // reverse on rollback, so capturing the pre-write envelope\n        // here lets a later mid-batch failure restore this output's\n        // prior state alongside the source op. Outside a transaction\n        // the context is null and tracking is skipped.\n        const txCtx = derivationSource.getActiveTxContext()\n\n        // ── Array-shape branch ─────────────────────────────────\n        if (out.kind === 'array') {\n          // Load the prior key set from the fanout sidecar.\n          const { loadFanoutSidecar, saveFanoutSidecar } = await import('./fanout-sidecar.js')\n          const prior = await loadFanoutSidecar(adapter, vault, spec.source, run.runId, key, getDEK, storeCiphertext)\n          const prevKeys = new Set<string>(prior?.keys ?? [])\n          const newKeysList = out.entries.map(e => e.key)\n          const newKeysSet = new Set<string>(newKeysList)\n\n          // Diff — delete keys that were in prev but not in new.\n          for (const k of prevKeys) {\n            if (newKeysSet.has(k)) continue\n            await outputCollection._internalDelete(k, txCtx)\n          }\n\n          // Upsert every entry in the new set. (Slice 1: no\n          // identity-skip optimisation; write every row, idempotent\n          // at the (collection, id) level.)\n          for (const entry of out.entries) {\n            if (txCtx !== null) {\n              trackPut(txCtx, outSpec.collection, entry.key, await adapter.get(vault, outSpec.collection, entry.key))\n            }\n            await putDerivedOutput(outputCollection, entry.key, entry.value, outCtx, { source: 'derived' })\n          }\n\n          // Persist the new key set last, for failure-mode symmetry.\n          await saveFanoutSidecar(adapter, vault, {\n            source: spec.source,\n            sourceId: run.runId,\n            outputKey: key,\n            outputCollection: outSpec.collection,\n            keys: newKeysList,\n          }, getDEK, storeCiphertext)\n          continue\n        }\n\n        // ── Record-shape branch ────────────────────────────────\n        if (out.skipped === true) {\n          // Optional output returned null. Delete the\n          // previously-emitted output at this id, if any. Routed\n          // through `_internalDelete` so a user-registered\n          // `onDelete` on the output collection does NOT\n          // fire — this is a system-internal tombstone, not a\n          // user-initiated delete. The txCtx hookup captures the\n          // prior envelope inside `_internalDelete` for rollback\n          // symmetry; delete-of-absent is a silent no-op.\n          await outputCollection._internalDelete(run.runId, txCtx)\n          continue\n        }\n\n        // ── Self-write reverse-denorm ───────────────────────────\n        // An output back to its own source: patch ONLY the declared\n        // `denorm` fields onto the raw stored record, never the whole\n        // value (which would clobber user fields / i18n maps and carries\n        // the executor's `_derivedFrom` tag). If the patch changes\n        // nothing, skip the write — that value-equality is the cycle\n        // guard: the self-write re-fires the source-path derivation,\n        // which recomputes identical fields and terminates here.\n        if (outSpec.shape === 'record' && outSpec.denorm !== undefined && outSpec.collection === spec.source) {\n          const value = out.value\n          const patched: Record<string, unknown> = { ...run.base }\n          let changed = false\n          for (const f of outSpec.denorm) {\n            if (!selfWriteFieldEqual(run.base[f], value[f])) {\n              patched[f] = value[f]\n              changed = true\n            }\n          }\n          if (!changed) continue // cycle guard — nothing to write\n          if (txCtx !== null) {\n            trackPut(txCtx, outSpec.collection, run.runId, await adapter.get(vault, outSpec.collection, run.runId))\n          }\n          await putDerivedOutput(outputCollection, run.runId, patched, outCtx, { source: 'derived' })\n          continue\n        }\n\n        // ── Normal record output (separate output collection) ──\n        if (txCtx !== null) {\n          trackPut(txCtx, outSpec.collection, run.runId, await adapter.get(vault, outSpec.collection, run.runId))\n        }\n        await putDerivedOutput(outputCollection, run.runId, out.value, outCtx, { source: 'derived' })\n      }\n    }\n  }\n}\n"],"mappings":"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","names":["ctx"]}

package/dist/registry-FZXPQRAB.js

@@ -1,18 +0,0 @@
-import {
-  DerivationRegistry
-} from "./chunk-OEA5NVSU.js";
-import "./chunk-UB5CRTFF.js";
-import "./chunk-CIGAQBJR.js";
-import "./chunk-4RUFYGWG.js";
-import "./chunk-BOWNCWZT.js";
-import "./chunk-YSRUYAVU.js";
-import "./chunk-RMF67KCG.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-SL3JAAKN.js";
-import "./chunk-N4CHCXDL.js";
-import "./chunk-7O3Y4PPD.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  DerivationRegistry
-};
-//# sourceMappingURL=registry-FZXPQRAB.js.map