@abloatai/ablo 0.36.0 → 0.37.0

package/dist/storeContract.d.ts

@@ -1,145 +0,0 @@
-/**
- * The framework-neutral store contract. {@link SyncStoreContract} is the minimal
- * store interface the SDK's hooks and mutators are written against, and
- * {@link BaseSyncedStore} is the concrete class that implements it. Framework
- * integrations, such as the React bindings, re-export these types, so a hook can
- * accept any store that satisfies the contract without depending on a particular
- * UI framework.
- *
- * This module is type-only: it has no runtime imports and contributes nothing to
- * the runtime bundle beyond the erased interface declarations.
- */
-import type { Model } from './Model.js';
-import type { ModelScope } from './transaction/types/index.js';
-import type { QueryView, QueryViewOptions } from './views/QueryView.js';
-import type { ViewRegistry } from './views/ViewRegistry.js';
-import type { ParticipantScope } from './sync/participants.js';
-/**
- * A snapshot of the client's synchronization state, shaped for binding to UI.
- * {@link SyncStoreContract.syncStatus} exposes a reactive instance of this, and
- * the `useSyncStatus()` hook reads its fields to render connection and progress
- * indicators.
- */
-export interface SyncStatus {
-    state: 'idle' | 'syncing' | 'error' | 'offline' | 'reconnecting';
-    progress: number;
-    error?: Error;
-    /** When true, the error is a session/auth error requiring re-authentication. */
-    isSessionError: boolean;
-    lastSyncAt?: Date;
-    pendingChanges: number;
-    offlineSince?: Date;
-}
-/**
- * A single locally-originated mutation, observed as it flows through the commit
- * stream. The undo system records these to build its inverse operations: one is
- * emitted per local create, update, delete, or archive. Changes arriving from
- * other participants do not appear here — they apply through a separate path
- * that does not queue mutations. Because `previousData` captures the field
- * values as they were before the edit, each event carries everything needed to
- * derive its inverse, with no separate snapshot step. A store exposes this
- * stream through {@link SyncStoreContract.subscribeLocalMutations}.
- */
-export interface LocalMutation {
-    type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
-    /** The registered name of the mutated model, for example `'Block'`. */
-    modelName: string;
-    modelId: string;
-    /** The new field values, for a create or an update. */
-    data?: Record<string, unknown> | null;
-    /** The field values as they were before the edit. For an update these form
-     *  the inverse patch; for a delete they hold the full row needed to recreate
-     *  it. */
-    previousData?: Record<string, unknown> | null;
-}
-/**
- * The minimal store interface the SDK's hooks and mutators depend on. Provide a
- * concrete store that implements it — {@link BaseSyncedStore} is the built-in
- * implementation — and the hooks work against your store without knowing its
- * exact type. Optional members exist so lightweight test doubles can implement
- * only the parts they exercise.
- */
-export interface SyncStoreContract {
-    /**
-     * Subscribes to the stream of local mutations for undo recording, delivering
-     * each optimistic write before it is acknowledged by the server. See
-     * {@link LocalMutation}. Returns a function that removes the subscription.
-     * This is optional: when a store does not implement it, undo scopes simply
-     * record nothing.
-     */
-    subscribeLocalMutations?(handler: (mutation: LocalMutation) => void): () => void;
-    retrieve(modelClass: abstract new (...args: never[]) => Model, id: string): Model | undefined;
-    queryByClass(modelClass: abstract new (...args: never[]) => Model, options?: {
-        predicate?: (model: Model) => boolean;
-        scope?: ModelScope;
-        orderBy?: keyof Model;
-        order?: 'asc' | 'desc';
-        limit?: number;
-        offset?: number;
-    }): {
-        data: Model[];
-    };
-    /**
-     * Saves one entity, creating it if new or updating it if it already exists.
-     * Calling `save` repeatedly within the same tick is efficient: the writes are
-     * coalesced and persisted, then sent to the server, as a single commit. There
-     * is deliberately no bulk method — issue one `save` per row and let the tick
-     * boundary batch them.
-     *
-     * Pass `skipValidation` on trusted, high-volume paths — bulk import or
-     * hydration, where the data has already been validated — to skip the per-row
-     * schema check, which is a measurable cost at that volume.
-     */
-    save(model: Model, options?: {
-        skipValidation?: boolean;
-    }): Promise<void>;
-    delete(model: Model): Promise<void>;
-    archive(model: Model): Promise<void>;
-    unarchive(model: Model): Promise<void>;
-    /** The in-memory object pool: look up individual entities or collections by
-     *  id or model name, create views, and resolve foreign-key relationships. */
-    pool: {
-        get(id: string): Model | undefined;
-        getByTypeName(typename: string, scope?: ModelScope): Model[];
-        getByForeignKey(modelName: string, fieldName: string, fieldValue: string): Model[];
-        createFromData(data: Record<string, unknown>): Model | null;
-        hasForeignKeyIndex(typename: string, fieldName: string): boolean;
-        createView<T extends Record<string, unknown>>(typename: string, options?: QueryViewOptions<T>): QueryView<T>;
-        viewRegistry: ViewRegistry;
-    };
-    /**
-     * Reactive getters for the current sync state. In the built-in store these
-     * are backed by observable computeds, so reading them inside a reactive
-     * context — an observer component or a reaction — re-runs that context when
-     * the state changes. Code that prefers not to work with the reactivity system
-     * directly can read the same values through the `useSyncStatus()` hook.
-     */
-    readonly isReady: boolean;
-    readonly isSyncing: boolean;
-    readonly isOffline: boolean;
-    readonly isReconnecting: boolean;
-    readonly isError: boolean;
-    readonly hasUnsyncedChanges: boolean;
-    /**
-     * Manages the connection's area of interest — the dynamic set of data it
-     * subscribes to. Call `enterScope` and `leaveScope` to move that interest as
-     * the user navigates between documents, and `pinScope` and `unpinScope` to
-     * keep a scope subscribed while it stays important, such as while a claim is
-     * held. Every scope resolves through the same resolver the claim path uses, so
-     * read subscriptions and write claims always agree on which group they refer
-     * to. These are optional and do nothing until the connection is open.
-     */
-    enterScope?(scope: ParticipantScope, opts?: {
-        hydrate?: boolean;
-    }): Promise<void>;
-    leaveScope?(scope: ParticipantScope): Promise<void>;
-    pinScope?(scope: ParticipantScope): Promise<void>;
-    unpinScope?(scope: ParticipantScope): Promise<void>;
-    /**
-     * The full reactive {@link SyncStatus} record. The `useSyncStatus()` hook
-     * reads its fields — `state`, `progress`, `pendingChanges`, `isSessionError`,
-     * and `error` — to present the current sync state. It is part of the contract
-     * so hooks and test doubles can read or set it directly.
-     */
-    readonly syncStatus: SyncStatus;
-}

