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

package/dist/index.js

@@ -1,32 +1,20 @@
+import {
+  LinkEndpointError
+} from "./chunk-3F7GLNAE.js";
 import {
   persistSchemaIfNeeded
-} from "./chunk-K6LHRFBL.js";
+} from "./chunk-6LMQ5R26.js";
 import {
-  LinkEndpointError
-} from "./chunk-6GMZ7HEE.js";
+  ComputedFieldError,
+  evalComputedFields
+} from "./chunk-IT22PWKV.js";
 import {
   WithdrawalRequestError,
   approveWithdrawal,
   listWithdrawalRequests,
   rejectWithdrawal,
   requestWithdrawal
-} from "./chunk-XTXOCYOJ.js";
-import {
-  ComputedFieldError,
-  evalComputedFields
-} from "./chunk-LWBCUYZW.js";
-import {
-  DEFAULT_FRESHNESS_MS,
-  PERSONAL_POLICY,
-  STRICT_POLICY,
-  checkGate,
-  describeGate,
-  mergePolicy
-} from "./chunk-SPYWXKJN.js";
-import "./chunk-GJW4HX2O.js";
-import {
-  UserApi
-} from "./chunk-MUM7IANK.js";
+} from "./chunk-FCKWQE2H.js";
 import {
   routeStore,
   withCache,
@@ -43,56 +31,60 @@ import {
   isMoneyString,
   moneyNumber,
   mulRate
-} from "./chunk-GY4WYNNG.js";
+} from "./chunk-ID6Z6E66.js";
 import {
   COVER_FIELDS,
   DEFAULT_COVER_SCHEMA,
   resolveSchema
-} from "./chunk-CUZLNGD5.js";
+} from "./chunk-B2YY6WDD.js";
 import {
   additiveOnly,
   blindUpdate,
   coordinatedCutover,
   lockSchema
-} from "./chunk-RMS3NEA3.js";
+} from "./chunk-HT2AHGQI.js";
 import "./chunk-ZVF37PKE.js";
 import {
-  classified,
-  luhnCheck
-} from "./chunk-FXBIP2WD.js";
+  DEFAULT_FRESHNESS_MS,
+  PERSONAL_POLICY,
+  STRICT_POLICY,
+  checkGate,
+  describeGate,
+  mergePolicy
+} from "./chunk-F7XGHL5O.js";
+import "./chunk-GJW4HX2O.js";
+import {
+  UserApi
+} from "./chunk-4MXI3ODD.js";
 import {
   decryptExtractedPartition,
   withCargo
-} from "./chunk-J6FXAEUG.js";
+} from "./chunk-6B3VNR4P.js";
 import {
   diffVault
 } from "./chunk-LFUID7OW.js";
-import "./chunk-3RCJJBNR.js";
+import "./chunk-3ELRMVJK.js";
 import {
   createDeedOwner,
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "./chunk-CHJBLCOG.js";
+} from "./chunk-HVSCEIYL.js";
 import {
   withdrawAccessibleData
-} from "./chunk-BSFNRLK2.js";
+} from "./chunk-S57HTZ6X.js";
 import {
   exportAccessibleData
-} from "./chunk-L7CIOOBW.js";
+} from "./chunk-WNJ4AVGE.js";
 import {
   applyListProjection
 } from "./chunk-VG2ZSFYD.js";
-import {
-  withDerivation,
-  withRollup
-} from "./chunk-BUE2D7PX.js";
 import {
   withMaterializedView
-} from "./chunk-6X6SEMEE.js";
-import "./chunk-NA2NIJZI.js";
-import "./chunk-QIBVIOXO.js";
-import "./chunk-FMZY5Q6L.js";
+} from "./chunk-X25NWUZB.js";
+import "./chunk-QBBUZ3I3.js";
+import "./chunk-NWHBJQAL.js";
+import "./chunk-WX5ADGTZ.js";
 import {
   MoneyCurrencyError,
   MoneyPrecisionError,
@@ -101,19 +93,50 @@ import {
   isMoneyDescriptor,
   money,
   scaleForCurrency
-} from "./chunk-VXANTWBJ.js";
+} from "./chunk-WY2XXTET.js";
 import {
   withOverlayedView
-} from "./chunk-SFAWCTEM.js";
-import "./chunk-Q2PU57HC.js";
+} from "./chunk-B57AFBY2.js";
+import "./chunk-BK2HHQGN.js";
 import {
   PresenceHandle,
   SyncEngine,
   SyncTransaction
-} from "./chunk-CPWQB3N5.js";
+} from "./chunk-N5DNADLQ.js";
 import {
   isDiscriminant
 } from "./chunk-PY4KJPYU.js";
+import {
+  classified,
+  luhnCheck
+} from "./chunk-BUDAGWL5.js";
+import {
+  immutableGuard,
+  transitionGuard,
+  withGuard
+} from "./chunk-SI3V7D4G.js";
+import "./chunk-FN5EBVTQ.js";
+import "./chunk-VNNRUGMM.js";
+import "./chunk-JK733I5V.js";
+import {
+  CollectionFrame,
+  VaultFrame
+} from "./chunk-6OWXYZK2.js";
+import {
+  withDerivation,
+  withRollup
+} from "./chunk-32YV3TJT.js";
+import {
+  withLazy
+} from "./chunk-ULUMAZ5S.js";
+import "./chunk-T52GX4SA.js";
+import {
+  reduceRecords
+} from "./chunk-CF5UU4S7.js";
+import {
+  mergeCrdtStates,
+  resolveCrdtSnapshot
+} from "./chunk-4GPE63GU.js";
 import {
   createPodStore,
   followRedirects,
@@ -121,7 +144,7 @@ import {
   signRedirect,
   verifyRedirect,
   wrapPodStore
-} from "./chunk-WEQEYLCS.js";
+} from "./chunk-LGRLME4M.js";
 import {
   Collection,
   ELEVATION_AUDIT_COLLECTION,
@@ -138,107 +161,47 @@ import {
   ref,
   refArray,
   withArchive
-} from "./chunk-6GOE5PGN.js";
+} from "./chunk-T2LBQ5DV.js";
+import {
+  LinkIntegrityError,
+  isLinkCollectionName
+} from "./chunk-AOWGXU6D.js";
+import "./chunk-6K7DPM7D.js";
+import "./chunk-TROR3ALR.js";
 import {
   deriveSchemaManifest,
   loadSchemaManifestEntry
-} from "./chunk-VXGSWL6L.js";
+} from "./chunk-SYVZW77S.js";
 import {
   MANIFEST_COLLECTION,
   isManifestReservedCollection
 } from "./chunk-EPFF7LOX.js";
-import {
-  LinkIntegrityError,
-  isLinkCollectionName
-} from "./chunk-QIZPZMUI.js";
-import "./chunk-TUFM4UZP.js";
-import "./chunk-SMH6SRX7.js";
-import "./chunk-453F654R.js";
-import "./chunk-SPXXX5E4.js";
+import "./chunk-L7DOS3TE.js";
+import "./chunk-6LNL42F5.js";
 import "./chunk-GYGLAVCX.js";
 import "./chunk-6LJY7X5A.js";
