@noy-db/hub 0.2.0-pre.9 → 0.3.0-pre.10

package/dist/index.js

@@ -3,86 +3,239 @@ import {
   issueDelegation,
   loadActiveDelegations,
   revokeDelegation
-} from "./chunk-5T22KDPN.js";
+} from "./chunk-DV4HUP5G.js";
+import {
+  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
+  PUBLIC_ENVELOPE_FIELDS,
+  resolveSchema
+} from "./chunk-WXSYDNBT.js";
+import {
+  UserApi
+} from "./chunk-BKARNZJN.js";
 import {
-  Collection,
   DEFAULT_FRESHNESS_MS,
+  PERSONAL_POLICY,
+  STRICT_POLICY,
+  checkGate,
+  describeGate,
+  mergePolicy
+} from "./chunk-2OZXVKVP.js";
+import {
+  Collection,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
-  Lru,
-  META_COLLECTION,
   Noydb,
-  PERSONAL_POLICY,
-  POLICY_RECORD_ID,
   QuickUnlockStore,
   RefIntegrityError,
   RefRegistry,
   RefScopeError,
-  STRICT_POLICY,
-  UserApi,
   Vault,
-  checkGate,
   createNoydb,
-  derivePersistedSchema,
   describeAllUsersAuth,
   describeAuthConfig,
-  describeGate,
   describeUserAuth,
   diagramAuthConfig,
-  estimateRecordBytes,
-  isZodSchema,
-  loadVaultPolicy,
-  mergePolicy,
-  parseBytes,
-  persistSchemaIfNeeded,
+  isRefArray,
+  isViaFieldSpec,
+  memoryStore,
   ref,
-  saveVaultPolicy,
-  validateSchemaInput,
-  validateSchemaOutput
-} from "./chunk-6CME4UEK.js";
+  refArray,
+  via,
+  withArchive
+} from "./chunk-DSKDQP3G.js";
+import "./chunk-VYYM3MEN.js";
 import {
-  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
-  PUBLIC_ENVELOPE_FIELDS,
-  resolveSchema
-} from "./chunk-EMIGCR7X.js";
+  NO_SEQUENCE,
+  SequenceStore,
+  compileSequenceFormat,
+  resolveSequenceKey,
+  withSequence
+} from "./chunk-6G5ORS5D.js";
+import {
+  META_COLLECTION,
+  POLICY_RECORD_ID,
+  loadVaultPolicy,
+  saveVaultPolicy
+} from "./chunk-G4JYND6L.js";
+import {
+  LinkEndpointError
+} from "./chunk-FORYWFN6.js";
+import {
+  LinkIntegrityError,
+  isLinkCollectionName
+} from "./chunk-HY3AUMFI.js";
+import "./chunk-VQRAIPYF.js";
+import {
+  persistSchemaIfNeeded
+} from "./chunk-WBJIQSLL.js";
+import "./chunk-XREOISSI.js";
+import {
+  NO_SEARCH,
+  tokenize,
+  withSearch
+} from "./chunk-VJV7GKQK.js";
+import {
+  derivePersistedSchema,
+  isZodSchema
+} from "./chunk-5I35DOHK.js";
+import {
+  ComputedFieldError,
+  evalComputedFields
+} from "./chunk-O45M6LDB.js";
+import "./chunk-GYGLAVCX.js";
+import {
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-WIGQB62E.js";
+import "./chunk-XGDAPN6M.js";
+import {
+  isDiscriminant
+} from "./chunk-PY4KJPYU.js";
+import "./chunk-QOC3VYL2.js";
+import {
+  classified,
+  luhnCheck
+} from "./chunk-Y3A5CB5G.js";
+import {
+  ClassifiedNeverStoredError,
+  ClassifiedValidationError,
+  isClassifiedFieldSpec,
+  isClassifiedGroup,
+  resolveClassifiedFields
+} from "./chunk-VWM3DAVB.js";
+import "./chunk-7P2SDJG3.js";
+import "./chunk-RHK32N73.js";
+import {
+  withCargo
+} from "./chunk-U3WZCU7E.js";
+import {
+  CustodyApi,
+  NO_CARGO,
+  NO_CUSTODY,
+  withCustody
+} from "./chunk-ZYJ55N7N.js";
+import {
+  DEED_RECORD_ID,
+  createDeedOwner,
+  isDeedVault,
+  liberateVault,
+  loadDeedMarker
+} from "./chunk-UN4FVIBH.js";
+import {
+  fuseRetrieval
+} from "./chunk-AURFOK3D.js";
+import {
+  withdrawAccessibleData
+} from "./chunk-OBKWYKYC.js";
+import {
+  exportAccessibleData
+} from "./chunk-OT76OZL6.js";
+import "./chunk-TWKKOM55.js";
+import {
+  diffVault
+} from "./chunk-LB7FD65R.js";
+import "./chunk-DJ7KIPLV.js";
+import {
+  PERIODS_COLLECTION
+} from "./chunk-FRP6D2DM.js";
+import "./chunk-GHVIKOHT.js";
+import {
+  immutableGuard,
+  transitionGuard,
+  withGuard
+} from "./chunk-F4CEK5YM.js";
+import "./chunk-YMUGBZN2.js";
+import "./chunk-JK733I5V.js";
+import "./chunk-VWRRVE6D.js";
+import {
+  CollectionFrame,
+  VaultFrame
+} from "./chunk-VRIYFLBA.js";
 import {
   TxCollection,
   TxContext,
   TxVault,
   runTransaction
-} from "./chunk-TFBP23BX.js";
+} from "./chunk-ICXIFFYZ.js";
 import {
-  withDerivation
-} from "./chunk-RAZ4OVLL.js";
-import "./chunk-DE6GKS6G.js";
-import "./chunk-DO7C2TOG.js";
+  withDerivation,
+  withRollup
+} from "./chunk-KNZB6JMR.js";
+import "./chunk-XUBPSPKD.js";
+import "./chunk-FUOE7UUV.js";
+import "./chunk-LEJIKBBB.js";
 import {
   withMaterializedView
-} from "./chunk-K3DK3NU5.js";
-import "./chunk-HNRHLRDC.js";
-import "./chunk-O3VZPBZG.js";
-import "./chunk-T7JEBOGN.js";
+} from "./chunk-RW3Y22MW.js";
+import "./chunk-LL2NIVUR.js";
+import {
+  buildLookupSnapshot
+} from "./chunk-WZSCE6RM.js";
+import "./chunk-3QSIU3UT.js";
+import "./chunk-2REPHKET.js";
 import {
   withOverlayedView
-} from "./chunk-SYMWGEET.js";
-import "./chunk-VTKGMEPP.js";
-import "./chunk-DJHHA6XH.js";
-import "./chunk-2WUSG3IT.js";
+} from "./chunk-PS2NEWEX.js";
+import "./chunk-OHHKHSJP.js";
+import "./chunk-6P5XCKSD.js";
+import {
+  importExternalObjects,
+  memoryObjectProjection
+} from "./chunk-4Q6HSHHL.js";
+import "./chunk-BQISD5ZV.js";
+import "./chunk-CB7CWSKW.js";
+import {
+  withLazy
+} from "./chunk-THNJ3IKU.js";
+import {
+  Lru,
+  estimateRecordBytes,
+  parseBytes
+} from "./chunk-NO272T7Q.js";
 import {
   mergeCrdtStates,
   resolveCrdtSnapshot
-} from "./chunk-J66GRPNH.js";
+} from "./chunk-6S7T6WC4.js";
+import {
+  decryptExtractedPartition
+} from "./chunk-5VG4IJR7.js";
+import {
+  SCHEMAS_COLLECTION,
+  loadPersistedSchema,
+  savePersistedSchema
+} from "./chunk-T7WSLRAU.js";
 import {
   MemoryRecipientSealer,
   MemorySealingKeyProvider,
-  SCHEMAS_COLLECTION,
   SEALED_PASSPHRASE_RECORD_ID,
-  loadPersistedSchema,
+  aesGcmOpen,
   loadSealedPassphrase,
+  parseRsaOaepTlv,
   parseSealedEnvelope,
-  savePersistedSchema,
-  saveSealedPassphrase
-} from "./chunk-I5FOWO4J.js";
+  saveSealedPassphrase,
+  sealRsaOaepTlv
+} from "./chunk-YCXCR7VG.js";
+import {
+  BLOB_CHUNKS_COLLECTION,
+  BLOB_COLLECTION,
+  BLOB_INDEX_COLLECTION,
+  BLOB_SLOTS_PREFIX,
+  BLOB_VERSIONS_PREFIX,
+  BlobSet,
+  DEFAULT_CHUNK_SIZE,
+  detectMagic,
+  detectMimeType,
+  isPreCompressed
+} from "./chunk-XH7XP3OL.js";
+import {
+  createBundleStore,
+  createPodStore,
+  wrapBundleStore,
+  wrapPodStore
+} from "./chunk-5YESYH2C.js";
 import {
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -91,9 +244,12 @@ import {
   readNoydbBundle,
   readNoydbBundleHeader,
   readNoydbBundlePublicEnvelope,
+  readPod,
+  readPodHeader,
   resetBrotliSupportCache,
-  writeNoydbBundle
-} from "./chunk-BVRYKATC.js";
+  writeNoydbBundle,
+  writePod
+} from "./chunk-QSFOZUYL.js";
 import {
   PUBLIC_ENVELOPE_RECORD_ID,
   isPublicEnvelope,
@@ -101,140 +257,106 @@ import {
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-ML236QKC.js";
+} from "./chunk-OXCSVM3B.js";
 import {
   CONSENT_AUDIT_COLLECTION
-} from "./chunk-XJFLDA7A.js";
-import {
-  PERIODS_COLLECTION
-} from "./chunk-JWRVQKRZ.js";
-import "./chunk-UF3BUNQZ.js";
-import {
-  withGuard
-} from "./chunk-OQ6PIGHA.js";
-import "./chunk-A3JMGXPG.js";
-import "./chunk-UMLVJTYV.js";
-import "./chunk-NONAAENK.js";
-import {
-  CollectionFrame,
-  VaultFrame
-} from "./chunk-DFMLEQZB.js";
-import {
-  enforceScript,
-  inferScripts
-} from "./chunk-6STK5TQP.js";
+} from "./chunk-TMBXVJKT.js";
+import "./chunk-JJZ2LW6T.js";
 import {
-  DICT_COLLECTION_PREFIX,
-  DictionaryHandle,
-  applyI18nLocale,
-  dictCollectionName,
   dictKey,
-  i18nText,
-  isDictCollectionName,
-  isDictKeyDescriptor,
-  isI18nTextDescriptor,
-  resolveI18nText,
-  resolvePolicy,
-  validateI18nTextValue
-} from "./chunk-22DWZL57.js";
+  staticDict
+} from "./chunk-ET67AY6B.js";
 import {
-  createBundleStore,
-  routeStore,
-  withCache,
-  withCircuitBreaker,
-  withHealthCheck,
-  withLogging,
-  withMetrics,
-  withRetry,
-  wrapBundleStore,
-  wrapStore
-} from "./chunk-QEILDE6R.js";
+  DICT_COLLECTION_PREFIX,
+  LookupHandle,
+  dictCollectionName
+} from "./chunk-NUEQU36L.js";
 import {
-  SYNC_CREDENTIALS_COLLECTION,
   credentialStatus,
   deleteCredential,
   getCredential,
   listCredentials,
-  putCredential
-} from "./chunk-ZYWZWG6G.js";
+  putCredential,
+  withTeam
+} from "./chunk-4OMCIY6F.js";
 import {
   MAGIC_LINK_CONTENT_INFO_PREFIX,
   MAGIC_LINK_GRANTS_COLLECTION,
   MAGIC_LINK_KEK_INFO_PREFIX,
-  ManagedRecoveryNotEnrolledError,
-  PolicyDeniedError,
-  RecoveryNotEnrolledError,
-  RecoveryProfileNotImplementedError,
-  burnPaperRecoveryEntry,
+  NO_TEAM,
   deriveMagicLinkContentKey,
   enrollAuthenticator,
   findAuthenticator,
-  hasRecoveryEnrolled,
   isMagicLinkGrantExpired,
   listMagicLinkGrants,
-  loadPaperRecoveryEntries,
-  loadShamirRecoveryEntries,
   magicLinkGrantRecordId,
-  mintPaperRecoveryEntry,
-  mintShamirRecoveryEntry,
-  mintWrappedDeksBlob,
   readMagicLinkGrantRecord,
   recoverPassphrase,
   recoverUser,
   removeAuthenticator,
   revokeMagicLinkGrant,
   rotatePassphrase,
+  unwrapMagicLinkGrant,
+  writeMagicLinkGrant
+} from "./chunk-KJ2BCBTL.js";
+import {
+  burnPaperRecoveryEntry,
+  hasRecoveryEnrolled,
+  loadPaperRecoveryEntries,
+  loadShamirRecoveryEntries,
+  mintPaperRecoveryEntry,
+  mintShamirRecoveryEntry,
+  mintWrappedDeksBlob,
   savePaperRecoveryEntries,
   saveShamirRecoveryEntries,
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
-  unwrapDeksFromShamirEntry,
-  unwrapMagicLinkGrant,
-  writeMagicLinkGrant
-} from "./chunk-3YPCK6JX.js";
-import {
-  assertTierAccess,
-  dekKey,
-  effectiveClearance
-} from "./chunk-U26HQ6KJ.js";
+  unwrapDeksFromShamirEntry
+} from "./chunk-P33LUIML.js";
 import {
   PresenceHandle,
   SyncEngine,
   SyncTransaction
-} from "./chunk-WPLVTJ5D.js";
+} from "./chunk-TAKWLZZX.js";
 import {
-  DIRECTORY_RECORD_ID,
-  USER_ENVELOPE_COLLECTION,
-  USER_ENVELOPE_MAX_BYTES,
-  UserEnvelopeOversizedError,
-  VISIBILITY_RECORD_PREFIX,
+  BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY,
+  POD_STORE_POLICY,
+  SyncScheduler
+} from "./chunk-VQNJ7UZL.js";
+import {
+  assertTierAccess,
+  dekKey,
+  effectiveClearance
+} from "./chunk-7BWJHO2A.js";
+import {
+  SYNC_CREDENTIALS_COLLECTION,
   WeakPassphraseError,
   assertStrongPassphrase,
   buildRecipientKeyringFile,
-  deleteUserEnvelope,
-  deleteUserVisibility,
   estimateEntropy,
   evaluateExportCapability,
   evaluateImportCapability,
   hasExportCapability,
   hasImportCapability,
-  listUserEnvelopeIds,
   listUsers,
   listUsersWithEnvelopes,
+  validatePassphrase
+} from "./chunk-J4LPNIGK.js";
+import {
+  DIRECTORY_RECORD_ID,
+  VISIBILITY_RECORD_PREFIX,
+  deleteUserEnvelope,
+  deleteUserVisibility,
+  listUserEnvelopeIds,
   loadUserEnvelope,
   persistDirectoryConfig,
   persistUserVisibility,
   readDirectoryConfig,
   readUserVisibility,
   saveUserEnvelope,
-  validatePassphrase,
   visibilityRecordId
-} from "./chunk-DONMZAD2.js";
-import {
-  BUNDLE_STORE_POLICY,
-  INDEXED_STORE_POLICY,
-  SyncScheduler
-} from "./chunk-2QR2PQTT.js";
+} from "./chunk-OVYRLHPE.js";
 import {
   PolicyEnforcer,
   activeSessionCount,
@@ -249,24 +371,28 @@ import {
   revokeAllSessions,
   revokeSession,
   validateSessionPolicy
-} from "./chunk-H2X3ISXG.js";
+} from "./chunk-3MATJ6O4.js";
 import {
   generateULID,
   isULID
-} from "./chunk-FZU343FL.js";
+} from "./chunk-ZJADGNYF.js";
 import {
   CollectionInstant,
-  VaultInstant,
+  VaultInstant
+} from "./chunk-IVLTXX4W.js";
+import {
   diff,
   formatDiff
-} from "./chunk-F3GDRNUT.js";
+} from "./chunk-SVLR4POP.js";
 import {
-  LEDGER_COLLECTION,
-  LEDGER_DELTAS_COLLECTION,
   LedgerStore,
   applyPatch,
   computePatch
-} from "./chunk-PE2FR4J3.js";
+} from "./chunk-3JXPAHOZ.js";
+import {
+  LEDGER_COLLECTION,
+  LEDGER_DELTAS_COLLECTION
+} from "./chunk-I7FD46FF.js";
 import {
   canonicalJson,
   envelopePayloadHash,
@@ -274,7 +400,35 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-Z6FNBOTC.js";
+} from "./chunk-UF362QVH.js";
+import "./chunk-ANB77BVV.js";
+import "./chunk-HPWKV3YB.js";
+import {
+  validateSchemaInput,
+  validateSchemaOutput
+} from "./chunk-MCHVVJIA.js";
+import "./chunk-QA2KUPCP.js";
+import "./chunk-2OV5NVE7.js";
+import "./chunk-VEPTFUJY.js";
+import "./chunk-HYR4WZZ3.js";
+import "./chunk-LP7BEXCT.js";
+import {
+  base64ToBuffer,
+  bufferToBase64,
+  decryptBytes,
+  decryptDeterministic,
+  derivePresenceKey,
+  encryptBytes,
+  encryptDeterministic
+} from "./chunk-3OPY6MK2.js";
+import {
+  NOYDB_BACKUP_VERSION,
+  NOYDB_FORMAT_VERSION,
+  NOYDB_KEYRING_VERSION,
+  NOYDB_SYNC_VERSION,
+  SealedHandle,
+  createStore
+} from "./chunk-YN5IAHN6.js";
 import {
   DEFAULT_CROSS_JOIN_MAX_ROWS,
   DEFAULT_JOIN_MAX_ROWS,
@@ -284,17 +438,10 @@ import {
   buildLiveQuery,
   executePlan,
   resetJoinWarnings
-} from "./chunk-2GLDA55J.js";
+} from "./chunk-BUAQ7YI3.js";
 import {
   CollectionIndexes
-} from "./chunk-OIF6LZUR.js";
-import {
-  avg,
-  count,
-  max,
-  min,
-  sum
-} from "./chunk-W6EQLGMB.js";
+} from "./chunk-KPZS5QAQ.js";
 import {
   Aggregation,
   GROUPBY_MAX_CARDINALITY,
@@ -302,56 +449,65 @@ import {
   GroupedAggregation,
   GroupedQuery,
   GroupedQueryN,
+  avg,
+  count,
   groupAndReduce,
-  reduceRecords
-} from "./chunk-5XHKQ56N.js";
+  max,
+  min,
+  moneyMax,
+  moneyMin,
+  moneySum,
+  reduceRecords,
+  reducerBuilder,
+  sum
+} from "./chunk-DFVUTGT2.js";
 import {
   evaluateClause,
   evaluateFieldClause,
   readPath
-} from "./chunk-TV3YZ35S.js";
-import {
-  BLOB_CHUNKS_COLLECTION,
-  BLOB_COLLECTION,
-  BLOB_INDEX_COLLECTION,
-  BLOB_SLOTS_PREFIX,
-  BLOB_VERSIONS_PREFIX,
-  BlobSet,
-  DEFAULT_CHUNK_SIZE,
-  detectMagic,
-  detectMimeType,
-  isPreCompressed
-} from "./chunk-QODLLGQ7.js";
-import "./chunk-3BFJOWSU.js";
+} from "./chunk-IGJCYUT5.js";
 import {
-  NOYDB_BACKUP_VERSION,
-  NOYDB_FORMAT_VERSION,
-  NOYDB_KEYRING_VERSION,
-  NOYDB_SYNC_VERSION,
-  createStore
-} from "./chunk-WIRRPTFH.js";
+  applyI18nLocale,
+  enforceScript,
+  getAtPath,
+  i18nText,
+  inferScripts,
+  isDictCollectionName,
+  isDictKeyDescriptor,
+  isI18nTextDescriptor,
+  isStaticDictDescriptor,
+  resolveI18nText,
+  resolvePolicy,
+  setAtPathInPlace,
+  validateI18nTextValue
+} from "./chunk-EOXAAJTY.js";
 import {
-  base64ToBuffer,
-  bufferToBase64,
-  decryptBytes,
-  decryptDeterministic,
-  derivePresenceKey,
-  encryptBytes,
-  encryptDeterministic
-} from "./chunk-PP6W64Y3.js";
+  installViaBinder
+} from "./chunk-VEAVKDDB.js";
 import {
   AlreadyElevatedError,
   AmendmentForbiddenError,
   AttestationError,
+  AttestationNotEnabledError,
   BackupCorruptedError,
   BackupLedgerError,
   BundleIntegrityError,
   BundleSealMismatchError,
   BundleVersionConflictError,
+  CargoNotEnabledError,
+  ClassifiedConfigError,
+  ClassifiedNotEnabledError,
+  ClassifiedRevealError,
+  ClassifiedRotationError,
+  ClassifiedVerifyError,
   ConflictError,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
+  CustodyNotEnabledError,
   DanglingReferenceError,
+  DataResidencyError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   DelegationTargetMissingError,
   DerivationCapExceededError,
@@ -363,10 +519,16 @@ import {
   DictKeyMissingError,
   DirectoryDisabledError,
   ElevationExpiredError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
+  FieldNotQueryableError,
   FilenameSanitizationError,
+  ForgetStrategyNotConfiguredError,
   GroupCardinalityError,
+  IllegalTransitionError,
   ImportCapabilityError,
   IndexRequiredError,
   IndexWriteFailureError,
@@ -377,6 +539,7 @@ import {
   KeyringExpiredError,
   LedgerContentionError,
   LocaleNotSpecifiedError,
+  ManagedRecoveryNotEnrolledError,
   MaterializedViewConfigError,
   MaterializedViewCycleError,
   MaterializedViewSourceUnknownError,
@@ -388,6 +551,7 @@ import {
   NonAdditiveSchemaChangeError,
   NotFoundError,
   NoydbError,
+  NumberingUncertaintyError,
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
@@ -395,33 +559,109 @@ import {
   PathEscapeError,
   PeriodClosedError,
   PermissionDeniedError,
+  PodVersionConflictError,
+  PolicyDeniedError,
+  PortabilityNotEnabledError,
   PrivilegeEscalationError,
   QuiesceTimeoutError,
   ReadOnlyAtInstantError,
   ReadOnlyError,
   ReadOnlyFrameError,
+  RecordCekNotFoundError,
   RecordLockedError,
+  RecoveryNotEnrolledError,
+  RecoveryProfileNotImplementedError,
   ReservedCollectionNameError,
+  ReservedVaultNameError,
+  RestrictRefUnresolvableError,
+  STATE_VAULT_NAME,
   SchemaFenceError,
   SchemaLockedError,
   SchemaUpdateError,
   SchemaValidationError,
   ScriptViolationError,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  SealedRecordNotEnabledError,
+  SearchNotEnabledError,
+  SequenceContentionError,
+  SequenceNotEnabledError,
+  SequenceOfflineError,
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
+  ShardProvisioningError,
   SnapshotNotFoundError,
+  StaticDictReadonlyError,
   StoreCapabilityError,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
+  TiersNotEnabledError,
   TranslatorNotConfiguredError,
-  ValidationError
-} from "./chunk-B6PB7JLN.js";
+  USER_ENVELOPE_COLLECTION,
+  USER_ENVELOPE_MAX_BYTES,
+  UniqueConstraintError,
+  UnknownDictCodeError,
+  UnknownLookupKeyError,
+  UnknownShardError,
+  UnsupportedIndexOptionError,
+  UserEnvelopeOversizedError,
+  ValidationError,
+  VaultTemplateNotFoundError
+} from "./chunk-S7VFUQM2.js";
+import "./chunk-PZ5AY32C.js";
 
-// src/schema-update/strategies.ts
-function blindUpdate() {
-  return { name: "blindUpdate", onSchemaDelta: () => ({ action: "allow" }) };
+// src/kernel/debug.ts
+function readPlaintextRecord(envelope) {
+  if (envelope._iv !== "") {
+    throw new Error(
+      "readPlaintextRecord: envelope is encrypted (non-empty _iv) \u2014 decrypt via the vault, not this helper"
+    );
+  }
+  if (envelope._debug !== void 0) {
+    const record = {};
+    for (const [key, value] of Object.entries(envelope)) {
+      if (!key.startsWith("_")) record[key] = value;
+    }
+    return record;
+  }
+  if (!envelope._data) return null;
+  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" }) };
 }
 function additiveOnly() {
   return {
@@ -457,7 +697,7 @@ function lockSchema(opts) {
   };
 }
 
-// src/schema-update/cutover.ts
+// src/with-shape/schema-update/cutover.ts
 function coordinatedCutover(opts) {
   return {
     name: "coordinatedCutover",
@@ -470,162 +710,2004 @@ function coordinatedCutover(opts) {
   };
 }
 
-// src/vault-diff.ts
-async function diffVault(vault, candidate, options = {}) {
-  const idKey = options.idKey ?? "id";
-  const filter = options.collections ? new Set(options.collections) : null;
-  const compareFn = options.compareFn ?? ((a, b) => diff(a, b).length === 0);
-  const live = /* @__PURE__ */ new Map();
-  for await (const chunk of vault.exportStream({ granularity: "collection" })) {
-    if (filter && !filter.has(chunk.collection)) continue;
-    const collection = live.get(chunk.collection) ?? /* @__PURE__ */ new Map();
-    for (const record of chunk.records) {
-      const id = readIdField(record, idKey);
-      if (!id) continue;
-      collection.set(id, record);
-    }
-    live.set(chunk.collection, collection);
-  }
-  const cand = await normaliseCandidate(candidate, idKey, filter);
-  const added = [];
-  const modified = [];
-  const deleted = [];
-  const unchanged = options.includeUnchanged ? [] : void 0;
-  const collectionNames = /* @__PURE__ */ new Set([...live.keys(), ...cand.keys()]);
-  for (const collection of [...collectionNames].sort()) {
-    const liveColl = live.get(collection) ?? /* @__PURE__ */ new Map();
-    const candColl = cand.get(collection) ?? /* @__PURE__ */ new Map();
-    const allIds = /* @__PURE__ */ new Set([...liveColl.keys(), ...candColl.keys()]);
-    for (const id of [...allIds].sort()) {
-      const before = liveColl.get(id);
-      const after = candColl.get(id);
-      if (before === void 0 && after !== void 0) {
-        added.push({ collection, id, record: after });
-      } else if (before !== void 0 && after === void 0) {
-        deleted.push({ collection, id, record: before });
-      } else if (before !== void 0 && after !== void 0) {
-        if (compareFn(before, after)) {
-          unchanged?.push({ collection, id, record: after });
-        } else {
-          const fieldDiffs = diff(before, after);
-          const fieldsChanged = uniqueTopLevelKeys(fieldDiffs);
-          modified.push({
-            collection,
-            id,
-            record: after,
-            before,
-            fieldsChanged,
-            fieldDiffs
-          });
+// src/with-store/route-store.ts
+var BLOB_CHUNKS = "_blob_chunks";
+var BLOB_INDEX = "_blob_index";
+var BLOB_SLOTS = "_blob_slots_";
+var BLOB_VERSIONS = "_blob_versions_";
+function routeStore(opts) {
+  const primary = opts.default;
+  const blobsIsSimple = opts.blobs && "get" in opts.blobs;
+  const simpleBlobStore = blobsIsSimple ? opts.blobs : void 0;
+  const tieredBlobs = !blobsIsSimple ? opts.blobs : void 0;
+  const blobThreshold = tieredBlobs?.threshold ?? 400 * 1024;
+  const allStores = /* @__PURE__ */ new Set([primary]);
+  if (simpleBlobStore) allStores.add(simpleBlobStore);
+  if (tieredBlobs?.large) allStores.add(tieredBlobs.large);
+  if (tieredBlobs?.small) allStores.add(tieredBlobs.small);
+  if (opts.age?.cold) allStores.add(opts.age.cold);
+  if (opts.routes) for (const s of Object.values(opts.routes)) allStores.add(s);
+  if (opts.vaultRoutes) for (const s of Object.values(opts.vaultRoutes)) allStores.add(s);
+  if (opts.blobRoutes) for (const s of Object.values(opts.blobRoutes)) allStores.add(s);
+  if (opts.overflow) allStores.add(opts.overflow);
+  if (opts.blobLifecycle?.archiveStore) allStores.add(opts.blobLifecycle.archiveStore);
+  const overrides = /* @__PURE__ */ new Map();
+  const suspended = /* @__PURE__ */ new Set();
+  const writeQueues = /* @__PURE__ */ new Map();
+  const NULL_STORE = {
+    name: "suspended",
+    async get() {
+      return null;
+    },
+    async put() {
+    },
+    async delete() {
+    },
+    async list() {
+      return [];
+    },
+    async loadAll() {
+      return {};
+    },
+    async saveAll() {
+    }
+  };
+  function routeNameFor(vault, collection) {
+    if (opts.vaultRoutes) {
+      for (const prefix of Object.keys(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return prefix;
+      }
+    }
+    if (opts.routes && !collection.startsWith("_") && opts.routes[collection]) {
+      return collection;
+    }
+    if (isBlobChunks(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.routeBlobMeta && isBlobMeta(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.age && !collection.startsWith("_")) {
+    }
+    return "default";
+  }
+  const quotaExceeded = false;
+  function resolveOriginalStore(route) {
+    if (route === "blobs") return simpleBlobStore ?? tieredBlobs?.large ?? primary;
+    if (route === "cold") return opts.age?.cold ?? primary;
+    if (opts.routes?.[route]) return opts.routes[route];
+    if (opts.vaultRoutes?.[route]) return opts.vaultRoutes[route];
+    return primary;
+  }
+  function maybeQueueWrite(routeName, method, vault, collection, id, envelope, expectedVersion) {
+    if (!suspended.has(routeName)) return false;
+    const queue = writeQueues.get(routeName);
+    if (!queue) return false;
+    if (queue.writes.length >= queue.maxSize) {
+      queue.writes.shift();
+    }
+    queue.writes.push({
+      method,
+      vault,
+      collection,
+      id,
+      ...envelope !== void 0 ? { envelope } : {},
+      ...expectedVersion !== void 0 ? { expectedVersion } : {}
+    });
+    return true;
+  }
+  function isBlobChunks(collection) {
+    return collection === BLOB_CHUNKS;
+  }
+  function isBlobMeta(collection) {
+    return collection === BLOB_INDEX || collection.startsWith(BLOB_SLOTS) || collection.startsWith(BLOB_VERSIONS);
+  }
+  function isInternal(collection) {
+    return collection.startsWith("_");
+  }
+  function storeFor(vault, collection) {
+    const rName = routeNameFor(vault, collection);
+    if (suspended.has(rName)) return NULL_STORE;
+    if (overrides.has(rName)) return overrides.get(rName);
+    if (opts.vaultRoutes) {
+      for (const [prefix, store2] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return store2;
+      }
+    }
+    if (opts.routes && !isInternal(collection) && opts.routes[collection]) {
+      return opts.routes[collection];
+    }
+    if (isBlobChunks(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (opts.routeBlobMeta && isBlobMeta(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (quotaExceeded && opts.overflow) return opts.overflow;
+    return primary;
+  }
+  function blobStoreForSize(dataSize) {
+    if (!tieredBlobs) return simpleBlobStore ?? primary;
+    if (dataSize <= blobThreshold) {
+      return tieredBlobs.small ?? primary;
+    }
+    return tieredBlobs.large;
+  }
+  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 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);
+      if (result === null && opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          return opts.age.cold.get(vault, collection, id);
+        }
+      }
+      return result;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "put", vault, collection, id, envelope, expectedVersion)) return;
+      if (isBlobChunks(collection) && tieredBlobs) {
+        const dataSize = envelope._data.length;
+        const s2 = blobStoreForSize(dataSize);
+        return s2.put(vault, collection, id, envelope, expectedVersion);
+      }
+      const s = storeFor(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+      return s.put(vault, collection, id, envelope, expectedVersion);
+    },
+    async delete(vault, collection, id) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "delete", vault, collection, id)) return;
+      const s = storeFor(vault, collection);
+      await s.delete(vault, collection, id);
+      if (opts.age && !isInternal(collection)) {
+        await opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+    },
+    async list(vault, collection) {
+      const s = storeFor(vault, collection);
+      const ids = await s.list(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          const coldIds = await opts.age.cold.list(vault, collection).catch(() => []);
+          if (coldIds.length > 0) {
+            const merged = new Set(ids);
+            for (const id of coldIds) merged.add(id);
+            return [...merged];
+          }
         }
       }
+      return ids;
+    },
+    async loadAll(vault) {
+      const stores = getStoresForVault(vault);
+      const snapshots = await Promise.all(
+        stores.map((s) => s.loadAll(vault).catch(() => ({})))
+      );
+      return mergeSnapshots(snapshots);
+    },
+    async saveAll(vault, data) {
+      const partitioned = /* @__PURE__ */ new Map();
+      for (const [collection, records] of Object.entries(data)) {
+        const s = storeFor(vault, collection);
+        if (!partitioned.has(s)) partitioned.set(s, {});
+        partitioned.get(s)[collection] = records;
+      }
+      await Promise.all(
+        [...partitioned.entries()].map(([s, snap]) => s.saveAll(vault, snap))
+      );
+    },
+    async compact(vault, compactOpts) {
+      if (!opts.age) return 0;
+      let migrated = 0;
+      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, compactOpts?.before)) {
+            await opts.age.cold.put(vault, collection, id, envelope);
+            await primary.delete(vault, collection, id);
+            migrated++;
+          }
+        }
+      }
+      return migrated;
+    },
+    // ── Runtime override / suspend ──────────────────────
+    override(route, overrideStore, overrideOpts) {
+      if (overrideOpts?.hydrate) {
+        return (async () => {
+          overrides.set(route, overrideStore);
+        })();
+      }
+      overrides.set(route, overrideStore);
+    },
+    clearOverride(route) {
+      overrides.delete(route);
+    },
+    suspend(route, suspendOpts) {
+      suspended.add(route);
+      if (suspendOpts?.queue) {
+        writeQueues.set(route, {
+          writes: [],
+          maxSize: suspendOpts.maxQueueSize ?? 1e4
+        });
+      }
+    },
+    async resume(route) {
+      suspended.delete(route);
+      const queue = writeQueues.get(route);
+      if (!queue || queue.writes.length === 0) {
+        writeQueues.delete(route);
+        return 0;
+      }
+      let replayed = 0;
+      const target = overrides.get(route) ?? resolveOriginalStore(route);
+      for (const write of queue.writes) {
+        try {
+          if (write.method === "put" && write.envelope) {
+            await target.put(write.vault, write.collection, write.id, write.envelope, write.expectedVersion);
+          } else if (write.method === "delete") {
+            await target.delete(write.vault, write.collection, write.id);
+          }
+          replayed++;
+        } catch {
+        }
+      }
+      writeQueues.delete(route);
+      return replayed;
+    },
+    routeStatus() {
+      const ov = {};
+      for (const [k, v] of overrides) ov[k] = v.name ?? "unnamed";
+      const q = {};
+      for (const [k, v] of writeQueues) q[k] = v.writes.length;
+      return { overrides: ov, suspended: [...suspended], queued: q };
+    },
+    resolveBackend(vaultId) {
+      if (opts.vaultRoutes) {
+        for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
+          if (vaultId.startsWith(prefix)) return s;
+        }
+      }
+      return primary;
+    }
+  };
+  if (anyHas("listVaults")) {
+    store.listVaults = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.listVaults !== void 0).map((s) => s.listVaults().catch(() => []))
+      );
+      return [...new Set(results.flat())];
+    };
+  }
+  if (anyHas("ping")) {
+    store.ping = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.ping !== void 0).map((s) => s.ping().catch(() => false))
+      );
+      return results.some(Boolean);
+    };
+  }
+  return store;
+  function buildName() {
+    const names = [...allStores].map((s) => s.name ?? "?").join("+");
+    return `route(${names})`;
+  }
+  function anyHas(method) {
+    return [...allStores].some((s) => s[method]);
+  }
+  function getStoresForVault(vault) {
+    const stores = /* @__PURE__ */ new Set();
+    if (opts.vaultRoutes) {
+      for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) {
+          stores.add(s);
+          return [...stores];
+        }
+      }
+    }
+    stores.add(primary);
+    if (simpleBlobStore) stores.add(simpleBlobStore);
+    if (tieredBlobs?.large) stores.add(tieredBlobs.large);
+    if (tieredBlobs?.small && tieredBlobs.small !== primary) stores.add(tieredBlobs.small);
+    if (opts.age?.cold) stores.add(opts.age.cold);
+    if (opts.routes) {
+      for (const s of Object.values(opts.routes)) stores.add(s);
+    }
+    return [...stores];
+  }
+}
+function mergeSnapshots(snapshots) {
+  const merged = {};
+  for (const snap of snapshots) {
+    for (const [collection, records] of Object.entries(snap)) {
+      if (!merged[collection]) {
+        merged[collection] = { ...records };
+        continue;
+      }
+      for (const [id, envelope] of Object.entries(records)) {
+        const existing = merged[collection][id];
+        if (!existing || envelope._ts >= existing._ts) {
+          merged[collection][id] = envelope;
+        }
+      }
+    }
+  }
+  return merged;
+}
+
+// src/with-store/store-middleware.ts
+function wrapStore(store, ...middlewares) {
+  let result = store;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    result = middlewares[i](result);
+  }
+  return result;
+}
+function withRetry(opts = {}) {
+  const maxRetries = opts.maxRetries ?? 3;
+  const backoffMs = opts.backoffMs ?? 500;
+  const jitter = opts.jitter ?? 0.3;
+  const retryOn = opts.retryOn ? new Set(opts.retryOn) : null;
+  function shouldRetry(err) {
+    if (!retryOn) return true;
+    if (err && typeof err === "object" && "code" in err) {
+      return retryOn.has(err.code);
+    }
+    return true;
+  }
+  async function retryable(fn) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt >= maxRetries || !shouldRetry(err)) throw err;
+        const delay = backoffMs * Math.pow(2, attempt) * (1 + Math.random() * jitter);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastError;
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `retry(${next.name})` : "retry",
+    get: (v, c, id) => retryable(() => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => retryable(() => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => retryable(() => next.delete(v, c, id)),
+    list: (v, c) => retryable(() => next.list(v, c)),
+    loadAll: (v) => retryable(() => next.loadAll(v)),
+    saveAll: (v, d) => retryable(() => next.saveAll(v, d))
+  });
+}
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function withLogging(opts = {}) {
+  const minLevel = LOG_LEVELS[opts.level ?? "info"];
+  const logger = opts.logger ?? console;
+  const logData = opts.logData ?? false;
+  function log(level, method, args, durationMs) {
+    if (LOG_LEVELS[level] < minLevel) return;
+    const parts = [`[noydb:${method}]`, ...Object.entries(args).map(([k, v]) => `${k}=${String(v)}`)];
+    if (durationMs !== void 0) parts.push(`${durationMs}ms`);
+    logger[level](parts.join(" "));
+  }
+  function timed(method, args, fn) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        log("debug", method, args, Date.now() - start);
+        return result;
+      },
+      (err) => {
+        log("error", method, { ...args, error: err.message }, Date.now() - start);
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `log(${next.name})` : "log",
+    get: (v, c, id) => timed("get", { vault: v, collection: c, id }, () => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => timed("put", {
+      vault: v,
+      collection: c,
+      id,
+      version: env._v,
+      ...logData ? { data: env._data.slice(0, 40) + "..." } : {}
+    }, () => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => timed("delete", { vault: v, collection: c, id }, () => next.delete(v, c, id)),
+    list: (v, c) => timed("list", { vault: v, collection: c }, () => next.list(v, c)),
+    loadAll: (v) => timed("loadAll", { vault: v }, () => next.loadAll(v)),
+    saveAll: (v, d) => timed("saveAll", { vault: v }, () => next.saveAll(v, d))
+  });
+}
+function withMetrics(opts) {
+  function tracked(method, vault, fn, collection, id) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: true
+        });
+        return result;
+      },
+      (err) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: false,
+          error: err
+        });
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `metrics(${next.name})` : "metrics",
+    get: (v, c, id) => tracked("get", v, () => next.get(v, c, id), c, id),
+    put: (v, c, id, env, ev) => tracked("put", v, () => next.put(v, c, id, env, ev), c, id),
+    delete: (v, c, id) => tracked("delete", v, () => next.delete(v, c, id), c, id),
+    list: (v, c) => tracked("list", v, () => next.list(v, c), c),
+    loadAll: (v) => tracked("loadAll", v, () => next.loadAll(v)),
+    saveAll: (v, d) => tracked("saveAll", v, () => next.saveAll(v, d))
+  });
+}
+function withCircuitBreaker(opts = {}) {
+  const threshold = opts.failureThreshold ?? 5;
+  const resetMs = opts.resetTimeoutMs ?? 3e4;
+  let state = "closed";
+  let failures = 0;
+  let lastFailureTime = 0;
+  function recordSuccess() {
+    if (state === "half-open") {
+      state = "closed";
+      failures = 0;
+      opts.onClose?.();
+    }
+    failures = 0;
+  }
+  function recordFailure() {
+    failures++;
+    lastFailureTime = Date.now();
+    if (failures >= threshold && state === "closed") {
+      state = "open";
+      opts.onOpen?.();
+    }
+  }
+  function canAttempt() {
+    if (state === "closed") return true;
+    if (state === "open") {
+      if (Date.now() - lastFailureTime >= resetMs) {
+        state = "half-open";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function guarded(fn, fallback) {
+    if (!canAttempt()) return fallback;
+    try {
+      const result = await fn();
+      recordSuccess();
+      return result;
+    } catch (err) {
+      recordFailure();
+      throw err;
     }
   }
-  const summary = {
-    add: added.length,
-    modify: modified.length,
-    delete: deleted.length,
-    total: added.length + modified.length + deleted.length
+  return (next) => ({
+    ...next,
+    name: next.name ? `cb(${next.name})` : "cb",
+    get: (v, c, id) => guarded(() => next.get(v, c, id), null),
+    put: (v, c, id, env, ev) => guarded(() => next.put(v, c, id, env, ev), void 0),
+    delete: (v, c, id) => guarded(() => next.delete(v, c, id), void 0),
+    list: (v, c) => guarded(() => next.list(v, c), []),
+    loadAll: (v) => guarded(() => next.loadAll(v), {}),
+    saveAll: (v, d) => guarded(() => next.saveAll(v, d), void 0)
+  });
+}
+function withCache(opts = {}) {
+  const maxEntries = opts.maxEntries ?? 500;
+  const ttlMs = opts.ttlMs ?? 6e4;
+  const cache = /* @__PURE__ */ new Map();
+  function cacheKey(vault, collection, id) {
+    return `${vault}\0${collection}\0${id}`;
+  }
+  function getFromCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return void 0;
+    if (ttlMs > 0 && Date.now() - entry.cachedAt > ttlMs) {
+      cache.delete(key);
+      return void 0;
+    }
+    cache.delete(key);
+    cache.set(key, entry);
+    return entry.envelope;
+  }
+  function setInCache(key, envelope) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, { envelope, cachedAt: Date.now() });
+  }
+  function invalidate(key) {
+    cache.delete(key);
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `cache(${next.name})` : "cache",
+    async get(vault, collection, id) {
+      const key = cacheKey(vault, collection, id);
+      const cached = getFromCache(key);
+      if (cached !== void 0) return cached;
+      const result = await next.get(vault, collection, id);
+      setInCache(key, result);
+      return result;
+    },
+    async put(vault, collection, id, env, ev) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.put(vault, collection, id, env, ev);
+      setInCache(cacheKey(vault, collection, id), env);
+    },
+    async delete(vault, collection, id) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.delete(vault, collection, id);
+    },
+    list: (v, c) => next.list(v, c),
+    loadAll: (v) => next.loadAll(v),
+    saveAll: (v, d) => next.saveAll(v, d)
+  });
+}
+function withHealthCheck(opts = {}) {
+  const intervalMs = opts.checkIntervalMs ?? 3e4;
+  const failThreshold = opts.suspendAfterFailures ?? 3;
+  const successThreshold = opts.resumeAfterSuccess ?? 1;
+  let isSuspended = false;
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  return (next) => {
+    const checkFn = opts.check ?? (next.ping ? () => next.ping() : async () => {
+      await next.list("__health__", "__ping__");
+      return true;
+    });
+    async function doCheck() {
+      try {
+        const ok = await checkFn();
+        if (ok) {
+          consecutiveFailures = 0;
+          consecutiveSuccesses++;
+          if (isSuspended && consecutiveSuccesses >= successThreshold) {
+            isSuspended = false;
+            consecutiveSuccesses = 0;
+            opts.onResume?.();
+          }
+        } else {
+          throw new Error("Health check returned false");
+        }
+      } catch {
+        consecutiveSuccesses = 0;
+        consecutiveFailures++;
+        if (!isSuspended && consecutiveFailures >= failThreshold) {
+          isSuspended = true;
+          consecutiveFailures = 0;
+          opts.onSuspend?.();
+        }
+      }
+    }
+    setInterval(() => {
+      void doCheck();
+    }, intervalMs);
+    const wrapped = {
+      ...next,
+      name: next.name ? `health(${next.name})` : "health",
+      async get(v, c, id) {
+        return isSuspended ? null : next.get(v, c, id);
+      },
+      async put(v, c, id, env, ev) {
+        if (!isSuspended) await next.put(v, c, id, env, ev);
+      },
+      async delete(v, c, id) {
+        if (!isSuspended) await next.delete(v, c, id);
+      },
+      async list(v, c) {
+        return isSuspended ? [] : next.list(v, c);
+      },
+      async loadAll(v) {
+        return isSuspended ? {} : next.loadAll(v);
+      },
+      async saveAll(v, d) {
+        if (!isSuspended) await next.saveAll(v, d);
+      }
+    };
+    return wrapped;
   };
+}
+
+// src/with-commit/numbering/descriptor.ts
+function withDeferredNumbering(config) {
   return {
-    added,
-    modified,
-    deleted,
-    unchanged,
-    summary,
-    format(opts) {
-      return formatDiff2(opts?.detail ?? "full", { added, modified, deleted, summary });
+    series: config.series,
+    collection: config.collection,
+    field: config.field,
+    settleWindowMs: config.settleWindowMs ?? 0
+  };
+}
+
+// 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
   };
 }
