@noy-db/hub 0.2.0-pre.14 → 0.2.0-pre.16

package/dist/bundle/index.cjs

@@ -3894,6 +3894,115 @@ var init_descriptor = __esm({
   }
 });
 
+// src/money/paths.ts
+function parseMoneyPath(path) {
+  const cached = parseCache.get(path);
+  if (cached) return cached;
+  if (typeof path !== "string" || path.length === 0) {
+    throw new ValidationError("moneyFields: path must be a non-empty string");
+  }
+  const segments = [];
+  for (const part of path.split(".")) {
+    const m = SEGMENT_RE.exec(part);
+    if (!m) {
+      throw new ValidationError(
+        `moneyFields: invalid path "${path}" \u2014 segment "${part}" must be a key, "key[]", "*", or "*[]"`
+      );
+    }
+    const array = m[2] === "[]";
+    segments.push(
+      m[1] === "*" ? { kind: "wildcard", array } : { kind: "key", key: m[1], array }
+    );
+  }
+  parseCache.set(path, segments);
+  return segments;
+}
+function isSimpleMoneyPath(path) {
+  return !path.includes(".") && !path.includes("[") && !path.includes("*");
+}
+function validateMoneyFieldPaths(moneyFields) {
+  for (const path of Object.keys(moneyFields)) parseMoneyPath(path);
+}
+function transformAtMoneyPath(node, path, segments, index, visit, lenient) {
+  if (node === null || node === void 0) return node;
+  const seg = segments[index];
+  const last = index === segments.length - 1;
+  if (seg.kind === "key") {
+    if (typeof node !== "object" || Array.isArray(node)) {
+      if (lenient) return node;
+      throw new ValidationError(
+        `moneyFields: path "${path}" expected an object at segment "${seg.key}", got ${Array.isArray(node) ? "an array" : typeof node}`
+      );
+    }
+    const obj2 = node;
+    if (!(seg.key in obj2) || obj2[seg.key] === null || obj2[seg.key] === void 0) return node;
+    if (seg.array) {
+      const arr = obj2[seg.key];
+      if (!Array.isArray(arr)) {
+        if (lenient) return node;
+        throw new ValidationError(
+          `moneyFields: path "${path}" declares "${seg.key}[]" but the value is not an array`
+        );
+      }
+      const cloned = [...arr];
+      if (last) {
+        for (let i = 0; i < cloned.length; i++) visit(cloned, i);
+      } else {
+        for (let i = 0; i < cloned.length; i++) {
+          cloned[i] = transformAtMoneyPath(cloned[i], path, segments, index + 1, visit, lenient);
+        }
+      }
+      return { ...obj2, [seg.key]: cloned };
+    }
+    const clone3 = { ...obj2 };
+    if (last) {
+      visit(clone3, seg.key);
+    } else {
+      clone3[seg.key] = transformAtMoneyPath(clone3[seg.key], path, segments, index + 1, visit, lenient);
+    }
+    return clone3;
+  }
+  if (seg.array) {
+    if (!Array.isArray(node)) {
+      if (lenient) return node;
+      throw new ValidationError(`moneyFields: path "${path}" declares "*[]" but the value is not an array`);
+    }
+    const cloned = [...node];
+    if (last) {
+      for (let i = 0; i < cloned.length; i++) visit(cloned, i);
+    } else {
+      for (let i = 0; i < cloned.length; i++) {
+        cloned[i] = transformAtMoneyPath(cloned[i], path, segments, index + 1, visit, lenient);
+      }
+    }
+    return cloned;
+  }
+  if (typeof node !== "object" || Array.isArray(node)) {
+    if (lenient) return node;
+    throw new ValidationError(
+      `moneyFields: path "${path}" applies "*" to a non-object (${Array.isArray(node) ? 'array \u2014 use "*[]"' : typeof node})`
+    );
+  }
+  const obj = node;
+  const clone2 = { ...obj };
+  for (const key of Object.keys(obj)) {
+    const v = clone2[key];
+    if (v === null || v === void 0) continue;
+    if (last) visit(clone2, key);
+    else clone2[key] = transformAtMoneyPath(v, path, segments, index + 1, visit, lenient);
+  }
+  return clone2;
+}
+var SEGMENT_RE, parseCache;
+var init_paths = __esm({
+  "src/money/paths.ts"() {
+    "use strict";
+    init_errors();
+    SEGMENT_RE = /^(\*|[^.[\]*]+)(\[\])?$/;
+    parseCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/money/normalize.ts
 function isMoneyValueObject(v) {
   return typeof v === "object" && v !== null && "currency" in v;
@@ -3906,33 +4015,68 @@ function quantizeAmount(field, input, scale, rounding) {
   }
   return r.value.toString();
 }
+function canonicalizeStoredMoney(record, moneyFields) {
+  if (record === null || record === void 0) return record;
+  if (!moneyFields || Object.keys(moneyFields).length === 0) return record;
+  return decodeMoneyFields(record, moneyFields, "raw");
+}
+function canonicalizeIncomingMoney(record, moneyFields) {
+  if (!moneyFields || Object.keys(moneyFields).length === 0) return record;
+  try {
+    return decodeMoneyFields(
+      quantizeMoneyFields(record, moneyFields),
+      moneyFields,
+      "raw"
+    );
+  } catch {
+    return record;
+  }
+}
+function quantizeValue(field, raw, desc) {
+  if (desc.mode === "fixed") {
+    const currency2 = desc.fixedCurrency;
+    return quantizeAmount(field, raw, desc.scaleFor(currency2), desc.rounding);
+  }
+  let amount;
+  let currency;
+  if (isMoneyValueObject(raw)) {
+    currency = String(raw.currency);
+    amount = raw.amount;
+  } else {
+    const sole = desc.soleCurrency();
+    if (sole === void 0) {
+      throw new TypeError(
+        `money: field "${field}" is multi-currency \u2014 write { amount, currency }, not a bare amount`
+      );
+    }
+    currency = sole;
+    amount = raw;
+  }
+  const scale = desc.scaleFor(currency);
+  return { amount: quantizeAmount(field, amount, scale, desc.rounding), currency };
+}
 function quantizeMoneyFields(record, moneyFields) {
-  const out = { ...record };
-  for (const [field, desc] of Object.entries(moneyFields)) {
-    const raw = out[field];
-    if (raw === null || raw === void 0) continue;
-    if (desc.mode === "fixed") {
-      const currency2 = desc.fixedCurrency;
-      out[field] = quantizeAmount(field, raw, desc.scaleFor(currency2), desc.rounding);
+  let out = { ...record };
+  for (const [path, desc] of Object.entries(moneyFields)) {
+    if (isSimpleMoneyPath(path)) {
+      const raw = out[path];
+      if (raw === null || raw === void 0) continue;
+      out[path] = quantizeValue(path, raw, desc);
       continue;
     }
-    let amount;
-    let currency;
-    if (isMoneyValueObject(raw)) {
-      currency = String(raw.currency);
-      amount = raw.amount;
-    } else {
-      const sole = desc.soleCurrency();
-      if (sole === void 0) {
-        throw new TypeError(
-          `money: field "${field}" is multi-currency \u2014 write { amount, currency }, not a bare amount`
-        );
-      }
-      currency = sole;
-      amount = raw;
-    }
-    const scale = desc.scaleFor(currency);
-    out[field] = { amount: quantizeAmount(field, amount, scale, desc.rounding), currency };
+    out = transformAtMoneyPath(
+      out,
+      path,
+      parseMoneyPath(path),
+      0,
+      (container, key) => {
+        const raw = container[key];
+        if (raw === null || raw === void 0) return;
+        container[key] = quantizeValue(path, raw, desc);
+      },
+      /* lenient */
+      false
+    );
   }
   return out;
 }
@@ -3945,33 +4089,70 @@ function formatCurrency(decimal, currency, scale, locale) {
   });
   return fmt.format(decimal);
 }
+function decodeValue(stored, desc) {
+  let currency;
+  let scaledIntString;
+  if (desc.mode === "fixed") {
+    if (typeof stored !== "string" && typeof stored !== "number") return null;
+    currency = desc.fixedCurrency;
+    scaledIntString = String(stored);
+  } else {
+    if (!isMoneyValueObject(stored)) return null;
+    const amount = stored.amount;
+    if (typeof stored.currency !== "string" || typeof amount !== "string" && typeof amount !== "number") return null;
+    currency = stored.currency;
+    scaledIntString = String(amount);
+  }
+  const scale = desc.scaleFor(currency);
+  let decimal;
+  try {
+    decimal = formatScaledInt(BigInt(scaledIntString), scale);
+  } catch {
+    return null;
+  }
+  return {
+    decoded: desc.mode === "fixed" ? decimal : { amount: decimal, currency },
+    decimal,
+    currency,
+    scale
+  };
+}
 function decodeMoneyFields(record, moneyFields, locale) {
-  const out = { ...record };
+  let out = { ...record };
   const format = locale !== "raw";
   const fmtLocale = typeof locale === "string" && locale !== "raw" ? locale : "en-US";
-  for (const [field, desc] of Object.entries(moneyFields)) {
-    const stored = out[field];
-    if (stored === null || stored === void 0) continue;
-    let currency;
-    let scaledIntString;
-    if (desc.mode === "fixed") {
-      if (typeof stored !== "string" && typeof stored !== "number") continue;
-      currency = desc.fixedCurrency;
-      scaledIntString = String(stored);
-    } else {
-      if (!isMoneyValueObject(stored)) continue;
-      const amount = stored.amount;
-      if (typeof stored.currency !== "string" || typeof amount !== "string" && typeof amount !== "number") continue;
-      currency = stored.currency;
-      scaledIntString = String(amount);
-    }
-    const scale = desc.scaleFor(currency);
-    const decimal = formatScaledInt(BigInt(scaledIntString), scale);
-    out[field] = desc.mode === "fixed" ? decimal : { amount: decimal, currency };
-    if (format) {
-      out[`${field}Formatted`] = formatCurrency(decimal, currency, scale, fmtLocale);
-      out[`${field}Number`] = Number(decimal);
+  for (const [path, desc] of Object.entries(moneyFields)) {
+    if (isSimpleMoneyPath(path)) {
+      const stored = out[path];
+      if (stored === null || stored === void 0) continue;
+      const r = decodeValue(stored, desc);
+      if (r === null) continue;
+      out[path] = r.decoded;
+      if (format) {
+        out[`${path}Formatted`] = formatCurrency(r.decimal, r.currency, r.scale, fmtLocale);
+        out[`${path}Number`] = Number(r.decimal);
+      }
+      continue;
     }
+    out = transformAtMoneyPath(
+      out,
+      path,
+      parseMoneyPath(path),
+      0,
+      (container, key) => {
+        const stored = container[key];
+        if (stored === null || stored === void 0) return;
+        const r = decodeValue(stored, desc);
+        if (r === null) return;
+        container[key] = r.decoded;
+        if (format && typeof key === "string" && !Array.isArray(container)) {
+          container[`${key}Formatted`] = formatCurrency(r.decimal, r.currency, r.scale, fmtLocale);
+          container[`${key}Number`] = Number(r.decimal);
+        }
+      },
+      /* lenient */
+      true
+    );
   }
   return out;
 }
@@ -3980,6 +4161,7 @@ var init_normalize = __esm({
     "use strict";
     init_fixed_point();
     init_descriptor();
+    init_paths();
   }
 });
 
@@ -4152,6 +4334,146 @@ var init_strategy3 = __esm({
   }
 });
 
+// src/money/where.ts
+function isMoneyValueObject2(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function parseOperand(field, raw, desc) {
+  let amount;
+  let currency;
+  if (desc.mode === "fixed") {
+    currency = desc.fixedCurrency;
+    amount = raw;
+  } else if (isMoneyValueObject2(raw)) {
+    currency = String(raw.currency);
+    amount = raw.amount;
+  } else {
+    const sole = desc.soleCurrency();
+    if (sole === void 0) {
+      throw new MoneyUnsupportedError(
+        `where("${field}"): field is multi-currency \u2014 compare against { amount, currency }, not a bare amount`
+      );
+    }
+    currency = sole;
+    amount = raw;
+  }
+  if (typeof amount !== "number" && typeof amount !== "string") {
+    throw new MoneyUnsupportedError(
+      `where("${field}"): operand ${JSON.stringify(raw)} is not a money amount`
+    );
+  }
+  const r = parseToScaledInt(amount, desc.scaleFor(currency), desc.rounding);
+  if (!r.ok) {
+    throw new MoneyUnsupportedError(
+      `where("${field}"): operand ${JSON.stringify(amount)} is not a finite decimal`
+    );
+  }
+  return { scaled: r.value.toString(), currency };
+}
+function moneyFieldClause(field, op, value, desc) {
+  switch (op) {
+    case "==":
+    case "!=":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=": {
+      const e = parseOperand(field, value, desc);
+      return withMoney(field, op, value, desc, [e]);
+    }
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new MoneyUnsupportedError(`where("${field}"): 'between' needs a [lo, hi] tuple`);
+      }
+      const lo = parseOperand(field, value[0], desc);
+      const hi = parseOperand(field, value[1], desc);
+      if (lo.currency !== hi.currency) {
+        throw new MoneyUnsupportedError(
+          `where("${field}"): 'between' bounds mix currencies (${lo.currency} vs ${hi.currency})`
+        );
+      }
+      return withMoney(field, op, value, desc, [lo, hi]);
+    }
+    case "in": {
+      if (!Array.isArray(value)) {
+        throw new MoneyUnsupportedError(`where("${field}"): 'in' needs an array of amounts`);
+      }
+      return withMoney(field, op, value, desc, value.map((v) => parseOperand(field, v, desc)));
+    }
+    default:
+      throw new MoneyUnsupportedError(
+        `where("${field}"): operator '${op}' is not supported on a money field`
+      );
+  }
+}
+function withMoney(field, op, originalValue, desc, entries) {
+  const money = { mode: desc.mode, entries };
+  const value = desc.mode !== "fixed" ? originalValue : entries.length === 1 && op !== "in" && op !== "between" ? entries[0].scaled : entries.map((e) => e.scaled);
+  return { type: "field", field, op, value, money };
+}
+function readStored(actual, operand) {
+  let amount;
+  let currency;
+  if (operand.mode === "fixed") {
+    if (typeof actual !== "string" && typeof actual !== "number") return null;
+    amount = actual;
+    currency = operand.entries[0]?.currency ?? "";
+  } else {
+    if (!isMoneyValueObject2(actual)) return null;
+    if (typeof actual.currency !== "string") return null;
+    amount = actual.amount;
+    currency = actual.currency;
+  }
+  if (typeof amount !== "string" && typeof amount !== "number") return null;
+  try {
+    return { scaled: BigInt(amount).toString(), currency };
+  } catch {
+    return null;
+  }
+}
+function evaluateMoneyClause(actual, op, operand) {
+  const stored = readStored(actual, operand);
+  if (stored === null) return op === "!=";
+  const a = BigInt(stored.scaled);
+  if (op === "in") {
+    return operand.entries.some(
+      (e2) => e2.currency === stored.currency && BigInt(e2.scaled) === a
+    );
+  }
+  if (op === "between") {
+    const [lo, hi] = operand.entries;
+    if (!lo || !hi || lo.currency !== stored.currency) return false;
+    return a >= BigInt(lo.scaled) && a <= BigInt(hi.scaled);
+  }
+  const e = operand.entries[0];
+  if (!e) return false;
+  if (e.currency !== stored.currency) return op === "!=";
+  const b = BigInt(e.scaled);
+  switch (op) {
+    case "==":
+      return a === b;
+    case "!=":
+      return a !== b;
+    case "<":
+      return a < b;
+    case "<=":
+      return a <= b;
+    case ">":
+      return a > b;
+    case ">=":
+      return a >= b;
+    default:
+      return false;
+  }
+}
+var init_where = __esm({
+  "src/money/where.ts"() {
+    "use strict";
+    init_fixed_point();
+    init_descriptor();
+  }
+});
+
 // src/query/predicate.ts
 function readPath(record, path) {
   if (record === null || record === void 0) return void 0;
@@ -4169,6 +4491,7 @@ function readPath(record, path) {
 function evaluateFieldClause(record, clause) {
   const actual = readPath(record, clause.field);
   const { op, value } = clause;
+  if (clause.money) return evaluateMoneyClause(actual, op, clause.money);
   switch (op) {
     case "==":
       return actual === value;
@@ -4209,14 +4532,14 @@ function isComparable(a, b) {
   if (a instanceof Date && b instanceof Date) return true;
   return false;
 }
-function evaluateClause(record, clause) {
+function evaluateClause(record, clause, fnRecord) {
   switch (clause.type) {
     case "field":
       return evaluateFieldClause(record, clause);
     case "filter":
-      return clause.fn(record);
+      return clause.fn(fnRecord !== void 0 ? fnRecord : record);
     case "wherePredicate":
-      return clause.fn(record, clause.ctx);
+      return clause.fn(fnRecord !== void 0 ? fnRecord : record, clause.ctx);
     case "crossJoin":
       throw new Error(
         `evaluateClause: 'crossJoin' clauses are expansion primitives and are not evaluated per-record. This is a query planner routing error \u2014 crossJoin clauses must be extracted from the clause list before calling evaluateClause or filterRecords.`
@@ -4224,20 +4547,28 @@ function evaluateClause(record, clause) {
     case "group":
       if (clause.op === "and") {
         for (const child of clause.clauses) {
-          if (!evaluateClause(record, child)) return false;
+          if (!evaluateClause(record, child, fnRecord)) return false;
         }
         return true;
       } else {
         for (const child of clause.clauses) {
-          if (evaluateClause(record, child)) return true;
+          if (evaluateClause(record, child, fnRecord)) return true;
         }
         return false;
       }
   }
 }
+function hasFnClause(clauses) {
+  for (const c of clauses) {
+    if (c.type === "filter" || c.type === "wherePredicate") return true;
+    if (c.type === "group" && hasFnClause(c.clauses)) return true;
+  }
+  return false;
+}
 var init_predicate = __esm({
   "src/query/predicate.ts"() {
     "use strict";
+    init_where();
   }
 });
 
@@ -4503,13 +4834,22 @@ var init_strategy4 = __esm({
 });
 
 // src/money/money-reducer.ts
-function toScaledInt(v) {
-  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint") {
-    try {
-      return BigInt(v);
-    } catch {
-      return null;
+function toScaledIntFromAny(v, scale) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") {
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
+  }
+  if (typeof v === "string") {
+    if (!v.includes(".")) {
+      try {
+        return BigInt(v);
+      } catch {
+        return null;
+      }
     }
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
   }
   return null;
 }
@@ -4517,13 +4857,15 @@ function readMoney(record, field, desc) {
   const raw = readPath(record, field);
   if (raw === null || raw === void 0) return null;
   if (desc.mode === "fixed") {
-    const value2 = toScaledInt(raw);
-    return value2 === null ? null : { currency: desc.fixedCurrency, value: value2 };
+    const cur = desc.fixedCurrency;
+    const value2 = toScaledIntFromAny(raw, desc.scaleFor(cur));
+    return value2 === null ? null : { currency: cur, value: value2 };
   }
   if (typeof raw !== "object") return null;
   const o = raw;
   if (typeof o.currency !== "string") return null;
-  const value = toScaledInt(o.amount);
+  const scale = desc.allows(o.currency) ? desc.scaleFor(o.currency) : 0;
+  const value = toScaledIntFromAny(o.amount, scale);
   return value === null ? null : { currency: o.currency, value };
 }
 function targetScaleFor(desc, currency) {
@@ -4698,7 +5040,7 @@ function executePlanWithSource(source, plan, joinContext) {
     result = executeClausePipeline(source, plan.clauses, joinContext);
   } else {
     const { candidates, remainingClauses } = candidateRecords(source, plan.clauses);
-    result = remainingClauses.length === 0 ? [...candidates] : filterRecords(candidates, remainingClauses);
+    result = remainingClauses.length === 0 ? [...candidates] : filterRecords(candidates, remainingClauses, fnViewDecoder(source));
   }
   if (plan.orderBy.length > 0) {
     result = sortRecords(result, plan.orderBy);
@@ -4721,6 +5063,7 @@ function candidateRecords(source, clauses) {
     const clause = clauses[i];
     if (clause.type !== "field") continue;
     if (!indexes.has(clause.field)) continue;
+    if (clause.money?.mode === "multi") continue;
     let ids = null;
     if (clause.op === "==") {
       ids = indexes.lookupEqual(clause.field, clause.value);
@@ -4748,13 +5091,20 @@ function materializeIds(ids, lookupById) {
   }
   return out;
 }
-function filterRecords(records, clauses) {
+function fnViewDecoder(source) {
+  const mf = source.moneyFields;
+  if (!mf || Object.keys(mf).length === 0) return void 0;
+  return (r) => decodeMoneyFields(r, mf, "raw");
+}
+function filterRecords(records, clauses, decodeForFns) {
   if (clauses.length === 0) return [...records];
+  const needsFnView = decodeForFns !== void 0 && hasFnClause(clauses);
   const out = [];
   for (const r of records) {
+    const fnView = needsFnView ? decodeForFns(r) : void 0;
     let matches = true;
     for (const clause of clauses) {
-      if (!evaluateClause(r, clause)) {
+      if (!evaluateClause(r, clause, fnView)) {
         matches = false;
         break;
       }
@@ -4766,10 +5116,11 @@ function filterRecords(records, clauses) {
 function executeClausePipeline(source, clauses, joinContext) {
   let rel = [...source.snapshot()];
   let filterBatch = [];
+  const decodeForFns = fnViewDecoder(source);
   for (const clause of clauses) {
     if (clause.type === "crossJoin") {
       if (filterBatch.length > 0) {
-        rel = filterRecords(rel, filterBatch);
+        rel = filterRecords(rel, filterBatch, decodeForFns);
         filterBatch = [];
       }
       const rightSource = joinContext.resolveSource(clause.target);
@@ -4782,7 +5133,7 @@ function executeClausePipeline(source, clauses, joinContext) {
     }
   }
   if (filterBatch.length > 0) {
-    rel = filterRecords(rel, filterBatch);
+    rel = filterRecords(rel, filterBatch, decodeForFns);
   }
   return rel;
 }
@@ -4963,6 +5314,7 @@ var init_builder = __esm({
     init_strategy4();
     init_money_reducer();
     init_normalize();
+    init_where();
     EMPTY_PLAN = {
       clauses: [],
       orderBy: [],
@@ -5054,9 +5406,18 @@ var init_builder = __esm({
           this.predicates
         );
       }
-      /** Add a field comparison. Multiple where() calls are AND-combined. */
+      /**
+       * Add a field comparison. Multiple where() calls are AND-combined.
+       *
+       * A declared money field compares in MAJOR units (#336): the operand
+       * (`10000`, `'10000.00'`, or `{ amount, currency }` in multi mode) is
+       * quantized into stored scaled-int space at build time and evaluated
+       * BigInt-exact per record. A malformed operand or a string operator
+       * (`contains`/`startsWith`) throws here, at the call site.
+       */
       where(field, op, value) {
-        const clause = { type: "field", field, op, value };
+        const desc = this.source.moneyFields?.[field];
+        const clause = desc ? moneyFieldClause(field, op, value, desc) : { type: "field", field, op, value };
         return new _Query(
           this.source,
           { ...this.plan, clauses: [...this.plan.clauses, clause] },
@@ -5382,7 +5743,7 @@ var init_builder = __esm({
         }
         const { candidates, remainingClauses } = candidateRecords(this.source, this.plan.clauses);
         if (remainingClauses.length === 0) return candidates.length;
-        return filterRecords(candidates, remainingClauses).length;
+        return filterRecords(candidates, remainingClauses, fnViewDecoder(this.source)).length;
       }
       /**
        * Reduce the matching records through a named set of reducers.
@@ -5439,7 +5800,7 @@ var init_builder = __esm({
             return executeClausePipeline(source, clauses, joinCtx);
           }
           const { candidates, remainingClauses } = candidateRecords(source, clauses);
-          return remainingClauses.length === 0 ? candidates : filterRecords(candidates, remainingClauses);
+          return remainingClauses.length === 0 ? candidates : filterRecords(candidates, remainingClauses, fnViewDecoder(source));
         };
         const upstreams = [];
         if (source.subscribe) {
@@ -5462,7 +5823,7 @@ var init_builder = __esm({
             return executeClausePipeline(source, clauses, joinCtx);
           }
           const { candidates, remainingClauses } = candidateRecords(source, clauses);
-          return remainingClauses.length === 0 ? candidates : filterRecords(candidates, remainingClauses);
+          return remainingClauses.length === 0 ? candidates : filterRecords(candidates, remainingClauses, fnViewDecoder(source));
         };
         const upstreams = [];
         if (source.subscribe) {
@@ -5655,11 +6016,14 @@ function warnCardinalityApproaching(fields, observed) {
     `[noy-db] .groupBy(${label}) produced ${observed} distinct groups, ${Math.round(observed / GROUPBY_MAX_CARDINALITY * 100)}% of the ${GROUPBY_MAX_CARDINALITY}-group ceiling. Narrow the query with .where() before grouping, or switch to a lower-cardinality field.`
   );
 }
-function groupAndReduce(records, fieldOrFields, spec) {
+function groupAndReduce(records, fieldOrFields, spec, moneyFields) {
   const fields = typeof fieldOrFields === "string" ? [fieldOrFields] : fieldOrFields;
   if (fields.length === 0) {
     throw new Error(".groupBy() requires at least one field");
   }
+  if (moneyFields) {
+    spec = wrapMoneyReducers(spec, moneyFields);
+  }
   const buckets = /* @__PURE__ */ new Map();
   const fieldLabel = fields.length === 1 ? fields[0] : `[${fields.join(", ")}]`;
   for (const record of records) {
@@ -5715,6 +6079,7 @@ var init_groupby = __esm({
     init_predicate();
     init_canonical_key();
     init_errors();
+    init_money_reducer();
     GROUPBY_WARN_CARDINALITY = 1e4;
     GROUPBY_MAX_CARDINALITY = 1e5;
     warnedCardinalityFields = /* @__PURE__ */ new Set();
@@ -5735,6 +6100,7 @@ var init_scan_builder = __esm({
     init_predicate();
     init_errors();
     init_normalize();
+    init_where();
     DEFAULT_SCAN_PAGE_SIZE = 100;
     ScanBuilder = class _ScanBuilder {
       pageProvider;
@@ -5798,7 +6164,8 @@ var init_scan_builder = __esm({
        * evaluates clauses per record in O(1) per clause.
        */
       where(field, op, value) {
-        const clause = { type: "field", field, op, value };
+        const desc = this.moneyFields?.[field];
+        const clause = desc ? moneyFieldClause(field, op, value, desc) : { type: "field", field, op, value };
         return new _ScanBuilder(
           this.pageProvider,
           this.pageSize,
@@ -6144,8 +6511,9 @@ var init_scan_builder = __esm({
        */
       recordMatches(record) {
         if (this.clauses.length === 0) return true;
+        const fnView = this.moneyFields && Object.keys(this.moneyFields).length > 0 && hasFnClause(this.clauses) ? this.decodeMoney(record) : void 0;
         for (const clause of this.clauses) {
-          if (!evaluateClause(record, clause)) return false;
+          if (!evaluateClause(record, clause, fnView)) return false;
         }
         return true;
       }
@@ -7113,10 +7481,14 @@ function summarizeQueryPlan(query) {
   });
 }
 function summarizeUnionPlan(spec) {
-  const arms = (spec.unionSources ?? []).map((s) => s.collection).join(",");
+  const arms = (spec.unionSources ?? []).map((s) => {
+    const joins = s.join?.length ? `[${s.join.map((j) => `${j.field}\u2192${j.as}`).join(";")}]` : "";
+    return `${s.collection}${joins}`;
+  }).join(",");
   const groupBy = Array.isArray(spec.groupBy) ? [...spec.groupBy].sort().join(",") : typeof spec.groupBy === "string" ? spec.groupBy : "";
   const aggKeys = spec.aggregate ? Object.keys(spec.aggregate).sort().join(",") : "";
-  return `union(${arms})|groupBy(${groupBy})|aggregate(${aggKeys})`;
+  const moneyKeys = spec.moneyFields ? Object.keys(spec.moneyFields).sort().join(",") : "";
+  return `union(${arms})|groupBy(${groupBy})|aggregate(${aggKeys})|money(${moneyKeys})`;
 }
 var init_dependency_analyzer = __esm({
   "src/materialized-views/dependency-analyzer.ts"() {
@@ -7243,6 +7615,7 @@ var init_registry = __esm({
         let isQuery = false;
         if (spec.unionSources) {
           dependencies = new Set(spec.unionSources.map((s) => s.collection));
+          if (spec.sources) for (const s of spec.sources) dependencies.add(s);
           queryPlanSummary = summarizeUnionPlan(spec);
         } else {
           const q = spec.query(dbForQuery);
@@ -7397,7 +7770,13 @@ async function materializeUnionResult(spec, db) {
   const unified = [];
   for (const arm of spec.unionSources) {
     const coll = db.collection(arm.collection);
-    const sourceRows = coll.query().toArray();
+    let q = coll.query();
+    if (arm.join?.length) {
+      for (const leg of arm.join) {
+        q = q.join(leg.field, { as: leg.as, maxRows: leg.maxRows, strategy: leg.strategy });
+      }
+    }
+    const sourceRows = q.toArray();
     for (const r of sourceRows) {
       const mapped = arm.map(r);
       if (mapped == null) continue;
@@ -7414,7 +7793,7 @@ async function materializeUnionResult(spec, db) {
     }
     return [...seen.values()];
   }
-  return groupAndReduce(unified, groupFields, spec.aggregate);
+  return groupAndReduce(unified, groupFields, spec.aggregate, spec.moneyFields);
 }
 async function listOutputIds(outputColl) {
   const cAny = outputColl;
@@ -7686,6 +8065,7 @@ var init_collection = __esm({
     init_strategy();
     init_core();
     init_normalize();
+    init_paths();
     init_computed();
     init_strategy2();
     init_policy();
@@ -8008,6 +8388,7 @@ var init_collection = __esm({
         this.joinResolver = opts.joinResolver;
         this.i18nFields = opts.i18nFields;
         this.dictKeyFields = opts.dictKeyFields;
+        if (opts.moneyFields) validateMoneyFieldPaths(opts.moneyFields);
         this.moneyFields = opts.moneyFields;
         this.computed = opts.computed;
         this.dictLabelResolver = opts.dictLabelResolver;
@@ -8141,7 +8522,9 @@ var init_collection = __esm({
        * declaration; this reconciles that ordering. First-wins. Not public.
        */
       _applyMoneyFields(moneyFields) {
-        if (this.moneyFields === void 0) this.moneyFields = moneyFields;
+        if (this.moneyFields !== void 0) return;
+        validateMoneyFieldPaths(moneyFields);
+        this.moneyFields = moneyFields;
       }
       /** @internal — attach computed fields post-construction. See {@link _applyMoneyFields}. */
       _applyComputed(computed) {
@@ -8308,6 +8691,7 @@ var init_collection = __esm({
         if (!hasWritePermission(this.keyring, this.name)) {
           throw new ReadOnlyError();
         }
+        record = canonicalizeIncomingMoney(record, this.moneyFields);
         if (this.subsystemBus?.hasGateHandlers("beforePut")) {
           const existingEnv = await this.adapter.get(this.vault, this.name, id);
           let existingRecord = null;
@@ -8324,7 +8708,7 @@ var init_collection = __esm({
             collection: this.name,
             docId: id,
             incoming: record,
-            existing: existingRecord,
+            existing: canonicalizeStoredMoney(existingRecord, this.moneyFields),
             existingVersion: existingEnv?._v ?? 0,
             existingTs: existingEnv?._ts,
             userId: this.keyring.userId,
@@ -8593,7 +8977,7 @@ var init_collection = __esm({
        */
       async dispatchDerivations(id, record, version) {
         if (this.derivationSource === void 0) return;
-        const incoming = record;
+        const incoming = canonicalizeStoredMoney(record, this.moneyFields);
         if (incoming && typeof incoming === "object" && "_derivedFrom" in incoming) return;
         const registry = this.derivationSource.registry();
         const strategies = registry.strategiesForSource(this.name);
@@ -8605,9 +8989,18 @@ var init_collection = __esm({
             if (DerivationExecutor2 === null) {
               ({ DerivationExecutor: DerivationExecutor2 } = await Promise.resolve().then(() => (init_executor(), executor_exports)));
             }
-            const sourceWithId = { ...incoming, id };
+            let sourceWithId;
+            let sourceVersion = version;
+            if (spec.source === this.name) {
+              sourceWithId = { ...incoming, id };
+            } else {
+              const primary = await this.derivationSource.getCollection(spec.source).get(id);
+              if (primary === null || primary === void 0) continue;
+              sourceWithId = { ...primary, id };
+              sourceVersion = 0;
+            }
             const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
-            const result = await DerivationExecutor2.run(spec, sourceWithId, version, strategyHash, ctx);
+            const result = await DerivationExecutor2.run(spec, sourceWithId, sourceVersion, strategyHash, ctx);
             for (const key of Object.keys(spec.outputs)) {
               const out = result.outputs[key];
               if (!out) continue;
@@ -8826,7 +9219,7 @@ var init_collection = __esm({
               vault: this.vault,
               collection: this.name,
               docId: id,
-              existing: existingRecord,
+              existing: canonicalizeStoredMoney(existingRecord, this.moneyFields),
               existingVersion: existingEnv._v,
               existingTs: existingEnv._ts,
               internal,
@@ -10559,37 +10952,34 @@ var init_virtual_collection = __esm({
       /** Get the merged row by id. */
       async get(id) {
         const overlayRow = await this.overlayCollection.get(id);
-        if (overlayRow !== null && this.shadowPredicateApplies(overlayRow)) {
-          return overlayRow;
-        }
         const baseRow = await this.baseCollection.get(id);
-        if (baseRow !== null) return baseRow;
-        return null;
+        return this.mergeRows(overlayRow, baseRow);
       }
       /** List union of base + overlay ids, applying the merge per row. */
       async list() {
         const baseRows = await this.baseCollection.list();
         const overlayRows = await this.overlayCollection.list();
-        const merged = /* @__PURE__ */ new Map();
         const idOf = (row) => {
           if (this.baseRowKey) return this.baseRowKey(row);
           const idField = row.id;
           return typeof idField === "string" ? idField : "";
         };
+        const baseById = /* @__PURE__ */ new Map();
+        const overlayById = /* @__PURE__ */ new Map();
         for (const row of baseRows) {
           const id = idOf(row);
-          if (id) merged.set(id, row);
+          if (id) baseById.set(id, row);
         }
         for (const row of overlayRows) {
           const id = idOf(row);
-          if (!id) continue;
-          if (this.shadowPredicateApplies(row)) {
-            merged.set(id, row);
-          } else if (!merged.has(id)) {
-            continue;
-          }
+          if (id) overlayById.set(id, row);
+        }
+        const out = [];
+        for (const id of /* @__PURE__ */ new Set([...baseById.keys(), ...overlayById.keys()])) {
+          const merged = this.mergeRows(overlayById.get(id) ?? null, baseById.get(id) ?? null);
+          if (merged !== null) out.push(merged);
         }
-        return [...merged.values()];
+        return out;
       }
       /**
        * Write to the overlay. Two forms:
@@ -10629,9 +11019,42 @@ var init_virtual_collection = __esm({
       async delete(id) {
         await this.overlayCollection.delete(id);
       }
-      /** True when `overlay[shadowField] === shadowValue`. */
-      shadowPredicateApplies(row) {
-        return row[this.spec.shadowField] === this.spec.shadowValue;
+      /**
+       * Merge a single id's overlay + base rows into the visible row.
+       *
+       * Priority (first match wins):
+       *  1. Binary shadow win — overlay present AND
+       *     `overlay[shadowField] === shadowValue` → return the overlay row
+       *     entirely. This stays FIRST so the original binary behaviour is
+       *     unchanged whether or not `mergeMode` is configured.
+       *  2. Field-level merge — overlay present, `mergeMode` configured,
+       *     and a rule whose `whenStatus` equals `overlay[shadowField]`.
+       *     The matched rule pulls its `overlayFields` (those present on
+       *     the overlay row) on top of the base row. With no base row, the
+       *     overlay row is returned as-is.
+       *  3. Fallback — return the base row (possibly `null`). An
+       *     overlay-only row that qualifies under neither (1) nor (2) and
+       *     has no base is therefore NOT surfaced.
+       */
+      mergeRows(overlayRow, baseRow) {
+        const shadowField = this.spec.shadowField;
+        if (overlayRow !== null && overlayRow[shadowField] === this.spec.shadowValue) {
+          return overlayRow;
+        }
+        if (overlayRow !== null && this.spec.mergeMode) {
+          const status = overlayRow[shadowField];
+          const rule = this.spec.mergeMode.rules.find((r) => r.whenStatus === status);
+          if (rule) {
+            if (baseRow === null) return overlayRow;
+            const overlaySrc = overlayRow;
+            const picked = {};
+            for (const field of rule.overlayFields) {
+              if (field in overlaySrc) picked[field] = overlaySrc[field];
+            }
+            return { ...baseRow, ...picked };
+          }
+        }
+        return baseRow;
       }
       // ─── Throw-stubs for the unimplemented Collection<T> surface ───────
       //
@@ -10781,6 +11204,21 @@ var init_archive = __esm({
 });
 
 // src/sequence/index.ts
+function resolveSequenceKey(series, opts) {
+  const partition = opts?.partition;
+  if (!partition || partition.length === 0) return series;
+  const parts = partition.map((p) => {
+    if (typeof p === "number" && !Number.isFinite(p)) {
+      throw new ValidationError(`sequence partition component must be a finite number, got ${p}`);
+    }
+    const s = String(p);
+    if (s === "") {
+      throw new ValidationError("sequence partition component must not be empty");
+    }
+    return encodeURIComponent(s);
+  });
+  return `${series}\0${parts.join("/")}`;
+}
 async function sleepBackoff2(attempt) {
   const ceil = Math.min(2 ** attempt, 32);
   const ms = Math.floor(Math.random() * ceil);
@@ -10820,7 +11258,8 @@ var init_sequence = __esm({
       handle(name) {
         return {
           next: () => this.next(name),
-          peek: () => this.peek(name)
+          peek: () => this.peek(name),
+          seedTo: (n) => this.seedTo(name, n)
         };
       }
       assertOnline() {
@@ -10873,6 +11312,30 @@ var init_sequence = __esm({
         void lastConflict;
         throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
       }
+      async seedTo(name, n) {
+        this.assertOnline();
+        if (n <= 0) return;
+        let lastConflict;
+        for (let attempt = 0; attempt < MAX_NEXT_ATTEMPTS; attempt++) {
+          const { env, value } = await this.read(name);
+          if (value >= n) return;
+          const expectedVersion = env?._v ?? 0;
+          const envelope = await this.encryptState({ value: n }, expectedVersion + 1);
+          try {
+            await this.adapter.put(this.vault, SEQUENCE_COLLECTION, name, envelope, expectedVersion);
+            return;
+          } catch (err) {
+            if (err instanceof ConflictError) {
+              lastConflict = err;
+              if (attempt < MAX_NEXT_ATTEMPTS - 1) await sleepBackoff2(attempt);
+              continue;
+            }
+            throw err;
+          }
+        }
+        void lastConflict;
+        throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
+      }
     };
   }
 });
@@ -12887,11 +13350,15 @@ var init_read_only_facade = __esm({
 });
 
 // src/derivations/strategy-hash.ts
-async function computeStrategyHash(source, outputKeys, derive) {
+async function computeStrategyHash(source, outputKeys, derive, sources) {
   const canonical2 = JSON.stringify({
     source,
     outputs: [...outputKeys].sort(),
-    derive: derive.toString()
+    derive: derive.toString(),
+    // Declared sibling sources (#344) — adding/removing a trigger
+    // collection invalidates cached derived records. Omitted when empty
+    // so strategies without siblings keep their existing hash.
+    ...sources?.length ? { sources: [...sources].sort() } : {}
   });
   const bytes = new TextEncoder().encode(canonical2);
   const digest = await crypto.subtle.digest("SHA-256", bytes);
@@ -12920,11 +13387,16 @@ var init_registry3 = __esm({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async register(spec) {
         const outputKeys = Object.keys(spec.outputs);
-        const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive);
+        const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources);
         const reg = { spec, strategyHash };
         const fromSource = this._bySource.get(spec.source);
         if (fromSource) fromSource.push(reg);
         else this._bySource.set(spec.source, [reg]);
+        for (const extra of spec.sources ?? []) {
+          const fromExtra = this._bySource.get(extra);
+          if (fromExtra) fromExtra.push(reg);
+          else this._bySource.set(extra, [reg]);
+        }
         for (const key of outputKeys) {
           const output = spec.outputs[key];
           if (!output) continue;
@@ -14100,17 +14572,23 @@ var init_vault = __esm({
        * const cur = await vault.sequence('invoice-2026').peek()  // current value, no allocation
        * ```
        */
-      sequence(name) {
-        if (this.numberingConfigs.has(name)) {
+      sequence(series, opts) {
+        if (series.includes("\0")) {
+          throw new ValidationError(`sequence("${series}"): series name must not contain a null byte (\\x00).`);
+        }
+        if (this.numberingConfigs.has(series)) {
           const eng = this.deferred();
           return {
-            next: async (opts) => {
-              if (!opts?.for) {
-                throw new ValidationError(`sequence("${name}") is a deferred-numbering series; call next({ for: recordId }).`);
+            next: async (nextOpts) => {
+              if (!nextOpts?.for) {
+                throw new ValidationError(`sequence("${series}") is a deferred-numbering series; call next({ for: recordId }).`);
               }
-              return (await eng.enqueue(name, opts.for)).assigned;
+              return (await eng.enqueue(series, nextOpts.for)).assigned;
             },
-            peek: () => eng.peek(name)
+            peek: () => eng.peek(series),
+            seedTo: () => {
+              throw new ValidationError(`sequence("${series}") is a deferred-numbering series; seedTo is CAS-only.`);
+            }
           };
         }
         if (!this.sequenceStore) {
@@ -14122,7 +14600,7 @@ var init_vault = __esm({
             actor: this.keyring.userId
           });
         }
-        return this.sequenceStore.handle(name);
+        return this.sequenceStore.handle(resolveSequenceKey(series, opts));
       }
       /** @internal — lazily build the deferred-numbering engine with a cache-coherent stamp. */
       deferred() {
@@ -14414,9 +14892,24 @@ var init_vault = __esm({
               });
             }
             if (rule.mode === "cascade") {
+              const txCtx = this.noydb._activeTxContextOrNull;
               for (const match of matches) {
                 const matchId = match["id"] ?? null;
                 if (matchId === null) continue;
+                if (txCtx !== null) {
+                  const prior = await this.adapter.get(this.name, rule.collection, matchId);
+                  if (prior !== null) {
+                    txCtx._executed.push({
+                      op: {
+                        type: "delete",
+                        vaultName: this.name,
+                        collectionName: rule.collection,
+                        id: matchId
+                      },
+                      priorEnvelope: prior
+                    });
+                  }
+                }
                 await fromCollection.delete(matchId);
               }
             }
@@ -16805,7 +17298,7 @@ var init_strategy11 = __esm({
       'Multi-record transactions require the tx strategy. Import `{ withTransactions }` from "@noy-db/hub/tx" and pass it to `createNoydb({ txStrategy: withTransactions() })`.'
     );
     NO_TX = {
-      async runTransaction() {
+      async runTransaction(_db, _fn, _options, _txInvariants) {
         throw NOT_ENABLED6;
       },
       async runDryRun() {