@klum-db/lobby 0.2.0-pre.26 → 0.2.0-pre.27

package/dist/index.cjs

@@ -30,6 +30,182 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/bundle/uint32.ts
+function readUint32BE(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUint32BE(bytes, offset, value) {
+  bytes[offset] = value >>> 24 & 255;
+  bytes[offset + 1] = value >>> 16 & 255;
+  bytes[offset + 2] = value >>> 8 & 255;
+  bytes[offset + 3] = value & 255;
+}
+var init_uint32 = __esm({
+  "src/bundle/uint32.ts"() {
+    "use strict";
+  }
+});
+
+// src/bundle/multi-bundle.ts
+function encodeMultiBundle(manifest, inner) {
+  validateManifest(manifest);
+  if (manifest.compartments.length !== inner.length) {
+    throw new Error(`multi-bundle: manifest has ${manifest.compartments.length} compartments but ${inner.length} inner bundles were provided.`);
+  }
+  for (let i = 0; i < inner.length; i++) {
+    if (manifest.compartments[i].innerBytes !== inner[i].length) {
+      throw new Error(`multi-bundle: compartment ${i} declares innerBytes ${manifest.compartments[i].innerBytes} but ${inner[i].length} bytes were provided.`);
+    }
+  }
+  const manifestBytes = new TextEncoder().encode(JSON.stringify(manifest));
+  const bodyLen = inner.reduce((n, b) => n + b.length, 0);
+  const out = new Uint8Array(NOYDB_MULTI_BUNDLE_PREFIX_BYTES + manifestBytes.length + bodyLen);
+  out.set(NOYDB_MULTI_BUNDLE_MAGIC, 0);
+  out[4] = NOYDB_MULTI_BUNDLE_VERSION;
+  out[5] = 0;
+  writeUint32BE(out, 6, manifestBytes.length);
+  out.set(manifestBytes, NOYDB_MULTI_BUNDLE_PREFIX_BYTES);
+  let off = NOYDB_MULTI_BUNDLE_PREFIX_BYTES + manifestBytes.length;
+  for (const b of inner) {
+    out.set(b, off);
+    off += b.length;
+  }
+  return out;
+}
+function hasMultiMagic(bytes) {
+  if (bytes.length < NOYDB_MULTI_BUNDLE_MAGIC.length) return false;
+  for (let i = 0; i < NOYDB_MULTI_BUNDLE_MAGIC.length; i++) if (bytes[i] !== NOYDB_MULTI_BUNDLE_MAGIC[i]) return false;
+  return true;
+}
+function validateManifest(parsed) {
+  if (parsed === null || typeof parsed !== "object") throw new Error("multi-bundle manifest must be a JSON object.");
+  const m = parsed;
+  if (m["multiFormatVersion"] !== NOYDB_MULTI_BUNDLE_VERSION) throw new Error(`multi-bundle manifest.multiFormatVersion must be ${NOYDB_MULTI_BUNDLE_VERSION}, got ${String(m["multiFormatVersion"])}.`);
+  if (typeof m["handle"] !== "string" || m["handle"].length === 0) throw new Error("multi-bundle manifest.handle must be a non-empty string.");
+  if (!Array.isArray(m["compartments"])) throw new Error("multi-bundle manifest.compartments must be an array.");
+  const seenHandles = /* @__PURE__ */ new Set();
+  for (const c of m["compartments"]) {
+    if (c === null || typeof c !== "object") throw new Error("multi-bundle compartment must be an object.");
+    const e = c;
+    if (typeof e["handle"] !== "string" || e["handle"].length === 0) throw new Error("multi-bundle compartment.handle must be a non-empty string.");
+    if (seenHandles.has(e["handle"])) {
+      throw new Error(`multi-bundle manifest has a duplicate compartment handle "${e["handle"]}".`);
+    }
+    seenHandles.add(e["handle"]);
+    if (typeof e["innerBytes"] !== "number" || !Number.isInteger(e["innerBytes"]) || e["innerBytes"] < 0) throw new Error("multi-bundle compartment.innerBytes must be a non-negative integer.");
+    if (typeof e["innerSha256"] !== "string" || !/^[0-9a-f]{64}$/.test(e["innerSha256"])) throw new Error("multi-bundle compartment.innerSha256 must be 64-char lowercase hex.");
+  }
+}
+function decodeMultiBundle(bytes) {
+  if (!hasMultiMagic(bytes)) throw new Error("not a NOYDB multi-bundle: missing NDBM magic.");
+  if (bytes.length < NOYDB_MULTI_BUNDLE_PREFIX_BYTES) throw new Error("multi-bundle truncated: shorter than the fixed prefix.");
+  if (bytes[4] !== NOYDB_MULTI_BUNDLE_VERSION) throw new Error(`unsupported multi-bundle version ${String(bytes[4])}.`);
+  const manifestLen = readUint32BE(bytes, 6);
+  const manifestEnd = NOYDB_MULTI_BUNDLE_PREFIX_BYTES + manifestLen;
+  if (manifestEnd > bytes.length) throw new Error("multi-bundle truncated: manifest length overruns the buffer.");
+  const manifestJson = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(NOYDB_MULTI_BUNDLE_PREFIX_BYTES, manifestEnd));
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestJson);
+  } catch (err) {
+    throw new Error(`multi-bundle manifest is not valid JSON: ${err.message}`);
+  }
+  validateManifest(parsed);
+  const inner = [];
+  let off = manifestEnd;
+  for (const c of parsed.compartments) {
+    const end = off + c.innerBytes;
+    if (end > bytes.length) throw new Error(`multi-bundle truncated: compartment "${c.handle}" innerBytes overruns the buffer.`);
+    inner.push(bytes.subarray(off, end));
+    off = end;
+  }
+  if (off !== bytes.length) {
+    throw new Error(`multi-bundle: ${bytes.length - off} trailing byte(s) after the last compartment \u2014 buffer may be corrupt.`);
+  }
+  return { manifest: parsed, inner };
+}
+async function writeMultiVaultBundle(compartments, opts = {}) {
+  if (compartments.length === 0) throw new Error("writeMultiVaultBundle: at least one compartment is required.");
+  const inner = [];
+  const entries = [];
+  for (const c of compartments) {
+    const innerBytes = await (0, import_bundle.writeNoydbBundle)(c.vault, c.bundleOptions ?? {});
+    const header = (0, import_bundle.readNoydbBundleHeader)(innerBytes);
+    const entry = {
+      handle: header.handle,
+      exportedAt: c.exportedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      innerBytes: innerBytes.length,
+      innerSha256: await (0, import_kernel.sha256Hex)(innerBytes)
+    };
+    if (c.roleTag !== void 0) entry.roleTag = c.roleTag;
+    if (c.disclose?.name !== void 0 && c.disclose.name !== false) {
+      entry.name = c.disclose.name === true ? c.vault.name : c.disclose.name;
+    }
+    if (c.disclose?.collections === true) {
+      const names = await c.vault.collections();
+      entry.collections = await Promise.all(
+        names.map(async (n) => ({ name: n, count: await c.vault.collection(n).count() }))
+      );
+    }
+    if (c.disclose?.publicEnvelope === true) {
+      const env = (0, import_hub.readNoydbBundlePublicEnvelope)(innerBytes);
+      if (env !== void 0) entry.publicEnvelope = env;
+    }
+    const fence = await c.vault.schemaFenceState();
+    entry.schemaVersion = fence.currentSchemaVersion;
+    inner.push(innerBytes);
+    entries.push(entry);
+  }
+  const manifest = {
+    multiFormatVersion: NOYDB_MULTI_BUNDLE_VERSION,
+    handle: opts.handle ?? (0, import_kernel.generateULID)(),
+    compartments: entries
+  };
+  return encodeMultiBundle(manifest, inner);
+}
+async function readNoydbBundleManifest(bytes) {
+  if (hasMultiMagic(bytes)) return [...decodeMultiBundle(bytes).manifest.compartments];
+  if ((0, import_hub.hasNoydbBundleMagic)(bytes)) {
+    const header = (0, import_bundle.readNoydbBundleHeader)(bytes);
+    const env = (0, import_hub.readNoydbBundlePublicEnvelope)(bytes);
+    const entry = {
+      handle: header.handle,
+      innerBytes: bytes.length,
+      innerSha256: await (0, import_kernel.sha256Hex)(bytes)
+    };
+    if (env !== void 0) entry.publicEnvelope = env;
+    return [entry];
+  }
+  throw new Error("readNoydbBundleManifest: not a NOYDB bundle (no NDB1 or NDBM magic).");
+}
+function readMultiVaultBundleCompartment(bytes, selector) {
+  if (typeof selector === "number" && !Number.isInteger(selector)) {
+    throw new Error(`readMultiVaultBundleCompartment: numeric selector must be an integer, got ${selector}.`);
+  }
+  if ((0, import_hub.hasNoydbBundleMagic)(bytes) && !hasMultiMagic(bytes)) {
+    const header = (0, import_bundle.readNoydbBundleHeader)(bytes);
+    if (selector === 0 || selector === header.handle) return bytes;
+    throw new Error(`readMultiVaultBundleCompartment: single v1 bundle has only compartment "${header.handle}".`);
+  }
+  const { manifest, inner } = decodeMultiBundle(bytes);
+  const idx = typeof selector === "number" ? selector : manifest.compartments.findIndex((c) => c.handle === selector);
+  if (idx < 0 || idx >= inner.length) throw new Error(`readMultiVaultBundleCompartment: no compartment ${typeof selector === "number" ? `at index ${selector}` : `"${selector}"`}.`);
+  return inner[idx];
+}
+var import_kernel, import_bundle, import_hub, NOYDB_MULTI_BUNDLE_MAGIC, NOYDB_MULTI_BUNDLE_PREFIX_BYTES, NOYDB_MULTI_BUNDLE_VERSION;
+var init_multi_bundle = __esm({
+  "src/bundle/multi-bundle.ts"() {
+    "use strict";
+    import_kernel = require("@noy-db/hub/kernel");
+    import_bundle = require("@noy-db/hub/bundle");
+    import_hub = require("@noy-db/hub");
+    init_uint32();
+    NOYDB_MULTI_BUNDLE_MAGIC = new Uint8Array([78, 68, 66, 77]);
+    NOYDB_MULTI_BUNDLE_PREFIX_BYTES = 10;
+    NOYDB_MULTI_BUNDLE_VERSION = 1;
+  }
+});
+
 // src/interchange/extract-cross-vault.ts
 var extract_cross_vault_exports = {};
 __export(extract_cross_vault_exports, {
@@ -95,7 +271,7 @@ async function walkCrossVaultClosure(openVault, opts) {
     for (const vaultName of batch) {
       const seeds = perVaultSeeds.get(vaultName);
       const v = await openVault(vaultName);
-      const { closure } = await (0, import_bundle.walkClosure)(v, {
+      const { closure } = await (0, import_bundle2.walkClosure)(v, {
         seeds,
         ...opts.maxDepth !== void 0 ? { maxDepth: opts.maxDepth } : {}
       });
@@ -147,20 +323,20 @@ async function extractCrossVaultPartition(openVault, opts) {
   const sealIds = {};
   for (const [vaultName, seeds] of plan.perVaultSeeds) {
     const v = await openVault(vaultName);
-    const { bundleBytes, transferKey, sealId } = await (0, import_bundle.extractPartition)(v, {
+    const { bundleBytes, transferKey, sealId } = await (0, import_bundle2.extractPartition)(v, {
       seeds,
       ...opts.maxDepth !== void 0 ? { maxDepth: opts.maxDepth } : {},
       carrySchemas: opts.carrySchemas ?? true,
       carryLedger: opts.carryLedger ?? false,
       ...opts.compression !== void 0 ? { compression: opts.compression } : {}
     });
-    const header = (0, import_bundle.readNoydbBundleHeader)(bundleBytes);
+    const header = (0, import_bundle2.readNoydbBundleHeader)(bundleBytes);
     const meta = opts.compartmentMeta?.[vaultName];
     const entry = {
       handle: header.handle,
       exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
       innerBytes: bundleBytes.length,
-      innerSha256: await (0, import_kernel.sha256Hex)(bundleBytes)
+      innerSha256: await (0, import_kernel2.sha256Hex)(bundleBytes)
     };
     if (meta?.roleTag !== void 0) entry.roleTag = meta.roleTag;
     if (meta?.disclose?.name !== void 0 && meta.disclose.name !== false) {
@@ -178,18 +354,18 @@ async function extractCrossVaultPartition(openVault, opts) {
     sealIds[vaultName] = sealId;
   }
   const manifest = {
-    multiFormatVersion: import_bundle.NOYDB_MULTI_BUNDLE_VERSION,
-    handle: (0, import_bundle.generateULID)(),
+    multiFormatVersion: NOYDB_MULTI_BUNDLE_VERSION,
+    handle: (0, import_kernel2.generateULID)(),
     compartments
   };
-  return { bundle: (0, import_bundle.encodeMultiBundle)(manifest, inner), transferKeys, sealIds };
+  return { bundle: encodeMultiBundle(manifest, inner), transferKeys, sealIds };
 }
 async function describeCrossVaultExtraction(openVault, opts) {
   const plan = await walkCrossVaultClosure(openVault, opts);
   const compartments = [];
   for (const [vaultName, seeds] of plan.perVaultSeeds) {
     const v = await openVault(vaultName);
-    const preview = await (0, import_bundle.describeExtraction)(v, {
+    const preview = await (0, import_bundle2.describeExtraction)(v, {
       seeds,
       ...opts.maxDepth !== void 0 ? { maxDepth: opts.maxDepth } : {}
     });
@@ -197,12 +373,13 @@ async function describeCrossVaultExtraction(openVault, opts) {
   }
   return { compartments, dangling: plan.dangling };
 }
-var import_bundle, import_kernel, CrossVaultDanglingRefError;
+var import_bundle2, import_kernel2, CrossVaultDanglingRefError;
 var init_extract_cross_vault = __esm({
   "src/interchange/extract-cross-vault.ts"() {
     "use strict";
-    import_bundle = require("@noy-db/hub/bundle");
-    import_kernel = require("@noy-db/hub/kernel");
+    import_bundle2 = require("@noy-db/hub/bundle");
+    import_kernel2 = require("@noy-db/hub/kernel");
+    init_multi_bundle();
     CrossVaultDanglingRefError = class extends Error {
       constructor(dangling) {
         super(
@@ -287,7 +464,7 @@ async function mergeDecryptedRecords(receiver, decrypted, opts) {
     incomingSource.set(coll, srcMap);
     incomingSourceTs.set(coll, stsMap);
   }
-  const diff = await (0, import_hub.diffVault)(receiver, candidate);
+  const diff = await (0, import_hub2.diffVault)(receiver, candidate);
   const byCollection = {};
   const conflicts = [];
   const writes = [];
@@ -403,15 +580,15 @@ async function mergeDecryptedRecords(receiver, decrypted, opts) {
   };
 }
 async function mergeCompartment(receiver, compartmentBytes, opts) {
-  const incoming = await (0, import_bundle2.decryptExtractedPartition)(compartmentBytes, opts.transferKey);
+  const incoming = await (0, import_bundle3.decryptExtractedPartition)(compartmentBytes, opts.transferKey);
   return mergeDecryptedRecords(receiver, incoming, opts);
 }
-var import_hub, import_bundle2, FieldLevelDeferredError;
+var import_hub2, import_bundle3, FieldLevelDeferredError;
 var init_merge_compartment = __esm({
   "src/interchange/merge-compartment.ts"() {
     "use strict";
-    import_hub = require("@noy-db/hub");
-    import_bundle2 = require("@noy-db/hub/bundle");
+    import_hub2 = require("@noy-db/hub");
+    import_bundle3 = require("@noy-db/hub/bundle");
     init_field_authority();
     FieldLevelDeferredError = class extends Error {
       constructor(collection) {
@@ -507,7 +684,7 @@ async function graduate(noydb, docked, opts) {
   await mergeDecryptedRecords(vault, staged, { strategy: "take-incoming", reason: "dock:graduate" });
   let deedSealed = false;
   if (opts.deed) {
-    await (0, import_hub2.createDeedOwner)(noydb._store, opts.vaultName, opts.deed.ownerId, opts.deed.sealingProvider);
+    await (0, import_hub3.createDeedOwner)(noydb._store, opts.vaultName, opts.deed.ownerId, opts.deed.sealingProvider);
     deedSealed = true;
   }
   if (opts.stateVault) {
@@ -527,11 +704,11 @@ async function graduate(noydb, docked, opts) {
     event: { type: "unit-graduated", unitId: docked.unitId, vault: opts.vaultName }
   };
 }
-var import_hub2, UnitGraduationError, ISO_EPOCH;
+var import_hub3, UnitGraduationError, ISO_EPOCH;
 var init_graduate = __esm({
   "src/dock/graduate.ts"() {
     "use strict";
-    import_hub2 = require("@noy-db/hub");
+    import_hub3 = require("@noy-db/hub");
     init_merge_compartment();
     init_stage_records();
     UnitGraduationError = class extends Error {
@@ -561,7 +738,7 @@ __export(surface_exports, {
 async function proposeSurface(smv, def, proposedBy, now) {
   const row = {
     ...def,
-    id: def.id ?? (0, import_kernel2.generateULID)(),
+    id: def.id ?? (0, import_kernel3.generateULID)(),
     status: "proposed",
     proposedBy,
     createdAt: now
@@ -582,7 +759,7 @@ async function exportSurface(source, surface) {
     throw new SurfaceStateError(surface.id, surface.status, "agreed");
   }
   const seeds = Object.fromEntries(surface.collections.map((c) => [c, () => true]));
-  const { bundleBytes, transferKey } = await (0, import_bundle4.extractPartition)(source, {
+  const { bundleBytes, transferKey } = await (0, import_bundle5.extractPartition)(source, {
     seeds,
     maxDepth: 0,
     ...surface.fields ? { fieldProjection: surface.fields } : {},
@@ -620,12 +797,12 @@ async function markSynced(smv, id, now) {
     nextSyncDueAt: now + cadenceMs
   });
 }
-var import_kernel2, import_bundle4, SurfaceNotFoundError, SurfaceStateError, SurfaceCadenceScheduler;
+var import_kernel3, import_bundle5, SurfaceNotFoundError, SurfaceStateError, SurfaceCadenceScheduler;
 var init_surface = __esm({
   "src/interchange/surface.ts"() {
     "use strict";
-    import_kernel2 = require("@noy-db/hub/kernel");
-    import_bundle4 = require("@noy-db/hub/bundle");
+    import_kernel3 = require("@noy-db/hub/kernel");
+    import_bundle5 = require("@noy-db/hub/bundle");
     init_merge_compartment();
     SurfaceNotFoundError = class extends Error {
       name = "SurfaceNotFoundError";
@@ -730,38 +907,38 @@ function canonical(value) {
   return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(obj[k])}`).join(",")}}`;
 }
 async function fingerprintBlueprint(bp) {
-  return (0, import_kernel3.sha256Hex)(new TextEncoder().encode(canonical(bp)));
+  return (0, import_kernel4.sha256Hex)(new TextEncoder().encode(canonical(bp)));
 }
-var import_kernel3;
+var import_kernel4;
 var init_schema_manifest = __esm({
   "src/federation/schema-manifest.ts"() {
     "use strict";
-    import_kernel3 = require("@noy-db/hub/kernel");
+    import_kernel4 = require("@noy-db/hub/kernel");
   }
 });
 
 // src/federation/constants.ts
-var import_hub3;
+var import_hub4;
 var init_constants = __esm({
   "src/federation/constants.ts"() {
     "use strict";
-    import_hub3 = require("@noy-db/hub");
+    import_hub4 = require("@noy-db/hub");
   }
 });
 
 // src/federation/state-vault.ts
 var state_vault_exports = {};
 __export(state_vault_exports, {
-  STATE_VAULT_NAME: () => import_hub3.STATE_VAULT_NAME,
+  STATE_VAULT_NAME: () => import_hub4.STATE_VAULT_NAME,
   StateManagementVault: () => StateManagementVault
 });
-var import_kernel4, REGISTRY, MANIFEST, EVENTS, MIGRATION_STATUS, SURFACES, StateManagementVault;
+var import_kernel5, REGISTRY, MANIFEST, EVENTS, MIGRATION_STATUS, SURFACES, StateManagementVault;
 var init_state_vault = __esm({
   "src/federation/state-vault.ts"() {
     "use strict";
     init_schema_manifest();
     init_constants();
-    import_kernel4 = require("@noy-db/hub/kernel");
+    import_kernel5 = require("@noy-db/hub/kernel");
     init_constants();
     REGISTRY = "vaultRegistry";
     MANIFEST = "schemaManifest";
@@ -791,7 +968,7 @@ var init_state_vault = __esm({
       #surfaces;
       /** Idempotently open the reserved state vault and bind the control-plane collections. */
       static async open(db) {
-        const vault = await db.openVault(import_hub3.STATE_VAULT_NAME);
+        const vault = await db.openVault(import_hub4.STATE_VAULT_NAME);
         return new _StateManagementVault(
           vault.collection(REGISTRY),
           vault.collection(MANIFEST),
@@ -851,7 +1028,7 @@ var init_state_vault = __esm({
        */
       async appendEvent(event) {
         const ts = event.ts ?? Date.now();
-        const id = (0, import_kernel4.generateULID)();
+        const id = (0, import_kernel5.generateULID)();
         await this.#events.put(id, { ...event, id, ts });
       }
       /**
@@ -893,13 +1070,13 @@ var init_state_vault = __esm({
 
 // src/federation/classify-skip.ts
 function classifyShardSkip(err) {
-  return err instanceof import_kernel5.NoAccessError ? "no-grant" : "error";
+  return err instanceof import_kernel6.NoAccessError ? "no-grant" : "error";
 }
-var import_kernel5;
+var import_kernel6;
 var init_classify_skip = __esm({
   "src/federation/classify-skip.ts"() {
     "use strict";
-    import_kernel5 = require("@noy-db/hub/kernel");
+    import_kernel6 = require("@noy-db/hub/kernel");
   }
 });
 
@@ -924,7 +1101,7 @@ async function applyBroadcastLegs(rows, legs) {
   for (const leg of legs) {
     const map = /* @__PURE__ */ new Map();
     for (const rec of await leg.from.list()) {
-      const k = coerceKey((0, import_kernel6.readPath)(rec, leg.on));
+      const k = coerceKey((0, import_kernel7.readPath)(rec, leg.on));
       if (k !== null && !map.has(k)) map.set(k, rec);
     }
     indexes.push({ leg, map });
@@ -932,7 +1109,7 @@ async function applyBroadcastLegs(rows, legs) {
   return rows.map((row) => {
     const out = { ...row };
     for (const { leg, map } of indexes) {
-      const key = coerceKey((0, import_kernel6.readPath)(row, leg.field));
+      const key = coerceKey((0, import_kernel7.readPath)(row, leg.field));
       const match = key === null ? null : map.get(key) ?? null;
       if (match === null && leg.mode === "warn") {
         warnOnceBroadcastMiss(leg.field, leg.as, key ?? "<null>");
@@ -942,11 +1119,11 @@ async function applyBroadcastLegs(rows, legs) {
     return out;
   });
 }
-var import_kernel6, warnedBroadcastKeys;
+var import_kernel7, warnedBroadcastKeys;
 var init_cross_shard_join = __esm({
   "src/federation/cross-shard-join.ts"() {
     "use strict";
-    import_kernel6 = require("@noy-db/hub/kernel");
+    import_kernel7 = require("@noy-db/hub/kernel");
     warnedBroadcastKeys = /* @__PURE__ */ new Set();
   }
 });
@@ -1092,12 +1269,12 @@ var init_insight_auto_push = __esm({
 });
 
 // src/federation/aggregate-across.ts
-var import_kernel7, import_kernel8, CrossVaultAggregation, CrossVaultGroupedAggregation;
+var import_kernel8, import_kernel9, CrossVaultAggregation, CrossVaultGroupedAggregation;
 var init_aggregate_across = __esm({
   "src/federation/aggregate-across.ts"() {
     "use strict";
-    import_kernel7 = require("@noy-db/hub/kernel");
     import_kernel8 = require("@noy-db/hub/kernel");
+    import_kernel9 = require("@noy-db/hub/kernel");
     init_cross_vault_live();
     CrossVaultAggregation = class {
       constructor(src, spec, bind) {
@@ -1110,7 +1287,7 @@ var init_aggregate_across = __esm({
       bind;
       async run(options = {}) {
         const { records, skippedVaults } = await this.src.fanoutRecords(options);
-        return { result: (0, import_kernel7.reduceRecords)(records, this.spec), skippedVaults };
+        return { result: (0, import_kernel8.reduceRecords)(records, this.spec), skippedVaults };
       }
       live(options = {}) {
         if (!this.bind) throw new Error("CrossVaultAggregation: live() requires a LiveBinding \u2014 use ShardedQuery.aggregate()");
@@ -1121,7 +1298,7 @@ var init_aggregate_across = __esm({
           isRelevant: this.bind.isRelevant,
           compute: async () => {
             const { records, skippedVaults } = await src.fanoutRecords(options);
-            return { value: (0, import_kernel7.reduceRecords)(records, spec), skipped: skippedVaults };
+            return { value: (0, import_kernel8.reduceRecords)(records, spec), skipped: skippedVaults };
           },
           initialSnapshot: { value: void 0, skipped: [] },
           ...options.debounceMs !== void 0 ? { debounceMs: options.debounceMs } : {}
@@ -1156,7 +1333,7 @@ var init_aggregate_across = __esm({
       async run(options = {}) {
         const { records, skippedVaults } = await this.src.fanoutRecords(options);
         return {
-          results: (0, import_kernel8.groupAndReduce)(records, this.field, this.spec),
+          results: (0, import_kernel9.groupAndReduce)(records, this.field, this.spec),
           skippedVaults
         };
       }
@@ -1171,7 +1348,7 @@ var init_aggregate_across = __esm({
           compute: async () => {
             const { records, skippedVaults } = await src.fanoutRecords(options);
             return {
-              records: (0, import_kernel8.groupAndReduce)(records, field, spec),
+              records: (0, import_kernel9.groupAndReduce)(records, field, spec),
               skipped: skippedVaults
             };
           },
@@ -1207,28 +1384,28 @@ __export(vault_group_exports, {
 });
 function assertSafePartitionKey(partitionKey) {
   if (partitionKey.length === 0) {
-    throw new import_kernel9.ValidationError("partitionKey must be a non-empty string");
+    throw new import_kernel10.ValidationError("partitionKey must be a non-empty string");
   }
-  if (partitionKey === import_hub3.STATE_VAULT_NAME) {
-    throw new import_kernel9.ReservedVaultNameError(partitionKey);
+  if (partitionKey === import_hub4.STATE_VAULT_NAME) {
+    throw new import_kernel10.ReservedVaultNameError(partitionKey);
   }
   if (!SAFE_PARTITION_KEY.test(partitionKey)) {
-    throw new import_kernel9.ValidationError(
+    throw new import_kernel10.ValidationError(
       `partitionKey "${partitionKey}" contains characters outside [A-Za-z0-9._-]. Map your records to a store-safe key in sharding.keyOf.`
     );
   }
   if (partitionKey.includes(SHARD_SEPARATOR)) {
-    throw new import_kernel9.ValidationError(
+    throw new import_kernel10.ValidationError(
       `partitionKey "${partitionKey}" must not contain "--" \u2014 it is reserved as the shard vault-id separator and would risk shard-id collisions.`
     );
   }
 }
-var import_kernel9, SHARD_SEPARATOR, SAFE_PARTITION_KEY, VaultGroup, ShardedCollection, ShardedQuery, ShardedGroupedQuery;
+var import_kernel10, SHARD_SEPARATOR, SAFE_PARTITION_KEY, VaultGroup, ShardedCollection, ShardedQuery, ShardedGroupedQuery;
 var init_vault_group = __esm({
   "src/federation/vault-group.ts"() {
     "use strict";
     init_state_vault();
-    import_kernel9 = require("@noy-db/hub/kernel");
+    import_kernel10 = require("@noy-db/hub/kernel");
     init_constants();
     init_classify_skip();
     init_cross_shard_join();
@@ -1246,7 +1423,7 @@ var init_vault_group = __esm({
         this.template = template;
         this.migrateOnOpen = migrateOnOpen;
         if (name.includes(SHARD_SEPARATOR)) {
-          throw new import_kernel9.ValidationError(
+          throw new import_kernel10.ValidationError(
             `VaultGroup name "${name}" must not contain "--" (reserved shard vault-id separator).`
           );
         }
@@ -1326,11 +1503,11 @@ var init_vault_group = __esm({
         const vaultId = this.shardVaultId(partitionKey);
         const row = await this.registry.get(this.registryId(partitionKey));
         const provisioned = await this.db._shardVaultProvisioned(vaultId);
-        if (row && !provisioned) throw new import_kernel9.ShardProvisioningError(vaultId, partitionKey);
+        if (row && !provisioned) throw new import_kernel10.ShardProvisioningError(vaultId, partitionKey);
         if (row && provisioned) return this.openShard(partitionKey);
         if (region !== void 0) {
           const backendRegion = this.db._resolveBackend(vaultId).capabilities?.region;
-          if (backendRegion !== region) throw new import_kernel9.DataResidencyError(vaultId, region, backendRegion);
+          if (backendRegion !== region) throw new import_kernel10.DataResidencyError(vaultId, region, backendRegion);
         }
         const vault = await this.db.openVault(vaultId);
         this.template.configure(vault);
@@ -1364,9 +1541,9 @@ var init_vault_group = __esm({
       async shard(partitionKey) {
         const vaultId = this.shardVaultId(partitionKey);
         const row = await this.registry.get(this.registryId(partitionKey));
-        if (!row) throw new import_kernel9.UnknownShardError(partitionKey, this.name);
+        if (!row) throw new import_kernel10.UnknownShardError(partitionKey, this.name);
         const provisioned = await this.db._shardVaultProvisioned(vaultId);
-        if (!provisioned) throw new import_kernel9.ShardProvisioningError(vaultId, partitionKey);
+        if (!provisioned) throw new import_kernel10.ShardProvisioningError(vaultId, partitionKey);
         return this.openShard(partitionKey);
       }
       /** A sharded view over one logical collection across all shards. */
@@ -1387,7 +1564,7 @@ var init_vault_group = __esm({
         const eligible = [];
         versionOk.forEach((row, i) => {
           if (provisioned[i]) eligible.push(row);
-          else skipped.push({ vaultId: row.vaultId, reason: "error", error: new import_kernel9.ShardProvisioningError(row.vaultId, row.partitionKey) });
+          else skipped.push({ vaultId: row.vaultId, reason: "error", error: new import_kernel10.ShardProvisioningError(row.vaultId, row.partitionKey) });
         });
         return { eligible, skipped };
       }
@@ -1424,7 +1601,7 @@ var init_vault_group = __esm({
       withCrossVaultDerivation(spec) {
         const target = spec.target.vault;
         if (target === this.name || target.startsWith(`${this.name}${SHARD_SEPARATOR}`)) {
-          throw new import_kernel9.ValidationError(
+          throw new import_kernel10.ValidationError(
             `withCrossVaultDerivation: target.vault "${target}" is the "${this.name}" group itself or one of its shards \u2014 an Insight summary must target a SEPARATE analytics vault, never write back into client-shard data (it would breach the per-shard DEK boundary). Use a distinct vault name.`
           );
         }
@@ -1529,7 +1706,7 @@ var init_vault_group = __esm({
       async migrateShard(partitionKey) {
         const vaultId = this.shardVaultId(partitionKey);
         const row = await this.registry.get(this.registryId(partitionKey));
-        if (!row) throw new import_kernel9.UnknownShardError(partitionKey, this.name);
+        if (!row) throw new import_kernel10.UnknownShardError(partitionKey, this.name);
         const target = this.template.version;
         const sv = await this.ensureStateVault();
         const base = { vaultId, group: this.name, currentVersion: row.schemaVersion, targetVersion: target };
@@ -1612,7 +1789,7 @@ var init_vault_group = __esm({
         let vault;
         if (!row) {
           if (this.group.sharding.autoCreate === false) {
-            throw new import_kernel9.UnknownShardError(key, this.group.name);
+            throw new import_kernel10.UnknownShardError(key, this.group.name);
           }
           vault = await this.group.createShard(key, this.group.sharding.regionOf?.(record));
         } else {
@@ -1684,7 +1861,7 @@ var init_vault_group = __esm({
           this.group.template.configure(probe);
           for (const leg of this.coPartitionedLegs) {
             if (!probe.resolveRef(this.collectionName, leg.field)) {
-              throw new import_kernel9.CrossShardJoinError(
+              throw new import_kernel10.CrossShardJoinError(
                 `crossShardJoin("${leg.field}"): no ref() declared for "${leg.field}" on collection "${this.collectionName}" in template "${this.group.sharding.vaultTemplate}". Add refs: { ${leg.field}: ref('<target>') } to the template's collection options.`
               );
             }
@@ -1741,7 +1918,7 @@ var init_vault_group = __esm({
       /** @internal — joined queries don't support reactive/aggregate surfaces in v1. */
       assertNoJoinLegs(surface) {
         if (this.coPartitionedLegs.length || this.broadcastLegs.length) {
-          throw new import_kernel9.CrossShardJoinError(
+          throw new import_kernel10.CrossShardJoinError(
             `${surface}() is not supported on a ShardedQuery with crossShardJoin/broadcastJoin legs in v1. Use toArray() for joined cross-shard queries.`
           );
         }
@@ -1807,10 +1984,10 @@ var init_vault_group = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CrossShardJoinError: () => import_kernel11.CrossShardJoinError,
+  CrossShardJoinError: () => import_kernel12.CrossShardJoinError,
   CrossVaultDanglingRefError: () => CrossVaultDanglingRefError,
-  CustodyApi: () => import_hub5.CustodyApi,
-  DataResidencyError: () => import_kernel11.DataResidencyError,
+  CustodyApi: () => import_hub6.CustodyApi,
+  DataResidencyError: () => import_kernel12.DataResidencyError,
   DockedUnit: () => DockedUnit,
   FieldAuthorityPolicyMissingError: () => FieldAuthorityPolicyMissingError,
   FieldLevelDeferredError: () => FieldLevelDeferredError,
@@ -1818,38 +1995,46 @@ __export(index_exports, {
   Lobby: () => Lobby,
   MigrationTransformRequiredError: () => MigrationTransformRequiredError,
   MinVersionError: () => MinVersionError,
-  ReservedVaultNameError: () => import_kernel11.ReservedVaultNameError,
-  ShardProvisioningError: () => import_kernel11.ShardProvisioningError,
+  NOYDB_MULTI_BUNDLE_MAGIC: () => NOYDB_MULTI_BUNDLE_MAGIC,
+  NOYDB_MULTI_BUNDLE_PREFIX_BYTES: () => NOYDB_MULTI_BUNDLE_PREFIX_BYTES,
+  NOYDB_MULTI_BUNDLE_VERSION: () => NOYDB_MULTI_BUNDLE_VERSION,
+  ReservedVaultNameError: () => import_kernel12.ReservedVaultNameError,
+  ShardProvisioningError: () => import_kernel12.ShardProvisioningError,
   SurfaceCadenceScheduler: () => SurfaceCadenceScheduler,
   SurfaceNotFoundError: () => SurfaceNotFoundError,
   SurfaceStateError: () => SurfaceStateError,
   UnitGraduationError: () => UnitGraduationError,
-  UnknownShardError: () => import_kernel11.UnknownShardError,
-  VaultTemplateNotFoundError: () => import_kernel11.VaultTemplateNotFoundError,
+  UnknownShardError: () => import_kernel12.UnknownShardError,
+  VaultTemplateNotFoundError: () => import_kernel12.VaultTemplateNotFoundError,
   agreeSurface: () => agreeSurface,
   applySurface: () => applySurface,
-  createDeedOwner: () => import_hub5.createDeedOwner,
+  createDeedOwner: () => import_hub6.createDeedOwner,
   createLobby: () => createLobby,
+  decodeMultiBundle: () => decodeMultiBundle,
   describeCrossVaultExtraction: () => describeCrossVaultExtraction,
+  encodeMultiBundle: () => encodeMultiBundle,
   exportSurface: () => exportSurface,
   extractCrossVaultPartition: () => extractCrossVaultPartition,
-  isDeedVault: () => import_hub5.isDeedVault,
+  isDeedVault: () => import_hub6.isDeedVault,
   isSurfaceDue: () => isSurfaceDue,
-  liberateVault: () => import_hub5.liberateVault,
+  liberateVault: () => import_hub6.liberateVault,
   listDueSurfaces: () => listDueSurfaces,
-  loadDeedMarker: () => import_hub5.loadDeedMarker,
+  loadDeedMarker: () => import_hub6.loadDeedMarker,
   markSynced: () => markSynced,
   mergeCompartment: () => mergeCompartment,
   mergeDecryptedRecords: () => mergeDecryptedRecords,
   migrateThenMerge: () => migrateThenMerge,
   proposeSurface: () => proposeSurface,
+  readMultiVaultBundleCompartment: () => readMultiVaultBundleCompartment,
+  readNoydbBundleManifest: () => readNoydbBundleManifest,
   resolveFieldAuthority: () => resolveFieldAuthority,
   resolveRecordByFieldAuthority: () => resolveRecordByFieldAuthority,
-  walkCrossVaultClosure: () => walkCrossVaultClosure
+  walkCrossVaultClosure: () => walkCrossVaultClosure,
+  writeMultiVaultBundle: () => writeMultiVaultBundle
 });
 module.exports = __toCommonJS(index_exports);
-var import_kernel10 = require("@noy-db/hub/kernel");
-var import_hub4 = require("@noy-db/hub");
+var import_kernel11 = require("@noy-db/hub/kernel");
+var import_hub5 = require("@noy-db/hub");
 
 // src/dock/docked-unit.ts
 var DockedUnit = class {
@@ -1869,12 +2054,13 @@ var DockedUnit = class {
 };
 
 // src/index.ts
-var import_kernel11 = require("@noy-db/hub/kernel");
+var import_kernel12 = require("@noy-db/hub/kernel");
+init_multi_bundle();
 init_extract_cross_vault();
 init_merge_compartment();
 
 // src/interchange/migrate-then-merge.ts
-var import_bundle3 = require("@noy-db/hub/bundle");
+var import_bundle4 = require("@noy-db/hub/bundle");
 init_merge_compartment();
 init_stage_records();
 init_stage_records();
@@ -1899,7 +2085,7 @@ async function migrateThenMerge(receiver, compartmentBytes, opts) {
     );
   }
   if (fromVersion > toVersion) throw new MinVersionError(fromVersion, toVersion);
-  const incoming = await (0, import_bundle3.decryptExtractedPartition)(compartmentBytes, opts.transferKey);
+  const incoming = await (0, import_bundle4.decryptExtractedPartition)(compartmentBytes, opts.transferKey);
   const transformsByCollection = {};
   const migrationByCollection = {};
   for (const [coll, recs] of Object.entries(incoming)) {
@@ -1922,7 +2108,7 @@ async function migrateThenMerge(receiver, compartmentBytes, opts) {
 
 // src/index.ts
 init_field_authority();
-var import_hub5 = require("@noy-db/hub");
+var import_hub6 = require("@noy-db/hub");
 
 // src/dock/unit-driver.ts
 var InMemoryUnitDriver = class {
@@ -1956,10 +2142,10 @@ var Lobby = class {
   }
   async openVaultGroup(name, opts) {
     const db = this.noydb;
-    if (db.isClosed) throw new import_kernel10.ValidationError("Instance is closed");
-    if (name === import_hub4.STATE_VAULT_NAME) throw new import_kernel10.ReservedVaultNameError(name);
+    if (db.isClosed) throw new import_kernel11.ValidationError("Instance is closed");
+    if (name === import_hub5.STATE_VAULT_NAME) throw new import_kernel11.ReservedVaultNameError(name);
     const template = this.vaultTemplates.get(opts.sharding.vaultTemplate);
-    if (!template) throw new import_kernel10.VaultTemplateNotFoundError(opts.sharding.vaultTemplate);
+    if (!template) throw new import_kernel11.VaultTemplateNotFoundError(opts.sharding.vaultTemplate);
     const { VaultGroup: VaultGroup2 } = await Promise.resolve().then(() => (init_vault_group(), vault_group_exports));
     const { StateManagementVault: StateManagementVault2 } = await Promise.resolve().then(() => (init_state_vault(), state_vault_exports));
     const stateVault = opts.registry ? void 0 : await StateManagementVault2.open(db);
@@ -1978,7 +2164,7 @@ var Lobby = class {
   }
   async openStateManagementVault() {
     const db = this.noydb;
-    if (db.isClosed) throw new import_kernel10.ValidationError("Instance is closed");
+    if (db.isClosed) throw new import_kernel11.ValidationError("Instance is closed");
     const { StateManagementVault: StateManagementVault2 } = await Promise.resolve().then(() => (init_state_vault(), state_vault_exports));
     return StateManagementVault2.open(db);
   }
@@ -2077,6 +2263,9 @@ function createLobby(noydb) {
   Lobby,
   MigrationTransformRequiredError,
   MinVersionError,
+  NOYDB_MULTI_BUNDLE_MAGIC,
+  NOYDB_MULTI_BUNDLE_PREFIX_BYTES,
+  NOYDB_MULTI_BUNDLE_VERSION,
   ReservedVaultNameError,
   ShardProvisioningError,
   SurfaceCadenceScheduler,
@@ -2089,7 +2278,9 @@ function createLobby(noydb) {
   applySurface,
   createDeedOwner,
   createLobby,
+  decodeMultiBundle,
   describeCrossVaultExtraction,
+  encodeMultiBundle,
   exportSurface,
   extractCrossVaultPartition,
   isDeedVault,
@@ -2102,8 +2293,11 @@ function createLobby(noydb) {
   mergeDecryptedRecords,
   migrateThenMerge,
   proposeSurface,
+  readMultiVaultBundleCompartment,
+  readNoydbBundleManifest,
   resolveFieldAuthority,
   resolveRecordByFieldAuthority,
-  walkCrossVaultClosure
+  walkCrossVaultClosure,
+  writeMultiVaultBundle
 });
 //# sourceMappingURL=index.cjs.map