@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/index.js

@@ -1,19 +1,7 @@
-import {
-  DEFAULT_FRESHNESS_MS,
-  PERSONAL_POLICY,
-  STRICT_POLICY,
-  checkGate,
-  describeGate,
-  mergePolicy
-} from "./chunk-5N6CZTCY.js";
 import {
   Collection,
-  ComputedFieldError,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
-  LinkEndpointError,
-  LinkIntegrityError,
-  Lru,
   Noydb,
   QuickUnlockStore,
   RefIntegrityError,
@@ -21,35 +9,25 @@ import {
   RefScopeError,
   Vault,
   createNoydb,
-  derivePersistedSchema,
   describeAllUsersAuth,
   describeAuthConfig,
   describeUserAuth,
   diagramAuthConfig,
-  estimateRecordBytes,
-  evalComputedFields,
-  isLinkCollectionName,
   isRefArray,
-  isZodSchema,
+  isViaFieldSpec,
   memoryStore,
-  parseBytes,
-  persistSchemaIfNeeded,
   ref,
   refArray,
+  via,
   withArchive
-} from "./chunk-5R5JW2JT.js";
-import {
-  META_COLLECTION,
-  POLICY_RECORD_ID,
-  loadVaultPolicy,
-  saveVaultPolicy
-} from "./chunk-SM3AVUHC.js";
+} from "./chunk-A2QF4JUE.js";
 import {
   DELEGATIONS_COLLECTION,
   issueDelegation,
   loadActiveDelegations,
   revokeDelegation
-} from "./chunk-VFQGRQIH.js";
+} from "./chunk-IDIV5NVH.js";
+import "./chunk-VYYM3MEN.js";
 import {
   DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
   PUBLIC_ENVELOPE_FIELDS,
@@ -61,113 +39,214 @@ import {
   compileSequenceFormat,
   resolveSequenceKey,
   withSequence
-} from "./chunk-GYGWYIOZ.js";
+} from "./chunk-5JB73NMC.js";
 import {
   UserApi
-} from "./chunk-UDRIWL7A.js";
+} from "./chunk-HFJIGWJC.js";
 import {
-  WithdrawalRequestError,
-  approveWithdrawal,
-  listWithdrawalRequests,
-  rejectWithdrawal,
-  requestWithdrawal
-} from "./chunk-XXYIOFUB.js";
-import "./chunk-IAGBDSCS.js";
+  DEFAULT_FRESHNESS_MS,
+  PERSONAL_POLICY,
+  STRICT_POLICY,
+  checkGate,
+  describeGate,
+  mergePolicy
+} from "./chunk-MCEKIAO4.js";
+import {
+  META_COLLECTION,
+  POLICY_RECORD_ID,
+  loadVaultPolicy,
+  saveVaultPolicy
+} from "./chunk-DIRRS7WP.js";
+import {
+  LinkEndpointError
+} from "./chunk-57V5S7PW.js";
+import {
+  LinkIntegrityError,
+  isLinkCollectionName
+} from "./chunk-AWB5JZW6.js";
+import "./chunk-7ITPJFGC.js";
+import {
+  persistSchemaIfNeeded
+} from "./chunk-WGV4CUZT.js";
+import "./chunk-Q3XSMOZM.js";
 import {
   NO_SEARCH,
   tokenize,
   withSearch
-} from "./chunk-TEILUWOI.js";
-import "./chunk-5R3ERCDH.js";
+} from "./chunk-P5RY4ZWD.js";
 import {
-  isDiscriminant
-} from "./chunk-PY4KJPYU.js";
-import "./chunk-WYSO2NIH.js";
-import "./chunk-IPB7FTQX.js";
-import "./chunk-KVOXU4T5.js";
+  derivePersistedSchema,
+  isZodSchema
+} from "./chunk-QLLKLFE2.js";
+import {
+  ComputedFieldError,
+  evalComputedFields
+} from "./chunk-45ZZLTFH.js";
+import "./chunk-GYGLAVCX.js";
+import {
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-SRVQHVNX.js";
 import {
   withCargo
-} from "./chunk-M6OST55S.js";
+} from "./chunk-UFILRICG.js";
 import {
   CustodyApi,
   NO_CARGO,
   NO_CUSTODY,
   withCustody
-} from "./chunk-TJYQIGAP.js";
+} from "./chunk-BZO4WCJI.js";
 import {
   DEED_RECORD_ID,
   createDeedOwner,
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "./chunk-KXGNJJXB.js";
+} from "./chunk-PXWVF7MC.js";
+import {
+  fuseRetrieval
+} from "./chunk-AURFOK3D.js";
+import {
+  diffVault
+} from "./chunk-LB7FD65R.js";
 import {
   withdrawAccessibleData
-} from "./chunk-PSMV73A5.js";
+} from "./chunk-7NS43EXZ.js";
 import {
   exportAccessibleData
-} from "./chunk-HCIPRAGS.js";
+} from "./chunk-BCYQA5BK.js";
+import "./chunk-JOQ53DMI.js";
+import "./chunk-D26JB3LZ.js";
 import {
-  diffVault
-} from "./chunk-LB7FD65R.js";
-import "./chunk-BGIZAFY7.js";
+  withOverlayedView
+} from "./chunk-YXOUQ2H7.js";
+import "./chunk-A2Y6YFVN.js";
+import "./chunk-OFJ5GPNA.js";
 import {
-  fuseRetrieval
-} from "./chunk-AURFOK3D.js";
-import "./chunk-QHJW5EXU.js";
+  isDiscriminant
+} from "./chunk-PY4KJPYU.js";
+import "./chunk-XHV25KBM.js";
+import {
+  classified,
+  luhnCheck
+} from "./chunk-DMFNPHCX.js";
+import {
+  ClassifiedNeverStoredError,
+  ClassifiedValidationError,
+  isClassifiedFieldSpec,
+  isClassifiedGroup,
+  resolveClassifiedFields
+} from "./chunk-PR5LC5YX.js";
+import "./chunk-H6HM6CVR.js";
+import "./chunk-ODJWBC5I.js";
+import {
+  CONSENT_AUDIT_COLLECTION
+} from "./chunk-C3YH34IL.js";
+import "./chunk-O2DYPAZY.js";
+import {
+  PERIODS_COLLECTION
+} from "./chunk-FXK4X4BL.js";
+import "./chunk-GHVIKOHT.js";
 import {
   immutableGuard,
   transitionGuard,
   withGuard
-} from "./chunk-TA66UMI4.js";
+} from "./chunk-VA4ZWLFY.js";
 import "./chunk-YMUGBZN2.js";
-import "./chunk-RUIMKQTA.js";
-import "./chunk-RUEKROOS.js";
+import "./chunk-JK733I5V.js";
+import "./chunk-ZP5PL65C.js";
 import {
   CollectionFrame,
   VaultFrame
-} from "./chunk-NF5JWERG.js";
+} from "./chunk-3MSQLQNZ.js";
 import {
   TxCollection,
   TxContext,
   TxVault,
   runTransaction
-} from "./chunk-SKF73JOP.js";
+} from "./chunk-H44ZE4IE.js";
 import {
   withDerivation,
   withRollup
-} from "./chunk-LMTH2RM6.js";
-import "./chunk-Q7SS3IME.js";
-import "./chunk-PKHL44ER.js";
+} from "./chunk-CB25ONKC.js";
+import "./chunk-BEIRE5K4.js";
+import "./chunk-7QIXUSDQ.js";
+import "./chunk-YSXEFGND.js";
 import {
   withMaterializedView
-} from "./chunk-3YFXJ3ZP.js";
-import "./chunk-AQTBSL7R.js";
-import "./chunk-62QYRORB.js";
-import "./chunk-BG3SPSR4.js";
+} from "./chunk-UTLEAJXC.js";
+import "./chunk-2JMMY7HZ.js";
 import {
-  withOverlayedView
-} from "./chunk-EIZUR2XW.js";
-import "./chunk-CMGR4ZEW.js";
-import "./chunk-VCTFO5CO.js";
+  buildLookupSnapshot
+} from "./chunk-DGH65E7Q.js";
+import "./chunk-3G4KMVUN.js";
+import "./chunk-TPH5EO6L.js";
+import {
+  DEFAULT_CROSS_JOIN_MAX_ROWS,
+  DEFAULT_JOIN_MAX_ROWS,
+  Query,
+  ScanBuilder,
+  applyJoins,
+  buildLiveQuery,
+  executePlan,
+  resetJoinWarnings
+} from "./chunk-H6CZSDWK.js";
 import {
   importExternalObjects,
   memoryObjectProjection
 } from "./chunk-4Q6HSHHL.js";
