@noy-db/hub 0.2.0-pre.8 → 0.3.0-pre.1

package/dist/index.js

@@ -1,88 +1,202 @@
 import {
-  DELEGATIONS_COLLECTION,
-  issueDelegation,
-  loadActiveDelegations,
-  revokeDelegation
-} from "./chunk-5T22KDPN.js";
+  DEFAULT_FRESHNESS_MS,
+  PERSONAL_POLICY,
+  STRICT_POLICY,
+  checkGate,
+  describeGate,
+  mergePolicy
+} from "./chunk-5N6CZTCY.js";
 import {
   Collection,
-  DEFAULT_FRESHNESS_MS,
+  ComputedFieldError,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
+  LinkEndpointError,
+  LinkIntegrityError,
   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,
+  evalComputedFields,
+  isLinkCollectionName,
+  isRefArray,
   isZodSchema,
-  loadVaultPolicy,
-  mergePolicy,
+  memoryStore,
   parseBytes,
   persistSchemaIfNeeded,
   ref,
-  saveVaultPolicy,
-  validateSchemaInput,
-  validateSchemaOutput
-} from "./chunk-6774ZOQ7.js";
+  refArray,
+  withArchive
+} from "./chunk-5R5JW2JT.js";
+import {
+  META_COLLECTION,
+  POLICY_RECORD_ID,
+  loadVaultPolicy,
+  saveVaultPolicy
+} from "./chunk-SM3AVUHC.js";
+import {
+  DELEGATIONS_COLLECTION,
+  issueDelegation,
+  loadActiveDelegations,
+  revokeDelegation
+} from "./chunk-VFQGRQIH.js";
 import {
   DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
   PUBLIC_ENVELOPE_FIELDS,
   resolveSchema
-} from "./chunk-EMIGCR7X.js";
+} from "./chunk-WXSYDNBT.js";
+import {
+  NO_SEQUENCE,
+  SequenceStore,
+  compileSequenceFormat,
+  resolveSequenceKey,
+  withSequence
+} from "./chunk-GYGWYIOZ.js";
+import {
+  UserApi
+} from "./chunk-UDRIWL7A.js";
+import {
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-XXYIOFUB.js";
+import "./chunk-IAGBDSCS.js";
+import {
+  NO_SEARCH,
+  tokenize,
+  withSearch
+} from "./chunk-TEILUWOI.js";
+import "./chunk-5R3ERCDH.js";
+import {
+  isDiscriminant
+} from "./chunk-PY4KJPYU.js";
+import "./chunk-WYSO2NIH.js";
+import "./chunk-IPB7FTQX.js";
+import "./chunk-KVOXU4T5.js";
+import {
+  withCargo
+} from "./chunk-M6OST55S.js";
+import {
+  CustodyApi,
+  NO_CARGO,
+  NO_CUSTODY,
+  withCustody
+} from "./chunk-TJYQIGAP.js";
+import {
+  DEED_RECORD_ID,
+  createDeedOwner,
+  isDeedVault,
+  liberateVault,
+  loadDeedMarker
+} from "./chunk-KXGNJJXB.js";
+import {
+  withdrawAccessibleData
+} from "./chunk-PSMV73A5.js";
+import {
+  exportAccessibleData
+} from "./chunk-HCIPRAGS.js";
+import {
+  diffVault
+} from "./chunk-LB7FD65R.js";
+import "./chunk-BGIZAFY7.js";
+import {
+  fuseRetrieval
+} from "./chunk-AURFOK3D.js";
+import "./chunk-QHJW5EXU.js";
+import {
+  immutableGuard,
+  transitionGuard,
+  withGuard
+} from "./chunk-TA66UMI4.js";
+import "./chunk-YMUGBZN2.js";
+import "./chunk-RUIMKQTA.js";
+import "./chunk-RUEKROOS.js";
+import {
+  CollectionFrame,
+  VaultFrame
+} from "./chunk-NF5JWERG.js";
 import {
   TxCollection,
   TxContext,
   TxVault,
   runTransaction
-} from "./chunk-TFBP23BX.js";
+} from "./chunk-SKF73JOP.js";
 import {
-  withDerivation
-} from "./chunk-RAZ4OVLL.js";
-import "./chunk-DE6GKS6G.js";
-import "./chunk-DO7C2TOG.js";
+  withDerivation,
+  withRollup
+} from "./chunk-LMTH2RM6.js";
+import "./chunk-Q7SS3IME.js";
+import "./chunk-PKHL44ER.js";
 import {
   withMaterializedView
-} from "./chunk-K3DK3NU5.js";
-import "./chunk-HNRHLRDC.js";
-import "./chunk-O3VZPBZG.js";
-import "./chunk-T7JEBOGN.js";
+} from "./chunk-3YFXJ3ZP.js";
+import "./chunk-AQTBSL7R.js";
+import "./chunk-62QYRORB.js";
+import "./chunk-BG3SPSR4.js";
 import {
   withOverlayedView
-} from "./chunk-SYMWGEET.js";
-import "./chunk-VTKGMEPP.js";
-import "./chunk-DJHHA6XH.js";
-import "./chunk-2WUSG3IT.js";
+} from "./chunk-EIZUR2XW.js";
+import "./chunk-CMGR4ZEW.js";
+import "./chunk-VCTFO5CO.js";
+import {
+  importExternalObjects,
+  memoryObjectProjection
+} from "./chunk-4Q6HSHHL.js";
+import "./chunk-Y22T3KQE.js";
+import "./chunk-V7RWQRG7.js";
 import {
   mergeCrdtStates,
   resolveCrdtSnapshot
-} from "./chunk-J66GRPNH.js";
+} from "./chunk-6S7T6WC4.js";
+import {
+  decryptExtractedPartition
+} from "./chunk-2P2HZEXU.js";
+import {
+  SCHEMAS_COLLECTION,
+  loadPersistedSchema,
+  savePersistedSchema
+} from "./chunk-26LGBE4T.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-ZCGAHGUS.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-DFEMTNPJ.js";
+import {
+  createBundleStore,
+  createPodStore,
+  wrapBundleStore,
+  wrapPodStore
+} from "./chunk-AZAOEIKW.js";
 import {
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -91,9 +205,12 @@ import {
   readNoydbBundle,
   readNoydbBundleHeader,
   readNoydbBundlePublicEnvelope,
+  readPod,
+  readPodHeader,
   resetBrotliSupportCache,
-  writeNoydbBundle
-} from "./chunk-BVRYKATC.js";
+  writeNoydbBundle,
+  writePod
+} from "./chunk-FISN7WE4.js";
 import {
   PUBLIC_ENVELOPE_RECORD_ID,
   isPublicEnvelope,
@@ -101,54 +218,25 @@ import {
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-ML236QKC.js";
+} from "./chunk-SMXWYP24.js";
 import {
   CONSENT_AUDIT_COLLECTION
-} from "./chunk-XJFLDA7A.js";
+} from "./chunk-MTMJVJ5W.js";
+import "./chunk-CWPPNPOH.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-IELYAOGG.js";
+import "./chunk-GHVIKOHT.js";
 import {
   DICT_COLLECTION_PREFIX,
   DictionaryHandle,
-  applyI18nLocale,
   dictCollectionName,
   dictKey,
-  i18nText,
   isDictCollectionName,
   isDictKeyDescriptor,
-  isI18nTextDescriptor,
-  resolveI18nText,
-  resolvePolicy,
-  validateI18nTextValue
-} from "./chunk-22DWZL57.js";
-import {
-  createBundleStore,
-  routeStore,
-  withCache,
-  withCircuitBreaker,
-  withHealthCheck,
-  withLogging,
-  withMetrics,
-  withRetry,
-  wrapBundleStore,
-  wrapStore
-} from "./chunk-QEILDE6R.js";
+  isStaticDictDescriptor,
+  staticDict
+} from "./chunk-LFLXAY2W.js";
 import {
   SYNC_CREDENTIALS_COLLECTION,
   credentialStatus,
@@ -156,85 +244,83 @@ import {
   getCredential,
   listCredentials,
   putCredential
-} from "./chunk-ZYWZWG6G.js";
+} from "./chunk-DGDI2D4M.js";
 import {
   MAGIC_LINK_CONTENT_INFO_PREFIX,
   MAGIC_LINK_GRANTS_COLLECTION,
   MAGIC_LINK_KEK_INFO_PREFIX,
-  ManagedRecoveryNotEnrolledError,
-  PolicyDeniedError,
-  RecoveryNotEnrolledError,
-  RecoveryProfileNotImplementedError,
-  burnPaperRecoveryEntry,
   deriveMagicLinkContentKey,
   enrollAuthenticator,
   findAuthenticator,
-  hasRecoveryEnrolled,
   isMagicLinkGrantExpired,
   listMagicLinkGrants,
-  loadPaperRecoveryEntries,
-  loadShamirRecoveryEntries,
   magicLinkGrantRecordId,
-  mintPaperRecoveryEntry,
-  mintShamirRecoveryEntry,
-  mintWrappedDeksBlob,
   readMagicLinkGrantRecord,
   recoverPassphrase,
   recoverUser,
   removeAuthenticator,
   revokeMagicLinkGrant,
   rotatePassphrase,
+  unwrapMagicLinkGrant,
+  writeMagicLinkGrant
+} from "./chunk-UPJNJGGA.js";
+import {
+  burnPaperRecoveryEntry,
+  hasRecoveryEnrolled,
+  loadPaperRecoveryEntries,
+  loadShamirRecoveryEntries,
+  mintPaperRecoveryEntry,
+  mintShamirRecoveryEntry,
+  mintWrappedDeksBlob,
   savePaperRecoveryEntries,
   saveShamirRecoveryEntries,
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
-  unwrapDeksFromShamirEntry,
-  unwrapMagicLinkGrant,
-  writeMagicLinkGrant
-} from "./chunk-3YPCK6JX.js";
+  unwrapDeksFromShamirEntry
+} from "./chunk-IGUYVGGI.js";
 import {
   assertTierAccess,
   dekKey,
   effectiveClearance
-} from "./chunk-U26HQ6KJ.js";
+} from "./chunk-IO6GRPT6.js";
 import {
   PresenceHandle,
   SyncEngine,
   SyncTransaction
-} from "./chunk-WPLVTJ5D.js";
+} from "./chunk-IUEN57TV.js";
+import {
+  BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY,
+  POD_STORE_POLICY,
+  SyncScheduler
+} from "./chunk-VQNJ7UZL.js";
 import {
-  DIRECTORY_RECORD_ID,
-  USER_ENVELOPE_COLLECTION,
-  USER_ENVELOPE_MAX_BYTES,
-  UserEnvelopeOversizedError,
-  VISIBILITY_RECORD_PREFIX,
   WeakPassphraseError,
   assertStrongPassphrase,
   buildRecipientKeyringFile,
-  deleteUserEnvelope,
-  deleteUserVisibility,
   estimateEntropy,
   evaluateExportCapability,
   evaluateImportCapability,
   hasExportCapability,
   hasImportCapability,
-  listUserEnvelopeIds,
   listUsers,
   listUsersWithEnvelopes,
+  validatePassphrase
+} from "./chunk-WWGT2MDV.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-ITNUCOXM.js";
 import {
   PolicyEnforcer,
   activeSessionCount,
@@ -249,24 +335,28 @@ import {
   revokeAllSessions,
   revokeSession,
   validateSessionPolicy
-} from "./chunk-H2X3ISXG.js";
+} from "./chunk-UAG5KWVA.js";
 import {
   generateULID,
   isULID
-} from "./chunk-FZU343FL.js";
+} from "./chunk-ZJADGNYF.js";
 import {
   CollectionInstant,
-  VaultInstant,
+  VaultInstant
+} from "./chunk-MD3Y6J3L.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-LXQT4WMP.js";
+import {
+  LEDGER_COLLECTION,
+  LEDGER_DELTAS_COLLECTION
+} from "./chunk-I7FD46FF.js";
 import {
   canonicalJson,
   envelopePayloadHash,
@@ -274,7 +364,28 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-Z6FNBOTC.js";
+} from "./chunk-AIWULCUO.js";
+import "./chunk-SRB2XEWB.js";
+import "./chunk-UV5MFVO3.js";
+import {
+  base64ToBuffer,
+  bufferToBase64,
+  decryptBytes,
+  decryptDeterministic,
+  derivePresenceKey,
+  encryptBytes,
+  encryptDeterministic,
+  validateSchemaInput,
+  validateSchemaOutput
+} from "./chunk-5O3AOPDT.js";
+import {
+  NOYDB_BACKUP_VERSION,
+  NOYDB_FORMAT_VERSION,
+  NOYDB_KEYRING_VERSION,
+  NOYDB_SYNC_VERSION,
+  SealedHandle,
+  createStore
+} from "./chunk-5TDJ56JE.js";
 import {
   DEFAULT_CROSS_JOIN_MAX_ROWS,
   DEFAULT_JOIN_MAX_ROWS,
@@ -284,17 +395,10 @@ import {
   buildLiveQuery,
   executePlan,
   resetJoinWarnings
-} from "./chunk-2GLDA55J.js";
+} from "./chunk-UIU2THRG.js";
 import {
   CollectionIndexes
-} from "./chunk-OIF6LZUR.js";
-import {
-  avg,
-  count,
-  max,
-  min,
-  sum
-} from "./chunk-W6EQLGMB.js";
+} from "./chunk-I3TIKTJO.js";
 import {
   Aggregation,
   GROUPBY_MAX_CARDINALITY,
@@ -302,56 +406,62 @@ import {
   GroupedAggregation,
   GroupedQuery,
   GroupedQueryN,
+  avg,
+  count,
   groupAndReduce,
-  reduceRecords
-} from "./chunk-5XHKQ56N.js";
+  max,
+  min,
+  moneyMax,
+  moneyMin,
+  moneySum,
+  reduceRecords,
+  reducerBuilder,
+  sum
+} from "./chunk-LV7M27WM.js";
 import {
+  MoneyCurrencyError,
+  MoneyPrecisionError,
+  MoneyUnsupportedError,
+  decimalScaleOf,
   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";
-import {
-  NOYDB_BACKUP_VERSION,
-  NOYDB_FORMAT_VERSION,
-  NOYDB_KEYRING_VERSION,
-  NOYDB_SYNC_VERSION,
-  createStore
-} from "./chunk-WIRRPTFH.js";
+  formatScaledInt,
+  isMoneyDescriptor,
+  money,
+  parseToScaledInt,
+  readPath,
+  rescaleScaledInt,
+  scaleForCurrency
+} from "./chunk-M2YKN37S.js";
 import {
-  base64ToBuffer,
-  bufferToBase64,
-  decryptBytes,
-  decryptDeterministic,
-  derivePresenceKey,
-  encryptBytes,
-  encryptDeterministic
-} from "./chunk-PP6W64Y3.js";
+  applyI18nLocale,
+  enforceScript,
+  i18nText,
+  inferScripts,
+  isI18nTextDescriptor,
+  resolveI18nText,
+  resolvePolicy,
+  validateI18nTextValue
+} from "./chunk-5LUY7UTV.js";
 import {
   AlreadyElevatedError,
   AmendmentForbiddenError,
   AttestationError,
+  AttestationNotEnabledError,
   BackupCorruptedError,
   BackupLedgerError,
   BundleIntegrityError,
   BundleSealMismatchError,
   BundleVersionConflictError,
+  CargoNotEnabledError,
   ConflictError,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
+  CustodyNotEnabledError,
   DanglingReferenceError,
+  DataResidencyError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   DelegationTargetMissingError,
   DerivationCapExceededError,
@@ -363,10 +473,15 @@ import {
   DictKeyMissingError,
   DirectoryDisabledError,
   ElevationExpiredError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
   FilenameSanitizationError,
+  ForgetStrategyNotConfiguredError,
   GroupCardinalityError,
+  IllegalTransitionError,
   ImportCapabilityError,
   IndexRequiredError,
   IndexWriteFailureError,
@@ -377,6 +492,7 @@ import {
   KeyringExpiredError,
   LedgerContentionError,
   LocaleNotSpecifiedError,
+  ManagedRecoveryNotEnrolledError,
   MaterializedViewConfigError,
   MaterializedViewCycleError,
   MaterializedViewSourceUnknownError,
@@ -388,6 +504,7 @@ import {
   NonAdditiveSchemaChangeError,
   NotFoundError,
   NoydbError,
+  NumberingUncertaintyError,
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
@@ -395,31 +512,76 @@ import {
   PathEscapeError,
   PeriodClosedError,
   PermissionDeniedError,
+  PodVersionConflictError,
+  PolicyDeniedError,
+  PortabilityNotEnabledError,
   PrivilegeEscalationError,
   QuiesceTimeoutError,
   ReadOnlyAtInstantError,
   ReadOnlyError,
   ReadOnlyFrameError,
+  RecordCekNotFoundError,
   RecordLockedError,
+  RecoveryNotEnrolledError,
+  RecoveryProfileNotImplementedError,
   ReservedCollectionNameError,
+  ReservedVaultNameError,
+  STATE_VAULT_NAME,
   SchemaFenceError,
   SchemaLockedError,
   SchemaUpdateError,
   SchemaValidationError,
   ScriptViolationError,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  SealedRecordNotEnabledError,
+  SearchNotEnabledError,
+  SequenceContentionError,
+  SequenceNotEnabledError,
+  SequenceOfflineError,
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
+  ShardProvisioningError,
   SnapshotNotFoundError,
+  StaticDictReadonlyError,
   StoreCapabilityError,
   TamperedError,
   TierDemoteDeniedError,
   TierNotGrantedError,
+  TiersNotEnabledError,
   TranslatorNotConfiguredError,
-  ValidationError
-} from "./chunk-B6PB7JLN.js";
+  USER_ENVELOPE_COLLECTION,
+  USER_ENVELOPE_MAX_BYTES,
+  UniqueConstraintError,
+  UnknownDictCodeError,
+  UnknownShardError,
+  UnsupportedIndexOptionError,
+  UserEnvelopeOversizedError,
+  ValidationError,
+  VaultTemplateNotFoundError
+} from "./chunk-ZYUC53LT.js";
+import "./chunk-PZ5AY32C.js";
 
-// src/schema-update/strategies.ts
+// 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/schema-update/strategies.ts
 function blindUpdate() {
   return { name: "blindUpdate", onSchemaDelta: () => ({ action: "allow" }) };
 }
@@ -457,7 +619,7 @@ function lockSchema(opts) {
   };
 }
 
-// src/schema-update/cutover.ts
+// src/with-shape/schema-update/cutover.ts
 function coordinatedCutover(opts) {
   return {
     name: "coordinatedCutover",
@@ -470,162 +632,770 @@ 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);
+// 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() {
     }
-    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
-          });
-        }
+  };
+  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 summary = {
-    add: added.length,
-    modify: modified.length,
-    delete: deleted.length,
-    total: added.length + modified.length + deleted.length
-  };
-  return {
-    added,
-    modified,
-    deleted,
-    unchanged,
-    summary,
-    format(opts) {
-      return formatDiff2(opts?.detail ?? "full", { added, modified, deleted, summary });
+  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) {
+    if (!opts.age) return false;
+    if (isInternal(collection)) return false;
+    if (opts.age.collections && opts.age.collections.length > 0) {
+      if (!opts.age.collections.includes(collection)) return false;
+    }
+    const cutoff = Date.now() - opts.age.coldAfterDays * 24 * 60 * 60 * 1e3;
+    const ts = new Date(envelope._ts).getTime();
+    return ts < cutoff;
+  }
+  const store = {
+    name: buildName(),
+    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) {
+      if (!opts.age) return 0;
+      let migrated = 0;
+      const collections = opts.age.collections?.length ? opts.age.collections : await primary.list(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)) {
+            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))
+  });
 }