-import "./chunk-Q7HZX3IF.js";
-import "./chunk-KJIMGIWO.js";
-import "./chunk-BZ3534YM.js";
+import "./chunk-UPD5NWI5.js";
+import "./chunk-ZUVBC32X.js";
 import {
   NO_CARGO
-} from "./chunk-NQKIUNW5.js";
+} from "./chunk-A6IJU4TK.js";
+import "./chunk-RXLYKVTF.js";
 import {
   MemoryRecipientSealer,
   MemorySealer,
   aesGcmOpen,
   parseRsaOaepTlv,
   sealRsaOaepTlv
-} from "./chunk-4GVM6QZA.js";
-import "./chunk-VTFVLCUH.js";
-import "./chunk-RXLYKVTF.js";
-import {
-  NO_SEQUENCE,
-  SequenceStore,
-  compileSequenceFormat,
-  resolveSequenceKey,
-  withSequence
-} from "./chunk-ZVO4QVPD.js";
-import {
-  CustodyApi,
-  NO_CUSTODY,
-  withCustody
-} from "./chunk-GPEQUXHL.js";
-import {
-  isViaFieldSpec,
-  via
-} from "./chunk-2C3AQB46.js";
-import "./chunk-TFMM5DBB.js";
-import "./chunk-RTBJ5IOO.js";
-import {
-  ClassifiedNeverStoredError,
-  ClassifiedValidationError,
-  isClassifiedFieldSpec,
-  isClassifiedGroup,
-  resolveClassifiedFields
-} from "./chunk-5VCRVKOZ.js";
-import "./chunk-VYYM3MEN.js";
-import {
-  derivePersistedSchema,
-  isZodSchema
-} from "./chunk-REDOOY2Q.js";
-import "./chunk-Y2NBBT6K.js";
-import {
-  SCHEMAS_COLLECTION,
-  loadPersistedSchema,
-  savePersistedSchema
-} from "./chunk-2Y4IMKA6.js";
-import "./chunk-CARABLSQ.js";
-import {
-  buildLookupSnapshot
-} from "./chunk-U4FOQDY4.js";
-import "./chunk-SKGMN35F.js";
+} from "./chunk-ENAG3IY7.js";
+import "./chunk-3JWHAR6E.js";
+import "./chunk-K6W7BVZ6.js";
+import "./chunk-MLPHLJIQ.js";
 import {
   INDEXED_STORE_POLICY,
   POD_STORE_POLICY,
   SyncScheduler
 } from "./chunk-T7IR4N2S.js";
-import {
-  CONSENT_AUDIT_COLLECTION
-} from "./chunk-NKHRDYOR.js";
-import "./chunk-PEOZ34EM.js";
-import "./chunk-PT43Y56J.js";
-import "./chunk-GHVIKOHT.js";
-import {
-  PERIODS_COLLECTION
-} from "./chunk-FAHMLERK.js";
-import {
-  immutableGuard,
-  transitionGuard,
-  withGuard
-} from "./chunk-YYP7WSEB.js";
-import "./chunk-4OZNXTO4.js";
-import "./chunk-DGOZ4UZD.js";
-import "./chunk-JK733I5V.js";
-import {
-  CollectionFrame,
-  VaultFrame
-} from "./chunk-XLMEZIAJ.js";
+import "./chunk-X4773RBR.js";
 import "./chunk-SMY5X46Z.js";
 import "./chunk-DZFQVICS.js";
 import {
@@ -256,7 +219,7 @@ import {
   verifyPodHeader,
   verifyRecord,
   writePod
-} from "./chunk-5WDXHNSW.js";
+} from "./chunk-HBPPGWUM.js";
 import {
   COVER_RECORD_ID,
   isCover,
@@ -264,39 +227,141 @@ import {
   readCover,
   saveCover,
   validateCoverInput
-} from "./chunk-EQEYOJBM.js";
+} from "./chunk-IUWCVHQ7.js";
 import {
   TxCollection,
   TxContext,
   TxVault,
   runTransaction
-} from "./chunk-BLN54W3L.js";
+} from "./chunk-5FDLC6G7.js";
 import "./chunk-5D2ALSM5.js";
 import {
   NO_SEARCH,
   tokenize,
   withSearch
-} from "./chunk-UXWB3FPF.js";
+} from "./chunk-I3JDRCMW.js";
 import {
   fuseRetrieval
 } from "./chunk-AURFOK3D.js";
-import "./chunk-6YXCPL4T.js";
 import {
-  DEFAULT_CROSS_JOIN_MAX_ROWS,
+  NO_SEQUENCE,
+  SequenceStore,
+  compileSequenceFormat,
+  resolveSequenceKey,
+  withSequence
+} from "./chunk-M522UYZ2.js";
+import {
+  CustodyApi,
+  NO_CUSTODY,
+  withCustody
+} from "./chunk-B6SJIBQK.js";
+import {
+  isViaFieldSpec,
+  via
+} from "./chunk-UD5EVGZ7.js";
+import "./chunk-TFMM5DBB.js";
+import "./chunk-MDWKM2XC.js";
+import "./chunk-VYYM3MEN.js";
+import {
+  derivePersistedSchema,
+  isZodSchema
+} from "./chunk-PSIV7CJV.js";
+import "./chunk-Y2NBBT6K.js";
+import {
+  SCHEMAS_COLLECTION,
+  loadPersistedSchema,
+  savePersistedSchema
+} from "./chunk-3H5KLDZN.js";
+import {
+  buildLookupSnapshot
+} from "./chunk-FH2L2E34.js";
+import {
+  ClassifiedNeverStoredError,
+  ClassifiedValidationError,
+  isClassifiedFieldSpec,
+  isClassifiedGroup,
+  resolveClassifiedFields
+} from "./chunk-QOOUUR4A.js";
+import {
+  DEFAULT_INDEX_MIN_VECTORS,
+  withVectorIndex
+} from "./chunk-NYMLINRP.js";
+import "./chunk-HBRLNOHL.js";
+import "./chunk-66TQOPFM.js";
+import {
+  Lru,
+  estimateRecordBytes,
+  parseBytes
+} from "./chunk-V4PXLYWM.js";
+import "./chunk-XZHEOSQ2.js";
+import "./chunk-PVEWA2DU.js";
+import {
+  CONSENT_AUDIT_COLLECTION
+} from "./chunk-FQ5VRHIB.js";
+import "./chunk-PEOZ34EM.js";
+import "./chunk-RHVMZSUU.js";
+import "./chunk-NRT6QZQB.js";
+import "./chunk-GHVIKOHT.js";
+import {
+  PERIODS_COLLECTION
+} from "./chunk-FW22ZCXT.js";
+import "./chunk-PDCG6PR5.js";
+import "./chunk-BKT776R5.js";
+import {
+  CollectionIndexes
+} from "./chunk-YSK2CU2Q.js";
+import {
+  ALL_PARTITIONS,
+  describePartitionScope,
+  partitionsInScope,
+  resolvePartitionScope
+} from "./chunk-CY2CYVWZ.js";
+import {
   Query,
-  ScanBuilder,
-  buildLiveQuery,
+  ScanBuilder as ScanBuilder2,
   executePlan
-} from "./chunk-7MG2LHO5.js";
+} from "./chunk-TOPYQ6GA.js";
+import {
+  buildLiveQuery
+} from "./chunk-FQ54DWUQ.js";
+import "./chunk-FXQBGFOX.js";
+import "./chunk-F2TDU7MQ.js";
+import "./chunk-ORDURZBU.js";
+import "./chunk-SUZKW6UR.js";
+import "./chunk-BJ2IXQ5Q.js";
+import "./chunk-VHM7HCKB.js";
+import "./chunk-XBKH4FOC.js";
+import {
+  explainPlan,
+  renderExplainText
+} from "./chunk-ZSX4S5XB.js";
 import {
+  DEFAULT_CROSS_JOIN_MAX_ROWS,
   DEFAULT_JOIN_MAX_ROWS,
   applyJoins
-} from "./chunk-ZORTV6NH.js";
+} from "./chunk-4I522ERM.js";
+import "./chunk-MKXXMNJH.js";
+import "./chunk-LGNDFRYC.js";
+import {
+  ScanBuilder
+} from "./chunk-F24ZZTHQ.js";
+import "./chunk-F6NCB7KT.js";
+import {
+  sortRecords
+} from "./chunk-7JE7BDYJ.js";
+import "./chunk-3TDUWVWB.js";
+import "./chunk-5O7D6ZTW.js";
+import {
+  evaluateClause,
+  evaluateFieldClause,
+  evaluateOperator,
+  readPath
+} from "./chunk-HLEK5VAN.js";
 import {
   importExternalObjects,
   memoryObjectProjection
 } from "./chunk-4Q6HSHHL.js";