-import "./chunk-Y22T3KQE.js";
-import "./chunk-V7RWQRG7.js";
+import "./chunk-QYPKGVT4.js";
+import "./chunk-3CNQ7FQ3.js";
+import {
+  CollectionIndexes
+} from "./chunk-KPZS5QAQ.js";
+import {
+  withLazy
+} from "./chunk-THNJ3IKU.js";
+import {
+  Lru,
+  estimateRecordBytes,
+  parseBytes
+} from "./chunk-NO272T7Q.js";
+import {
+  Aggregation,
+  GROUPBY_MAX_CARDINALITY,
+  GROUPBY_WARN_CARDINALITY,
+  GroupedAggregation,
+  GroupedQuery,
+  GroupedQueryN,
+  avg,
+  count,
+  groupAndReduce,
+  max,
+  min,
+  moneyMax,
+  moneyMin,
+  moneySum,
+  reduceRecords,
+  reducerBuilder,
+  sum
+} from "./chunk-IGJHJYM6.js";
+import {
+  evaluateClause,
+  evaluateFieldClause,
+  readPath
+} from "./chunk-IGJCYUT5.js";
 import {
   mergeCrdtStates,
   resolveCrdtSnapshot
-} from "./chunk-6S7T6WC4.js";
+} from "./chunk-4GPE63GU.js";
 import {
   decryptExtractedPartition
-} from "./chunk-2P2HZEXU.js";
+} from "./chunk-GA2QHD6P.js";
 import {
   SCHEMAS_COLLECTION,
   loadPersistedSchema,
   savePersistedSchema
-} from "./chunk-26LGBE4T.js";
+} from "./chunk-C7NTK5I3.js";
 import {
   MemoryRecipientSealer,
   MemorySealingKeyProvider,
@@ -178,7 +257,7 @@ import {
   parseSealedEnvelope,
   saveSealedPassphrase,
   sealRsaOaepTlv
-} from "./chunk-ZCGAHGUS.js";
+} from "./chunk-KPGX66PM.js";
 import {
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
@@ -190,13 +269,13 @@ import {
   detectMagic,
   detectMimeType,
   isPreCompressed
-} from "./chunk-DFEMTNPJ.js";
+} from "./chunk-AOVDSIL3.js";
 import {
   createBundleStore,
   createPodStore,
   wrapBundleStore,
   wrapPodStore
-} from "./chunk-AZAOEIKW.js";
+} from "./chunk-7E67FJ33.js";
 import {
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -210,7 +289,7 @@ import {
   resetBrotliSupportCache,
   writeNoydbBundle,
   writePod
-} from "./chunk-FISN7WE4.js";
+} from "./chunk-K62IUKOD.js";
 import {
   PUBLIC_ENVELOPE_RECORD_ID,
   isPublicEnvelope,
@@ -218,37 +297,48 @@ import {
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-SMXWYP24.js";
+} from "./chunk-5XIPOCQC.js";
+import "./chunk-67TNU77I.js";
 import {
-  CONSENT_AUDIT_COLLECTION
-} from "./chunk-MTMJVJ5W.js";
-import "./chunk-CWPPNPOH.js";
-import {
-  PERIODS_COLLECTION
-} from "./chunk-IELYAOGG.js";
-import "./chunk-GHVIKOHT.js";
+  dictKey,
+  staticDict
+} from "./chunk-7VSGW5KJ.js";
 import {
   DICT_COLLECTION_PREFIX,
-  DictionaryHandle,
-  dictCollectionName,
-  dictKey,
+  LookupHandle,
+  dictCollectionName
+} from "./chunk-ELNBMFOS.js";
+import {
+  applyI18nLocale,
+  enforceScript,
+  getAtPath,
+  i18nText,
+  inferScripts,
   isDictCollectionName,
   isDictKeyDescriptor,
+  isI18nTextDescriptor,
   isStaticDictDescriptor,
-  staticDict
-} from "./chunk-LFLXAY2W.js";
+  resolveI18nText,
+  resolvePolicy,
+  setAtPathInPlace,
+  validateI18nTextValue
+} from "./chunk-BE7N3AXA.js";
+import {
+  installViaBinder
+} from "./chunk-ARSAMO24.js";
 import {
-  SYNC_CREDENTIALS_COLLECTION,
   credentialStatus,
   deleteCredential,
   getCredential,
   listCredentials,
-  putCredential
-} from "./chunk-DGDI2D4M.js";
+  putCredential,
+  withTeam
+} from "./chunk-OOLO4LQG.js";
 import {
   MAGIC_LINK_CONTENT_INFO_PREFIX,
   MAGIC_LINK_GRANTS_COLLECTION,
   MAGIC_LINK_KEK_INFO_PREFIX,
+  NO_TEAM,
   deriveMagicLinkContentKey,
   enrollAuthenticator,
   findAuthenticator,
@@ -263,7 +353,7 @@ import {
   rotatePassphrase,
   unwrapMagicLinkGrant,
   writeMagicLinkGrant
-} from "./chunk-UPJNJGGA.js";
+} from "./chunk-IP2QBAGS.js";
 import {
   burnPaperRecoveryEntry,
   hasRecoveryEnrolled,
@@ -277,17 +367,12 @@ import {
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
   unwrapDeksFromShamirEntry
-} from "./chunk-IGUYVGGI.js";
-import {
-  assertTierAccess,
-  dekKey,
-  effectiveClearance
-} from "./chunk-IO6GRPT6.js";
+} from "./chunk-6QILBDZU.js";
 import {
   PresenceHandle,
   SyncEngine,
   SyncTransaction
-} from "./chunk-IUEN57TV.js";
+} from "./chunk-W5D62AQD.js";
 import {
   BUNDLE_STORE_POLICY,
   INDEXED_STORE_POLICY,
@@ -295,6 +380,12 @@ import {
   SyncScheduler
 } from "./chunk-VQNJ7UZL.js";
 import {
+  assertTierAccess,
+  dekKey,
+  effectiveClearance
+} from "./chunk-4R4Q64W5.js";
+import {
+  SYNC_CREDENTIALS_COLLECTION,
   WeakPassphraseError,
   assertStrongPassphrase,
   buildRecipientKeyringFile,
@@ -306,7 +397,7 @@ import {
   listUsers,
   listUsersWithEnvelopes,
   validatePassphrase
-} from "./chunk-WWGT2MDV.js";
+} from "./chunk-5ZOSG3RJ.js";
 import {
   DIRECTORY_RECORD_ID,
   VISIBILITY_RECORD_PREFIX,
@@ -320,7 +411,8 @@ import {
   readUserVisibility,
   saveUserEnvelope,
   visibilityRecordId
-} from "./chunk-ITNUCOXM.js";
+} from "./chunk-4N5QFSNQ.js";
+import "./chunk-WTUNZACT.js";
 import {
   PolicyEnforcer,
   activeSessionCount,
@@ -335,7 +427,7 @@ import {
   revokeAllSessions,
   revokeSession,
   validateSessionPolicy
-} from "./chunk-UAG5KWVA.js";
+} from "./chunk-VR24ILCR.js";
 import {
   generateULID,
   isULID
@@ -343,7 +435,7 @@ import {
 import {
   CollectionInstant,
   VaultInstant
-} from "./chunk-MD3Y6J3L.js";
+} from "./chunk-MELR46EF.js";
 import {
   diff,
   formatDiff
@@ -352,7 +444,7 @@ import {
   LedgerStore,
   applyPatch,
   computePatch
-} from "./chunk-LXQT4WMP.js";
+} from "./chunk-OEAATWH5.js";
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
@@ -364,9 +456,18 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-AIWULCUO.js";
-import "./chunk-SRB2XEWB.js";
-import "./chunk-UV5MFVO3.js";
+} from "./chunk-25NDNMQ7.js";
+import "./chunk-DJ3VKYFA.js";
+import "./chunk-CIKY6I4W.js";
+import {
+  validateSchemaInput,
+  validateSchemaOutput
+} from "./chunk-QQJXBZCO.js";
+import "./chunk-FQQF23MC.js";
+import "./chunk-MSPNM2OM.js";
+import "./chunk-SYMS4546.js";
+import "./chunk-X6CMGUAG.js";
+import "./chunk-LP7BEXCT.js";
 import {
   base64ToBuffer,
   bufferToBase64,
@@ -374,10 +475,8 @@ import {
   decryptDeterministic,
   derivePresenceKey,
   encryptBytes,
-  encryptDeterministic,
-  validateSchemaInput,
-  validateSchemaOutput
-} from "./chunk-5O3AOPDT.js";
+  encryptDeterministic
+} from "./chunk-HUS3J5WM.js";
 import {
   NOYDB_BACKUP_VERSION,
   NOYDB_FORMAT_VERSION,
@@ -385,64 +484,7 @@ import {
   NOYDB_SYNC_VERSION,
   SealedHandle,
   createStore
-} from "./chunk-5TDJ56JE.js";
-import {
-  DEFAULT_CROSS_JOIN_MAX_ROWS,
-  DEFAULT_JOIN_MAX_ROWS,
-  Query,
-  ScanBuilder,
-  applyJoins,
-  buildLiveQuery,
-  executePlan,
-  resetJoinWarnings
-} from "./chunk-UIU2THRG.js";
-import {
-  CollectionIndexes
-} from "./chunk-I3TIKTJO.js";
-import {
-  Aggregation,
-  GROUPBY_MAX_CARDINALITY,
-  GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation,
-  GroupedQuery,
-  GroupedQueryN,
-  avg,
-  count,
-  groupAndReduce,
-  max,
-  min,
-  moneyMax,
-  moneyMin,
-  moneySum,
-  reduceRecords,
-  reducerBuilder,
-  sum
-} from "./chunk-LV7M27WM.js";
-import {
-  MoneyCurrencyError,
-  MoneyPrecisionError,
-  MoneyUnsupportedError,
-  decimalScaleOf,
-  evaluateClause,
-  evaluateFieldClause,
-  formatScaledInt,
-  isMoneyDescriptor,
-  money,
-  parseToScaledInt,
-  readPath,
-  rescaleScaledInt,
-  scaleForCurrency
-} from "./chunk-M2YKN37S.js";
-import {
-  applyI18nLocale,
-  enforceScript,
-  i18nText,
-  inferScripts,
-  isI18nTextDescriptor,
-  resolveI18nText,
-  resolvePolicy,
-  validateI18nTextValue
-} from "./chunk-5LUY7UTV.js";
+} from "./chunk-CKZW6P5V.js";
 import {
   AlreadyElevatedError,
   AmendmentForbiddenError,
@@ -454,6 +496,11 @@ import {
   BundleSealMismatchError,
   BundleVersionConflictError,
   CargoNotEnabledError,
+  ClassifiedConfigError,
+  ClassifiedNotEnabledError,
+  ClassifiedRevealError,
+  ClassifiedRotationError,
+  ClassifiedVerifyError,
   ConflictError,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -478,6 +525,7 @@ import {
   EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
+  FieldNotQueryableError,
   FilenameSanitizationError,
   ForgetStrategyNotConfiguredError,
   GroupCardinalityError,
@@ -526,6 +574,7 @@ import {
   RecoveryProfileNotImplementedError,
   ReservedCollectionNameError,
   ReservedVaultNameError,
+  RestrictRefUnresolvableError,
   STATE_VAULT_NAME,
   SchemaFenceError,
   SchemaLockedError,
@@ -547,6 +596,7 @@ import {
   StaticDictReadonlyError,
   StoreCapabilityError,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TiersNotEnabledError,
@@ -555,12 +605,13 @@ import {
   USER_ENVELOPE_MAX_BYTES,
   UniqueConstraintError,
   UnknownDictCodeError,
+  UnknownLookupKeyError,
   UnknownShardError,
   UnsupportedIndexOptionError,
   UserEnvelopeOversizedError,
   ValidationError,
   VaultTemplateNotFoundError
-} from "./chunk-ZYUC53LT.js";
+} from "./chunk-FH542DDY.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/kernel/debug.ts
@@ -581,6 +632,34 @@ function readPlaintextRecord(envelope) {
   return JSON.parse(envelope._data);
 }
 
+// src/with-shape/introspection/projection.ts
+function applyListProjection(desc, record, opts) {
+  const out = { ...record };
+  for (const f of desc.fields) {
+    if (f.classified !== void 0) {
+      const list = f.classified.list;
+      if (list === "omit") {
+        delete out[f.key];
+        continue;
+      }
+      if ("mask" in list) {
+        out[f.key] = list.mask.replace(/\$\{(\w+)\}/g, (_m, rider) => {
+          const v = record[`${f.key}_${rider}`];
+          return v === void 0 || v === null ? "\u2022" : `${v}`;
+        });
+        continue;
+      }
+      out[f.key] = record[`${f.key}_${list.rider}`];
+      continue;
+    }
+    if (opts?.sensitivity !== void 0 && (f.sensitivity === "pii" || f.sensitivity === "secret")) {
+      if (opts.sensitivity === "omit") delete out[f.key];
+      else out[f.key] = "\u2022\u2022\u2022";
+    }
+  }
+  return out;
+}
+
 // src/with-shape/schema-update/strategies.ts
 function blindUpdate() {
   return { name: "blindUpdate", onSchemaDelta: () => ({ action: "allow" }) };
@@ -753,18 +832,19 @@ function routeStore(opts) {
     }
     return tieredBlobs.large;
   }
-  function isCold(collection, envelope) {
+  function isCold(collection, envelope, before) {
     if (!opts.age) return false;
     if (isInternal(collection)) return false;
     if (opts.age.collections && opts.age.collections.length > 0) {
       if (!opts.age.collections.includes(collection)) return false;
     }
-    const cutoff = Date.now() - opts.age.coldAfterDays * 24 * 60 * 60 * 1e3;
-    const ts = new Date(envelope._ts).getTime();
-    return ts < cutoff;
+    const cutoffIso = before ?? (opts.age.coldAfterDays != null ? new Date(Date.now() - opts.age.coldAfterDays * 24 * 60 * 60 * 1e3).toISOString() : void 0);
+    if (cutoffIso === void 0) return false;
+    return envelope._ts < cutoffIso;
   }
   const store = {
     name: buildName(),
+    ...opts.age?.cold ? { capabilities: { ...primary.capabilities, coldArchival: true } } : primary.capabilities ? { capabilities: { ...primary.capabilities, coldArchival: false } } : {},
     async get(vault, collection, id) {
       const s = storeFor(vault, collection);
       const result = await s.get(vault, collection, id);
@@ -833,16 +913,16 @@ function routeStore(opts) {
         [...partitioned.entries()].map(([s, snap]) => s.saveAll(vault, snap))
       );
     },
-    async compact(vault) {
+    async compact(vault, compactOpts) {
       if (!opts.age) return 0;
       let migrated = 0;
-      const collections = opts.age.collections?.length ? opts.age.collections : await primary.list(vault, "").catch(() => []);
+      const collections = opts.age.collections?.length ? opts.age.collections : Object.keys(await primary.loadAll(vault).catch(() => ({})));
       for (const collection of collections) {
         const ids = await primary.list(vault, collection).catch(() => []);
         for (const id of ids) {
           const envelope = await primary.get(vault, collection, id);
           if (!envelope) continue;
-          if (isCold(collection, envelope)) {
+          if (isCold(collection, envelope, compactOpts?.before)) {
             await opts.age.cold.put(vault, collection, id, envelope);
             await primary.delete(vault, collection, id);
             migrated++;
@@ -1284,7 +1364,950 @@ function withDeferredNumbering(config) {
   };
 }
 
-// src/with-shape/money/arith.ts
+// src/via/money/iso4217.ts
+var MINOR_UNITS = {
+  // 2-decimal majors
+  EUR: 2,
+  USD: 2,
+  GBP: 2,
+  CHF: 2,
+  CAD: 2,
+  AUD: 2,
+  NZD: 2,
+  SGD: 2,
+  HKD: 2,
+  CNY: 2,
+  INR: 2,
+  BRL: 2,
+  MXN: 2,
+  ZAR: 2,
+  RUB: 2,
+  TRY: 2,
+  PLN: 2,
+  SEK: 2,
+  NOK: 2,
+  DKK: 2,
+  CZK: 2,
+  HUF: 2,
+  RON: 2,
+  ILS: 2,
+  THB: 2,
+  PHP: 2,
+  MYR: 2,
+  IDR: 2,
+  AED: 2,
+  SAR: 2,
+  QAR: 2,
+  EGP: 2,
+  // 0-decimal
+  JPY: 0,
+  KRW: 0,
+  ISK: 0,
+  CLP: 0,
+  VND: 0,
+  XOF: 0,
+  XAF: 0,
+  PYG: 0,
+  // 3-decimal
+  BHD: 3,
+  KWD: 3,
+  OMR: 3,
+  TND: 3,
+  JOD: 3,
+  IQD: 3,
+  LYD: 3
+};
+function scaleForCurrency(code) {
+  const v = MINOR_UNITS[code];
+  return v === void 0 ? null : v;
+}
+
+// src/via/money/fixed-point.ts
+function expandExponent(s) {
+  const m = /^([+-]?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
+  if (!m) return s;
+  const sign = m[1] === "-" ? "-" : "";
+  const intp = m[2];
+  const frac = m[3] ?? "";
+  const exp = Number(m[4]);
+  const digits = intp + frac;
+  const pointPos = intp.length + exp;
+  let body;
+  if (pointPos <= 0) {
+    body = "0." + "0".repeat(-pointPos) + digits;
+  } else if (pointPos >= digits.length) {
+    body = digits + "0".repeat(pointPos - digits.length);
+  } else {
+    body = digits.slice(0, pointPos) + "." + digits.slice(pointPos);
+  }
+  return sign + body;
+}
+function toCanonicalDecimalString(input) {
+  let s;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) return null;
+    s = String(input);
+  } else {
+    s = input.trim();
+  }
+  s = expandExponent(s);
+  if (s.startsWith("+")) s = s.slice(1);
+  if (!/^-?(\d+(\.\d*)?|\.\d+)$/.test(s)) return null;
+  return s;
+}
+function shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, mode) {
+  switch (mode) {
+    case "up":
+      return true;
+    case "down":
+      return false;
+    case "ceil":
+      return !negative;
+    case "floor":
+      return negative;
+    case "half-up":
+      return firstDiscarded >= 5;
+    case "half-down":
+      return firstDiscarded > 5 || firstDiscarded === 5 && hasMoreNonZeroAfterFirst;
+    case "half-even":
+      if (firstDiscarded > 5) return true;
+      if (firstDiscarded < 5) return false;
+      return hasMoreNonZeroAfterFirst || lastKeptDigit % 2 === 1;
+  }
+}
+function parseToScaledInt(input, scale, rounding) {
+  const canonical = toCanonicalDecimalString(input);
+  if (canonical === null) return { ok: false, reason: "nonfinite" };
+  const negative = canonical.startsWith("-");
+  const unsigned = negative ? canonical.slice(1) : canonical;
+  const dot = unsigned.indexOf(".");
+  const intPart = dot === -1 ? unsigned : unsigned.slice(0, dot);
+  const fracPart = dot === -1 ? "" : unsigned.slice(dot + 1);
+  const intDigits = intPart === "" ? "0" : intPart;
+  if (fracPart.length <= scale) {
+    const keep2 = fracPart.padEnd(scale, "0");
+    const magnitude2 = BigInt(intDigits + keep2);
+    return { ok: true, value: negative && magnitude2 !== 0n ? -magnitude2 : magnitude2 };
+  }
+  const keep = fracPart.slice(0, scale);
+  const tail = fracPart.slice(scale);
+  const magnitudeDigits = intDigits + keep;
+  let magnitude = BigInt(magnitudeDigits);
+  if (/^0+$/.test(tail)) {
+    return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+  }
+  if (rounding === void 0) return { ok: false, reason: "precision" };
+  const lastKeptDigit = Number(magnitudeDigits[magnitudeDigits.length - 1]);
+  const firstDiscarded = Number(tail[0]);
+  const hasMoreNonZeroAfterFirst = /[1-9]/.test(tail.slice(1));
+  if (shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, rounding)) {
+    magnitude += 1n;
+  }
+  return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+}
+function decimalScaleOf(input) {
+  const s = toCanonicalDecimalString(input);
+  if (s === null) return null;
+  const dot = s.indexOf(".");
+  return dot === -1 ? 0 : s.length - dot - 1;
+}
+function rescaleScaledInt(value, fromScale, toScale, rounding = "half-up") {
+  if (toScale >= fromScale) return value * 10n ** BigInt(toScale - fromScale);
+  const drop = fromScale - toScale;
+  const negative = value < 0n;
+  const absStr = (negative ? -value : value).toString().padStart(drop + 1, "0");
+  const keptStr = absStr.slice(0, absStr.length - drop);
+  const tail = absStr.slice(absStr.length - drop);
+  let magnitude = BigInt(keptStr);
+  if (!/^0+$/.test(tail)) {
+    const lastKeptDigit = Number(keptStr[keptStr.length - 1]);
+    const firstDiscarded = Number(tail[0]);
+    const hasMoreNonZeroAfterFirst = /[1-9]/.test(tail.slice(1));
+    if (shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, rounding)) {
+      magnitude += 1n;
+    }
+  }
+  return negative && magnitude !== 0n ? -magnitude : magnitude;
+}
+function formatScaledInt(value, scale) {
+  const negative = value < 0n;
+  const abs = (negative ? -value : value).toString();
+  if (scale === 0) return (negative ? "-" : "") + abs;
+  const padded = abs.padStart(scale + 1, "0");
+  const cut = padded.length - scale;
+  const intPart = padded.slice(0, cut);
+  const fracPart = padded.slice(cut);
+  return (negative ? "-" : "") + intPart + "." + fracPart;
+}
+
+// src/via/money/paths.ts
+var SEGMENT_RE = /^(\*|[^.[\]*]+)(\[\])?$/;
+var parseCache = /* @__PURE__ */ new Map();
+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 clone2 = { ...obj2 };
+    if (last) {
+      visit(clone2, seg.key);
+    } else {
+      clone2[seg.key] = transformAtMoneyPath(clone2[seg.key], path, segments, index + 1, visit, lenient);
+    }
+    return clone2;
+  }
+  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 clone = { ...obj };
+  for (const key of Object.keys(obj)) {
+    const v = clone[key];
+    if (v === null || v === void 0) continue;
+    if (last) visit(clone, key);
+    else clone[key] = transformAtMoneyPath(v, path, segments, index + 1, visit, lenient);
+  }
+  return clone;
+}
+
+// src/via/money/normalize.ts
+function isMoneyValueObject(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function quantizeAmount(field, input, scale, rounding) {
+  const r = parseToScaledInt(input, scale, rounding);
+  if (!r.ok) {
+    if (r.reason === "precision") throw new MoneyPrecisionError(field, input, scale);
+    throw new TypeError(`money: field "${field}" value ${JSON.stringify(input)} is not a finite decimal`);
+  }
+  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) {
+  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;
+    }
+    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;
+}
+function formatCurrency(decimal, currency, scale, locale) {
+  const fmt = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: scale,
+    maximumFractionDigits: scale
+  });
+  return fmt.format(decimal);
+}
+function moneyScaledValue(stored, desc) {
+  let raw;
+  if (desc.mode === "fixed") {
+    raw = stored;
+  } else {
+    if (!isMoneyValueObject(stored)) return null;
+    raw = stored.amount;
+  }
+  if (typeof raw !== "string" && typeof raw !== "number") return null;
+  try {
+    return BigInt(String(raw));
+  } catch {
+    return null;
+  }
+}
+function canonicalizeMoneyIndexKey(field, rawValue, moneyFields) {
+  const desc = moneyFields[field];
+  if (!desc || desc.mode !== "fixed") return void 0;
+  return moneyScaledValue(rawValue, desc)?.toString();
+}
+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 presentVirtualMoneyFields(record, moneyFields, virtualMoney, locale) {
+  let out = record;
+  const format = locale !== "raw";
+  const fmtLocale = typeof locale === "string" && locale !== "raw" ? locale : "en-US";
+  for (const field of virtualMoney) {
+    const desc = moneyFields[field];
+    if (!desc || desc.mode !== "fixed") continue;
+    const raw = out[field];
+    if (raw === null || raw === void 0) continue;
+    if (typeof raw !== "number" && typeof raw !== "string") continue;
+    const currency = desc.fixedCurrency;
+    const scale = desc.scaleFor(currency);
+    const r = parseToScaledInt(raw, scale, desc.rounding);
+    if (!r.ok) continue;
+    if (out === record) out = { ...record };
+    const decimal = formatScaledInt(r.value, scale);
+    out[field] = decimal;
+    if (format) {
+      out[`${field}Formatted`] = formatCurrency(decimal, currency, scale, fmtLocale);
+      out[`${field}Number`] = Number(decimal);
+    }
+  }
+  return out;
+}
+function decodeMoneyFields(record, moneyFields, locale) {
+  let out = { ...record };
+  const format = locale !== "raw";
+  const fmtLocale = typeof locale === "string" && locale !== "raw" ? locale : "en-US";
+  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;
+}
+
+// src/via/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 { mode: desc.mode, entries: [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 { mode: desc.mode, entries: [lo, hi] };
+    }
+    case "in": {
+      if (!Array.isArray(value)) {
+        throw new MoneyUnsupportedError(`where("${field}"): 'in' needs an array of amounts`);
+      }
+      return { mode: desc.mode, entries: value.map((v) => parseOperand(field, v, desc)) };
+    }
+    default:
+      throw new MoneyUnsupportedError(
+        `where("${field}"): operator '${op}' is not supported on a money field`
+      );
+  }
+}
+function moneyIndexProbe(op, payload) {
+  if (payload.mode !== "fixed") return void 0;
+  if (op === "==") return payload.entries[0]?.scaled;
+  if (op === "in") return payload.entries.map((e) => e.scaled);
+  return void 0;
+}
+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;
+  }
+}
+
+// src/via/money/money-reducer.ts
+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;
+}
+function readMoney(record, field, desc) {
+  const raw = readPath(record, field);
+  if (raw === null || raw === void 0) return null;
+  if (desc.mode === "fixed") {
+    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 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) {
+  if (desc.allows(currency)) return desc.scaleFor(currency);
+  const s = scaleForCurrency(currency);
+  if (s === null) {
+    throw new Error(`money: cannot determine scale for conversion target "${currency}"`);
+  }
+  return s;
+}
+function parseRate(rate) {
+  const s = String(rate).trim();
+  const neg = s.startsWith("-");
+  const body = neg ? s.slice(1) : s;
+  const dot = body.indexOf(".");
+  const intPart = dot === -1 ? body : body.slice(0, dot);
+  const fracPart = dot === -1 ? "" : body.slice(dot + 1);
+  const int = BigInt((intPart === "" ? "0" : intPart) + fracPart);
+  return { int: neg ? -int : int, scale: fracPart.length };
+}
+function divRoundHalfEven(n, d) {
+  const q = n / d;
+  const r = n % d;
+  const twiceR = (r < 0n ? -r : r) * 2n;
+  if (twiceR < d) return q;
+  if (twiceR > d) return q + (n < 0n ? -1n : 1n);
+  return q % 2n === 0n ? q : q + (n < 0n ? -1n : 1n);
+}
+function convertScaled(value, srcScale, rate, targetScale) {
+  const { int: rateInt, scale: rateScale } = parseRate(rate);
+  const product = value * rateInt;
+  const curScale = srcScale + rateScale;
+  if (curScale === targetScale) return product;
+  if (curScale < targetScale) return product * 10n ** BigInt(targetScale - curScale);
+  return divRoundHalfEven(product, 10n ** BigInt(curScale - targetScale));
+}
+function finalizeSum(state, desc, convertTo, fx) {
+  if (convertTo !== void 0) {
+    if (fx === void 0) {
+      throw new Error(`money: sum convertTo "${convertTo}" requires an fx rate map`);
+    }
+    const targetScale = targetScaleFor(desc, convertTo);
+    let total = 0n;
+    for (const [cur, v] of state) {
+      if (cur === convertTo) {
+        total += convertScaled(v, desc.scaleFor(cur), 1, targetScale);
+        continue;
+      }
+      const rate = fx[`${cur}->${convertTo}`];
+      if (rate === void 0) {
+        throw new Error(`money: no fx rate for "${cur}->${convertTo}"`);
+      }
+      total += convertScaled(v, desc.scaleFor(cur), rate, targetScale);
+    }
+    return formatScaledInt(total, targetScale);
+  }
+  if (desc.mode === "fixed") {
+    const cur = desc.fixedCurrency;
+    return formatScaledInt(state.get(cur) ?? 0n, desc.scaleFor(cur));
+  }
+  const out = {};
+  for (const [cur, v] of state) out[cur] = formatScaledInt(v, desc.scaleFor(cur));
+  return out;
+}
+function moneySumReducer(field, desc, convertTo, fx) {
+  return {
+    op: "sum",
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) + m.value);
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) - m.value);
+      return state;
+    },
+    finalize: (state) => finalizeSum(state, desc, convertTo, fx)
+  };
+}
+function extremum(values, op) {
+  let out = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (op === "min" ? v < out : v > out) out = v;
+  }
+  return out;
+}
+function moneyMinMaxReducer(op, field, desc) {
+  return {
+    op,
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) arr.push(m.value);
+        else state.set(m.currency, [m.value]);
+      }
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) {
+          const idx = arr.indexOf(m.value);
+          if (idx >= 0) arr.splice(idx, 1);
+        }
+      }
+      return state;
+    },
+    finalize: (state) => {
+      if (desc.mode === "fixed") {
+        const cur = desc.fixedCurrency;
+        const arr = state.get(cur);
+        if (!arr || arr.length === 0) return null;
+        return formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      const out = {};
+      for (const [cur, arr] of state) {
+        if (arr.length > 0) out[cur] = formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      return out;
+    }
+  };
+}
+function wrapMoneyReducers(spec, moneyFields) {
+  let changed = false;
+  const out = {};
+  for (const [key, reducer] of Object.entries(spec)) {
+    const field = reducer.field;
+    const desc = field ? moneyFields[field] : void 0;
+    if (desc && reducer.op === "avg") {
+      throw new MoneyUnsupportedError(
+        field,
+        `avg() is not supported on money field "${field}" in v1 \u2014 use sum() and count() and divide at the boundary.`
+      );
+    }
+    if (desc && (reducer.op === "sum" || reducer.op === "min" || reducer.op === "max")) {
+      changed = true;
+      out[key] = reducer.op === "sum" ? moneySumReducer(field, desc, reducer.convertTo, reducer.fx) : moneyMinMaxReducer(reducer.op, field, desc);
+    } else {
+      out[key] = reducer;
+    }
+  }
+  return changed ? out : spec;
+}
+
+// src/via/money/binding.ts
+function moneyBinding(moneyFields, virtualMoneyFields) {
+  validateMoneyFieldPaths(moneyFields);
+  const hasVirtualMoney = virtualMoneyFields !== void 0 && virtualMoneyFields.size > 0;
+  const ordinaryPresentFields = hasVirtualMoney ? Object.fromEntries(Object.entries(moneyFields).filter(([f]) => !virtualMoneyFields.has(f))) : moneyFields;
+  return {
+    brand: "money",
+    posture: { encryptedAtRest: "envelope", queryable: "ordered", exportable: true, forgettable: true },
+    covers: (field) => field in moneyFields,
+    ingest: (r) => canonicalizeIncomingMoney(r, moneyFields),
+    canonicalizeStored: (r) => canonicalizeStoredMoney(r, moneyFields),
+    encodeWrite: (r) => quantizeMoneyFields(r, moneyFields),
+    present: (r, ctx) => decodeMoneyFields(r, ordinaryPresentFields, typeof ctx.locale === "string" ? ctx.locale : void 0),
+    ...hasVirtualMoney ? {
+      presentLate: (r, ctx) => presentVirtualMoneyFields(r, moneyFields, virtualMoneyFields, typeof ctx.locale === "string" ? ctx.locale : void 0)
+    } : {},
+    buildClause: (field, op, value) => {
+      const desc = moneyFields[field];
+      if (!desc) return void 0;
+      return moneyFieldClause(field, op, value, desc);
+    },
+    evaluateClause: (actual, op, payload) => evaluateMoneyClause(actual, op, payload),
+    indexProbe: (op, payload) => moneyIndexProbe(op, payload),
+    canonicalizeIndexKey: (field, rawValue) => canonicalizeMoneyIndexKey(field, rawValue, moneyFields),
+    decodeResults: (r) => decodeMoneyFields(r, moneyFields, "raw"),
+    compareForOrder: (field, a, b) => {
+      const desc = moneyFields[field];
+      if (!desc) return void 0;
+      const av = moneyScaledValue(a, desc);
+      const bv = moneyScaledValue(b, desc);
+      if (av === null) return bv === null ? 0 : 1;
+      if (bv === null) return -1;
+      return av < bv ? -1 : av > bv ? 1 : 0;
+    },
+    wrapReducers: (spec) => wrapMoneyReducers(spec, moneyFields)
+  };
+}
+function linkMoneyVia() {
+  installViaBinder("money", (cfg) => {
+    const c = cfg;
+    return moneyBinding(c.moneyFields, c.virtualMoneyFields);
+  });
+}
+
+// src/via/money/descriptor.ts
+var MoneyPrecisionError = class extends NoydbError {
+  constructor(field, value, scale) {
+    super(
+      "MONEY_PRECISION",
+      `money: value ${JSON.stringify(value)} for field "${field}" exceeds scale ${scale} and no rounding mode is configured`
+    );
+    this.field = field;
+    this.value = value;
+    this.scale = scale;
+    this.name = "MoneyPrecisionError";
+  }
+  field;
+  value;
+  scale;
+};
+var MoneyCurrencyError = class extends NoydbError {
+  constructor(currency, reason, field) {
+    super(
+      "MONEY_CURRENCY",
+      reason === "not-allowed" ? `money: currency "${currency}" is not allowed${field ? ` for field "${field}"` : ""}` : `money: no scale known for currency "${currency}"${field ? ` (field "${field}")` : ""} \u2014 pass an explicit scale / scaleOverrides`
+    );
+    this.currency = currency;
+    this.reason = reason;
+    this.field = field;
+    this.name = "MoneyCurrencyError";
+  }
+  currency;
+  reason;
+  field;
+};
+var MoneyUnsupportedError = class extends NoydbError {
+  constructor(field, message) {
+    super(
+      "MONEY_UNSUPPORTED",
+      message ?? `money: operation is not supported on field "${field}" \u2014 use sum() and count() and divide at the boundary`
+    );
+    this.field = field;
+    this.name = "MoneyUnsupportedError";
+  }
+  field;
+};
+function isMultiOptions(o) {
+  return "currencies" in o;
+}
+function money(options) {
+  linkMoneyVia();
+  const hasFixed = "currency" in options;
+  const hasMulti = "currencies" in options;
+  if (hasFixed && hasMulti) {
+    throw new TypeError("money: `currency` and `currencies` are mutually exclusive");
+  }
+  if (!hasFixed && !hasMulti) {
+    throw new TypeError("money: one of `currency` or `currencies` is required");
+  }
+  const rounding = options.rounding;
+  if (isMultiOptions(options)) {
+    const overrides = options.scaleOverrides ?? {};
+    const allowList = options.currencies;
+    const allows = (c) => allowList === "any" ? true : allowList.includes(c);
+    const scaleFor = (c) => {
+      if (!allows(c)) throw new MoneyCurrencyError(c, "not-allowed");
+      const s = overrides[c] ?? scaleForCurrency(c);
+      if (s === null || s === void 0) throw new MoneyCurrencyError(c, "unknown-scale");
+      return s;
+    };
+    if (allowList !== "any") for (const c of allowList) scaleFor(c);
+    const soleCurrency = () => allowList !== "any" && allowList.length === 1 ? allowList[0] : void 0;
+    return {
+      _noydbMoney: true,
+      _viaBrand: "money",
+      mode: "multi",
+      options,
+      rounding,
+      fixedCurrency: void 0,
+      scaleFor,
+      allows,
+      soleCurrency
+    };
+  }
+  const currency = options.currency;
+  const resolvedScale = options.scale ?? scaleForCurrency(currency);
+  if (resolvedScale === null || resolvedScale === void 0) {
+    throw new MoneyCurrencyError(currency, "unknown-scale");
+  }
+  return {
+    _noydbMoney: true,
+    _viaBrand: "money",
+    mode: "fixed",
+    options,
+    rounding,
+    fixedCurrency: currency,
+    scaleFor(c) {
+      if (c !== currency) throw new MoneyCurrencyError(c, "not-allowed");
+      return resolvedScale;
+    },
+    allows: (c) => c === currency,
+    soleCurrency: () => currency
+  };
+}
+function isMoneyDescriptor(x) {
+  return typeof x === "object" && x !== null && x._noydbMoney === true;
+}
+
+// src/via/money/arith.ts
 function parseAmount(label, amount, scale, rounding) {
   const r = parseToScaledInt(amount, scale, rounding);
   if (!r.ok) {
@@ -1369,7 +2392,7 @@ function allocate(amount, weights, opts = {}) {
   return base.map((p) => formatScaledInt(negative && p !== 0n ? -p : p, scale));
 }
 
-// src/with-shape/money/branded.ts
+// src/via/money/branded.ts
 function asMoney(value) {
   if (!isMoneyLike(value)) {
     throw new MoneyUnsupportedError(`asMoney: ${JSON.stringify(value)} is not a finite decimal`);
@@ -1390,6 +2413,296 @@ function isMoneyLike(value) {
   if (typeof value !== "string") return false;
   return decimalScaleOf(value) !== null;
 }
+
+// src/via/computed/descriptor.ts
+function computed(fn, opts) {
+  return {
+    _viaBrand: "computed",
+    fn,
+    ...opts?.deps !== void 0 ? { deps: opts.deps } : {},
+    mode: opts?.mode ?? "materialized"
+  };
+}
+function isComputedDescriptor(x) {
+  return typeof x === "object" && x !== null && x._viaBrand === "computed";
+}
+
+// src/via/lookup/binding.ts
+function hasLabelSource(desc) {
+  return !(desc.backing === "static" && desc.table === void 0);
+}
+async function fetchLookupLabel(desc, key, effLocale, fieldFallback, cfg) {
+  if (desc.backing === "collection") {
+    const getRow = cfg.getLookupBacking?.(desc);
+    const row = getRow ? await getRow(key) : void 0;
+    const labelField = desc.present?.label;
+    if (!row || labelField === void 0) return void 0;
+    const raw = row[labelField];
+    if (desc.present?.by !== void 0) {
+      return raw && typeof raw === "object" ? raw[effLocale] : void 0;
+    }
+    return typeof raw === "string" ? raw : void 0;
+  }
+  return cfg.lookupLabelResolver?.(desc.dimension, key, effLocale, fieldFallback);
+}
+async function runLookupPresent(record, ctx, cfg) {
+  const fields = Object.entries(cfg.lookupFields).filter(([, d]) => hasLabelSource(d));
+  if (fields.length === 0) return record;
+  const locale = typeof ctx.locale === "string" ? ctx.locale : void 0;
+  const fallback = ctx.fallback;
+  const layer = ctx.layer;
+  if (locale === "raw") return record;
+  const hasStaticDisplay = fields.some(([, d]) => d.backing === "static" && d.displayLocale !== void 0);
+  if (!locale && !hasStaticDisplay) return record;
+  let result = record;
+  const withLabels = { ...result };
+  for (const [field, desc] of fields) {
+    const policy = desc.onMissing ? resolvePolicy(desc.onMissing, layer) : "null";
+    const fieldFallback = policy === "substitute" ? fallback ?? desc.substitute : fallback;
+    const effLocale = locale ?? (desc.backing === "static" ? desc.displayLocale : void 0);
+    const resolveKey = async (key) => {
+      if (!effLocale) {
+        if (policy === "throw") {
+          throw new LocaleNotSpecifiedError(field, `lookup "${field}": no locale active to resolve key "${key}".`);
+        }
+        return null;
+      }
+      const label = await fetchLookupLabel(desc, key, effLocale, fieldFallback, cfg);
+      if (label === void 0) {
+        if (policy === "throw") {
+          throw new LocaleNotSpecifiedError(field, `lookup "${field}": no label for key "${key}" in locale "${effLocale}".`);
+        }
+        return null;
+      }
+      return label;
+    };
+    if (field.includes("[].")) {
+      const parts = field.split("[].");
+      const arrayKey = parts[0];
+      const leaf = parts[1];
+      if (!leaf || leaf.includes(".")) continue;
+      const arr = withLabels[arrayKey];
+      if (!Array.isArray(arr)) continue;
+      const labelKey = `${leaf}Label`;
+      withLabels[arrayKey] = await Promise.all(
+        arr.map(async (el) => {
+          if (!el || typeof el !== "object" || Array.isArray(el)) return el;
+          const k = el[leaf];
+          if (typeof k !== "string") return el;
+          return { ...el, [labelKey]: await resolveKey(k) };
+        })
+      );
+      continue;
+    }
+    const val = result[field];
+    if (Array.isArray(val)) {
+      withLabels[`${field}Label`] = await Promise.all(
+        val.map(async (k) => ({ key: k, label: typeof k === "string" ? await resolveKey(k) : null }))
+      );
+    } else if (typeof val === "string") {
+      const label = await resolveKey(val);
+      if (label !== null) withLabels[`${field}Label`] = label;
+    }
+  }
+  result = withLabels;
+  return result;
+}
+function buildLookupDescribeFragment(cfg) {
+  const lookupFields = {};
+  for (const [field, desc] of Object.entries(cfg.lookupFields)) {
+    lookupFields[field] = {
+      ...desc.dimension !== "" ? { dimension: desc.dimension } : {},
+      backing: desc.backing,
+      vocabulary: desc.vocabulary,
+      key: desc.key,
+      onDelete: desc.onDelete,
+      ...desc.altKeys !== void 0 ? { altKeys: desc.altKeys } : {},
+      ...desc.present !== void 0 ? { present: desc.present } : {},
+      ...desc.sortBy !== void 0 ? { sortBy: desc.sortBy } : {},
+      // #657 — static tier: when no `keys` was explicitly declared but a
+      // `table` was (the staticDict()-equivalent `lookup(dim, {backing:
+      // 'static', table})` shape), the table's own key set IS the
+      // statically-known closed-vocabulary set the DescribedField.lookup
+      // docblock promises ("declared `keys`, OR a static table's own
+      // keys"). Reserved/matrix tiers never carry `table`, so this branch
+      // never fires for them — their `keys` emission is unchanged.
+      ...desc.keys !== void 0 ? { keys: desc.keys } : desc.backing === "static" && desc.table !== void 0 ? { keys: Object.keys(desc.table) } : {}
+    };
+  }
+  return { lookupFields };
+}
+function getAltIndexOrThrow(field, desc, cfg) {
+  try {
+    return cfg.getAltIndex?.(desc);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("lazy-mode")) {
+      throw new ValidationError(
+        `lookup: altKeys on "${field}" require the backing collection "${desc.dimension}" to be prefetch-enabled (lazy mode unsupported); open it without {prefetch:false} or drop altKeys.`
+      );
+    }
+    throw err;
+  }
+}
+function runLookupIngest(record, cfg) {
+  const withAltKeys = Object.entries(cfg.lookupFields).filter(([, d]) => (d.altKeys?.length ?? 0) > 0);
+  if (withAltKeys.length === 0) return record;
+  let result = record;
+  for (const [field, desc] of withAltKeys) {
+    const backing = getAltIndexOrThrow(field, desc, cfg);
+    if (!backing || backing.altIndex.size === 0) continue;
+    if (field.includes("[].")) {
+      const [arrayKey, leaf] = field.split("[].");
+      if (!leaf || leaf.includes(".")) continue;
+      const arr = record[arrayKey];
+      if (!Array.isArray(arr)) continue;
+      let changed = false;
+      const normalized = arr.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+        const value2 = item[leaf];
+        if (typeof value2 !== "string") return item;
+        const canonical2 = backing.altIndex.get(value2);
+        if (canonical2 === void 0 || canonical2 === value2) return item;
+        changed = true;
+        return { ...item, [leaf]: canonical2 };
+      });
+      if (!changed) continue;
+      if (result === record) result = { ...record };
+      result[arrayKey] = normalized;
+      continue;
+    }
+    const values = getAtPath(record, field);
+    if (values.length !== 1) continue;
+    const value = values[0];
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      let changed = false;
+      const normalized = value.map((el) => {
+        if (typeof el !== "string") return el;
+        const canonical2 = backing.altIndex.get(el);
+        if (canonical2 === void 0 || canonical2 === el) return el;
+        changed = true;
+        return canonical2;
+      });
+      if (!changed) continue;
+      if (result === record) result = { ...record };
+      setAtPathInPlace(result, field, normalized);
+      continue;
+    }
+    if (typeof value !== "string") continue;
+    const canonical = backing.altIndex.get(value);
+    if (canonical === void 0 || canonical === value) continue;
+    if (result === record) result = { ...record };
+    setAtPathInPlace(result, field, canonical);
+  }
+  return result;
+}
+async function runLookupEnforceWrite(record, cfg) {
+  for (const [field, desc] of Object.entries(cfg.lookupFields)) {
+    if (desc.vocabulary !== "closed") continue;
+    for (const value of getAtPath(record, field)) {
+      if (Array.isArray(value)) {
+        for (const el of value) {
+          if (typeof el !== "string") continue;
+          const known2 = cfg.membership ? await cfg.membership(field, el) : true;
+          if (!known2) throw new UnknownLookupKeyError(desc.dimension, field, el);
+        }
+        continue;
+      }
+      if (typeof value !== "string") continue;
+      const known = cfg.membership ? await cfg.membership(field, value) : true;
+      if (!known) throw new UnknownLookupKeyError(desc.dimension, field, value);
+    }
+  }
+}
+function compareLookupOrder(field, a, b, cfg) {
+  if (typeof a !== "string" || typeof b !== "string") return void 0;
+  const desc = cfg.lookupFields[field];
+  if (!desc || desc.sortBy === void 0) return void 0;
+  const rows = desc.backing === "static" ? desc.table ? new Map(Object.entries(desc.table)) : void 0 : cfg.snapshotFor?.(desc);
+  if (!rows) return void 0;
+  return buildLookupSnapshot(desc.dimension, rows, desc).compareKeys(a, b, desc.displayLocale ?? "");
+}
+function resolveLookupOrderLabel(field, key, locale, cfg) {
+  const desc = cfg.lookupFields[field];
+  if (!desc) return void 0;
+  const rows = desc.backing === "static" ? desc.table ? new Map(Object.entries(desc.table)) : void 0 : cfg.snapshotFor?.(desc);
+  if (!rows) return void 0;
+  return buildLookupSnapshot(desc.dimension, rows, desc).label(key, locale ?? desc.displayLocale ?? "");
+}
+function lookupBinding(cfg) {
+  return {
+    brand: "lookup",
+    posture: { encryptedAtRest: "envelope", queryable: "full", exportable: true, forgettable: false },
+    reservedPrefixes: ["_dict_", "_lookup_"],
+    covers: (field) => field in cfg.lookupFields,
+    ingest: (record) => runLookupIngest(record, cfg),
+    enforceWrite: (record) => runLookupEnforceWrite(record, cfg),
+    present: async (record, ctx) => runLookupPresent(record, ctx, cfg),
+    compareForOrder: (field, a, b) => compareLookupOrder(field, a, b, cfg),
+    resolveOrderLabel: (field, key, locale) => resolveLookupOrderLabel(field, key, locale, cfg),
+    describeFragment: () => buildLookupDescribeFragment(cfg)
+  };
+}
+function linkLookupVia() {
+  installViaBinder("lookup", (c) => lookupBinding(c));
+}
+
+// src/via/lookup/descriptor.ts
+function warnIfSortByNeedsDisplayLocale(dimension, opts) {
+  if (opts?.sortBy !== void 0 && opts.present?.by !== void 0 && opts.displayLocale === void 0) {
+    console.warn(
+      `[noy-db] lookup("${dimension}"): sortBy "${opts.sortBy}" is locale-keyed (present.by is set) but no displayLocale is declared \u2014 a locale-less orderBy() will silently sort by the raw stored key instead of the resolved label. Declare displayLocale, or sort via orderBy(field, dir, { by: 'label' }), which resolves at the query's own per-call locale.`
+    );
+  }
+}
+function lookup(dimension, opts) {
+  linkLookupVia();
+  warnIfSortByNeedsDisplayLocale(dimension, opts);
+  return {
+    _viaBrand: "lookup",
+    dimension,
+    key: opts?.key ?? "id",
+    vocabulary: opts?.vocabulary ?? "open",
+    backing: opts?.backing ?? "collection",
+    onDelete: opts?.onDelete ?? "restrict",
+    ...opts?.altKeys !== void 0 ? { altKeys: opts.altKeys } : {},
+    ...opts?.present !== void 0 ? { present: opts.present } : {},
+    ...opts?.sortBy !== void 0 ? { sortBy: opts.sortBy } : {},
+    ...opts?.keys !== void 0 ? { keys: opts.keys } : {},
+    ...opts?.table !== void 0 ? { table: opts.table } : {},
+    ...opts?.displayLocale !== void 0 ? { displayLocale: opts.displayLocale } : {},
+    ...opts?.onMissing !== void 0 ? { onMissing: opts.onMissing } : {},
+    ...opts?.substitute !== void 0 ? { substitute: opts.substitute } : {},
+    ...opts?.labels !== void 0 ? { labels: opts.labels } : {}
+  };
+}
+function enumOf(keys) {
+  linkLookupVia();
+  return {
+    _viaBrand: "lookup",
+    dimension: "",
+    key: "id",
+    vocabulary: "closed",
+    backing: "static",
+    onDelete: "restrict",
+    keys
+  };
+}
+function dict(dimension, opts) {
+  linkLookupVia();
+  return {
+    _viaBrand: "lookup",
+    dimension,
+    key: "id",
+    vocabulary: opts?.vocabulary ?? "open",
+    backing: "reserved",
+    onDelete: opts?.onDelete ?? "restrict",
+    ...opts?.keys !== void 0 ? { keys: opts.keys } : {},
+    ...opts?.present !== void 0 ? { present: opts.present } : {},
+    ...opts?.onMissing !== void 0 ? { onMissing: opts.onMissing } : {},
+    ...opts?.substitute !== void 0 ? { substitute: opts.substitute } : {}
+  };
+}
 export {
   Aggregation,
   AlreadyElevatedError,
@@ -1410,6 +2723,13 @@ export {
   BundleVersionConflictError,
   CONSENT_AUDIT_COLLECTION,
   CargoNotEnabledError,
+  ClassifiedConfigError,
+  ClassifiedNeverStoredError,
+  ClassifiedNotEnabledError,
+  ClassifiedRevealError,
+  ClassifiedRotationError,
+  ClassifiedValidationError,
+  ClassifiedVerifyError,
   Collection,
   CollectionFrame,
   CollectionIndexes,
@@ -1442,7 +2762,7 @@ export {
   DerivationOutputUnknownError,
   DictKeyInUseError,
   DictKeyMissingError,
-  DictionaryHandle,
+  LookupHandle as DictionaryHandle,
   DirectoryDisabledError,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
@@ -1452,6 +2772,7 @@ export {
   EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
+  FieldNotQueryableError,
   FilenameSanitizationError,
   ForgetStrategyNotConfiguredError,
   GROUPBY_MAX_CARDINALITY,
@@ -1505,6 +2826,7 @@ export {
   NO_CUSTODY,
   NO_SEARCH,
   NO_SEQUENCE,
+  NO_TEAM,
   NetworkError,
   NoAccessError,
   NonAdditiveSchemaChangeError,
@@ -1546,6 +2868,7 @@ export {
   RefScopeError,
   ReservedCollectionNameError,
   ReservedVaultNameError,
+  RestrictRefUnresolvableError,
   SCHEMAS_COLLECTION,
   SEALED_PASSPHRASE_RECORD_ID,
   STATE_VAULT_NAME,
@@ -1577,6 +2900,7 @@ export {
   SyncScheduler,
   SyncTransaction,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TiersNotEnabledError,
@@ -1588,6 +2912,7 @@ export {
   USER_ENVELOPE_MAX_BYTES,
   UniqueConstraintError,
   UnknownDictCodeError,
+  UnknownLookupKeyError,
   UnknownShardError,
   UnsupportedIndexOptionError,
   UserApi,
@@ -1606,6 +2931,7 @@ export {
   allocate,
   applyI18nLocale,
   applyJoins,
+  applyListProjection,
   applyPatch,
   approveWithdrawal,
   asMoney,
@@ -1620,9 +2946,11 @@ export {
   burnPaperRecoveryEntry,
   canonicalJson,
   checkGate,
+  classified,
   clearDevUnlock,
   compileSequenceFormat,
   computePatch,
+  computed,
   coordinatedCutover,
   count,
   createBundleStore,
@@ -1650,6 +2978,7 @@ export {
   detectMagic,
   detectMimeType,
   diagramAuthConfig,
+  dict,
   dictCollectionName,
   dictKey,
   diff,
@@ -1660,6 +2989,8 @@ export {
   encryptDeterministic,
   enforceScript,
   enrollAuthenticator,
+  enumOf as enum,
+  enumOf,
   envelopePayloadHash,
   estimateEntropy,
   estimateRecordBytes,
@@ -1685,6 +3016,9 @@ export {
   immutableGuard,
   importExternalObjects,
   inferScripts,
+  isClassifiedFieldSpec,
+  isClassifiedGroup,
+  isComputedDescriptor,
   isDeedVault,
   isDevUnlockActive,
   isDictCollectionName,
@@ -1701,6 +3035,7 @@ export {
   isSessionAlive,
   isStaticDictDescriptor,
   isULID,
+  isViaFieldSpec,
   isZodSchema,
   issueDelegation,
   recoverPassphrase as keyringRecoverPassphrase,
@@ -1723,6 +3058,8 @@ export {
   loadUserEnvelope,
   loadVaultPolicy,
   lockSchema,
+  lookup,
+  luhnCheck,
   magicLinkGrantRecordId,
   max,
   memoryObjectProjection,
@@ -1769,6 +3106,7 @@ export {
   requestWithdrawal,
   resetBrotliSupportCache,
   resetJoinWarnings,
+  resolveClassifiedFields,
   resolveCrdtSnapshot,
   resolveI18nText,
   resolvePolicy,
@@ -1805,6 +3143,7 @@ export {
   validateSchemaInput,
   validateSchemaOutput,
   validateSessionPolicy,
+  via,
   visibilityRecordId,
   withArchive,
   withCache,
@@ -1815,6 +3154,7 @@ export {
   withDerivation,
   withGuard,
   withHealthCheck,
+  withLazy,
   withLogging,
   withMaterializedView,
   withMetrics,
@@ -1823,6 +3163,7 @@ export {
   withRollup,
   withSearch,
   withSequence,
+  withTeam,
   withdrawAccessibleData,
   wrapBundleStore,
   wrapPodStore,