package/dist/storeContract.js

@@ -1,12 +0,0 @@
-/**
- * The framework-neutral store contract. {@link SyncStoreContract} is the minimal
- * store interface the SDK's hooks and mutators are written against, and
- * {@link BaseSyncedStore} is the concrete class that implements it. Framework
- * integrations, such as the React bindings, re-export these types, so a hook can
- * accept any store that satisfies the contract without depending on a particular
- * UI framework.
- *
- * This module is type-only: it has no runtime imports and contributes nothing to
- * the runtime bundle beyond the erased interface declarations.
- */
-export {};

package/dist/stores/DatabaseManager.d.ts

@@ -1,107 +0,0 @@
-/**
- * Manages the client-side IndexedDB databases the sync engine keeps in the
- * browser. There are two tiers. A single registry database, `ablo_databases`,
- * records metadata about every workspace database. Each user-and-workspace pair
- * then gets its own data database, named `ablo_<hash>`, that holds the synced
- * rows. {@link DatabaseManager} creates, versions, and deletes both tiers.
- */
-import type { RuntimeContext } from '../RuntimeContext.js';
-export interface DatabaseInfo {
-    name: string;
-    userId: string;
-    workspaceId: string;
-    schemaHash: string;
-    schemaVersion: number;
-    userVersion?: number;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface WorkspaceMetadata {
-    lastSyncId: number;
-    firstSyncId: number;
-    backendDatabaseVersion: number;
-    subscribedSyncGroups: string[];
-    updatedAt: Date;
-    schemaHash?: string;
-    syncGroups?: string[];
-}
-/**
- * DatabaseManager - Manages Ablo's two-tier database architecture
- *
- * Key responsibilities:
- * - Manages ablo_databases (database registry)
- * - Creates workspace-specific databases (ablo_hash)
- * - Handles database migration and versioning
- * - Provides database info and metadata management
- */
-export declare class DatabaseManager {
-    private readonly runtime;
-    private metaDb;
-    private readonly metaDbName;
-    constructor(runtime?: RuntimeContext);
-    /**
-     * Initialize the meta database (ablo_databases)
-     */
-    initializeMetaDatabase(): Promise<void>;
-    /**
-     * Calculate database info for a user/workspace combination
-     */
-    calculateDatabaseInfo(userId: string, workspaceId: string, userVersion?: number): Promise<DatabaseInfo>;
-    /**
-     * Generate deterministic database name
-     */
-    private generateDatabaseName;
-    /**
-     * Register database info in ablo_databases
-     */
-    registerDatabase(info: DatabaseInfo): Promise<void>;
-    /**
-     * Get database info by name
-     */
-    getDatabaseInfo(name: string): Promise<DatabaseInfo | null>;
-    /**
-     * Get all databases for a user
-     */
-    getDatabasesForUser(userId: string): Promise<DatabaseInfo[]>;
-    /**
-     * Open workspace-specific database
-     */
-    openWorkspaceDatabase(dbInfo: DatabaseInfo, createStoresFn?: (db: IDBDatabase, tx: IDBTransaction) => Promise<void>): Promise<IDBDatabase>;
-    /**
-     * Read workspace metadata from __meta table
-     */
-    getWorkspaceMetadata(db: IDBDatabase): Promise<WorkspaceMetadata | null>;
-    /**
-     * Write workspace metadata to __meta table
-     */
-    setWorkspaceMetadata(db: IDBDatabase, metadata: WorkspaceMetadata): Promise<void>;
-    /**
-     * Check if a model is persisted (all instances loaded)
-     */
-    isModelPersisted(db: IDBDatabase, modelName: string): Promise<boolean>;
-    /**
-     * Mark a model as persisted
-     */
-    setModelPersisted(db: IDBDatabase, modelName: string, persisted: boolean): Promise<void>;
-    /**
-     * Get all model persistence states
-     */
-    getAllModelPersistenceStates(db: IDBDatabase): Promise<Record<string, boolean>>;
-    /**
-     * Delete a workspace database
-     */
-    deleteWorkspaceDatabase(dbInfo: DatabaseInfo): Promise<void>;
-    /**
-     * Get comprehensive database statistics
-     */
-    getDatabaseStatistics(): Promise<{
-        metaDatabaseSize: number;
-        totalWorkspaceDatabases: number;
-        databasesByUser: Record<string, number>;
-        schemaVersions: Record<string, number>;
-    }>;
-    /**
-     * Close all database connections
-     */
-    close(): Promise<void>;
-}

package/dist/stores/DatabaseManager.js

@@ -1,388 +0,0 @@
-/**
- * Manages the client-side IndexedDB databases the sync engine keeps in the
- * browser. There are two tiers. A single registry database, `ablo_databases`,
- * records metadata about every workspace database. Each user-and-workspace pair
- * then gets its own data database, named `ablo_<hash>`, that holds the synced
- * rows. {@link DatabaseManager} creates, versions, and deletes both tiers.
- */
-import { globalRuntime } from '../context.js';
-import { openIDBWithTimeout, deleteIDBWithTimeout, IDBOpenTimeoutError, } from './openIDBWithTimeout.js';
-import { AbloConnectionError } from '../transaction/errors.js';
-import { getActiveRegistry, hasActiveRegistry } from '../ModelRegistry.js';
-/**
- * DatabaseManager - Manages Ablo's two-tier database architecture
- *
- * Key responsibilities:
- * - Manages ablo_databases (database registry)
- * - Creates workspace-specific databases (ablo_hash)
- * - Handles database migration and versioning
- * - Provides database info and metadata management
- */
-export class DatabaseManager {
-    runtime;
-    metaDb = null;
-    metaDbName = 'ablo_databases';
-    constructor(runtime = globalRuntime) {
-        this.runtime = runtime;
-    }
-    /**
-     * Initialize the meta database (ablo_databases)
-     */
-    async initializeMetaDatabase() {
-        const open = () => openIDBWithTimeout(this.metaDbName, 1, {
-            onUpgrade: (request) => {
-                const db = request.result;
-                if (!db.objectStoreNames.contains('databases')) {
-                    const store = db.createObjectStore('databases', { keyPath: 'name' });
-                    store.createIndex('userId', 'userId');
-                    store.createIndex('workspaceId', 'workspaceId');
-                    store.createIndex('schemaHash', 'schemaHash');
-                    store.createIndex('updatedAt', 'updatedAt');
-                }
-            },
-        });
-        try {
-            this.metaDb = await open();
-        }
-        catch (error) {
-            // Self-heal a wedged meta DB. When `ablo_databases`'s backing store gets
-            // stuck (a corrupted store, or a leaked connection from a prior
-            // timed-out open), every open of that name hangs with no event and the
-            // app is permanently bricked until the user manually clears site data —
-            // the "open did not resolve within 10000ms" dead end. The registry this
-            // DB holds is rebuildable from the server on the next bootstrap, so it is
-            // safe to delete and re-create. Try exactly once: delete, then re-open.
-            if (!(error instanceof IDBOpenTimeoutError))
-                throw error;
-            this.runtime.logger.debug('[sync-engine] meta DB open timed out — attempting self-heal (delete + retry)', { db: this.metaDbName, reason: error.reason });
-            this.runtime.observability.captureBootstrapFailure(error, {
-                type: 'meta-db-open-timeout',
-            });
-            const deleted = await deleteIDBWithTimeout(this.metaDbName);
-            if (!deleted) {
-                // The delete itself was blocked/stuck — a live connection in another
-                // window or a deadlocked backing store. We cannot recover in-page;
-                // rethrow so the provider surfaces the real (now actionable) error.
-                throw error;
-            }
-            // Fresh store — this open creates `ablo_databases` from scratch.
-            this.metaDb = await open();
-            this.runtime.logger.info('[sync-engine] meta DB self-heal succeeded');
-        }
-    }
-    /**
-     * Calculate database info for a user/workspace combination
-     */
-    async calculateDatabaseInfo(userId, workspaceId, userVersion = 1) {
-        // Get schema hash from the active ModelRegistry
-        const schemaHash = hasActiveRegistry()
-            ? getActiveRegistry().getSchemaHash()
-            : 'no-registry-hash';
-        // Generate database name from userId, workspaceId, and versions
-        const dbName = this.generateDatabaseName(userId, workspaceId, userVersion);
-        // Check if we need to increment schema version
-        const existingInfo = await this.getDatabaseInfo(dbName);
-        let schemaVersion = 1;
-        if (existingInfo && existingInfo.schemaHash !== schemaHash) {
-            schemaVersion = (existingInfo.schemaVersion || 1) + 1;
-        }
-        else if (existingInfo) {
-            schemaVersion = existingInfo.schemaVersion || 1;
-        }
-        // Record the existing databases for this user so duplicates can be detected.
-        const allUserDatabases = await this.getDatabasesForUser(userId);
-        const allIndexedDBs = (await indexedDB.databases?.()) || [];
-        const abloDatabases = allIndexedDBs.filter((db) => db.name?.startsWith('ablo_'));
-        this.runtime.observability.breadcrumb('Database info calculated', 'sync.database', 'info', {
-            dbName,
-            schemaVersion,
-            existingDbCount: allUserDatabases.length,
-            abloDbCount: abloDatabases.length,
-        });
-        return {
-            name: dbName,
-            userId,
-            workspaceId,
-            schemaHash,
-            schemaVersion,
-            userVersion,
-            createdAt: existingInfo?.createdAt ?? new Date(),
-            updatedAt: new Date(),
-        };
-    }
-    /**
-     * Generate deterministic database name
-     */
-    generateDatabaseName(userId, workspaceId, userVersion = 1) {
-        // Combine userId, workspaceId, and userVersion for unique database
-        const combined = `${userId}:${workspaceId}:${userVersion}`;
-        // Hash the combined key into a compact, deterministic identifier.
-        let hash = 0;
-        for (let i = 0; i < combined.length; i++) {
-            hash = (hash << 5) - hash + combined.charCodeAt(i);
-            hash = hash & hash; // Convert to 32bit integer
-        }
-        // Convert to hex and create Ablo-style name
-        const hexHash = Math.abs(hash).toString(16).padStart(8, '0');
-        return `ablo_${hexHash}`;
-    }
-    /**
-     * Register database info in ablo_databases
-     */
-    async registerDatabase(info) {
-        if (!this.metaDb) {
-            throw new AbloConnectionError('Meta database not initialized', {
-                code: 'meta_db_not_initialized',
-            });
-        }
-        return new Promise((resolve, reject) => {
-            const tx = this.metaDb.transaction(['databases'], 'readwrite');
-            const store = tx.objectStore('databases');
-            const request = store.put(info);
-            tx.oncomplete = () => {
-                resolve();
-            };
-            tx.onerror = () => { reject(tx.error); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get database info by name
-     */
-    async getDatabaseInfo(name) {
-        if (!this.metaDb)
-            return null;
-        return new Promise((resolve, reject) => {
-            const tx = this.metaDb.transaction(['databases'], 'readonly');
-            const store = tx.objectStore('databases');
-            const request = store.get(name);
-            request.onsuccess = () => { resolve(request.result ?? null); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get all databases for a user
-     */
-    async getDatabasesForUser(userId) {
-        if (!this.metaDb)
-            return [];
-        return new Promise((resolve, reject) => {
-            const tx = this.metaDb.transaction(['databases'], 'readonly');
-            const store = tx.objectStore('databases');
-            const index = store.index('userId');
-            const request = index.getAll(userId);
-            request.onsuccess = () => { resolve(request.result || []); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Open workspace-specific database
-     */
-    async openWorkspaceDatabase(dbInfo, createStoresFn) {
-        try {
-            return await openIDBWithTimeout(dbInfo.name, dbInfo.schemaVersion, {
-                onUpgrade: (request, event) => {
-                    const db = request.result;
-                    const tx = event.target.transaction;
-                    // IndexedDB rule: only awaits on IndexedDB requests keep an upgrade
-                    // transaction alive. Any other await — a fetch, a timer — commits the
-                    // transaction early, and later operations then throw
-                    // `TransactionInactiveError`. StoreManager.createStores runs only
-                    // synchronous createObjectStore / createIndex calls under an `async`
-                    // keyword, so calling it without awaiting is safe here.
-                    if (createStoresFn && tx) {
-                        try {
-                            void createStoresFn(db, tx).catch((err) => {
-                                this.runtime.observability.captureBootstrapFailure(err, {
-                                    type: 'store-creation',
-                                });
-                            });
-                        }
-                        catch (err) {
-                            this.runtime.observability.captureBootstrapFailure(err, {
-                                type: 'store-creation',
-                            });
-                        }
-                    }
-                },
-            });
-        }
-        catch (error) {
-            this.runtime.observability.captureBootstrapFailure(error, {
-                type: 'database-open',
-            });
-            throw error;
-        }
-    }
-    /**
-     * Read workspace metadata from __meta table
-     */
-    async getWorkspaceMetadata(db) {
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(['__meta'], 'readonly');
-            const store = tx.objectStore('__meta');
-            const request = store.get('metadata');
-            request.onsuccess = () => {
-                const data = request.result;
-                if (!data) {
-                    resolve(null);
-                    return;
-                }
-                const meta = {
-                    lastSyncId: data.lastSyncId ?? 0,
-                    firstSyncId: data.firstSyncId ?? 0,
-                    backendDatabaseVersion: data.backendDatabaseVersion ?? 1,
-                    subscribedSyncGroups: data.subscribedSyncGroups ?? [],
-                    updatedAt: data.updatedAt ? new Date(data.updatedAt) : new Date(),
-                    schemaHash: data.schemaHash,
-                    syncGroups: data.syncGroups,
-                    // Older persisted records may still carry an extra `versions` key
-                    // that is no longer used; it is tolerated by simply not reading it here.
-                };
-                resolve(meta);
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Write workspace metadata to __meta table
-     */
-    async setWorkspaceMetadata(db, metadata) {
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(['__meta'], 'readwrite');
-            const store = tx.objectStore('__meta');
-            const request = store.put(metadata, 'metadata');
-            tx.oncomplete = () => { resolve(); };
-            tx.onerror = () => { reject(tx.error); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Check if a model is persisted (all instances loaded)
-     */
-    async isModelPersisted(db, modelName) {
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(['__meta'], 'readonly');
-            const store = tx.objectStore('__meta');
-            const request = store.get(modelName);
-            request.onsuccess = () => {
-                const data = request.result;
-                resolve(data?.persisted === true);
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Mark a model as persisted
-     */
-    async setModelPersisted(db, modelName, persisted) {
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(['__meta'], 'readwrite');
-            const store = tx.objectStore('__meta');
-            const persistenceData = {
-                persisted,
-                modelName,
-                timestamp: Date.now(),
-                updatedAt: new Date().toISOString(),
-            };
-            const request = store.put(persistenceData, modelName);
-            tx.oncomplete = () => { resolve(); };
-            tx.onerror = () => { reject(tx.error); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get all model persistence states
-     */
-    async getAllModelPersistenceStates(db) {
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(['__meta'], 'readonly');
-            const store = tx.objectStore('__meta');
-            const request = store.getAll();
-            request.onsuccess = () => {
-                const states = {};
-                for (const item of request.result) {
-                    // Skip metadata entry
-                    if (item.key === 'metadata')
-                        continue;
-                    if (item.modelName) {
-                        states[item.modelName] = item.persisted === true;
-                    }
-                }
-                resolve(states);
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Delete a workspace database
-     */
-    async deleteWorkspaceDatabase(dbInfo) {
-        return new Promise((resolve, reject) => {
-            const deleteRequest = indexedDB.deleteDatabase(dbInfo.name);
-            deleteRequest.onsuccess = async () => {
-                // Remove from registry
-                if (this.metaDb) {
-                    const tx = this.metaDb.transaction(['databases'], 'readwrite');
-                    const store = tx.objectStore('databases');
-                    store.delete(dbInfo.name);
-                }
-                resolve();
-            };
-            deleteRequest.onerror = () => {
-                this.runtime.observability.breadcrumb(`Failed to delete workspace database: ${dbInfo.name}`, 'sync.database', 'error');
-                reject(deleteRequest.error);
-            };
-            deleteRequest.onblocked = () => {
-                this.runtime.observability.breadcrumb(`Database deletion blocked: ${dbInfo.name}`, 'sync.database', 'warning');
-                // Could implement retry logic or user notification
-            };
-        });
-    }
-    /**
-     * Get comprehensive database statistics
-     */
-    async getDatabaseStatistics() {
-        if (!this.metaDb) {
-            return {
-                metaDatabaseSize: 0,
-                totalWorkspaceDatabases: 0,
-                databasesByUser: {},
-                schemaVersions: {},
-            };
-        }
-        return new Promise((resolve, reject) => {
-            const tx = this.metaDb.transaction(['databases'], 'readonly');
-            const store = tx.objectStore('databases');
-            const request = store.getAll();
-            request.onsuccess = () => {
-                const databases = request.result;
-                const databasesByUser = {};
-                const schemaVersions = {};
-                for (const db of databases) {
-                    // Count by user
-                    databasesByUser[db.userId] = (databasesByUser[db.userId] ?? 0) + 1;
-                    // Count schema versions
-                    const versionKey = `v${db.schemaVersion}`;
-                    schemaVersions[versionKey] = (schemaVersions[versionKey] ?? 0) + 1;
-                }
-                resolve({
-                    metaDatabaseSize: databases.length,
-                    totalWorkspaceDatabases: databases.length,
-                    databasesByUser,
-                    schemaVersions,
-                });
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Close all database connections
-     */
-    async close() {
-        if (this.metaDb) {
-            this.metaDb.close();
-            this.metaDb = null;
-        }
-    }
-}