-import "./chunk-AO42KJO6.js";
+import "./chunk-GF5BZ7D4.js";
 import {
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
@@ -313,44 +378,17 @@ import {
   getIntent,
   isPreCompressed,
   sweepBlobIntents
-} from "./chunk-BM5TWITZ.js";
-import "./chunk-KTFRCC5C.js";
-import {
-  CollectionIndexes
-} from "./chunk-I3ISCYT7.js";
-import {
-  withLazy
-} from "./chunk-ULUMAZ5S.js";
-import "./chunk-66TQOPFM.js";
-import {
-  Lru,
-  estimateRecordBytes,
-  parseBytes
-} from "./chunk-V4PXLYWM.js";
-import "./chunk-ZN4FD4PE.js";
-import "./chunk-XZHEOSQ2.js";
-import "./chunk-YMUFFJCO.js";
-import "./chunk-ATL3ZVXT.js";
-import {
-  evaluateClause,
-  evaluateFieldClause,
-  readPath
-} from "./chunk-NSITFOCJ.js";
-import {
-  mergeCrdtStates,
-  resolveCrdtSnapshot
-} from "./chunk-4GPE63GU.js";
-import "./chunk-PVEWA2DU.js";
-import "./chunk-K7NTTA6P.js";
+} from "./chunk-ANWPSTZU.js";
+import "./chunk-EOVMT6TB.js";
 import {
   dictKey,
   staticDict
-} from "./chunk-MVMXZYXT.js";
+} from "./chunk-TKUOEU2F.js";
 import {
   DICT_COLLECTION_PREFIX,
   LookupHandle,
   dictCollectionName
-} from "./chunk-6I2RQCET.js";
+} from "./chunk-DF73H4UN.js";
 import {
   applyI18nLocale,
   enforceScript,
@@ -365,15 +403,16 @@ import {
   resolvePolicy,
   setAtPathInPlace,
   validateI18nTextValue
-} from "./chunk-TRGTKX5E.js";
+} from "./chunk-GHLTDZRS.js";
 import {
-  installViaBinder
-} from "./chunk-UXVWEX5L.js";
+  installViaBinder,
+  isViaPrefixProbe
+} from "./chunk-Z5HTYMMQ.js";
 import {
   MemoryDeviceSeal,
   beginEchoUnlock,
   withTeam
-} from "./chunk-EYBQEIUY.js";
+} from "./chunk-IEX7NK2K.js";
 import {
   MAGIC_LINK_GRANTS_COLLECTION,
   NO_TEAM,
@@ -402,13 +441,13 @@ import {
   unwrapDeksFromPaperEntry,
   unwrapMagicLinkGrant,
   writeMagicLinkGrant
-} from "./chunk-RRNRNANG.js";
+} from "./chunk-ZE4CHIED.js";
 import {
   META_COLLECTION,
   POLICY_RECORD_ID,
   loadVaultPolicy,
   saveVaultPolicy
-} from "./chunk-2577DKXB.js";
+} from "./chunk-DC5QVPV7.js";
 import {
   DEFAULT_ECHO_MIN_WORD_LENGTH,
   DEFAULT_ECHO_PROMPT_MIN_WORDS,
@@ -434,7 +473,7 @@ import {
   validateSecret,
   verifyPrompt,
   verifyTypedEcho
-} from "./chunk-G56KBWFY.js";
+} from "./chunk-M7NI3IWE.js";
 import {
   DIRECTORY_RECORD_ID,
   VISIBILITY_RECORD_PREFIX,
@@ -448,9 +487,9 @@ import {
   readUserVisibility,
   saveUserEnvelope,
   visibilityRecordId
-} from "./chunk-KG7TZKZG.js";
-import "./chunk-UGTBXF5U.js";
-import "./chunk-JBDFMYKQ.js";
+} from "./chunk-7VCXZDA4.js";
+import "./chunk-SOIQ4MM4.js";
+import "./chunk-4AF3TUMP.js";
 import {
   PolicyEnforcer,
   activeSessionCount,
@@ -465,7 +504,7 @@ import {
   revokeAllSessions,
   revokeSession,
   validateSessionPolicy
-} from "./chunk-ANSIZYEG.js";
+} from "./chunk-YNIUIERI.js";
 import "./chunk-VKQCVU2Z.js";
 import {
   generateULID,
@@ -474,17 +513,17 @@ import {
 import {
   CollectionInstant,
   VaultInstant
-} from "./chunk-KUJDV5QH.js";
+} from "./chunk-ISZQJBML.js";
 import {
   diff,
   formatDiff
 } from "./chunk-SVLR4POP.js";
-import "./chunk-X2DLENDQ.js";
+import "./chunk-QWGU66MP.js";
 import {
   LedgerStore,
   applyPatch,
   computePatch
-} from "./chunk-L742JPKZ.js";
+} from "./chunk-ZXABPVM6.js";
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
@@ -496,23 +535,23 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-BOET4NA4.js";
-import "./chunk-JMGDHKQF.js";
+} from "./chunk-CKNGS5MH.js";
+import "./chunk-JCN44NCY.js";
 import "./chunk-HK67PX4J.js";
