@noy-db/hub 0.7.1-pre.0 → 0.8.0

package/dist/{chunk-CUQPWYRX.js → chunk-IUT3GWP3.js}

@@ -1,43 +1,49 @@
 import {
   VectorSet
-} from "./chunk-RTBJ5IOO.js";
+} from "./chunk-M5B2W6YY.js";
 import {
   guardClassifiedCompat,
   resolveClassifiedFields
-} from "./chunk-5VCRVKOZ.js";
+} from "./chunk-GUZET4SG.js";
 import {
   jsonSchemaToFields
 } from "./chunk-VYYM3MEN.js";
 import {
   derivePersistedSchema,
   isZod4Schema
-} from "./chunk-ACAQ2DSG.js";
+} from "./chunk-747G6CT3.js";
 import {
   loadPersistedSchema
-} from "./chunk-SGZAIJCV.js";
+} from "./chunk-3L2NBKDR.js";
 import {
   buildPresentForJoin,
   isLookupDescriptor
-} from "./chunk-R7BX2NB3.js";
+} from "./chunk-244QBK7Z.js";
 import {
   Lru
 } from "./chunk-V4PXLYWM.js";
 import {
+  ViaPipeline
+} from "./chunk-3EWS67C7.js";
+import {
+  groupKeySourceField
+} from "./chunk-XBKH4FOC.js";
+import {
+  assertFieldPath,
   isDictKeyDescriptor,
   isI18nTextDescriptor,
   isStaticDictDescriptor
-} from "./chunk-TRGTKX5E.js";
+} from "./chunk-OKSTSITU.js";
 import {
   viaBinder
-} from "./chunk-UXVWEX5L.js";
+} from "./chunk-SYNY3VB5.js";
 import {
   ClassifiedConfigError,
   DerivationCycleError,
-  FieldNotQueryableError,
   MaterializedViewCycleError,
   UnsupportedTierCompositionError,
   ValidationError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-37EPTBBR.js";
 
 // src/with-shape/introspection/field-meta.ts
 var FieldMetaUnknownFieldError = class extends Error {
@@ -65,6 +71,7 @@ function resolveFieldMeta(key, inputs) {
   const semanticType = pick("semanticType");
   const unit = pick("unit");
   const sensitivity = pick("sensitivity");
+  const bulk = pick("bulk");
   const aggregate = pick("aggregate");
   const aliases = pick("aliases");
   const displayFor = pick("displayFor");
@@ -77,6 +84,7 @@ function resolveFieldMeta(key, inputs) {
     ...semanticType !== void 0 ? { semanticType } : {},
     ...unit !== void 0 ? { unit } : {},
     ...sensitivity !== void 0 ? { sensitivity } : {},
+    ...bulk !== void 0 ? { bulk } : {},
     ...aggregate !== void 0 ? { aggregate } : {},
     ...aliases !== void 0 ? { aliases } : {},
     ...displayFor !== void 0 ? { displayFor } : {},
@@ -130,7 +138,8 @@ var ZOD_META_KEYS = /* @__PURE__ */ new Set([
   "aliases",
   "displayFor",
   "group",
-  "order"
+  "order",
+  "bulk"
 ]);
 async function deriveZodFields(schema) {
   const envelope = await derivePersistedSchema(schema);
@@ -380,6 +389,7 @@ function buildDescription(input) {
       ...resolved.semanticType !== void 0 ? { semanticType: resolved.semanticType } : {},
       ...resolved.unit !== void 0 ? { unit: resolved.unit } : {},
       ...resolved.sensitivity !== void 0 ? { sensitivity: resolved.sensitivity } : {},
+      ...resolved.bulk !== void 0 ? { bulk: resolved.bulk } : {},
       ...resolved.aggregate !== void 0 ? { aggregate: resolved.aggregate } : {},
       ...resolved.aliases !== void 0 ? { aliases: resolved.aliases } : {},
       ...resolved.displayFor !== void 0 ? { displayFor: resolved.displayFor } : {},
@@ -439,7 +449,8 @@ function mergeViaFields(sources) {
       i18nFields: sources.i18nFields,
       dictKeyFields: sources.dictKeyFields,
       computedFields: void 0,
-      lookupFields: sources.lookupFields
+      lookupFields: sources.lookupFields,
+      geoFields: void 0
     };
   }
   const sugarFieldNames = /* @__PURE__ */ new Set([
@@ -453,6 +464,7 @@ function mergeViaFields(sources) {
   const viaDictKey = {};
   const viaComputed = {};
   const viaLookup = {};
+  const viaGeo = {};
   for (const [field, spec] of Object.entries(sources.viaFields)) {
     if (sugarFieldNames.has(field)) {
       throw new ValidationError(
@@ -469,8 +481,10 @@ function mergeViaFields(sources) {
         viaComputed[field] = descriptor;
       } else if (descriptor._viaBrand === "lookup" && isLookupDescriptor(descriptor)) {
         viaLookup[field] = descriptor;
+      } else if (descriptor._viaBrand === "geo") {
+        viaGeo[field] = descriptor;
       } else {
-        throw new ValidationError(`via(): field "${field}" has a descriptor with unrecognized _viaBrand "${descriptor._viaBrand}" \u2014 via() only supports money/i18n/computed/lookup descriptors today.`);
+        throw new ValidationError(`via(): field "${field}" has a descriptor with unrecognized _viaBrand "${descriptor._viaBrand}" \u2014 via() only supports money/i18n/computed/lookup/geo descriptors today.`);
       }
     }
   }
@@ -479,7 +493,8 @@ function mergeViaFields(sources) {
     i18nFields: Object.keys(viaI18nText).length > 0 ? { ...sources.i18nFields ?? {}, ...viaI18nText } : sources.i18nFields,
     dictKeyFields: Object.keys(viaDictKey).length > 0 ? { ...sources.dictKeyFields ?? {}, ...viaDictKey } : sources.dictKeyFields,
     computedFields: Object.keys(viaComputed).length > 0 ? viaComputed : void 0,
-    lookupFields: Object.keys(viaLookup).length > 0 ? { ...sources.lookupFields ?? {}, ...viaLookup } : sources.lookupFields
+    lookupFields: Object.keys(viaLookup).length > 0 ? { ...sources.lookupFields ?? {}, ...viaLookup } : sources.lookupFields,
+    geoFields: Object.keys(viaGeo).length > 0 ? viaGeo : void 0
   };
 }
 var VIA_FIELD_MAP_FAMILY = {
@@ -489,7 +504,8 @@ var VIA_FIELD_MAP_FAMILY = {
   lookupFields: "lookup",
   classifiedFields: "classified",
   blobFields: "blob",
-  computed: "computed"
+  computed: "computed",
+  geoFields: "geo"
 };
 function guardCrossBindingFieldCollisions(fieldMaps, callerPrefix = "compileVias()") {
   const claimantsByField = /* @__PURE__ */ new Map();
@@ -537,370 +553,6 @@ function guardReconcileCollisions(existingVia, incomingFieldMaps) {
   }
 }
 
-// src/kernel/via/pipeline.ts
-var ViaPipeline = class _ViaPipeline {
-  constructor(bindings, taint) {
-    this.bindings = bindings;
-    this.taint = taint;
-    const moneyVias = bindings.filter((b) => b.brand === "money");
-    const computedVias = bindings.filter((b) => b.brand === "computed");
-    const restBindings = bindings.filter((b) => b.brand !== "money" && b.brand !== "computed");
-    this._presentOrder = [...moneyVias, ...computedVias, ...restBindings];
-    this._presentLateBoundary = moneyVias.length + computedVias.length;
-  }
-  bindings;
-  taint;
-  /**
-   * Present-phase-ONLY order (#665, corrected under #665 review) — a stable
-   * THREE-WAY partition of `bindings` computed once here at construction:
-   * every `'money'`-brand binding first (existing relative order), then
-   * every `'computed'`-brand binding (existing relative order), then
-   * everything else (existing relative order). `present()` folds over this
-   * instead of `bindings` so a `mode: 'virtual'` computed field's value
-   * exists before i18n/lookup's dressing `present()` hooks run on it
-   * (today's `compileVias` order is money→i18n→lookup→classified→
-   * blob→computed, `collection-config.ts:554`, so dressing unconditionally
-   * ran BEFORE the value it dresses existed). This reorder is binding-level,
-   * not conditioned on any particular field composition — it applies to
-   * EVERY collection that compiles a `'computed'` binding at all, not only
-   * ones stacking a dresser on the SAME field as a computed one. EVERY other
-   * phase (`ingest`/`encodeWrite`/`encodeAtRest`/`enforceWrite`/etc.) keeps
-   * folding over `bindings` unchanged — those write/query phases need
-   * money-first (`_applyMoneyFields` PREPENDS money, `_applyClassifiedFields`
-   * APPENDS classified to preserve it, `kernel/collection.ts:1275-1284,1364-
-   * 1368`).
-   *
-   * Money is deliberately carved OUT of the generic "everything else" slice
-   * and kept FIRST — the original two-way `[computed..., rest...]` partition
-   * regressed money's composed-field behavior from a benign missing-dressing
-   * gap into VALUE CORRUPTION: money's `present()` DECODES its input as a
-   * STORED SCALED-INT (and derives `<field>Formatted` from it) — it is not a
-   * pure dressing CONSUMER like i18n/lookup, which only ADD a `<field>Label`
-   * key and never rewrite the field's own value. Running money AFTER
-   * computed on a field composing `computed(virtual)` + `money(...)` on
-   * ITSELF means money's decode sees the virtual field's raw MAJOR-unit
-   * output (e.g. `21`) and misreads it as a scaled-int, producing a
-   * corrupted value (`'0.21'`) instead of the pre-#665 result (the raw `21`
-   * surviving untouched, with no `Formatted` key added — a benign
-   * missing-dressing gap, not a wrong value). Money-first restores money's
-   * exact pre-#665 present position — byte-identical money behavior; the
-   * materialized composition pins from the #631 work and the money suites
-   * all ran under money-first. i18n/lookup are genuine dressing consumers
-   * (they only ADD, never rewrite), so they stay after computed, which is
-   * the fix #665 intended. A `'taint'` binding (appended LAST by
-   * `via/graph-wiring.ts#applyTaintOverlay`) stays last here too (it's
-   * neither money nor computed, so it lands at the tail of the "everything
-   * else" slice), preserving its "runs after computed, redacts tainted
-   * virtual output" contract (`via/taint-binding.ts`'s `taintBinding` doc
-   * comment).
-   *
-   * Money-dressing a virtual computed field's OWN output (the composed
-   * `computed(virtual) + money` case) is NOT resolved by this partition
-   * alone — #669 resolves it with a separate mid-fold hook instead:
-   * `NoydbVia.presentLate` runs after every binding's `present()` in this
-   * money+computed segment, before the "everything else" segment below, so
-   * money can quantize/reinterpret a virtual field's fresh MAJOR-UNITS
-   * output as if it were a stored value, without perturbing this ordering
-   * or the #665 invariant above it (`_presentLateBoundary` below marks
-   * exactly where that mid-fold point sits within `_presentOrder`).
-   */
-  _presentOrder;
-  /** #669 — index into `_presentOrder` where the money+computed segment ends and the
-   *  "everything else" segment begins (`moneyVias.length + computedVias.length`);
-   *  `present()` runs every binding's `presentLate` at exactly this boundary. */
-  _presentLateBoundary;
-  /** undefined when there is nothing to enforce — the zero-via fast path is
-   *  `this.via === undefined` (#553: keeps an all-plain collection sync). A
-   *  `'*'`-defaulted output collection (#642) counts as "something to enforce"
-   *  even with zero field-specific postures and zero bindings. */
-  static build(bindings, taint) {
-    if (bindings.length === 0 && (!taint || taint.postures.size === 0 && taint.defaultPosture === void 0)) return void 0;
-    return new _ViaPipeline(bindings, taint);
-  }
-  /** Refuse a write before crypto runs: awaits each binding's `enforceWrite` in order — first throw wins. */
-  async enforceWrite(record, ctx) {
-    for (const b of this.bindings) if (b.enforceWrite) await b.enforceWrite(record, ctx);
-  }
-  ingest(record) {
-    let r = record;
-    for (const b of this.bindings) if (b.ingest) r = b.ingest(r);
-    return r;
-  }
-  canonicalizeStored(record) {
-    let r = record;
-    for (const b of this.bindings) if (b.canonicalizeStored) r = b.canonicalizeStored(r);
-    return r;
-  }
-  async encodeWrite(record, ctx) {
-    let r = record;
-    for (const b of this.bindings) if (b.encodeWrite) r = await b.encodeWrite(r, ctx);
-    return r;
-  }
-  /**
-   * Final write-pipeline stage: folds each binding's `encodeAtRest` in
-   * order, threading the record and accumulating the sealed-slot map. A
-   * field belongs to exactly one via feature — two bindings sealing the
-   * same field is a brand-keyed collision and throws.
-   */
-  async encodeAtRest(record, crypto) {
-    let r = record;
-    let sealed;
-    const sealedBy = /* @__PURE__ */ new Map();
-    for (const b of this.bindings) {
-      if (!b.encodeAtRest) continue;
-      const result = await b.encodeAtRest(r, crypto);
-      r = result.record;
-      if (!result.sealed) continue;
-      for (const [field, ref] of Object.entries(result.sealed)) {
-        const priorBrand = sealedBy.get(field);
-        if (priorBrand !== void 0) {
-          throw new ValidationError(
-            `via encodeAtRest: field "${field}" sealed by binding "${priorBrand}" is also sealed by binding "${b.brand}"`
-          );
-        }
-        sealedBy.set(field, b.brand);
-        sealed ??= {};
-        sealed[field] = ref;
-      }
-    }
-    return sealed ? { record: r, sealed } : { record: r };
-  }
-  /** First read-pipeline stage: folds each binding's `decodeAtRest` in order. */
-  async decodeAtRest(record, sealed, crypto, opts) {
-    let r = record;
-    for (const b of this.bindings) if (b.decodeAtRest) r = await b.decodeAtRest(r, sealed, crypto, opts);
-    return r;
-  }
-  async present(record, ctx) {
-    let r = record;
-    for (let i = 0; i < this._presentLateBoundary; i++) {
-      const b = this._presentOrder[i];
-      if (b.present) r = await b.present(r, ctx);
-    }
-    for (const b of this.bindings) if (b.presentLate) r = await b.presentLate(r, ctx);
-    for (let i = this._presentLateBoundary; i < this._presentOrder.length; i++) {
-      const b = this._presentOrder[i];
-      if (b.present) r = await b.present(r, ctx);
-    }
-    return r;
-  }
-  buildClause(field, op, value) {
-    for (const b of this.bindings) {
-      const payload = b.buildClause?.(field, op, value);
-      if (payload !== void 0) return { brand: b.brand, payload };
-    }
-    return void 0;
-  }
-  evaluateClause(clause, actual, op) {
-    const b = this.bindings.find((x) => x.brand === clause.brand);
-    return b?.evaluateClause ? b.evaluateClause(actual, op, clause.payload) : false;
-  }
-  /**
-   * Resolve a `buildClause` payload to an index-probe operand (#625) —
-   * mirrors `evaluateClause`'s brand dispatch. `undefined` (a binding
-   * with no `indexProbe`, or one that declines to probe this op/payload)
-   * means the caller (`candidateRecords()`) must fall back to a scan.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-  indexProbe(clause, op) {
-    const b = this.bindings.find((x) => x.brand === clause.brand);
-    return b?.indexProbe ? b.indexProbe(op, clause.payload) : void 0;
-  }
-  /**
-   * Resolve a raw STORED field value to its canonical eager-index bucket
-   * key (#672) — folds every binding's `canonicalizeIndexKey`, first
-   * non-undefined wins (same fold discipline as `buildClause`). `undefined`
-   * means no binding claims `field` (or the value can't be canonicalized)
-   * — the caller buckets the raw stringified value, unchanged from before
-   * this hook existed.
-   */
-  canonicalizeIndexKey(field, rawValue) {
-    for (const b of this.bindings) {
-      const key = b.canonicalizeIndexKey?.(field, rawValue);
-      if (key !== void 0) return key;
-    }
-    return void 0;
-  }
-  decodeResults(record) {
-    let r = record;
-    for (const b of this.bindings) if (b.decodeResults) r = b.decodeResults(r);
-    return r;
-  }
-  /** undefined = no binding covers the field → caller falls back to generic compare. */
-  compareForOrder(field, a, b) {
-    for (const bind of this.bindings) {
-      const c = bind.compareForOrder?.(field, a, b);
-      if (c !== void 0) return c;
-    }
-    return void 0;
-  }
-  /** undefined = no binding resolves an order-sort label for `key` at `field`/`locale` (#650 Task 7 —
-   *  the `orderBy(..., {by:'label'})` per-call-locale channel `compareForOrder` above can't serve). */
-  resolveOrderLabel(field, key, locale) {
-    for (const bind of this.bindings) {
-      const label = bind.resolveOrderLabel?.(field, key, locale);
-      if (label !== void 0) return label;
-    }
-    return void 0;
-  }
-  /**
-   * Which posture governs `field`, if any binding covers it — `undefined`
-   * means no binding declares `field` (the generic, non-via query path
-   * applies). #629 Task 8's posture consumer: `.where()`/`.orderBy()`
-   * consult this before building/evaluating a clause, refusing fields whose
-   * posture is `queryable: 'none'` (e.g. blob); every other posture
-   * ('det-exact'/'ordered'/'full') is left to the existing per-binding
-   * buildClause/evaluateClause/compareForOrder machinery, unchanged.
-   *
-   * #638 Task 3: the graph-computed taint overlay is consulted FIRST — a
-   * derived field's assigned (most-restrictive-of-sources) posture wins over
-   * whatever a binding would otherwise report for that field name (no
-   * binding covers a computed/derived field today, so this never actually
-   * shadows one — see `via/taint-binding.ts`'s `taintBinding.covers`, which
-   * only claims the sealed subset for `encodeAtRest`/`decodeAtRest`, not for
-   * this lookup).
-   */
-  postureFor(field) {
-    const t = this.taint?.postures.get(field);
-    if (t) return t;
-    for (const b of this.bindings) {
-      if (b.covers?.(field)) return b.posture;
-    }
-    return this.taint?.defaultPosture;
-  }
-  /**
-   * Refuse any field-based reducer over a `queryable: 'none'` field (blob) —
-   * metadata-only: walks each reducer's `.field` and checks posture, no
-   * rewriting. Reducers with no `.field` (e.g. `count()`) are skipped.
-   *
-   * Shared by `wrapReducers` below (which ALSO applies each binding's
-   * rewrite, e.g. money's exact-BigInt reducer swap) and by
-   * `ScanBuilder.aggregate()` (#629 Task 8 review fix wave 1), which must
-   * call THIS, not `wrapReducers` — wiring full `wrapReducers` into
-   * `ScanBuilder.aggregate()` would newly activate money/i18n reducer
-   * wrapping on a path that has never run it, a parity-breaking behavior
-   * change for existing brands.
-   */
-  refuseUnqueryableReducers(spec) {
-    for (const reducer of Object.values(spec)) {
-      const field = reducer?.field;
-      if (field !== void 0 && this.postureFor(field)?.queryable === "none") {
-        throw new FieldNotQueryableError(field);
-      }
-    }
-  }
-  /**
-   * Rewrite an aggregate spec (money exact reducers), then refuse any
-   * field-based reducer over a `queryable: 'none'` field (blob) — the same
-   * posture gate `.where()`/`.orderBy()` apply, extended to `.aggregate()`
-   * (both the bare-spec and builder forms funnel through here).
-   */
-  wrapReducers(spec) {
-    this.refuseUnqueryableReducers(spec);
-    let s = spec;
-    for (const b of this.bindings) if (b.wrapReducers) s = b.wrapReducers(s);
-    return s;
-  }
-  /**
-   * Deliberate export-layer redaction (#629 Task 9's posture consumer):
-   * for every OWN field the decoded record carries, if the covering
-   * binding's posture declares `exportable: false` (classified today;
-   * money/i18n/blob are all `true`), replace the value with
-   * {@link EXPORT_REDACTION_MARKER} — the same `'[sealed]'` string
-   * `SealedHandle.toJSON()` (`kernel/types.ts`) already emits, so this is
-   * byte-parity with today's accidental redaction, now independent of the
-   * field's runtime shape. `SealedHandle.toJSON()` stays untouched as
-   * defense-in-depth: a record read via `collection.get()` and
-   * JSON.stringify'd outside `exportStream()` still gets the accident's
-   * redaction on its own. Never mutates the input; returns a new object
-   * only when a field was actually redacted.
-   */
-  redactForExport(record) {
-    let out;
-    for (const field of Object.keys(record)) {
-      if (this.postureFor(field)?.exportable === false) {
-        out ??= { ...record };
-        out[field] = EXPORT_REDACTION_MARKER;
-      }
-    }
-    return out ?? record;
-  }
-  /**
-   * Shared fold over a subset of `this.bindings`: runs each binding's
-   * `erase`, concatenating shredded/retainedShared counts and residue.
-   * Consults `posture.forgettable` (#629 Task 10) — a binding declaring
-   * `forgettable: false` is skipped even if it defines `erase` (none does
-   * today; a future non-forgettable binding is supported without a brand check).
-   */
-  async foldErase(ctx, bindings) {
-    let shredded = 0;
-    let retainedShared = 0;
-    const residue = [];
-    for (const b of bindings) {
-      if (!b.erase || b.posture.forgettable === false) continue;
-      const report = await b.erase(ctx);
-      shredded += report.shredded;
-      retainedShared += report.retainedShared ?? 0;
-      residue.push(...report.residue);
-    }
-    return retainedShared > 0 ? { shredded, residue, retainedShared } : { shredded, residue };
-  }
-  /** `forget()`'s per-ref erasure door: folds every binding's `erase`. */
-  async erase(ctx) {
-    return this.foldErase(ctx, this.bindings);
-  }
-  /**
-   * `forget()`'s SEALED-posture-only erase fold (#629 Task 10, `Collection._onViaErase`'s
-   * one caller) — classified today; metadata-filtered on
-   * `posture.encryptedAtRest`, not brand-checked. `undefined` when no
-   * sealed-posture binding is compiled in — `vault.ts` then falls back to
-   * its own bare-`sensitive` classification, which no via binding covers.
-   */
-  async eraseSealed(ctx) {
-    const sealed = this.bindings.filter((b) => b.posture.encryptedAtRest === "sealed");
-    return sealed.length === 0 ? void 0 : this.foldErase(ctx, sealed);
-  }
-  /** True iff any binding implements decodeResults (query fast-path gating). */
-  get hasResultDecode() {
-    return this.bindings.some((b) => b.decodeResults !== void 0);
-  }
-  /**
-   * True iff any binding declares an at-rest hook (`encodeAtRest`/
-   * `decodeAtRest`) — the codec boundary's async-stack gate (#629 Task 3
-   * consults this to choose between the hook path and today's inline
-   * sealed-slot path; a stack with only sync hooks, e.g. money-only, stays
-   * `false`).
-   */
-  get hasAtRestHooks() {
-    return this.bindings.some((b) => b.encodeAtRest !== void 0 || b.decodeAtRest !== void 0);
-  }
-  /**
-   * Fold every binding's `describeFragment()` into one `brand -> fragment`
-   * map (#650 Task 7 — the first-ever consumer; `describeFragment` was
-   * declared at `via/index.ts:136` since #623 with zero callers until this task).
-   * `undefined` when no compiled binding implements it. Consumed by
-   * `Collection.describe()`/`describeAsync()`, threaded to `buildDescription`
-   * as `BuildDescriptionInput.viaFragments`.
-   */
-  describeFragments() {
-    let out;
-    for (const b of this.bindings) {
-      const f = b.describeFragment?.();
-      if (f !== void 0) {
-        out ??= {};
-        out[b.brand] = f;
-      }
-    }
-    return out;
-  }
-};
-var EXPORT_REDACTION_MARKER = "[sealed]";
-function exportRedact(coll, record) {
-  if (record === null || typeof record !== "object") return record;
-  const via2 = coll._via;
-  return via2 ? via2.redactForExport(record) : record;
-}
-
 // src/kernel/collection-config.ts
 function computedEntryParts(entry) {
   if (typeof entry === "function") return { fn: entry, mode: "materialized" };
@@ -926,8 +578,36 @@ function matchTargetFieldNames(opts) {
 function unifyComputedFields(opts, viaComputedFields) {
   return { ...opts.computed ?? {}, ...viaComputedFields ?? {} };
 }
+function declaredFieldAllowList(opts, allComputedFields, exclude) {
+  const shape = schemaFieldKeys(opts.schema);
+  if (shape === void 0) return void 0;
+  const allow = new Set(shape);
+  for (const name of Object.keys(allComputedFields)) allow.add(name);
+  const others = {
+    fieldMeta: opts.fieldMeta,
+    moneyFields: opts.moneyFields,
+    dictKeyFields: opts.dictKeyFields,
+    blobFields: opts.blobFields,
+    classifiedFields: opts.classifiedFields,
+    i18nFields: opts.i18nFields,
+    lookupFields: opts.lookupFields
+  };
+  for (const [family, map] of Object.entries(others)) {
+    if (family === exclude || map === void 0) continue;
+    for (const name of Object.keys(map)) allow.add(name.split(".")[0].replace(/\[\]$/, ""));
+  }
+  return allow;
+}
+function assertDeclaredField(path, family, collection, allow) {
+  if (allow === void 0) return;
+  const root = path.split(".")[0].replace(/\[\]$/, "");
+  if (allow.has(root)) return;
+  throw new ValidationError(
+    `${family} on collection "${collection}" declares "${path}", but "${root}" is not a field of this collection. A declaration that resolves to nothing is not an error at read time \u2014 it simply never applies, so the rule you declared would be silently absent.`
+  );
+}
 function compileVias(opts, classifiedGuardCtx, eraseCfgOut) {
-  const { moneyFields, i18nFields, dictKeyFields, computedFields, lookupFields } = mergeViaFields(opts);
+  const { moneyFields, i18nFields, dictKeyFields, computedFields, lookupFields, geoFields } = mergeViaFields(opts);
   const allComputedFields = unifyComputedFields(opts, computedFields);
   guardCrossBindingFieldCollisions({
     moneyFields,
@@ -936,7 +616,8 @@ function compileVias(opts, classifiedGuardCtx, eraseCfgOut) {
     lookupFields,
     classifiedFields: opts.classifiedFields !== void 0 ? resolveClassifiedFields(opts.name, opts.classifiedFields).byField : void 0,
     blobFields: opts.blobFields,
-    computed: allComputedFields
+    computed: allComputedFields,
+    geoFields
   });
   const bindings = [];
   const virtualFields = /* @__PURE__ */ new Map();
@@ -950,6 +631,12 @@ function compileVias(opts, classifiedGuardCtx, eraseCfgOut) {
     const virtualMoney = resolveVirtualMoneyFields(Object.keys(moneyFields), (f) => virtualFields.has(f));
     bindings.push(viaBinder("money")({ moneyFields, ...virtualMoney.size > 0 ? { virtualMoneyFields: virtualMoney } : {} }));
   }
+  if (i18nFields) {
+    for (const field of Object.keys(i18nFields)) {
+      assertFieldPath(field, "i18nFields");
+      assertDeclaredField(field, "i18nFields", opts.name, declaredFieldAllowList(opts, allComputedFields, "i18nFields"));
+    }
+  }
   if (i18nFields || dictKeyFields) {
     const densify = i18nFields ? Object.fromEntries(
       Object.entries(i18nFields).filter(([, d]) => d.options.densifyOnWrite === true)
@@ -968,6 +655,7 @@ function compileVias(opts, classifiedGuardCtx, eraseCfgOut) {
     }));
   }
   if (lookupFields !== void 0) {
+    for (const field of Object.keys(lookupFields)) assertFieldPath(field, "lookupFields");
     bindings.push(viaBinder("lookup")({
       lookupFields,
       ...opts.lookupLabelResolver !== void 0 ? { lookupLabelResolver: opts.lookupLabelResolver } : {},
@@ -996,6 +684,9 @@ function compileVias(opts, classifiedGuardCtx, eraseCfgOut) {
   if (virtualFields.size > 0) {
     bindings.push(viaBinder("computed")({ virtualFields }));
   }
+  if (geoFields !== void 0) {
+    bindings.push(viaBinder("geo")({ geoFields }));
+  }
   return bindings;
 }
 function resolveVirtualMoneyFields(moneyFieldNames, isVirtual) {
@@ -1082,7 +773,7 @@ function resolveCollectionConfig(opts) {
       const virtualSet = new Set(virtualFieldNames);
       for (const reg of opts.materializedViewSource?.registry().mvsForSource(opts.name) ?? []) {
         const spec = reg.spec;
-        const fields = spec.groupBy === void 0 ? [] : typeof spec.groupBy === "string" ? [spec.groupBy] : spec.groupBy;
+        const fields = spec.groupBy === void 0 ? [] : (Array.isArray(spec.groupBy) ? spec.groupBy : [spec.groupBy]).map(groupKeySourceField);
         for (const f of fields) {
           if (!virtualSet.has(f)) continue;
           throw new ValidationError(
@@ -1244,8 +935,9 @@ function resolveCollectionConfig(opts) {
     joinResolver: opts.joinResolver,
     i18nFields: effectiveViaFields.i18nFields,
     textIndexes: opts.textIndexes,
+    textIndexPositions: opts.textIndexPositions,
     embeddings: opts.embeddings,
-    vectorSet: opts.embeddings ? new VectorSet() : void 0,
+    vectorSet: opts.embeddings ? new VectorSet(opts.embeddings.index) : void 0,
     dictKeyFields: effectiveViaFields.dictKeyFields,
     lookupFields: effectiveViaFields.lookupFields,
     // #650 Task 6 — the sync join-dressing hook (#626 retirement, spec §5);
@@ -1629,9 +1321,6 @@ var ViaGraph = class {
 };
 
 export {
-  ViaPipeline,
-  EXPORT_REDACTION_MARKER,
-  exportRedact,
   schemaFieldKeys,
   deriveZodFields,
   resolveDescribeFieldIds,
@@ -1649,4 +1338,4 @@ export {
   DEFAULT_POSTURE,
   ViaGraph
 };
-//# sourceMappingURL=chunk-CUQPWYRX.js.map
+//# sourceMappingURL=chunk-IUT3GWP3.js.map