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

package/dist/index.js

@@ -1401,13 +1401,13 @@ var init_vault_group = __esm({
     SHARD_SEPARATOR = "--";
     SAFE_PARTITION_KEY = /^[A-Za-z0-9._-]+$/;
     VaultGroup = class {
-      constructor(db, name, registry, sharding, template, migrateOnOpen = false) {
+      constructor(db, name, registry, sharding, template, cutoverOnOpen = false) {
         this.db = db;
         this.name = name;
         this.registry = registry;
         this.sharding = sharding;
         this.template = template;
-        this.migrateOnOpen = migrateOnOpen;
+        this.cutoverOnOpen = cutoverOnOpen;
         if (name.includes(SHARD_SEPARATOR)) {
           throw new ValidationError(
             `VaultGroup name "${name}" must not contain "--" (reserved shard vault-id separator).`
@@ -1419,7 +1419,7 @@ var init_vault_group = __esm({
       registry;
       sharding;
       template;
-      migrateOnOpen;
+      cutoverOnOpen;
       /** @internal — set when the group is managed (no explicit registry). */
       stateVault;
       /** @internal */
@@ -1454,20 +1454,20 @@ var init_vault_group = __esm({
         return rows.filter((r) => r.group === this.name);
       }
       /**
-       * Open an existing shard and apply the template. When `migrateOnOpen` is set
+       * 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
        * runs inline first — so a behind shard never surfaces a stale handle.
        */
       async openShard(partitionKey) {
-        if (this.migrateOnOpen) {
+        if (this.cutoverOnOpen) {
           const row = await this.registry.get(this.registryId(partitionKey));
           if (row && row.schemaVersion < this.template.version) {
-            await this.migrateShard(partitionKey);
+            await this.cutoverShard(partitionKey);
           }
         }
         return this._openShardRaw(partitionKey);
       }
-      /** @internal — open + configure with no migrate-on-open hook (used by the migration path itself to avoid recursion). */
+      /** @internal — open + configure with no cutover-on-open hook (used by the migration path itself to avoid recursion). */
       async _openShardRaw(partitionKey) {
         const vault = await this.db.openVault(this.shardVaultId(partitionKey), { create: false });
         this.template.configure(vault);
@@ -1689,7 +1689,7 @@ var init_vault_group = __esm({
        * Never throws on a cutover failure — it records `status: 'failed'` and
        * returns the row, so a fleet run continues past a bad shard.
        */
-      async migrateShard(partitionKey) {
+      async cutoverShard(partitionKey) {
         const vaultId = this.shardVaultId(partitionKey);
         const row = await this.registry.get(this.registryId(partitionKey));
         if (!row) throw new UnknownShardError(partitionKey, this.name);
@@ -1740,7 +1740,7 @@ var init_vault_group = __esm({
        * - `batchSize` — max shards migrated concurrently per batch (back-pressure).
        *   Default 4. Batches run sequentially; shards within a batch run in parallel.
        */
-      async migrateFleet(options = {}) {
+      async rolloutSchema(options = {}) {
         const target = this.template.version;
         const rows = await this.allRows();
         const cohort = options.cohort;
@@ -1752,7 +1752,7 @@ var init_vault_group = __esm({
         const failed = [];
         for (let i = 0; i < todo.length; i += batchSize) {
           const batch = todo.slice(i, i + batchSize);
-          const settled = await Promise.all(batch.map((r) => this.migrateShard(r.partitionKey)));
+          const settled = await Promise.all(batch.map((r) => this.cutoverShard(r.partitionKey)));
           for (const res of settled) {
             if (res.status === "done") migrated.push(res.vaultId);
             else failed.push({ vaultId: res.vaultId, error: res.error ?? "unknown" });
@@ -1988,6 +1988,68 @@ var DockedUnit = class {
   }
 };
 
+// src/federation/group-inspector.ts
+function groupInspector(group) {
+  let shardIds = /* @__PURE__ */ new Set();
+  const refresh = async () => {
+    const rows = await group.allRows();
+    shardIds = new Set(rows.map((r) => r.vaultId));
+    return rows;
+  };
+  return {
+    async listAccessibleVaults() {
+      const rows = await refresh();
+      return rows.map((r) => ({ id: r.vaultId, role: "owner" }));
+    },
+    async openVault(name) {
+      const vault = await group.db.openVault(name);
+      group.template.configure(vault);
+      return vault;
+    },
+    onAfterWrite(handler) {
+      return group.db.onAfterWrite((event) => {
+        if (shardIds.has(event.vault)) return handler(event);
+      });
+    },
+    onWriteConflict(handler) {
+      return group.db.onWriteConflict((c) => {
+        if (shardIds.has(c.vault)) handler(c);
+      });
+    },
+    get writeQueue() {
+      return group.db.writeQueue;
+    }
+  };
+}
+
+// src/federation/meter-group.ts
+async function meterGroup(group, opts = {}) {
+  const { eligible, skipped } = await group.resolveEligible(
+    opts.minVersion !== void 0 ? { minVersion: opts.minVersion } : {}
+  );
+  const perShard = [];
+  const names = /* @__PURE__ */ new Set();
+  let records = 0;
+  for (const row of eligible) {
+    const vault = await group.shard(row.partitionKey);
+    const collNames = await vault.collections();
+    let shardRecords = 0;
+    for (const n of collNames) {
+      names.add(n);
+      shardRecords += await vault.collection(n).count();
+    }
+    records += shardRecords;
+    perShard.push({
+      vaultId: row.vaultId,
+      partitionKey: row.partitionKey,
+      schemaVersion: row.schemaVersion,
+      collections: collNames.length,
+      records: shardRecords
+    });
+  }
+  return { vaults: eligible.length, collections: names.size, records, perShard, skipped };
+}
+
 // src/index.ts
 init_multi_bundle();
 init_extract_cross_vault();
@@ -2092,7 +2154,7 @@ var Lobby = class {
     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.migrateOnOpen ?? false);
+    const group = new VaultGroup2(db, name, registry, opts.sharding, template, opts.cutoverOnOpen ?? false);
     if (stateVault) {
       group._attachStateVault(stateVault);
       await stateVault.recordManifest(opts.sharding.vaultTemplate, template);
@@ -2224,6 +2286,7 @@ export {
   encodeMultiBundle,
   exportSurface,
   extractCrossVaultPartition,
+  groupInspector,
   isDeedVault,
   isSurfaceDue,
   liberateVault,
@@ -2232,6 +2295,7 @@ export {
   markSynced,
   mergeCompartment,
   mergeDecryptedRecords,
+  meterGroup,
   migrateThenMerge,
   proposeSurface,
   readMultiVaultBundleCompartment,