-import "./chunk-7V4TP3AF.js";
+import "./chunk-J6UOHJY5.js";
 import {
   buildRecordAad,
   openEnvelopeJson,
   recordAadFor,
   validateSchemaInput,
   validateSchemaOutput
-} from "./chunk-77K4PG6P.js";
+} from "./chunk-KJFW62P4.js";
 import {
   buildRecordEnvelope
-} from "./chunk-SZJ3DLZA.js";
-import "./chunk-BOWNCWZT.js";
-import "./chunk-YSRUYAVU.js";
-import "./chunk-RMF67KCG.js";
+} from "./chunk-SEE332EV.js";
+import "./chunk-6QSQQLSE.js";
+import "./chunk-DE4DH2RZ.js";
+import "./chunk-LQ4ZHOKP.js";
 import "./chunk-LP7BEXCT.js";
 import {
   base64ToBuffer,
@@ -523,7 +562,7 @@ import {
   encrypt,
   encryptBytes,
   encryptDeterministic
-} from "./chunk-SL3JAAKN.js";
+} from "./chunk-UYB234ZR.js";
 import {
   NOYDB_BACKUP_VERSION,
   NOYDB_ENVELOPE_GENERATION,
@@ -532,7 +571,7 @@ import {
   NOYDB_SYNC_VERSION,
   SealedHandle,
   createStore
-} from "./chunk-7MG7SJT7.js";
+} from "./chunk-ODVPTDPK.js";
 import {
   AlreadyElevatedError,
   AmendmentForbiddenError,
@@ -548,6 +587,7 @@ import {
   ClassifiedRevealError,
   ClassifiedRotationError,
   ClassifiedVerifyError,
+  CollectionNotHydratedError,
   ConflictError,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -608,6 +648,7 @@ import {
   OverlayIdMismatchError,
   OverlayNameCollisionError,
   PathEscapeError,
+  PeriodChainError,
   PeriodClosedError,
   PermissionDeniedError,
   PersistedIndexCompensationError,
@@ -618,6 +659,7 @@ import {
   PolicyDeniedError,
   PortabilityNotEnabledError,
   PrivilegeEscalationError,
+  QueryExtensionMissingError,
   QuiesceTimeoutError,
   ReadOnlyAtInstantError,
   ReadOnlyError,
@@ -661,6 +703,7 @@ import {
   TierWriteRefusedError,
   TiersNotEnabledError,
   TranslatorNotConfiguredError,
+  TraversalCycleError,
   USER_ENVELOPE_COLLECTION,
   USER_ENVELOPE_MAX_BYTES,
   UniqueConstraintError,
@@ -668,6 +711,7 @@ import {
   UnknownLookupKeyError,
   UnknownShardError,
   UnknownStoreKindError,
+  UnsafePatternError,
   UnsupportedIndexOptionError,
   UnsupportedTierCompositionError,
   UserEnvelopeOversizedError,
@@ -676,7 +720,129 @@ import {
   WrongEchoError,
   WrongPromptError,
   isConflictError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
+
+// src/with-sync/change-broadcast.ts
+function defaultChangeChannel(name) {
+  const Bc = globalThis.BroadcastChannel;
+  if (typeof Bc !== "function") return void 0;
+  const bc = new Bc(name);
+  const maybeUnref = bc;
+  if (typeof maybeUnref.unref === "function") maybeUnref.unref();
+  const listeners = /* @__PURE__ */ new Set();
+  bc.onmessage = (e) => {
+    for (const l of listeners) l(String(e.data));
+  };
+  return {
+    isOpen: true,
+    send(payload) {
+      bc.postMessage(payload);
+    },
+    on(event, listener) {
+      if (event === "message") {
+        const l = listener;
+        listeners.add(l);
+        return () => listeners.delete(l);
+      }
+      return () => {
+      };
+    },
+    close() {
+      listeners.clear();
+      bc.close();
+    }
+  };
+}
+function changeChannelName(storeId) {
+  return `noydb:change:${storeId}`;
+}
+var ChangeBroadcast = class {
+  #host;
+  #channel;
+  #originId;
+  #now;
+  #ownsChannel;
+  #unsubMsg;
+  #started = false;
+  #disposed = false;
+  constructor(host, channel, opts) {
+    this.#host = host;
+    this.#channel = channel;
+    this.#originId = opts.originId;
+    this.#now = opts.now;
+    this.#ownsChannel = opts.ownsChannel;
+  }
+  get originId() {
+    return this.#originId;
+  }
+  start() {
+    if (this.#started || this.#disposed) return;
+    this.#started = true;
+    this.#unsubMsg = this.#channel.on("message", (p) => this.#onMessage(p));
+    this.#host.on("change", this.#onLocalChange);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#host.off("change", this.#onLocalChange);
+    this.#unsubMsg?.();
+    if (this.#ownsChannel) this.#channel.close();
+  }
+  /**
+   * Echo suppression, first and primary layer: a change this instance produced
+   * BY APPLYING a peer's signal is tagged `remote` and is never re-posted. Two
+   * instances would otherwise volley one address forever.
+   */
+  #onLocalChange = (e) => {
+    if (this.#disposed || e.remote === true) return;
+    if (!this.#channel.isOpen) return;
+    const signal = {
+      kind: "noydb:change",
+      origin: this.#originId,
+      vault: e.vault,
+      collection: e.collection,
+      id: e.id,
+      ts: this.#now()
+    };
+    this.#channel.send(JSON.stringify(signal));
+  };
+  #onMessage(payload) {
+    if (this.#disposed) return;
+    let msg;
+    try {
+      msg = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (!isChangeSignal(msg) || msg.origin === this.#originId) return;
+    void Promise.resolve(this.#host._applyRemoteSignal(msg.vault, msg.collection, msg.id)).catch((err) => {
+      console.warn(`[noy-db] change-signal apply failed for ${msg.collection}/${msg.id}: ` + (err instanceof Error ? err.message : String(err)));
+    });
+  }
+};
+function enableChangeBroadcast(host, opts = {}) {
+  const storeId = opts.storeId ?? host._storeName ?? "default";
+  const channel = opts.channel ?? defaultChangeChannel(changeChannelName(storeId));
+  if (!channel) return { dispose: () => {
+  } };
+  const relay = new ChangeBroadcast(host, channel, {
+    originId: opts.originId ?? `noydb-${cheapRand()}`,
+    now: opts.now ?? (() => Date.now()),
+    // Own the channel only when we created it; never close a caller-injected one.
+    ownsChannel: opts.channel === void 0
+  });
+  relay.start();
+  return { dispose: () => relay.dispose() };
+}
+function isChangeSignal(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return o["kind"] === "noydb:change" && typeof o["origin"] === "string" && typeof o["vault"] === "string" && typeof o["collection"] === "string" && typeof o["id"] === "string" && typeof o["ts"] === "number";
+}
+function cheapRand() {
+  const g = globalThis;
+  return g.crypto?.randomUUID ? g.crypto.randomUUID() : `anon-${Math.random().toString(36).slice(2)}`;
+}
 
 // src/with-commit/numbering/descriptor.ts
 function withDeferredNumbering(opts) {
@@ -694,8 +860,12 @@ function computedVia(cfg) {
   const fields = cfg.virtualFields;
   return {
     brand: "computed",
+    presentIsSync: true,
+    // #1416 — `desc.fn(r)` is declared sync by the computed contract
     posture: VIRTUAL_POSTURE,
     covers: (field) => fields.has(field),
+    coveredFields: [...fields.keys()],
+    // #1447 — virtual fields live ONLY here, which is why a predicate cannot report them
     present: (record) => {
       let r = record;
       for (const [field, desc] of fields) {
@@ -710,6 +880,271 @@ function linkComputedVia() {
   installViaBinder("computed", (cfg) => computedVia(cfg));
 }
 
+// src/via/geo/geohash.ts
+var EARTH_RADIUS_KM = 6371.0088;
+var BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
+var MAX_PRECISION = 12;
+var DEG = Math.PI / 180;
+function isGeoPoint(p) {
+  if (typeof p !== "object" || p === null) return false;
+  const { lat, lng } = p;
+  return typeof lat === "number" && Number.isFinite(lat) && lat >= -90 && lat <= 90 && typeof lng === "number" && Number.isFinite(lng) && lng >= -180 && lng <= 180;
+}
+function haversineKm(a, b) {
+  const dLat = (b.lat - a.lat) * DEG;
+  const dLng = (b.lng - a.lng) * DEG;
+  const lat1 = a.lat * DEG;
+  const lat2 = b.lat * DEG;
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_KM * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function encodeGeohash(point, precision) {
+  if (!isGeoPoint(point)) throw new RangeError(`encodeGeohash: not a point: ${JSON.stringify(point)}`);
+  const p = clampPrecision(precision);
+  let latMin = -90, latMax = 90, lngMin = -180, lngMax = 180;
+  let hash = "", bits = 0, ch = 0, evenBit = true;
+  while (hash.length < p) {
+    if (evenBit) {
+      const mid = (lngMin + lngMax) / 2;
+      if (point.lng >= mid) {
+        ch = (ch << 1) + 1;
+        lngMin = mid;
+      } else {
+        ch <<= 1;
+        lngMax = mid;
+      }
+    } else {
+      const mid = (latMin + latMax) / 2;
+      if (point.lat >= mid) {
+        ch = (ch << 1) + 1;
+        latMin = mid;
+      } else {
+        ch <<= 1;
+        latMax = mid;
+      }
+    }
+    evenBit = !evenBit;
+    if (++bits === 5) {
+      hash += BASE32[ch];
+      bits = 0;
+      ch = 0;
+    }
+  }
+  return hash;
+}
+function decodeGeohashBox(hash) {
+  let latMin = -90, latMax = 90, lngMin = -180, lngMax = 180;
+  let evenBit = true;
+  for (const c of hash) {
+    const idx = BASE32.indexOf(c);
+    if (idx < 0) throw new RangeError(`decodeGeohashBox: "${c}" is not a geohash character`);
+    for (let n = 4; n >= 0; n--) {
+      const bit = idx >> n & 1;
+      if (evenBit) {
+        const mid = (lngMin + lngMax) / 2;
+        if (bit === 1) lngMin = mid;
+        else lngMax = mid;
+      } else {
+        const mid = (latMin + latMax) / 2;
+        if (bit === 1) latMin = mid;
+        else latMax = mid;
+      }
+      evenBit = !evenBit;
+    }
+  }
+  return { minLat: latMin, maxLat: latMax, minLng: lngMin, maxLng: lngMax };
+}
+function gridBits(precision) {
+  const total = clampPrecision(precision) * 5;
+  return { latBits: Math.floor(total / 2), lngBits: Math.ceil(total / 2) };
+}
+function boundingBox(center, radiusKm) {
+  if (!isGeoPoint(center)) throw new RangeError(`boundingBox: not a point: ${JSON.stringify(center)}`);
+  if (!Number.isFinite(radiusKm) || radiusKm < 0) throw new RangeError(`boundingBox: radiusKm must be a non-negative number, got ${radiusKm}`);
+  const eps = 1e-9;
+  const angular = radiusKm / EARTH_RADIUS_KM;
+  if (angular >= Math.PI) return [{ minLat: -90, maxLat: 90, minLng: -180, maxLng: 180 }];
+  const latDelta = angular / DEG + eps;
+  const minLat = center.lat - latDelta;
+  const maxLat = center.lat + latDelta;
+  if (minLat <= -90 || maxLat >= 90) {
+    return [{ minLat: Math.max(-90, minLat), maxLat: Math.min(90, maxLat), minLng: -180, maxLng: 180 }];
+  }
+  const worstLat = Math.max(Math.abs(minLat), Math.abs(maxLat)) * DEG;
+  const ratio = Math.sin(angular) / Math.cos(worstLat);
+  if (!(ratio < 1)) return [{ minLat, maxLat, minLng: -180, maxLng: 180 }];
+  const lngDelta = Math.asin(ratio) / DEG + eps;
+  const minLng = center.lng - lngDelta;
+  const maxLng = center.lng + lngDelta;
+  if (maxLng - minLng >= 360) return [{ minLat, maxLat, minLng: -180, maxLng: 180 }];
+  if (minLng < -180) return [{ minLat, maxLat, minLng: -180, maxLng }, { minLat, maxLat, minLng: minLng + 360, maxLng: 180 }];
+  if (maxLng > 180) return [{ minLat, maxLat, minLng, maxLng: 180 }, { minLat, maxLat, minLng: -180, maxLng: maxLng - 360 }];
+  return [{ minLat, maxLat, minLng, maxLng }];
+}
+function coverSize(boxes, precision) {
+  const { latBits, lngBits } = gridBits(precision);
+  const latCells = 2 ** latBits;
+  const lngCells = 2 ** lngBits;
+  let total = 0;
+  for (const box of boxes) {
+    const i0 = cellIndex(box.minLat, -90, 180, latCells);
+    const i1 = cellIndex(box.maxLat, -90, 180, latCells);
+    const j0 = cellIndex(box.minLng, -180, 360, lngCells);
+    const j1 = cellIndex(box.maxLng, -180, 360, lngCells);
+    total += (i1 - i0 + 1) * (j1 - j0 + 1);
+  }
+  return total;
+}
+function coverPrefixes(boxes, precision) {
+  const p = clampPrecision(precision);
+  const { latBits, lngBits } = gridBits(p);
+  const latCells = 2 ** latBits;
+  const lngCells = 2 ** lngBits;
+  const latStep = 180 / latCells;
+  const lngStep = 360 / lngCells;
+  const out = /* @__PURE__ */ new Set();
+  for (const box of boxes) {
+    const i0 = cellIndex(box.minLat, -90, 180, latCells);
+    const i1 = cellIndex(box.maxLat, -90, 180, latCells);
+    const j0 = cellIndex(box.minLng, -180, 360, lngCells);
+    const j1 = cellIndex(box.maxLng, -180, 360, lngCells);
+    for (let i = i0; i <= i1; i++) {
+      const lat = -90 + (i + 0.5) * latStep;
+      for (let j = j0; j <= j1; j++) {
+        const lng = -180 + (j + 0.5) * lngStep;
+        out.add(encodeGeohash({ lat, lng }, p));
+      }
+    }
+  }
+  return [...out].sort();
+}
+function prefixesForRadius(center, radiusKm, maxPrecision, maxCells) {
+  const boxes = boundingBox(center, radiusKm);
+  const ceiling = Math.max(1, maxCells);
+  for (let p = clampPrecision(maxPrecision); p > 1; p--) {
+    if (coverSize(boxes, p) <= ceiling) return { prefixes: coverPrefixes(boxes, p), precision: p };
+  }
+  return { prefixes: coverPrefixes(boxes, 1), precision: 1 };
+}
+function cellIndex(value, origin, span, cells) {
+  const raw = Math.floor((value - origin) / span * cells);
+  return Math.min(cells - 1, Math.max(0, raw));
+}
+function clampPrecision(precision) {
+  if (!Number.isInteger(precision) || precision < 1 || precision > MAX_PRECISION) {
+    throw new RangeError(`geo: precision must be an integer in 1..${MAX_PRECISION}, got ${precision}`);
+  }
+  return precision;
+}
+
+// src/via/geo/where.ts
+function geoFieldClause(field, op, value, desc) {
+  if (op !== "near") return { kind: "passthrough", value };
+  if (typeof value !== "object" || value === null) {
+    throw new ValidationError(`where("${field}", 'near', \u2026): operand must be { lat, lng, radiusKm }, got ${JSON.stringify(value)}`);
+  }
+  const { lat, lng, radiusKm } = value;
+  const center = { lat, lng };
+  if (!isGeoPoint(center)) {
+    throw new ValidationError(`where("${field}", 'near', \u2026): lat must be in [-90, 90] and lng in [-180, 180], got ${JSON.stringify({ lat, lng })}`);
+  }
+  if (typeof radiusKm !== "number" || !Number.isFinite(radiusKm) || radiusKm < 0) {
+    throw new ValidationError(`where("${field}", 'near', \u2026): radiusKm must be a non-negative number, got ${JSON.stringify(radiusKm)}`);
+  }
+  const { prefixes, precision } = prefixesForRadius(center, radiusKm, desc.precision, desc.maxPrefixes);
+  return { kind: "near", center, radiusKm, prefixes, precision };
+}
+function evaluateGeoClause(actual, op, payload) {
+  if (payload.kind === "passthrough") return evaluateOperator(actual, op, payload.value);
+  if (op !== "near") return false;
+  if (!isGeoPoint(actual)) return false;
+  return haversineKm(actual, payload.center) <= payload.radiusKm;
+}
+function geoIndexProbe(op, payload) {
+  if (op !== "near" || payload.kind !== "near") return void 0;
+  if (payload.prefixes.length === 0) return void 0;
+  return { kind: "via-prefixes", prefixes: payload.prefixes };
+}
+
+// src/via/geo/binding.ts
+function geoVia(geoFields) {
+  return {
+    brand: "geo",
+    // A coordinate is ordinary envelope-encrypted content; the ORDERED
+    // posture is what the geohash key earns — a prefix slice is a range
+    // answer, never a plaintext coordinate the store can read.
+    posture: { encryptedAtRest: "envelope", queryable: "ordered", exportable: true, forgettable: true },
+    covers: (field) => field in geoFields,
+    coveredFields: Object.keys(geoFields),
+    // #1447
+    ingest: (record) => {
+      let out = record;
+      for (const [field, desc] of Object.entries(geoFields)) {
+        const value = record[field];
+        if (value === null || value === void 0) continue;
+        if (!isGeoPoint(value)) throw new GeoPointError(field, value);
+        const geohash = encodeGeohash(value, desc.precision);
+        if (out === record) out = { ...record };
+        out[field] = { ...value, geohash };
+      }
+      return out;
+    },
+    // Claims EVERY operator on a covered field, not just `near` — see the
+    // header of `where.ts` for why an unclaimed operator on a field whose
+    // index key is rewritten is a soundness hole rather than a gap.
+    buildClause: (field, op, value) => {
+      const desc = geoFields[field];
+      if (!desc) return void 0;
+      return geoFieldClause(field, op, value, desc);
+    },
+    evaluateClause: (actual, op, payload) => evaluateGeoClause(actual, op, payload),
+    indexProbe: (op, payload) => geoIndexProbe(op, payload),
+    canonicalizeIndexKey: (field, rawValue) => {
+      const desc = geoFields[field];
+      if (!desc || !isGeoPoint(rawValue)) return void 0;
+      return encodeGeohash(rawValue, desc.precision);
+    },
+    describeFragment: () => ({
+      geo: Object.fromEntries(
+        Object.entries(geoFields).map(([field, d]) => [field, { precision: d.precision, maxPrefixes: d.maxPrefixes }])
+      )
+    })
+  };
+}
+function linkGeoVia() {
+  installViaBinder("geo", (cfg) => geoVia(cfg.geoFields));
+}
+
+// src/via/geo/descriptor.ts
+var GeoPointError = class extends NoydbError {
+  constructor(field, value) {
+    super(
+      "GEO_POINT",
+      `geo: field "${field}" expects { lat, lng } with lat in [-90, 90] and lng in [-180, 180], got ${JSON.stringify(value)}`
+    );
+    this.field = field;
+    this.value = value;
+    this.name = "GeoPointError";
+  }
+  field;
+  value;
+};
+function geo(options = {}) {
+  linkGeoVia();
+  const precision = options.precision ?? 9;
+  if (!Number.isInteger(precision) || precision < 1 || precision > MAX_PRECISION) {
+    throw new TypeError(`geo: precision must be an integer in 1..${MAX_PRECISION}, got ${String(precision)}`);
+  }
+  const maxPrefixes = options.maxPrefixes ?? 32;
+  if (!Number.isInteger(maxPrefixes) || maxPrefixes < 1) {
+    throw new TypeError(`geo: maxPrefixes must be a positive integer, got ${String(maxPrefixes)}`);
+  }
+  return { _viaBrand: "geo", precision, maxPrefixes };
+}
+function isGeoDescriptor(x) {
+  return typeof x === "object" && x !== null && x._viaBrand === "geo";
+}
+
 // src/via/computed/descriptor.ts
 function computed(fn, opts) {
   linkComputedVia();
@@ -932,6 +1367,8 @@ function lookupVia(cfg) {
     posture: { encryptedAtRest: "envelope", queryable: "full", exportable: true, forgettable: false },
     reservedPrefixes: ["_dict_", "_lookup_"],
     covers: (field) => field in cfg.lookupFields,
+    coveredFields: Object.keys(cfg.lookupFields),
+    // #1447
     ingest: (record) => runLookupIngest(record, cfg),
     enforceWrite: (record) => runLookupEnforceWrite(record, cfg),
     present: async (record, ctx) => runLookupPresent(record, ctx, cfg),
@@ -1049,7 +1486,342 @@ async function credentialStatus(adapter, vault, keyring, adapterId) {
   const expired = credential.expiresAt ? Date.now() > new Date(credential.expiresAt).getTime() : false;
   return { exists: true, expired };
 }
+
+// src/with-store/partitioned/index.ts
+var PARTITION_REGISTRY_COLLECTION = "_partition_sets";
+var defaultPartitionNamer = (name, partition) => `${name}@${partition}`;
+function partitioned(vault, spec) {
+  return new PartitionedCollection(vault, spec);
+}
+var PartitionedCollection = class {
+  name;
+  key;
+  vault;
+  namer;
+  collectionOptions;
+  declared;
+  /**
+   * Session cache of the REGISTRY's partition list — deliberately not of the
+   * merged set. The two are different questions and conflating them cost a
+   * red test: `ensurePartition` must persist a partition the caller DECLARED
+   * but never wrote, and a cache of the merged set makes every declared value
+   * look already-known, so the registry stays empty and a later session that
+   * declares nothing enumerates nothing.
+   */
+  stored = null;
+  constructor(vault, spec) {
+    this.vault = vault;
+    this.name = spec.name;
+    this.key = spec.key;
+    this.namer = spec.namer ?? defaultPartitionNamer;
+    this.collectionOptions = spec.collectionOptions;
+    this.declared = [...spec.partitions ?? []];
+  }
+  /** The member collection name for a partition value. */
+  collectionNameOf(partition) {
+    return this.namer(this.name, partition);
+  }
+  /** The member `Collection` for one partition. */
+  partition(value) {
+    return this.vault.collection(
+      this.collectionNameOf(value),
+      this.collectionOptions
+    );
+  }
+  /**
+   * The declared partition set, in declaration order.
+   *
+   * ⭐ **This is the "cheap enumeration" half of #1342, and cheap means a
+   * measured thing.** `vault.collections()` is `adapter.loadAll(vault)` — the
+   * whole vault snapshot, every collection, every envelope — so enumerating
+   * twelve quarters cost a full load before this existed. Here it is ONE
+   * record read out of {@link PARTITION_REGISTRY_COLLECTION}, and zero reads
+   * once the session has resolved it.
+   * `__tests__/partitioned-collection.test.ts` asserts the `loadAll` count is
+   * zero rather than trusting the sentence.
+   */
+  async partitions() {
+    const stored = await this.loadStored();
+    const merged = [...this.declared];
+    for (const p of stored) if (!merged.includes(p)) merged.push(p);
+    return merged;
+  }
+  /**
+   * Declare a partition, persisting it so a later session enumerates it
+   * without the caller re-declaring. Idempotent, and keyed on what the
+   * REGISTRY holds rather than on what this handle declared.
+   */
+  async ensurePartition(value) {
+    const stored = await this.loadStored();
+    if (stored.includes(value)) return;
+    stored.push(value);
+    await this.registry().put(this.name, { id: this.name, partitions: [...stored] });
+  }
+  async loadStored() {
+    if (this.stored === null) {
+      this.stored = [...(await this.registry().get(this.name))?.partitions ?? []];
+    }
+    return this.stored;
+  }
+  /**
+   * Write a record into the partition its key names, declaring that partition
+   * if it is new.
+   *
+   * Throws when `record[key]` is not a string — a partition value names a
+   * collection, and routing a record to a partition derived by coercion is
+   * how a record ends up somewhere no query will look for it.
+   */
+  async put(id, record) {
+    const value = record[this.key];
+    if (typeof value !== "string" || value === "") {
+      throw new PartitionKeyError(this.name, this.key, value);
+    }
+    await this.ensurePartition(value);
+    await this.partition(value).put(id, record);
+  }
+  /** A union query across the member collections, pruned by the predicate. */
+  query() {
+    return new PartitionedQuery(this, [], [], void 0, 0);
+  }
+  /**
+   * A union scan across the member collections, pruned by the predicate.
+   * Pages are decrypted, so an excluded partition is decryption never paid.
+   */
+  scan(opts = {}) {
+    return new PartitionedScan(this, [], opts.pageSize ?? 100);
+  }
+  /** @internal — the normalizer for clause shapes, and the union's legs. */
+  _registryName() {
+    return PARTITION_REGISTRY_COLLECTION;
+  }
+  registry() {
+    return this.vault.collection(
+      PARTITION_REGISTRY_COLLECTION
+    );
+  }
+};
+var PartitionKeyError = class extends Error {
+  constructor(collection, key, value) {
+    super(
+      `[noy-db] partitioned("${collection}"): record.${key} must be a non-empty string naming its partition, got ${typeof value === "string" ? '""' : String(value)}. A partition value names a collection; it is never coerced.`
+    );
+    this.name = "PartitionKeyError";
+  }
+};
+function replay(builder, steps) {
+  let out = builder;
+  for (const step of steps) {
+    out = step.kind === "where" ? out.where(step.field, step.op, step.value) : out.filter(step.fn);
+  }
+  return out;
+}
+function normalizedClauses(col, declared, steps) {
+  if (declared.length === 0) return [];
+  const probe = replay(col.partition(declared[0]).query(), steps);
+  return probe._plan().clauses;
+}
+var PartitionedQuery = class _PartitionedQuery {
+  constructor(col, steps, orderBys, limitN, offsetN) {
+    this.col = col;
+    this.steps = steps;
+    this.orderBys = orderBys;
+    this.limitN = limitN;
+    this.offsetN = offsetN;
+  }
+  col;
+  steps;
+  orderBys;
+  limitN;
+  offsetN;
+  with(patch) {
+    return new _PartitionedQuery(
+      this.col,
+      patch.steps ?? this.steps,
+      patch.orderBys ?? this.orderBys,
+      "limitN" in patch ? patch.limitN : this.limitN,
+      patch.offsetN ?? this.offsetN
+    );
+  }
+  where(field, op, value) {
+    return this.with({ steps: [...this.steps, { kind: "where", field, op, value }] });
+  }
+  filter(fn) {
+    return this.with({ steps: [...this.steps, { kind: "filter", fn }] });
+  }
+  orderBy(field, direction = "asc") {
+    return this.with({ orderBys: [...this.orderBys, { field, direction }] });
+  }
+  limit(n) {
+    return this.with({ limitN: n });
+  }
+  offset(n) {
+    return this.with({ offsetN: n });
+  }
+  /** The pruning decision for this query, and the set it was taken against. */
+  async scope() {
+    const declared = await this.col.partitions();
+    const clauses = normalizedClauses(this.col, declared, this.steps);
+    return { declared, scope: resolvePartitionScope(clauses, this.col.key, declared) };
+  }
+  /**
+   * The matched rows, unordered and unpaged — the set every reduce-shaped
+   * terminal reports over, matching `Query.count()`'s rule that orderBy /
+   * limit / offset describe a page and a reduction is not paginated.
+   */
+  async matched() {
+    const { declared, scope } = await this.scope();
+    const rows = [];
+    for (const p of partitionsInScope(scope, declared)) {
+      const leg = replay(this.col.partition(p).query(), this.steps);
+      rows.push(...leg.toArray());
+    }
+    return rows;
+  }
+  /** The union, sorted then paged. */
+  async all() {
+    let rows = await this.matched();
+    if (this.orderBys.length > 0) rows = sortRecords(rows, this.orderBys);
+    if (this.offsetN > 0) rows = rows.slice(this.offsetN);
+    if (this.limitN !== void 0) rows = rows.slice(0, this.limitN);
+    return rows;
+  }
+  async first() {
+    return (await this.all())[0] ?? null;
+  }
+  async count() {
+    return (await this.matched()).length;
+  }
+  async aggregate(spec) {
+    return reduceRecords(await this.matched(), spec);
+  }
+  /**
+   * The plan, with the partition decision as its first line:
+   *
+   * ```
+   * partitions partitions: 1 of 12 scanned [partitions:pruned] -- key "period"; FY2026-Q1
+   * source snapshot (no indexes) [source] rows=500
+   * where period == "FY2026-Q1" [scan] rows=500
+   * ```
+   *
+   * ⭐ The dispatch label is decided by {@link resolvePartitionScope} — the
+   * SAME call the executor makes, not a mirror of it. `explain.ts`'s header
+   * warns that its index dispatch mirrors `candidateRecords`; #1375 deleted
+   * one such mirror, and a partition dispatch would have been a third site.
+   *
+   * The nodes after the partition line are the FIRST in-scope member's own
+   * explanation. Every member runs the same plan over the same shape, so one
+   * leg's nodes describe them all; the partition line is what says how many
+   * legs there are.
+   */
+  async explain() {
+    const { declared, scope } = await this.scope();
+    const inScope = partitionsInScope(scope, declared);
+    const pruned = scope !== ALL_PARTITIONS && inScope.length < declared.length;
+    const notes = [`key "${this.col.key}"`];
+    notes.push(
+      inScope.length === 0 ? "no partition admits this predicate \u2014 nothing is read" : inScope.join(", ")
+    );
+    if (!pruned && declared.length > 0) {
+      notes.push("predicate proves no narrowing \u2014 every partition is read");
+    }
+    const head = {
+      op: "partitions",
+      dispatch: pruned ? "partitions:pruned" : "partitions:all",
+      detail: describePartitionScope(scope, declared),
+      estimatedRows: void 0,
+      notes,
+      children: []
+    };
+    const legNodes = inScope.length === 0 ? [] : replay(this.col.partition(inScope[0]).query(), this.steps).explain().nodes;
+    const nodes = [head, ...legNodes];
+    return { nodes, caps: [], reducerRewrite: [], text: renderExplainText(nodes) };
+  }
+};
+var PartitionedScan = class _PartitionedScan {
+  constructor(col, steps, pageSize) {
+    this.col = col;
+    this.steps = steps;
+    this.pageSize = pageSize;
+  }
+  col;
+  steps;
+  pageSize;
+  where(field, op, value) {
+    return new _PartitionedScan(
+      this.col,
+      [...this.steps, { kind: "where", field, op, value }],
+      this.pageSize
+    );
+  }
+  filter(fn) {
+    return new _PartitionedScan(this.col, [...this.steps, { kind: "filter", fn }], this.pageSize);
+  }
+  /** The pruning decision for this scan, and the set it was taken against. */
+  async scope() {
+    const declared = await this.col.partitions();
+    const clauses = normalizedClauses(this.col, declared, this.steps);
+    return { declared, scope: resolvePartitionScope(clauses, this.col.key, declared) };
+  }
+  /**
+   * The union as a single {@link ScanBuilder} — so `.aggregate()`,
+   * `.groupBy()` and `for await` come from the streaming machinery that
+   * already exists, at its existing O(reducers) memory bound, rather than
+   * from a second implementation of it.
+   */
+  async builder() {
+    const { declared, scope } = await this.scope();
+    const members = partitionsInScope(scope, declared).map((p) => this.col.partition(p));
+    return replay(
+      new ScanBuilder(unionPageProvider(members), this.pageSize),
+      this.steps
+    );
+  }
+  async *[Symbol.asyncIterator]() {
+    yield* await this.builder();
+  }
+  async aggregate(spec) {
+    return (await this.builder()).aggregate(spec);
+  }
+  /**
+   * **ASYNC here, unlike `Query.toArray()` (#1413).** Same method name, a
+   * different contract, because the surface underneath differs: this one
+   * genuinely fetches across every partition leg, so it genuinely awaits. `Query`'s terminal reads an
+   * already-decrypted in-memory cache and returns `T[]` synchronously.
+   */
+  async toArray() {
+    const out = [];
+    for await (const record of this) out.push(record);
+    return out;
+  }
+};
+function unionPageProvider(members) {
+  return {
+    async listPage(opts) {
+      let index = 0;
+      let inner;
+      if (opts.cursor !== void 0) {
+        const at = opts.cursor.indexOf("|");
+        index = Number.parseInt(opts.cursor.slice(0, at), 10);
+        const rest = opts.cursor.slice(at + 1);
+        inner = rest === "" ? void 0 : rest;
+      }
+      while (index < members.length) {
+        const page = await members[index].listPage({ ...inner !== void 0 ? { cursor: inner } : {}, ...opts.limit !== void 0 ? { limit: opts.limit } : {} });
+        if (page.nextCursor !== null) {
+          return { items: page.items, nextCursor: `${index}|${page.nextCursor}` };
+        }
+        index += 1;
+        inner = void 0;
+        if (page.items.length > 0) {
+          return { items: page.items, nextCursor: index < members.length ? `${index}|` : null };
+        }
+      }
+      return { items: [], nextCursor: null };
+    }
+  };
+}
 export {
+  ALL_PARTITIONS,
   AlreadyElevatedError,
   AmendmentForbiddenError,
   AttestationError,
@@ -1069,6 +1841,7 @@ export {
   COVER_FIELDS,
   COVER_RECORD_ID,
   CargoNotEnabledError,
+  ChangeBroadcast,
   ClassifiedConfigError,
   ClassifiedNeverStoredError,
   ClassifiedNotEnabledError,
@@ -1080,6 +1853,7 @@ export {
   CollectionFrame,
   CollectionIndexes,
   CollectionInstant,
+  CollectionNotHydratedError,
   ComputedFieldError,
   ConflictError,
   CrossJoinSourceUnknownError,
@@ -1092,6 +1866,7 @@ export {
   DEFAULT_ECHO_MIN_WORD_LENGTH,
   DEFAULT_ECHO_PROMPT_MIN_WORDS,
   DEFAULT_FRESHNESS_MS,
+  DEFAULT_INDEX_MIN_VECTORS,
   DEFAULT_JOIN_MAX_ROWS,
   DICT_COLLECTION_PREFIX,
   DIRECTORY_RECORD_ID,
@@ -1110,6 +1885,7 @@ export {
   DirectoryDisabledError,
   DuplicateBehaviorNameError,
   DuplicateStoreKindError,
+  EARTH_RADIUS_KM,
   ELEVATION_AUDIT_COLLECTION,
   EchoCeremonyRequiredError,
   ElevatedHandle,
@@ -1122,6 +1898,8 @@ export {
   FieldNotQueryableError,
   FilenameSanitizationError,
   ForgetStrategyNotConfiguredError,
+  MAX_PRECISION as GEO_MAX_PRECISION,
+  GeoPointError,
   GroupCardinalityError,
   INDEXED_STORE_POLICY,
   IllegalTransitionError,
@@ -1183,12 +1961,18 @@ export {
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
   OverlayNameCollisionError,
+  PARTITION_REGISTRY_COLLECTION,
   PERIODS_COLLECTION,
   PERSONAL_POLICY,
   POD_SIG_ALG,
   POD_STORE_POLICY,
   POLICY_RECORD_ID,
+  PartitionKeyError,
+  PartitionedCollection,
+  PartitionedQuery,
+  PartitionedScan,
   PathEscapeError,
+  PeriodChainError,
   PeriodClosedError,
   PermissionDeniedError,
   PersistedIndexCompensationError,
@@ -1202,6 +1986,7 @@ export {
   PresenceHandle,
   PrivilegeEscalationError,
   Query,
+  QueryExtensionMissingError,
   QuickUnlockStore,
   QuiesceTimeoutError,
   ReadOnlyAtInstantError,
@@ -1226,7 +2011,7 @@ export {
   STATE_VAULT_NAME,
   STRICT_POLICY,
   SYNC_CREDENTIALS_COLLECTION,
-  ScanBuilder,
+  ScanBuilder2 as ScanBuilder,
   SchemaFenceError,
   SchemaLockedError,
   SchemaUpdateError,
@@ -1258,6 +2043,7 @@ export {
   TierWriteRefusedError,
   TiersNotEnabledError,
   TranslatorNotConfiguredError,
+  TraversalCycleError,
   TxCollection,
   TxContext,
   TxVault,
@@ -1268,6 +2054,7 @@ export {
   UnknownLookupKeyError,
   UnknownShardError,
   UnknownStoreKindError,
+  UnsafePatternError,
   UnsupportedIndexOptionError,
   UnsupportedTierCompositionError,
   UserApi,
@@ -1305,6 +2092,7 @@ export {
   buildRecipientKeyringFile,
   burnPaperRecoveryEntry,
   canonicalJson,
+  changeChannelName,
   checkGate,
   classified,
   clearDevUnlock,
@@ -1320,9 +2108,12 @@ export {
   createSession,
   createStore,
   credentialStatus,
+  decodeGeohashBox,
   decryptBytes,
   decryptDeterministic,
   decryptExtractedPartition,
+  defaultChangeChannel,
+  defaultPartitionNamer,
   deleteCredential,
   deleteIntent,
   deleteUserEnvelope,
@@ -1343,7 +2134,9 @@ export {
   dictKey,
   diff,
   diffVault,
+  enableChangeBroadcast,
   enableDevUnlock,
+  encodeGeohash,
   encryptBytes,
   encryptDeterministic,
   enforceScript,
@@ -1360,18 +2153,26 @@ export {
   evaluateImportCapability,
   exactMath,
   executePlan,
+  explainPlan,
   exportAccessibleData,
   findAuthenticator,
   followRedirects,
   formatDiff,
   fuseRetrieval,
   generateULID,
+  geo,
+  boundingBox as geoBoundingBox,
+  coverPrefixes as geoCoverPrefixes,
+  coverSize as geoCoverSize,
+  gridBits as geoGridBits,
+  prefixesForRadius as geoPrefixesForRadius,
   getCredential,
   getIntent,
   hasExportCapability,
   hasImportCapability,
   hasNoydbPodMagic,
   hashEntry,
+  haversineKm,
   i18nText,
   immutableGuard,
   importExternalObjects,
@@ -1386,6 +2187,8 @@ export {
   isDictCollectionName,
   isDictKeyDescriptor,
   isDiscriminant,
+  isGeoDescriptor,
+  isGeoPoint,
   isI18nTextDescriptor,
   isLinkCollectionName,
   isMagicLinkGrantExpired,
@@ -1398,6 +2201,7 @@ export {
   isStaticDictDescriptor,
   isULID,
   isViaFieldSpec,
+  isViaPrefixProbe,
   isZodSchema,
   recoverSecret as keyringRecoverSecret,
   rotateSecret as keyringRotateSecret,
@@ -1435,6 +2239,7 @@ export {
   parseBytes,
   parseIndex,
   parseRsaOaepTlv,
+  partitioned,
   persistDirectoryConfig,
   persistSchemaIfNeeded,
   persistUserVisibility,
@@ -1460,6 +2265,7 @@ export {
   resolveCrdtSnapshot,
   resolveEchoReveal,
   resolveI18nText,
+  resolvePartitionScope,
   resolvePolicy,
   resolveSequenceKey,
   resolveSession,
@@ -1483,6 +2289,7 @@ export {
   sweepBlobIntents,
   tokenize,
   transitionGuard,
+  unionPageProvider,
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
   unwrapMagicLinkGrant,
@@ -1519,6 +2326,7 @@ export {
   withSearch,
   withSequence,
   withTeam,
+  withVectorIndex,
   withdrawAccessibleData,
   wrapPodStore,
   wrapStore,