-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 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;
       }
-      out.set(chunk.collection, collection);
+      return false;
     }
-    return out;
+    return true;
   }
-  if (typeof candidate === "string") {
-    let parsed;
+  async function guarded(fn, fallback) {
+    if (!canAttempt()) return fallback;
     try {
-      parsed = JSON.parse(candidate);
+      const result = await fn();
+      recordSuccess();
+      return result;
     } catch (err) {
-      throw new Error(
-        `diffVault: candidate string is not valid JSON (${err.message})`
-      );
+      recordFailure();
+      throw err;
+    }
+  }
+  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 {
+    series: config.series,
+    collection: config.collection,
+    field: config.field,
+    settleWindowMs: config.settleWindowMs ?? 0
+  };
+}
+
+// src/with-shape/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 collectionsFromObject(parsed, idKey, filter);
+    return explicit;
+  }
+  const inferred = decimalScaleOf(amount);
+  if (inferred === null) {
+    throw new MoneyUnsupportedError(`${label}: amount ${JSON.stringify(amount)} is not a finite decimal`);
   }
-  return collectionsFromObject(candidate, idKey, filter);
+  return inferred;
 }
-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");
-  }
-  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);
+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`);
     }
-    out.set(key, collection);
+    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 out;
+  return base.map((p) => formatScaledInt(negative && p !== 0n ? -p : p, scale));
 }
-function uniqueTopLevelKeys(diffs) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const d of diffs) {
-    const m = /^[^.[]+/.exec(d.path);
-    if (m) keys.add(m[0]);
+
+// src/with-shape/money/branded.ts
+function asMoney(value) {
+  if (!isMoneyLike(value)) {
+    throw new MoneyUnsupportedError(`asMoney: ${JSON.stringify(value)} is not a finite decimal`);
   }
-  return [...keys];
+  return String(value).trim();
 }
-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 isMoneyString(value) {
+  return typeof value === "string" && isMoneyLike(value);
 }
-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 moneyNumber(value) {
+  if (!isMoneyLike(value)) {
+    throw new MoneyUnsupportedError(`moneyNumber: ${JSON.stringify(value)} is not a finite decimal`);
+  }
+  return Number(value);
 }
-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 isMoneyLike(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "string") return false;
+  return decimalScaleOf(value) !== null;
 }
 export {
   Aggregation,
   AlreadyElevatedError,
   AmendmentForbiddenError,
   AttestationError,
+  AttestationNotEnabledError,
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
   BLOB_INDEX_COLLECTION,
@@ -639,13 +1409,18 @@ export {
   BundleSealMismatchError,
   BundleVersionConflictError,
   CONSENT_AUDIT_COLLECTION,
+  CargoNotEnabledError,
   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 +1430,9 @@ export {
   DICT_COLLECTION_PREFIX,
   DIRECTORY_RECORD_ID,
   DanglingReferenceError,
+  DataResidencyError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   DelegationTargetMissingError,
   DerivationCapExceededError,
@@ -669,9 +1447,13 @@ export {
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
   ElevationExpiredError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  EnclaveNotSupportedError,
   ExportCapabilityError,
   FieldFrozenError,
   FilenameSanitizationError,
+  ForgetStrategyNotConfiguredError,
   GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY,
   GroupCardinalityError,
@@ -679,6 +1461,7 @@ export {
   GroupedQuery,
   GroupedQueryN,
   INDEXED_STORE_POLICY,
+  IllegalTransitionError,
   ImportCapabilityError,
   IndexRequiredError,
   IndexWriteFailureError,
@@ -691,6 +1474,8 @@ export {
   LEDGER_DELTAS_COLLECTION,
   LedgerContentionError,
   LedgerStore,
+  LinkEndpointError,
+  LinkIntegrityError,
   LocaleNotSpecifiedError,
   Lru,
   MAGIC_LINK_CONTENT_INFO_PREFIX,
@@ -706,6 +1491,9 @@ export {
   MemorySealingKeyProvider,
   MigrationRequiredError,
   MissingTranslationError,
+  MoneyCurrencyError,
+  MoneyPrecisionError,
+  MoneyUnsupportedError,
   NOYDB_BACKUP_VERSION,
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -713,26 +1501,34 @@ export {
   NOYDB_FORMAT_VERSION,
   NOYDB_KEYRING_VERSION,
   NOYDB_SYNC_VERSION,
+  NO_CARGO,
+  NO_CUSTODY,
+  NO_SEARCH,
+  NO_SEQUENCE,
   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 +1537,7 @@ export {
   ReadOnlyAtInstantError,
   ReadOnlyError,
   ReadOnlyFrameError,
+  RecordCekNotFoundError,
   RecordLockedError,
   RecoveryNotEnrolledError,
   RecoveryProfileNotImplementedError,
@@ -748,8 +1545,10 @@ export {
   RefRegistry,
   RefScopeError,
   ReservedCollectionNameError,
+  ReservedVaultNameError,
   SCHEMAS_COLLECTION,
   SEALED_PASSPHRASE_RECORD_ID,
+  STATE_VAULT_NAME,
   STRICT_POLICY,
   SYNC_CREDENTIALS_COLLECTION,
   ScanBuilder,
@@ -758,10 +1557,21 @@ export {
   SchemaUpdateError,
   SchemaValidationError,
   ScriptViolationError,
+  SealedHandle,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  SealedRecordNotEnabledError,
+  SearchNotEnabledError,
+  SequenceContentionError,
+  SequenceNotEnabledError,
+  SequenceOfflineError,
+  SequenceStore,
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
+  ShardProvisioningError,
   SnapshotNotFoundError,
+  StaticDictReadonlyError,
   StoreCapabilityError,
   SyncEngine,
   SyncScheduler,
@@ -769,12 +1579,17 @@ export {
   TamperedError,
   TierDemoteDeniedError,
   TierNotGrantedError,
+  TiersNotEnabledError,
   TranslatorNotConfiguredError,
   TxCollection,
   TxContext,
   TxVault,
   USER_ENVELOPE_COLLECTION,
   USER_ENVELOPE_MAX_BYTES,
+  UniqueConstraintError,
+  UnknownDictCodeError,
+  UnknownShardError,
+  UnsupportedIndexOptionError,
   UserApi,
   UserEnvelopeOversizedError,
   VISIBILITY_RECORD_PREFIX,
@@ -782,12 +1597,18 @@ export {
   Vault,
   VaultFrame,
   VaultInstant,
+  VaultTemplateNotFoundError,
   WeakPassphraseError,
+  WithdrawalRequestError,
   activeSessionCount,
   additiveOnly,
+  aesGcmOpen,
+  allocate,
   applyI18nLocale,
   applyJoins,
   applyPatch,
+  approveWithdrawal,
+  asMoney,
   assertStrongPassphrase,
   assertTierAccess,
   avg,
@@ -800,17 +1621,21 @@ export {
   canonicalJson,
   checkGate,
   clearDevUnlock,
+  compileSequenceFormat,
   computePatch,
   coordinatedCutover,
   count,
   createBundleStore,
+  createDeedOwner,
   createEnforcer,
   createNoydb,
+  createPodStore,
   createSession,
   createStore,
   credentialStatus,
   decryptBytes,
   decryptDeterministic,
+  decryptExtractedPartition,
   dekKey,
   deleteCredential,
   deleteUserEnvelope,
@@ -838,13 +1663,16 @@ export {
   envelopePayloadHash,
   estimateEntropy,
   estimateRecordBytes,
+  evalComputedFields,
   evaluateClause,
   evaluateExportCapability,
   evaluateFieldClause,
   evaluateImportCapability,
   executePlan,
+  exportAccessibleData,
   findAuthenticator,
   formatDiff,
+  fuseRetrieval,
   generateULID,
   getCredential,
   groupAndReduce,
@@ -854,26 +1682,38 @@ export {
   hasRecoveryEnrolled,
   hashEntry,
   i18nText,
+  immutableGuard,
+  importExternalObjects,
   inferScripts,
+  isDeedVault,
   isDevUnlockActive,
   isDictCollectionName,
   isDictKeyDescriptor,
+  isDiscriminant,
   isI18nTextDescriptor,
+  isLinkCollectionName,
   isMagicLinkGrantExpired,
+  isMoneyDescriptor,
+  isMoneyString,
   isPreCompressed,
   isPublicEnvelope,
+  isRefArray,
   isSessionAlive,
+  isStaticDictDescriptor,
   isULID,
   isZodSchema,
   issueDelegation,
   recoverPassphrase as keyringRecoverPassphrase,
   rotatePassphrase as keyringRotatePassphrase,
+  liberateVault,
   listCredentials,
   listMagicLinkGrants,
   listUserEnvelopeIds,
   listUsers,
   listUsersWithEnvelopes,
+  listWithdrawalRequests,
   loadActiveDelegations,
+  loadDeedMarker,
   loadDevUnlock,
   loadPaperRecoveryEntries,
   loadPersistedSchema,
@@ -885,15 +1725,24 @@ export {
   lockSchema,
   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 +1754,26 @@ export {
   readNoydbBundleHeader,
   readNoydbBundlePublicEnvelope,
   readPath,
+  readPlaintextRecord,
+  readPod,
+  readPodHeader,
   readPublicEnvelope,
   readUserVisibility,
   recoverUser,
   reduceRecords,
+  reducerBuilder,
   ref,
+  refArray,
+  rejectWithdrawal,
   removeAuthenticator,
+  requestWithdrawal,
   resetBrotliSupportCache,
   resetJoinWarnings,
   resolveCrdtSnapshot,
   resolveI18nText,
   resolvePolicy,
   resolveSchema as resolvePublicEnvelopeSchema,
+  resolveSequenceKey,
   resolveSession,
   revokeAllSessions,
   revokeDelegation,
@@ -931,8 +1788,13 @@ export {
   saveShamirRecoveryEntries,
   saveUserEnvelope,
   saveVaultPolicy,
+  scaleForCurrency,
+  sealRsaOaepTlv,
   sha256Hex,
+  staticDict,
   sum,
+  tokenize,
+  transitionGuard,
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
   unwrapDeksFromShamirEntry,
@@ -944,8 +1806,12 @@ export {
   validateSchemaOutput,
   validateSessionPolicy,
   visibilityRecordId,
+  withArchive,
   withCache,
+  withCargo,
   withCircuitBreaker,
+  withCustody,
+  withDeferredNumbering,
   withDerivation,
   withGuard,
   withHealthCheck,
@@ -954,9 +1820,15 @@ export {
   withMetrics,
   withOverlayedView,
   withRetry,
+  withRollup,
+  withSearch,
+  withSequence,
+  withdrawAccessibleData,
   wrapBundleStore,
+  wrapPodStore,
   wrapStore,
   writeMagicLinkGrant,
-  writeNoydbBundle
+  writeNoydbBundle,
+  writePod
 };
 //# sourceMappingURL=index.js.map