@klum-db/lobby 0.2.0-pre.31 → 0.2.0-pre.33

package/dist/bin/klum.d.cts

@@ -1,4 +1,4 @@
-import { V as VaultGroup } from '../vault-group-DqEyXbN1.cjs';
+import { V as VaultGroup } from '../vault-group-SfkQJ3CM.cjs';
 import '@noy-db/hub/kernel';
 import '@noy-db/hub';
 import '@noy-db/hub/bundle';

package/dist/bin/klum.d.ts

@@ -1,4 +1,4 @@
-import { V as VaultGroup } from '../vault-group-DqEyXbN1.js';
+import { V as VaultGroup } from '../vault-group-SfkQJ3CM.js';
 import '@noy-db/hub/kernel';
 import '@noy-db/hub';
 import '@noy-db/hub/bundle';

package/dist/index.cjs

@@ -1223,28 +1223,33 @@ var init_insight_auto_push = __esm({
   "src/federation/insight-auto-push.ts"() {
     "use strict";
     InsightAutoPush = class {
-      constructor(recompute, isSource, onError = (err, pk) => console.warn(`[klum-db] insight auto-push failed for shard "${pk}":`, err)) {
+      constructor(recompute, isSource, onError = (err, pk) => console.warn(`[klum-db] insight auto-push failed for shard "${pk}":`, err), debounceMs) {
         this.recompute = recompute;
         this.isSource = isSource;
         this.onError = onError;
+        this.debounceMs = debounceMs;
       }
       recompute;
       isSource;
       onError;
-      /** Partition keys awaiting recompute. */
+      debounceMs;
       dirty = /* @__PURE__ */ new Set();
-      /** The in-flight flush, or null when idle. */
       pending = null;
+      timer = null;
+      resolvePending = null;
+      flushing = false;
       /** Called from a shard's onAfterWrite hook. Marks the shard dirty + schedules a flush. */
       noteWrite(partitionKey, collection) {
         if (!this.isSource(collection)) return;
         this.dirty.add(partitionKey);
-        this.schedule();
+        if (this.debounceMs !== void 0) this.scheduleDebounced();
+        else this.schedule();
       }
       /** Resolve once no flush is pending (drains rescheduled flushes too). */
       async whenSettled() {
         while (this.pending) await this.pending;
       }
+      // ── microtask path (unchanged default) ──
       schedule() {
         if (this.pending) return;
         this.pending = this.runFlush().finally(() => {
@@ -1252,6 +1257,29 @@ var init_insight_auto_push = __esm({
           if (this.dirty.size > 0) this.schedule();
         });
       }
+      // ── debounce path (#13) ──
+      scheduleDebounced() {
+        if (!this.pending) this.pending = new Promise((r) => {
+          this.resolvePending = r;
+        });
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+          this.timer = null;
+          if (this.flushing) return;
+          this.flushing = true;
+          void this.runFlush().finally(() => {
+            this.flushing = false;
+            if (this.dirty.size > 0) {
+              this.scheduleDebounced();
+            } else {
+              const resolve = this.resolvePending;
+              this.resolvePending = null;
+              this.pending = null;
+              resolve?.();
+            }
+          });
+        }, this.debounceMs);
+      }
       async runFlush() {
         await Promise.resolve();
         const pks = [...this.dirty];
@@ -1416,6 +1444,73 @@ var init_aggregate_across = __esm({
   }
 });
 
+// src/federation/retrieve-across.ts
+async function retrieveAcross(group, collectionName, query, opts = {}) {
+  const { eligible, skipped } = await group.resolveEligible({
+    ...opts.minVersion !== void 0 ? { minVersion: opts.minVersion } : {},
+    ...opts.failFast !== void 0 ? { failFast: opts.failFast } : {}
+  });
+  const across = await group.db.queryAcross(
+    eligible.map((r) => r.vaultId),
+    async (vault) => {
+      group.template.configure(vault);
+      const coll = vault.collection(collectionName);
+      let within;
+      if (opts.where?.length) {
+        let q = coll.query();
+        for (const [f, op, v] of opts.where) q = q.where(f, op, v);
+        within = q;
+      }
+      return coll.retrieve(query, {
+        ...opts.mode ? { mode: opts.mode } : {},
+        ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+        ...opts.minScore !== void 0 ? { minScore: opts.minScore } : {},
+        ...opts.fields ? { fields: opts.fields } : {},
+        ...opts.match ? { match: opts.match } : {},
+        ...opts.prefix ? { prefix: opts.prefix } : {},
+        ...opts.snippetWindow !== void 0 ? { snippetWindow: opts.snippetWindow } : {},
+        ...opts.includeRecord ? { includeRecord: true } : {},
+        ...within ? { within } : {}
+      });
+    },
+    { concurrency: opts.concurrency ?? 1, create: false }
+  );
+  const skippedVaults = [...skipped];
+  const perVault = [];
+  for (const r of across) {
+    if (r.error) {
+      if (opts.failFast) throw r.error;
+      skippedVaults.push({ vaultId: r.vault, reason: classifyShardSkip(r.error), error: r.error });
+    } else {
+      perVault.push({ vault: r.vault, hits: r.result });
+    }
+  }
+  const lists = perVault.map((pv) => {
+    if (pv.vault.includes(SEP)) {
+      throw new Error(`retrieveAcross: vault id "${pv.vault}" contains the reserved NUL separator`);
+    }
+    return pv.hits.map((h) => ({ ...h, id: pv.vault + SEP + h.id }));
+  });
+  const fused = (0, import_kernel10.fuseRetrieval)(lists, {
+    ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+    ...opts.rrfK !== void 0 ? { k: opts.rrfK } : {}
+  });
+  const hits = fused.map((h) => {
+    const i = h.id.indexOf(SEP);
+    return { ...h, vault: h.id.slice(0, i), id: h.id.slice(i + 1) };
+  });
+  return { hits, skippedVaults };
+}
+var import_kernel10, SEP;
+var init_retrieve_across = __esm({
+  "src/federation/retrieve-across.ts"() {
+    "use strict";
+    import_kernel10 = require("@noy-db/hub/kernel");
+    init_classify_skip();
+    SEP = "\0";
+  }
+});
+
 // src/federation/vault-group.ts
 var vault_group_exports = {};
 __export(vault_group_exports, {
@@ -1424,49 +1519,55 @@ __export(vault_group_exports, {
   ShardedQuery: () => ShardedQuery,
   VaultGroup: () => VaultGroup
 });
+function autoPushConfig(spec) {
+  if (!spec.autoPush) return null;
+  return spec.autoPush === true ? {} : spec.autoPush;
+}
 function assertSafePartitionKey(partitionKey) {
   if (partitionKey.length === 0) {
-    throw new import_kernel10.ValidationError("partitionKey must be a non-empty string");
+    throw new import_kernel11.ValidationError("partitionKey must be a non-empty string");
   }
   if (partitionKey === import_hub4.STATE_VAULT_NAME) {
-    throw new import_kernel10.ReservedVaultNameError(partitionKey);
+    throw new import_kernel11.ReservedVaultNameError(partitionKey);
   }
   if (!SAFE_PARTITION_KEY.test(partitionKey)) {
-    throw new import_kernel10.ValidationError(
+    throw new import_kernel11.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_kernel10.ValidationError(
+    throw new import_kernel11.ValidationError(
       `partitionKey "${partitionKey}" must not contain "--" \u2014 it is reserved as the shard vault-id separator and would risk shard-id collisions.`
     );
   }
 }
-var import_kernel10, SHARD_SEPARATOR, SAFE_PARTITION_KEY, VaultGroup, ShardedCollection, ShardedQuery, ShardedGroupedQuery;
+var import_kernel11, 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_kernel10 = require("@noy-db/hub/kernel");
+    import_kernel11 = require("@noy-db/hub/kernel");
     init_constants();
     init_classify_skip();
     init_cross_shard_join();
     init_cross_vault_live();
     init_insight_auto_push();
     init_aggregate_across();
+    init_retrieve_across();
     init_partial_reduce();
     SHARD_SEPARATOR = "--";
     SAFE_PARTITION_KEY = /^[A-Za-z0-9._-]+$/;
     VaultGroup = class {
-      constructor(db, name, registry, sharding, template, cutoverOnOpen = false) {
+      constructor(db, name, registry, sharding, template, cutoverOnOpen = false, meta) {
         this.db = db;
         this.name = name;
         this.registry = registry;
         this.sharding = sharding;
         this.template = template;
         this.cutoverOnOpen = cutoverOnOpen;
+        this.meta = meta;
         if (name.includes(SHARD_SEPARATOR)) {
-          throw new import_kernel10.ValidationError(
+          throw new import_kernel11.ValidationError(
             `VaultGroup name "${name}" must not contain "--" (reserved shard vault-id separator).`
           );
         }
@@ -1477,6 +1578,7 @@ var init_vault_group = __esm({
       sharding;
       template;
       cutoverOnOpen;
+      meta;
       /** @internal — set when the group is managed (no explicit registry). */
       stateVault;
       /** @internal */
@@ -1510,6 +1612,30 @@ var init_vault_group = __esm({
         const rows = this.registry.query().toArray();
         return rows.filter((r) => r.group === this.name);
       }
+      /**
+       * Federation-level descriptive metadata (#27): this group's `meta` plus each
+       * member vault's `vaultMeta` (read via `getMeta()`). Best-effort per shard — a
+       * shard that fails to open yields `meta: undefined` for that entry, never
+       * throwing. Member meta is transient per-open (noy-db sets it at `openVault`,
+       * does not persist it); this surfaces whatever each vault was opened with.
+       */
+      async federationMeta() {
+        const rows = await this.allRows();
+        const vaults = await Promise.all(
+          rows.map(async (row) => {
+            let meta;
+            try {
+              const vault = await this.db.openVault(row.vaultId);
+              this.template.configure(vault);
+              meta = vault.getMeta();
+            } catch {
+              meta = void 0;
+            }
+            return { vaultId: row.vaultId, partitionKey: row.partitionKey, meta };
+          })
+        );
+        return { meta: this.meta, vaults };
+      }
       /**
        * Open an existing shard and apply the template. When `cutoverOnOpen` is set
        * (#271) and the shard's registry version is behind the template, its cutover
@@ -1546,11 +1672,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_kernel10.ShardProvisioningError(vaultId, partitionKey);
+        if (row && !provisioned) throw new import_kernel11.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_kernel10.DataResidencyError(vaultId, region, backendRegion);
+          if (backendRegion !== region) throw new import_kernel11.DataResidencyError(vaultId, region, backendRegion);
         }
         const vault = await this.db.openVault(vaultId);
         this.template.configure(vault);
@@ -1584,9 +1710,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_kernel10.UnknownShardError(partitionKey, this.name);
+        if (!row) throw new import_kernel11.UnknownShardError(partitionKey, this.name);
         const provisioned = await this.db._shardVaultProvisioned(vaultId);
-        if (!provisioned) throw new import_kernel10.ShardProvisioningError(vaultId, partitionKey);
+        if (!provisioned) throw new import_kernel11.ShardProvisioningError(vaultId, partitionKey);
         return this.openShard(partitionKey);
       }
       /** A sharded view over one logical collection across all shards. */
@@ -1618,7 +1744,7 @@ var init_vault_group = __esm({
         for (const p of probes) {
           if ("error" in p) skipped.push({ vaultId: p.row.vaultId, reason: "error", error: p.error });
           else if (p.provisioned) eligible.push(p.row);
-          else skipped.push({ vaultId: p.row.vaultId, reason: "error", error: new import_kernel10.ShardProvisioningError(p.row.vaultId, p.row.partitionKey) });
+          else skipped.push({ vaultId: p.row.vaultId, reason: "error", error: new import_kernel11.ShardProvisioningError(p.row.vaultId, p.row.partitionKey) });
         }
         return { eligible, skipped };
       }
@@ -1655,15 +1781,18 @@ 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_kernel10.ValidationError(
+          throw new import_kernel11.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.`
           );
         }
         this.crossVaultDerivations.push(spec);
         if (spec.autoPush && !this.insightAutoPush) {
+          const cfg = autoPushConfig(spec);
           const controller = new InsightAutoPush(
             (pk) => this._recomputeShardInsights(pk),
-            (collection) => this.crossVaultDerivations.some((s) => s.autoPush && s.source === collection)
+            (collection) => this.crossVaultDerivations.some((s) => s.autoPush && s.source === collection),
+            void 0,
+            cfg?.debounceMs
           );
           this.insightAutoPush = controller;
           const prefix = `${this.name}${SHARD_SEPARATOR}`;
@@ -1744,6 +1873,8 @@ var init_vault_group = __esm({
         };
         for (const spec of this.crossVaultDerivations) {
           if (!spec.autoPush) continue;
+          const min = autoPushConfig(spec)?.minVersion;
+          if (min !== void 0 && row.schemaVersion < min) continue;
           const records = await shard.collection(spec.source).list();
           const summary = spec.derive(records, ctx);
           const insight = await this.db.openVault(spec.target.vault);
@@ -1776,7 +1907,7 @@ var init_vault_group = __esm({
       async cutoverShard(partitionKey) {
         const vaultId = this.shardVaultId(partitionKey);
         const row = await this.registry.get(this.registryId(partitionKey));
-        if (!row) throw new import_kernel10.UnknownShardError(partitionKey, this.name);
+        if (!row) throw new import_kernel11.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 };
@@ -1859,7 +1990,7 @@ var init_vault_group = __esm({
         let vault;
         if (!row) {
           if (this.group.sharding.autoCreate === false) {
-            throw new import_kernel10.UnknownShardError(key, this.group.name);
+            throw new import_kernel11.UnknownShardError(key, this.group.name);
           }
           vault = await this.group.createShard(key, this.group.sharding.regionOf?.(record));
         } else {
@@ -1871,6 +2002,17 @@ var init_vault_group = __esm({
       query() {
         return new ShardedQuery(this.group, this.collectionName, []);
       }
+      /**
+       * Cross-vault federated retrieval (#26): scatter-gather across all eligible
+       * shards — each shard runs its own trusted-tier `retrieve()`, then results are
+       * RRF-fused by rank only (no cross-vault statistics cross the DEK boundary).
+       * Every hit carries its originating `vault`. An unreachable, schema-drifted, or
+       * un-indexed shard is skipped (`skippedVaults`); pass `failFast` to re-throw
+       * the first per-shard error instead.
+       */
+      async retrieve(query, opts = {}) {
+        return retrieveAcross(this.group, this.collectionName, query, opts);
+      }
     };
     ShardedQuery = class _ShardedQuery {
       constructor(group, collectionName, clauses, coPartitionedLegs = [], broadcastLegs = []) {
@@ -1931,7 +2073,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_kernel10.CrossShardJoinError(
+              throw new import_kernel11.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.`
               );
             }
@@ -2013,23 +2155,23 @@ var init_vault_group = __esm({
           isRelevant: (e) => e.collection === collectionName && e.vault.startsWith(`${group.name}--`)
         };
       }
-      /** @internal — joined queries don't support reactive/aggregate surfaces in v1. */
-      assertNoJoinLegs(surface) {
-        if (this.coPartitionedLegs.length || this.broadcastLegs.length) {
-          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.`
-          );
-        }
-      }
-      /** Returns a reactive cross-shard live query — a facade over CrossVaultLive. */
+      /**
+       * Returns a reactive cross-shard live query — a facade over CrossVaultLive.
+       *
+       * Joined queries (crossShardJoin / broadcastJoin) are supported (#14): the live
+       * value reflects the fully-joined rows. **v1 limitation:** recomputes only on
+       * writes to the primary (left) collection; writes to a co-partitioned right
+       * collection or a broadcast-dimension collection do NOT trigger a recompute —
+       * re-run the query to pick those up.
+       */
       live(options = {}) {
-        this.assertNoJoinLegs("live");
         const bind = this.liveBinding();
         const core = new CrossVaultLive({
           ...bind,
           compute: async () => {
             const { records, skippedVaults } = await this.fanoutRecords(options);
-            return { records, skipped: skippedVaults };
+            const joined = await applyBroadcastLegs(records, this.broadcastLegs);
+            return { records: joined, skipped: skippedVaults };
           },
           initialSnapshot: { records: [], skipped: [] },
           ...options.debounceMs !== void 0 ? { debounceMs: options.debounceMs } : {}
@@ -2049,14 +2191,28 @@ var init_vault_group = __esm({
           stop: () => core.stop()
         };
       }
+      /**
+       * @internal — the FanoutRecordSource for aggregate surfaces. With no join legs,
+       * returns `this` (partial-reduce-eligible, #8). With join legs, returns a
+       * toArray-backed source (fully-joined rows) and NO fanoutReduce, forcing
+       * central-reduce over the joined rows (partial-reduce can't span the central
+       * broadcast join). Used by scalar `aggregate()` and `ShardedGroupedQuery`.
+       */
+      aggregateSource() {
+        if (!this.coPartitionedLegs.length && !this.broadcastLegs.length) return this;
+        return {
+          fanoutRecords: async (o) => {
+            const { results, skippedVaults } = await this.toArray(o);
+            return { records: results, skippedVaults };
+          }
+        };
+      }
       /** One-shot distributed aggregate — central reduce over all shard records. */
       aggregate(spec) {
-        this.assertNoJoinLegs("aggregate");
-        return new CrossVaultAggregation(this, spec, this.liveBinding());
+        return new CrossVaultAggregation(this.aggregateSource(), spec, this.liveBinding());
       }
       /** Begin a grouped cross-shard aggregate. */
       groupBy(field) {
-        this.assertNoJoinLegs("groupBy");
         return new ShardedGroupedQuery(this, field);
       }
     };
@@ -2069,7 +2225,7 @@ var init_vault_group = __esm({
       field;
       aggregate(spec) {
         return new CrossVaultGroupedAggregation(
-          { fanoutRecords: (o) => this.query.fanoutRecords(o) },
+          this.query.aggregateSource(),
           this.field,
           spec,
           this.query.liveBinding()
@@ -2082,10 +2238,10 @@ var init_vault_group = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CrossShardJoinError: () => import_kernel12.CrossShardJoinError,
+  CrossShardJoinError: () => import_kernel13.CrossShardJoinError,
   CrossVaultDanglingRefError: () => CrossVaultDanglingRefError,
   CustodyApi: () => import_hub6.CustodyApi,
-  DataResidencyError: () => import_kernel12.DataResidencyError,
+  DataResidencyError: () => import_kernel13.DataResidencyError,
   DockedUnit: () => DockedUnit,
   FieldAuthorityPolicyMissingError: () => FieldAuthorityPolicyMissingError,
   FieldLevelDeferredError: () => FieldLevelDeferredError,
@@ -2096,14 +2252,14 @@ __export(index_exports, {
   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,
+  ReservedVaultNameError: () => import_kernel13.ReservedVaultNameError,
+  ShardProvisioningError: () => import_kernel13.ShardProvisioningError,
   SurfaceCadenceScheduler: () => SurfaceCadenceScheduler,
   SurfaceNotFoundError: () => SurfaceNotFoundError,
   SurfaceStateError: () => SurfaceStateError,
   UnitGraduationError: () => UnitGraduationError,
-  UnknownShardError: () => import_kernel12.UnknownShardError,
-  VaultTemplateNotFoundError: () => import_kernel12.VaultTemplateNotFoundError,
+  UnknownShardError: () => import_kernel13.UnknownShardError,
+  VaultTemplateNotFoundError: () => import_kernel13.VaultTemplateNotFoundError,
   agreeSurface: () => agreeSurface,
   applySurface: () => applySurface,
   createDeedOwner: () => import_hub6.createDeedOwner,
@@ -2133,7 +2289,7 @@ __export(index_exports, {
   writeMultiVaultBundle: () => writeMultiVaultBundle
 });
 module.exports = __toCommonJS(index_exports);
-var import_kernel11 = require("@noy-db/hub/kernel");
+var import_kernel12 = require("@noy-db/hub/kernel");
 var import_hub5 = require("@noy-db/hub");
 
 // src/dock/docked-unit.ts
@@ -2216,7 +2372,7 @@ async function meterGroup(group, opts = {}) {
 }
 
 // src/index.ts
-var import_kernel12 = require("@noy-db/hub/kernel");
+var import_kernel13 = require("@noy-db/hub/kernel");
 init_multi_bundle();
 init_extract_cross_vault();
 init_merge_compartment();
@@ -2304,15 +2460,15 @@ var Lobby = class {
   }
   async openVaultGroup(name, opts) {
     const db = this.noydb;
-    if (db.isClosed) throw new import_kernel11.ValidationError("Instance is closed");
-    if (name === import_hub5.STATE_VAULT_NAME) throw new import_kernel11.ReservedVaultNameError(name);
+    if (db.isClosed) throw new import_kernel12.ValidationError("Instance is closed");
+    if (name === import_hub5.STATE_VAULT_NAME) throw new import_kernel12.ReservedVaultNameError(name);
     const template = this.vaultTemplates.get(opts.sharding.vaultTemplate);
-    if (!template) throw new import_kernel11.VaultTemplateNotFoundError(opts.sharding.vaultTemplate);
+    if (!template) throw new import_kernel12.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);
     const registry = opts.registry ?? stateVault.registry;
-    const group = new VaultGroup2(db, name, registry, opts.sharding, template, opts.cutoverOnOpen ?? false);
+    const group = new VaultGroup2(db, name, registry, opts.sharding, template, opts.cutoverOnOpen ?? false, opts.meta);
     if (stateVault) {
       group._attachStateVault(stateVault);
       await stateVault.recordManifest(opts.sharding.vaultTemplate, template);
@@ -2326,7 +2482,7 @@ var Lobby = class {
   }
   async openStateManagementVault() {
     const db = this.noydb;
-    if (db.isClosed) throw new import_kernel11.ValidationError("Instance is closed");
+    if (db.isClosed) throw new import_kernel12.ValidationError("Instance is closed");
     const { StateManagementVault: StateManagementVault2 } = await Promise.resolve().then(() => (init_state_vault(), state_vault_exports));
     return StateManagementVault2.open(db);
   }