-async function normaliseCandidate(candidate, idKey, filter) {
-  const out = /* @__PURE__ */ new Map();
-  if (typeof candidate === "object" && candidate !== null && "exportStream" in candidate && typeof candidate.exportStream === "function") {
-    for await (const chunk of candidate.exportStream({ granularity: "collection" })) {
-      if (filter && !filter.has(chunk.collection)) continue;
-      const collection = out.get(chunk.collection) ?? /* @__PURE__ */ new Map();
-      for (const record of chunk.records) {
-        const id = readIdField(record, idKey);
-        if (!id) continue;
-        collection.set(id, record);
+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);
       }
-      out.set(chunk.collection, collection);
+      continue;
     }
-    return out;
+    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
+    );
   }
-  if (typeof candidate === "string") {
-    let parsed;
-    try {
-      parsed = JSON.parse(candidate);
-    } catch (err) {
-      throw new Error(
-        `diffVault: candidate string is not valid JSON (${err.message})`
+  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`
       );
     }
-    return collectionsFromObject(parsed, idKey, filter);
+    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;
   }
-  return collectionsFromObject(candidate, idKey, filter);
 }
-function collectionsFromObject(raw, idKey, filter) {
-  const out = /* @__PURE__ */ new Map();
-  if (raw === null || typeof raw !== "object") {
-    throw new Error("diffVault: candidate must be a Vault, an object, or a JSON string");
+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
+    );
   }
-  for (const [key, value] of Object.entries(raw)) {
-    if (key.startsWith("_")) continue;
-    if (filter && !filter.has(key)) continue;
-    if (!Array.isArray(value)) continue;
-    const collection = /* @__PURE__ */ new Map();
-    for (const record of value) {
-      if (record === null || typeof record !== "object") continue;
-      const id = readIdField(record, idKey);
-      if (!id) continue;
-      collection.set(id, record);
+  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;
+      }
     }
-    out.set(key, collection);
+    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 uniqueTopLevelKeys(diffs) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const d of diffs) {
-    const m = /^[^.[]+/.exec(d.path);
-    if (m) keys.add(m[0]);
-  }
-  return [...keys];
-}
-function readIdField(record, idKey) {
-  if (record === null || typeof record !== "object") return "";
-  const v = record[idKey];
-  if (typeof v === "string") return v;
-  if (typeof v === "number" && Number.isFinite(v)) return String(v);
-  return "";
-}
-function formatDiff2(detail, b) {
-  const head = `${b.summary.add} added \xB7 ${b.summary.modify} modified \xB7 ${b.summary.delete} deleted`;
-  if (detail === "count") return head;
-  if (b.summary.total === 0) return head + "\n(no changes)";
-  if (detail === "one-line") return head;
-  const rows = [head, ""];
-  for (const e of b.added) rows.push(`${e.collection}/${e.id}	added`);
-  for (const e of b.modified) {
-    const fields = e.fieldDiffs.map((f) => `${f.path}: ${shortJSON(f.from)} \u2192 ${shortJSON(f.to)}`).join(", ");
-    rows.push(`${e.collection}/${e.id}	modified	${fields}`);
-  }
-  for (const e of b.deleted) rows.push(`${e.collection}/${e.id}	deleted`);
-  return rows.join("\n");
-}
-function shortJSON(value) {
-  if (value === void 0) return "undefined";
-  const s = JSON.stringify(value);
-  if (typeof s !== "string") return "<unrepresentable>";
-  return s.length > 60 ? s.slice(0, 57) + "..." : s;
+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) {
+    throw new MoneyUnsupportedError(
+      r.reason === "precision" ? `${label}: amount ${JSON.stringify(amount)} has more precision than scale ${scale} and no rounding mode is configured` : `${label}: amount ${JSON.stringify(amount)} is not a finite decimal`
+    );
+  }
+  return r.value;
+}
+function resolveScale(label, amount, explicit) {
+  if (explicit !== void 0) {
+    if (!Number.isInteger(explicit) || explicit < 0) {
+      throw new MoneyUnsupportedError(`${label}: scale must be a non-negative integer`);
+    }
+    return explicit;
+  }
+  const inferred = decimalScaleOf(amount);
+  if (inferred === null) {
+    throw new MoneyUnsupportedError(`${label}: amount ${JSON.stringify(amount)} is not a finite decimal`);
+  }
+  return inferred;
+}
+function mulRate(amount, rate, opts = {}) {
+  const scale = resolveScale("mulRate", amount, opts.scale);
+  const rounding = opts.rounding ?? "half-up";
+  const a = parseAmount("mulRate", amount, scale, rounding);
+  const rateScale = decimalScaleOf(rate);
+  if (rateScale === null) {
+    throw new MoneyUnsupportedError(`mulRate: rate ${JSON.stringify(rate)} is not a finite decimal`);
+  }
+  const r = parseToScaledInt(rate, rateScale);
+  if (!r.ok) {
+    throw new MoneyUnsupportedError(`mulRate: rate ${JSON.stringify(rate)} is not a finite decimal`);
+  }
+  const product = a * r.value;
+  return formatScaledInt(rescaleScaledInt(product, scale + rateScale, scale, rounding), scale);
+}
+function allocate(amount, weights, opts = {}) {
+  if (weights.length === 0) {
+    throw new MoneyUnsupportedError("allocate: weights must not be empty");
+  }
+  const scale = resolveScale("allocate", amount, opts.scale);
+  const a = parseAmount("allocate", amount, scale);
+  let weightScale = 0;
+  for (const w of weights) {
+    const s = decimalScaleOf(w);
+    if (s === null) {
+      throw new MoneyUnsupportedError(`allocate: weight ${JSON.stringify(w)} is not a finite decimal`);
+    }
+    if (s > weightScale) weightScale = s;
+  }
+  const scaledWeights = weights.map((w) => {
+    const r = parseToScaledInt(w, weightScale);
+    if (!r.ok || r.value < 0n) {
+      throw new MoneyUnsupportedError(`allocate: weight ${JSON.stringify(w)} must be a non-negative decimal`);
+    }
+    return r.value;
+  });
+  const sumW = scaledWeights.reduce((acc, w) => acc + w, 0n);
+  if (sumW === 0n) {
+    throw new MoneyUnsupportedError("allocate: weights must not all be zero");
+  }
+  const negative = a < 0n;
+  const mag = negative ? -a : a;
+  const base = [];
+  const remainders = [];
+  let distributed = 0n;
+  for (let i = 0; i < scaledWeights.length; i++) {
+    const product = mag * scaledWeights[i];
+    const share = product / sumW;
+    base.push(share);
+    distributed += share;
+    remainders.push({ index: i, rem: product % sumW });
+  }
+  let leftover = mag - distributed;
+  remainders.sort((x, y) => y.rem > x.rem ? 1 : y.rem < x.rem ? -1 : x.index - y.index);
+  for (const { index } of remainders) {
+    if (leftover === 0n) break;
+    base[index] = base[index] + 1n;
+    leftover -= 1n;
+  }
+  return base.map((p) => formatScaledInt(negative && p !== 0n ? -p : p, scale));
+}
+
+// src/via/money/branded.ts
+function asMoney(value) {
+  if (!isMoneyLike(value)) {
+    throw new MoneyUnsupportedError(`asMoney: ${JSON.stringify(value)} is not a finite decimal`);
+  }
+  return String(value).trim();
+}
+function isMoneyString(value) {
+  return typeof value === "string" && isMoneyLike(value);
+}
+function moneyNumber(value) {
+  if (!isMoneyLike(value)) {
+    throw new MoneyUnsupportedError(`moneyNumber: ${JSON.stringify(value)} is not a finite decimal`);
+  }
+  return Number(value);
+}
+function isMoneyLike(value) {
+  if (typeof value === "number") return Number.isFinite(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,
   AmendmentForbiddenError,
   AttestationError,
+  AttestationNotEnabledError,
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
   BLOB_INDEX_COLLECTION,
@@ -639,13 +2721,25 @@ export {
   BundleSealMismatchError,
   BundleVersionConflictError,
   CONSENT_AUDIT_COLLECTION,
+  CargoNotEnabledError,
+  ClassifiedConfigError,
+  ClassifiedNeverStoredError,
+  ClassifiedNotEnabledError,
+  ClassifiedRevealError,
+  ClassifiedRotationError,
+  ClassifiedValidationError,
+  ClassifiedVerifyError,
   Collection,
   CollectionFrame,
   CollectionIndexes,
   CollectionInstant,
+  ComputedFieldError,
   ConflictError,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
+  CustodyApi,
+  CustodyNotEnabledError,
+  DEED_RECORD_ID,
   DEFAULT_CHUNK_SIZE,
   DEFAULT_CROSS_JOIN_MAX_ROWS,
   DEFAULT_FRESHNESS_MS,
@@ -655,6 +2749,9 @@ export {
   DICT_COLLECTION_PREFIX,
   DIRECTORY_RECORD_ID,
   DanglingReferenceError,
+  DataResidencyError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   DelegationTargetMissingError,
   DerivationCapExceededError,
@@ -664,14 +2761,19 @@ export {
   DerivationOutputUnknownError,
   DictKeyInUseError,
   DictKeyMissingError,
-  DictionaryHandle,
+  LookupHandle as DictionaryHandle,
   DirectoryDisabledError,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
   ElevationExpiredError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
+  FieldNotQueryableError,
   FilenameSanitizationError,
+  ForgetStrategyNotConfiguredError,
   GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY,
   GroupCardinalityError,
@@ -679,6 +2781,7 @@ export {
   GroupedQuery,
   GroupedQueryN,
   INDEXED_STORE_POLICY,
+  IllegalTransitionError,
   ImportCapabilityError,
   IndexRequiredError,
   IndexWriteFailureError,
@@ -691,6 +2794,8 @@ export {
   LEDGER_DELTAS_COLLECTION,
   LedgerContentionError,
   LedgerStore,
+  LinkEndpointError,
+  LinkIntegrityError,
   LocaleNotSpecifiedError,
   Lru,
   MAGIC_LINK_CONTENT_INFO_PREFIX,
@@ -706,6 +2811,9 @@ export {
   MemorySealingKeyProvider,
   MigrationRequiredError,
   MissingTranslationError,
+  MoneyCurrencyError,
+  MoneyPrecisionError,
+  MoneyUnsupportedError,
   NOYDB_BACKUP_VERSION,
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -713,26 +2821,35 @@ export {
   NOYDB_FORMAT_VERSION,
   NOYDB_KEYRING_VERSION,
   NOYDB_SYNC_VERSION,
+  NO_CARGO,
+  NO_CUSTODY,
+  NO_SEARCH,
+  NO_SEQUENCE,
+  NO_TEAM,
   NetworkError,
   NoAccessError,
   NonAdditiveSchemaChangeError,
   NotFoundError,
   Noydb,
   NoydbError,
+  NumberingUncertaintyError,
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
   OverlayNameCollisionError,
   PERIODS_COLLECTION,
   PERSONAL_POLICY,
+  POD_STORE_POLICY,
   POLICY_RECORD_ID,
   PUBLIC_ENVELOPE_FIELDS,
   PUBLIC_ENVELOPE_RECORD_ID,
   PathEscapeError,
   PeriodClosedError,
   PermissionDeniedError,
+  PodVersionConflictError,
   PolicyDeniedError,
   PolicyEnforcer,
+  PortabilityNotEnabledError,
   PresenceHandle,
   PrivilegeEscalationError,
   Query,
@@ -741,6 +2858,7 @@ export {
   ReadOnlyAtInstantError,
   ReadOnlyError,
   ReadOnlyFrameError,
+  RecordCekNotFoundError,
   RecordLockedError,
   RecoveryNotEnrolledError,
   RecoveryProfileNotImplementedError,
@@ -748,8 +2866,11 @@ export {
   RefRegistry,
   RefScopeError,
   ReservedCollectionNameError,
+  ReservedVaultNameError,
+  RestrictRefUnresolvableError,
   SCHEMAS_COLLECTION,
   SEALED_PASSPHRASE_RECORD_ID,
+  STATE_VAULT_NAME,
   STRICT_POLICY,
   SYNC_CREDENTIALS_COLLECTION,
   ScanBuilder,
@@ -758,23 +2879,41 @@ export {
   SchemaUpdateError,
   SchemaValidationError,
   ScriptViolationError,
+  SealedHandle,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  SealedRecordNotEnabledError,
+  SearchNotEnabledError,
+  SequenceContentionError,
+  SequenceNotEnabledError,
+  SequenceOfflineError,
+  SequenceStore,
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
+  ShardProvisioningError,
   SnapshotNotFoundError,
+  StaticDictReadonlyError,
   StoreCapabilityError,
   SyncEngine,
   SyncScheduler,
   SyncTransaction,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
+  TiersNotEnabledError,
   TranslatorNotConfiguredError,
   TxCollection,
   TxContext,
   TxVault,
   USER_ENVELOPE_COLLECTION,
   USER_ENVELOPE_MAX_BYTES,
+  UniqueConstraintError,
+  UnknownDictCodeError,
+  UnknownLookupKeyError,
+  UnknownShardError,
+  UnsupportedIndexOptionError,
   UserApi,
   UserEnvelopeOversizedError,
   VISIBILITY_RECORD_PREFIX,
@@ -782,12 +2921,19 @@ export {
   Vault,
   VaultFrame,
   VaultInstant,
+  VaultTemplateNotFoundError,
   WeakPassphraseError,
+  WithdrawalRequestError,
   activeSessionCount,
   additiveOnly,
+  aesGcmOpen,
+  allocate,
   applyI18nLocale,
   applyJoins,
+  applyListProjection,
   applyPatch,
+  approveWithdrawal,
+  asMoney,
   assertStrongPassphrase,
   assertTierAccess,
   avg,
@@ -799,18 +2945,24 @@ export {
   burnPaperRecoveryEntry,
   canonicalJson,
   checkGate,
+  classified,
   clearDevUnlock,
+  compileSequenceFormat,
   computePatch,
+  computed,
   coordinatedCutover,
   count,
   createBundleStore,
+  createDeedOwner,
   createEnforcer,
   createNoydb,
+  createPodStore,
   createSession,
   createStore,
   credentialStatus,
   decryptBytes,
   decryptDeterministic,
+  decryptExtractedPartition,
   dekKey,
   deleteCredential,
   deleteUserEnvelope,
@@ -825,6 +2977,7 @@ export {
   detectMagic,
   detectMimeType,
   diagramAuthConfig,
+  dict,
   dictCollectionName,
   dictKey,
   diff,
@@ -835,16 +2988,21 @@ export {
   encryptDeterministic,
   enforceScript,
   enrollAuthenticator,
+  enumOf as enum,
+  enumOf,
   envelopePayloadHash,
   estimateEntropy,
   estimateRecordBytes,
+  evalComputedFields,
   evaluateClause,
   evaluateExportCapability,
   evaluateFieldClause,
   evaluateImportCapability,
   executePlan,
+  exportAccessibleData,
   findAuthenticator,
   formatDiff,
+  fuseRetrieval,
   generateULID,
   getCredential,
   groupAndReduce,
@@ -854,26 +3012,42 @@ export {
   hasRecoveryEnrolled,
   hashEntry,
   i18nText,
+  immutableGuard,
+  importExternalObjects,
   inferScripts,
+  isClassifiedFieldSpec,
+  isClassifiedGroup,
+  isComputedDescriptor,
+  isDeedVault,
   isDevUnlockActive,
   isDictCollectionName,
   isDictKeyDescriptor,
+  isDiscriminant,
   isI18nTextDescriptor,
+  isLinkCollectionName,
   isMagicLinkGrantExpired,
+  isMoneyDescriptor,
+  isMoneyString,
   isPreCompressed,
   isPublicEnvelope,
+  isRefArray,
   isSessionAlive,
+  isStaticDictDescriptor,
   isULID,
+  isViaFieldSpec,
   isZodSchema,
   issueDelegation,
   recoverPassphrase as keyringRecoverPassphrase,
   rotatePassphrase as keyringRotatePassphrase,
+  liberateVault,
   listCredentials,
   listMagicLinkGrants,
   listUserEnvelopeIds,
   listUsers,
   listUsersWithEnvelopes,
+  listWithdrawalRequests,
   loadActiveDelegations,
+  loadDeedMarker,
   loadDevUnlock,
   loadPaperRecoveryEntries,
   loadPersistedSchema,
@@ -883,17 +3057,28 @@ export {
   loadUserEnvelope,
   loadVaultPolicy,
   lockSchema,
+  lookup,
+  luhnCheck,
   magicLinkGrantRecordId,
   max,
+  memoryObjectProjection,
+  memoryStore,
   mergeCrdtStates,
   mergePolicy,
   min,
   mintPaperRecoveryEntry,
   mintShamirRecoveryEntry,
   mintWrappedDeksBlob,
+  money,
+  moneyMax,
+  moneyMin,
+  moneyNumber,
+  moneySum,
+  mulRate,
   paddedIndex,
   parseBytes,
   parseIndex,
+  parseRsaOaepTlv,
   parseSealedEnvelope,
   persistDirectoryConfig,
   persistSchemaIfNeeded,
@@ -905,18 +3090,27 @@ export {
   readNoydbBundleHeader,
   readNoydbBundlePublicEnvelope,
   readPath,
+  readPlaintextRecord,
+  readPod,
+  readPodHeader,
   readPublicEnvelope,
   readUserVisibility,
   recoverUser,
   reduceRecords,
+  reducerBuilder,
   ref,
+  refArray,
+  rejectWithdrawal,
   removeAuthenticator,
+  requestWithdrawal,
   resetBrotliSupportCache,
   resetJoinWarnings,
+  resolveClassifiedFields,
   resolveCrdtSnapshot,
   resolveI18nText,
   resolvePolicy,
   resolveSchema as resolvePublicEnvelopeSchema,
+  resolveSequenceKey,
   resolveSession,
   revokeAllSessions,
   revokeDelegation,
@@ -931,8 +3125,13 @@ export {
   saveShamirRecoveryEntries,
   saveUserEnvelope,
   saveVaultPolicy,
+  scaleForCurrency,
+  sealRsaOaepTlv,
   sha256Hex,
+  staticDict,
   sum,
+  tokenize,
+  transitionGuard,
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
   unwrapDeksFromShamirEntry,
@@ -943,20 +3142,33 @@ export {
   validateSchemaInput,
   validateSchemaOutput,
   validateSessionPolicy,
+  via,
   visibilityRecordId,
+  withArchive,
   withCache,
+  withCargo,
   withCircuitBreaker,
+  withCustody,
+  withDeferredNumbering,
   withDerivation,
   withGuard,
   withHealthCheck,
+  withLazy,
   withLogging,
   withMaterializedView,
   withMetrics,
   withOverlayedView,
   withRetry,
+  withRollup,
+  withSearch,
+  withSequence,
+  withTeam,
+  withdrawAccessibleData,
   wrapBundleStore,
+  wrapPodStore,
   wrapStore,
   writeMagicLinkGrant,
-  writeNoydbBundle
+  writeNoydbBundle,
+  writePod
 };
 //# sourceMappingURL=index.js.map