@abloatai/ablo 0.35.0 → 0.37.0

package/dist/core/StoreManager.js

@@ -1,302 +0,0 @@
-/**
- * Manages the {@link ObjectStore} instances the sync engine keeps in the
- * browser — one per registered model — alongside the single
- * {@link SyncActionStore} for pending changes. It creates each store from the
- * model's metadata, tracks readiness, and provisions the underlying IndexedDB
- * object stores. A model's load strategy — instant or lazy — decides how and
- * when its data is loaded.
- */
-import { ModelRegistry } from '../ModelRegistry.js';
-import { ObjectStore } from '../stores/ObjectStore.js';
-import { SyncActionStore } from '../stores/SyncActionStore.js';
-import { LoadStrategy } from '../transaction/types/index.js';
-import { AbloValidationError } from '../transaction/errors.js';
-/**
- * StoreManager - Central manager for all ObjectStore instances
- *
- * Key responsibilities:
- * - Creates ObjectStore instances for each registered model
- * - Manages store lifecycle and readiness
- * - Provides unified interface for database operations
- * - Handles store-specific optimizations based on load strategies
- */
-export class StoreManager {
-    stores = new Map();
-    /** Strict-durability wrapper for the client write journal and commit outbox. */
-    transactionStore = null;
-    syncactionStore = null;
-    db = null;
-    isInitialized = false;
-    modelRegistry;
-    constructor(modelRegistry) {
-        this.modelRegistry = modelRegistry;
-    }
-    /**
-     * Initialize all stores for registered models
-     */
-    async initializeStores(db) {
-        this.db = db;
-        if (this.isInitialized) {
-            // Idempotent re-entry — harmless, nothing for the consumer to act on → debug.
-            getContext().logger.debug('StoreManager already initialized');
-            return;
-        }
-        getContext().logger.info('Initializing ObjectStore instances for all models');
-        const startTime = performance.now();
-        // Get all registered models
-        const allModels = this.modelRegistry.getRegisteredModelNames();
-        for (const modelName of allModels) {
-            await this.createStoreForModel(modelName);
-        }
-        // Special stores are created during the IDB upgrade, but unlike model
-        // stores they have no registry metadata and therefore need an explicit
-        // runtime wrapper. Outbox acknowledgement must mean disk-backed, so this
-        // store opts into strict durability rather than the cache stores' relaxed
-        // mode.
-        this.transactionStore = new ObjectStore(this.db, '__transactions', '__transactions', { loadStrategy: LoadStrategy.instant }, 'strict');
-        // Initialize SyncactionStore
-        this.syncactionStore = new SyncActionStore(this.db);
-        await this.syncactionStore.initialize();
-        this.isInitialized = true;
-        const duration = performance.now() - startTime;
-        getContext().logger.info('Initialized ObjectStores and SyncactionStore', {
-            count: this.stores.size,
-            ms: duration.toFixed(2),
-        });
-    }
-    /**
-     * Create ObjectStore for a specific model
-     */
-    async createStoreForModel(modelName) {
-        const metadata = this.modelRegistry.getMetadata(modelName);
-        if (!metadata) {
-            throw new AbloValidationError(`No metadata found for model: ${modelName}`, {
-                code: 'store_manager_unknown_model',
-            });
-        }
-        // Use model name directly as store name
-        const storeName = modelName;
-        // Create the ObjectStore. One store type currently serves every load strategy.
-        const store = new ObjectStore(this.db, modelName, storeName, metadata);
-        this.stores.set(modelName, store);
-    }
-    /**
-     * Create stores (tables) in IndexedDB
-     */
-    async createStores(db) {
-        getContext().logger.info('Creating tables for all registered models');
-        for (const modelName of this.modelRegistry.getRegisteredModelNames()) {
-            const storeName = modelName;
-            // Skip if store already exists
-            if (db.objectStoreNames.contains(storeName)) {
-                continue;
-            }
-            getContext().logger.debug('Creating table', { storeName, modelName });
-            // Create object store with id as keyPath
-            const store = db.createObjectStore(storeName, { keyPath: 'id' });
-            // Create indexes for indexed properties
-            const indexedProperties = this.modelRegistry.getIndexedProperties(modelName);
-            for (const propName of indexedProperties) {
-                try {
-                    store.createIndex(propName, propName, { unique: false });
-                    getContext().logger.debug('Created index', { store: storeName, prop: propName });
-                }
-                catch (error) {
-                    // Internal IndexedDB index setup — a miss only affects local query
-                    // speed and isn't consumer-actionable → debug.
-                    getContext().logger.debug('Failed to create index', { store: storeName, prop: propName, error });
-                }
-            }
-        }
-        // Create special tables
-        this.createSpecialTables(db);
-    }
-    /**
-     * Create special tables (sync_action_table, model_table, model_table_partial, __meta, __transactions)
-     */
-    createSpecialTables(db) {
-        // Create sync_action_table for sync actions (delta packets)
-        if (!db.objectStoreNames.contains('sync_action_table')) {
-            const syncActionStore = db.createObjectStore('sync_action_table', { keyPath: 'id' });
-            syncActionStore.createIndex('syncId', 'id');
-            getContext().logger.debug('Created sync_action_table');
-        }
-        // Create __meta table for model persistence state and database metadata
-        if (!db.objectStoreNames.contains('__meta')) {
-            db.createObjectStore('__meta');
-            getContext().logger.debug('Created __meta table');
-        }
-        // Create __transactions table for unsent transactions
-        if (!db.objectStoreNames.contains('__transactions')) {
-            const transactionStore = db.createObjectStore('__transactions', {
-                keyPath: 'id',
-                autoIncrement: false,
-            });
-            // Create indexes for transaction queries
-            transactionStore.createIndex('timestamp', 'timestamp');
-            transactionStore.createIndex('status', 'status');
-            getContext().logger.debug('Created __transactions table');
-        }
-    }
-    /**
-     * Get ObjectStore for a model
-     */
-    getStore(modelName) {
-        if (modelName === '__transactions') {
-            return this.transactionStore ?? undefined;
-        }
-        return this.stores.get(modelName);
-    }
-    /**
-     * Get SyncactionStore instance
-     */
-    getSyncactionStore() {
-        return this.syncactionStore;
-    }
-    /**
-     * Get all stores
-     */
-    getAllStores() {
-        return new Map(this.stores);
-    }
-    /**
-     * Check readiness of all stores
-     */
-    async checkReadinessOfStores() {
-        const readyStores = [];
-        const notReadyStores = [];
-        for (const [modelName, store] of Array.from(this.stores)) {
-            const isReady = await store.checkIsReady();
-            if (isReady) {
-                readyStores.push(modelName);
-            }
-            else {
-                notReadyStores.push(modelName);
-            }
-        }
-        const allReady = notReadyStores.length === 0;
-        getContext().logger.debug('Store readiness', {
-            ready: readyStores.length,
-            total: this.stores.size,
-            notReady: notReadyStores,
-        });
-        return {
-            ready: allReady,
-            readyStores,
-            notReadyStores,
-            totalStores: this.stores.size,
-        };
-    }
-    /**
-     * Reports whether any data store holds at least one record. This is a
-     * cache-validity check: if the stores are empty, the sync cursor
-     * (`lastSyncId`) is meaningless no matter what the metadata says, because the
-     * cursor and the data must travel together — no data means no cursor, which
-     * forces a full bootstrap. To stay cheap it samples up to three stores rather
-     * than scanning them all, and returns true as soon as one has records.
-     */
-    async hasAnyData() {
-        const storeEntries = Array.from(this.stores);
-        // Sample a few stores — don't check all 30+ if the first one has data
-        const samplesToCheck = Math.min(storeEntries.length, 3);
-        for (let i = 0; i < samplesToCheck; i++) {
-            const entry = storeEntries[i];
-            if (!entry)
-                break;
-            const [, store] = entry;
-            try {
-                const count = await store.count();
-                if (count > 0)
-                    return true;
-            }
-            catch {
-                // Store not accessible — treat as empty
-            }
-        }
-        return false;
-    }
-    /**
-     * Get stores by load strategy
-     */
-    getStoresByStrategy(strategy) {
-        const stores = [];
-        for (const [modelName, store] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            if (metadata?.loadStrategy === strategy) {
-                stores.push(store);
-            }
-        }
-        return stores;
-    }
-    /**
-     * Perform maintenance on all stores
-     */
-    async performMaintenance() {
-        getContext().logger.info('Performing maintenance on all stores');
-        const promises = Array.from(this.stores.values()).map((store) => store.performMaintenance());
-        await Promise.all(promises);
-        getContext().logger.info('Store maintenance completed');
-    }
-    /**
-     * Clear all stores
-     */
-    async clearAllStores() {
-        // Lifecycle chatter (logout / identity switch / reset), not a warning.
-        // Logged at `debug` so it stays silent under the default `warn` threshold.
-        getContext().logger.debug('Clearing all stores');
-        const promises = Array.from(this.stores.values()).map((store) => store.clear());
-        await Promise.all(promises);
-        getContext().logger.info('All stores cleared');
-    }
-    /**
-     * Mark all stores as closing to prevent new operations
-     * Called before database connection is closed
-     */
-    markAllStoresAsClosing() {
-        getContext().logger.debug('Marking all stores as closing');
-        for (const store of this.stores.values()) {
-            store.markAsClosing();
-        }
-        this.transactionStore?.markAsClosing();
-        // SyncActionStore is a standalone store that does not extend ObjectStore
-        // and has no markAsClosing equivalent, so it is intentionally skipped here.
-        // If closing-state coordination is ever needed for sync actions, add it
-        // explicitly to SyncActionStore rather than casting to reach a method that
-        // may not exist.
-        getContext().logger.debug('All stores marked as closing');
-    }
-    /**
-     * Get comprehensive statistics
-     */
-    async getComprehensiveStats() {
-        const storeDetails = [];
-        let totalRecords = 0;
-        let readyCount = 0;
-        for (const [modelName, store] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            const storeName = modelName;
-            const ready = await store.checkIsReady();
-            const count = await store.count();
-            if (ready)
-                readyCount++;
-            totalRecords += count;
-            storeDetails.push({
-                modelName,
-                storeName,
-                strategy: metadata.loadStrategy,
-                ready,
-                count,
-            });
-        }
-        return {
-            totalStores: this.stores.size,
-            readiness: {
-                ready: readyCount,
-                notReady: this.stores.size - readyCount,
-            },
-            totalRecords,
-            storeDetails,
-        };
-    }
-}
-import { getContext } from '../context.js';

package/dist/core/ViewRegistry.d.ts

@@ -1,20 +0,0 @@
-/**
- * ViewRegistry — tracks active QueryViews per typename.
- *
- * When the InstanceCache mutates a model, it calls notifyAdded / notifyUpdated /
- * notifyRemoved on the registry, which fans the event out to every active
- * QueryView subscribed to that typename.
- */
-import { type Model } from '../Model.js';
-import type { IncrementalView } from './queryUtils.js';
-export declare class ViewRegistry {
-    private views;
-    register(typename: string, view: IncrementalView): void;
-    unregister(typename: string, view: IncrementalView): void;
-    /** Called by InstanceCache after a model is added to the pool. */
-    notifyAdded(typename: string, model: Model): void;
-    /** Called by InstanceCache after a model is updated in the pool. */
-    notifyUpdated(typename: string, model: Model): void;
-    /** Called by InstanceCache after a model is removed from the pool. */
-    notifyRemoved(typename: string, modelId: string): void;
-}

package/dist/core/ViewRegistry.js

@@ -1,55 +0,0 @@
-/**
- * ViewRegistry — tracks active QueryViews per typename.
- *
- * When the InstanceCache mutates a model, it calls notifyAdded / notifyUpdated /
- * notifyRemoved on the registry, which fans the event out to every active
- * QueryView subscribed to that typename.
- */
-import { modelAsRow } from '../Model.js';
-export class ViewRegistry {
-    views = new Map();
-    register(typename, view) {
-        let set = this.views.get(typename);
-        if (!set) {
-            set = new Set();
-            this.views.set(typename, set);
-        }
-        set.add(view);
-    }
-    unregister(typename, view) {
-        const set = this.views.get(typename);
-        if (!set)
-            return;
-        set.delete(view);
-        if (set.size === 0) {
-            this.views.delete(typename);
-        }
-    }
-    /** Called by InstanceCache after a model is added to the pool. */
-    notifyAdded(typename, model) {
-        const set = this.views.get(typename);
-        if (!set)
-            return;
-        for (const view of set) {
-            view.handleAdded(modelAsRow(model));
-        }
-    }
-    /** Called by InstanceCache after a model is updated in the pool. */
-    notifyUpdated(typename, model) {
-        const set = this.views.get(typename);
-        if (!set)
-            return;
-        for (const view of set) {
-            view.handleUpdated(modelAsRow(model));
-        }
-    }
-    /** Called by InstanceCache after a model is removed from the pool. */
-    notifyRemoved(typename, modelId) {
-        const set = this.views.get(typename);
-        if (!set)
-            return;
-        for (const view of set) {
-            view.handleRemoved(modelId);
-        }
-    }
-}

package/dist/core/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * The framework-extension entry point of this package. Import from here only
- * when you are building on top of the sync engine — wiring your own store and
- * provider stack, writing a sync adapter, or driving a test harness. Everyday
- * application code should use the `Ablo({ schema })` client from the package
- * root instead; the primitives exported here are lower-level building blocks.
- *
- * The surface is deliberately narrow: it exposes only the types and classes an
- * extension actually needs. Anything the engine does not export here is
- * internal and may change.
- */
-export { BaseSyncedStore, type ModelConstructor, type ConcreteModelConstructor, } from '../BaseSyncedStore.js';
-export { SyncClient } from '../SyncClient.js';
-export { Database } from '../Database.js';
-export { InstanceCache, ModelScope } from '../InstanceCache.js';
-/** @deprecated `ObjectPool` was renamed to {@link InstanceCache} — the class is an
- *  identity-map cache of live model instances, not a reuse pool. This alias keeps existing
- *  imports working and will be removed in a future major version. */
-export { InstanceCache as ObjectPool } from '../InstanceCache.js';
-export { Model } from '../Model.js';
-export { LazyReferenceCollection, type LazyCollectionOptions, } from '../LazyReferenceCollection.js';
-export { ModelRegistry, getActiveRegistry, } from '../ModelRegistry.js';
-export { postQuery, type PostQueryOptions } from '../query/client.js';
-export { computeFKDepthPriority } from '../client/schemaConfig.js';
-export type { SyncLogger, SyncObservabilityProvider, MutationExecutor, SessionErrorDetector, OnlineStatusProvider, CommitResult, MutationOperation, } from '../interfaces/index.js';
-export { SyncWebSocket, type SyncDelta, type SyncWebSocketOptions, } from '../sync/SyncWebSocket.js';
-export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
-/** @deprecated `BootstrapHelper` was renamed to {@link BootstrapFetcher}. This alias keeps
- *  existing imports working and will be removed in a future major version. */
-export { BootstrapFetcher as BootstrapHelper } from '../sync/BootstrapFetcher.js';
-export { createClaimStream, type AttachableClaimStream, type ClaimStreamConfig, } from '../sync/createClaimStream.js';
-export { awaitClaimGrant, type GrantTransport, } from '../sync/awaitClaimGrant.js';
-export { LoadStrategy } from '../transaction/types/index.js';

package/dist/core/index.js

@@ -1,48 +0,0 @@
-/**
- * The framework-extension entry point of this package. Import from here only
- * when you are building on top of the sync engine — wiring your own store and
- * provider stack, writing a sync adapter, or driving a test harness. Everyday
- * application code should use the `Ablo({ schema })` client from the package
- * root instead; the primitives exported here are lower-level building blocks.
- *
- * The surface is deliberately narrow: it exposes only the types and classes an
- * extension actually needs. Anything the engine does not export here is
- * internal and may change.
- */
-// The base store class, plus the constructor shapes that subclasses reference.
-export { BaseSyncedStore, } from '../BaseSyncedStore.js';
-// Core infrastructure classes
-export { SyncClient } from '../SyncClient.js';
-export { Database } from '../Database.js';
-export { InstanceCache, ModelScope } from '../InstanceCache.js';
-/** @deprecated `ObjectPool` was renamed to {@link InstanceCache} — the class is an
- *  identity-map cache of live model instances, not a reuse pool. This alias keeps existing
- *  imports working and will be removed in a future major version. */
-export { InstanceCache as ObjectPool } from '../InstanceCache.js';
-export { Model } from '../Model.js';
-export { LazyReferenceCollection, } from '../LazyReferenceCollection.js';
-export { ModelRegistry, getActiveRegistry, } from '../ModelRegistry.js';
-// A lower-level network read primitive. Prefer `ablo.<model>.list(...)` for
-// ordinary reads; reach for this only when writing a custom on-demand loader.
-export { postQuery } from '../query/client.js';
-// Computes a dependency-safe ordering for a set of models by walking their
-// foreign-key relationships, so writes commit parents before children. Used by
-// schema-aware test fixtures and scaffolding tools.
-export { computeFKDepthPriority } from '../client/schemaConfig.js';
-// The sync layer: the WebSocket wrapper and the delta shape it carries. Needed
-// when writing a sync adapter or a multi-participant test harness.
-export { SyncWebSocket, } from '../sync/SyncWebSocket.js';
-export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
-/** @deprecated `BootstrapHelper` was renamed to {@link BootstrapFetcher}. This alias keeps
- *  existing imports working and will be removed in a future major version. */
-export { BootstrapFetcher as BootstrapHelper } from '../sync/BootstrapFetcher.js';
-// The lower-level claim-coordination primitives behind the `ablo.<model>.claim`
-// API. `createClaimStream` builds the announce-and-await machinery on top of a
-// `SyncWebSocket`; `awaitClaimGrant` coordinates fair, first-in-first-out
-// grants. These are for extension code and test harnesses; ordinary
-// application code should use `ablo.<model>.claim`.
-export { createClaimStream, } from '../sync/createClaimStream.js';
-export { awaitClaimGrant, } from '../sync/awaitClaimGrant.js';
-// An enum naming the strategies for loading a model's data. Referenced when
-// registering models in extension code.
-export { LoadStrategy } from '../transaction/types/index.js';

package/dist/core/openIDBWithTimeout.d.ts

@@ -1,65 +0,0 @@
-/**
- * The error raised when opening an IndexedDB database does not complete in a
- * bounded time. {@link openIDBWithTimeout} throws it in two situations: another
- * browser tab is holding an older version of the database open and blocking the
- * upgrade (`reason: 'blocked'`), or the open request produced no result at all
- * within the timeout (`reason: 'timeout'`).
- *
- * The native open request can otherwise hang indefinitely — when a blocking tab
- * never closes its connection, neither the success nor the error callback fires,
- * and any code awaiting the open waits forever. Turning that into a thrown error
- * lets the surrounding application show a recoverable failure instead of an
- * unbreakable spinner.
- */
-export declare class IDBOpenTimeoutError extends Error {
-    readonly dbName: string;
-    readonly reason: 'blocked' | 'timeout';
-    /**
-     * A stable identifier for this failure, independent of the message text. When
-     * this error is wrapped into an {@link AbloError} by `toAbloError`, the string
-     * code is preserved, so error handlers can recognize a wedged-storage failure
-     * and offer a recovery path rather than matching on the message.
-     */
-    readonly code = "storage_open_timeout";
-    constructor(dbName: string, reason: 'blocked' | 'timeout', message: string);
-}
-/**
- * Returns true when a caught value is the storage-open-timeout failure. It
- * detects the failure by its stable `code`, so it still matches after the error
- * has been wrapped into an {@link AbloError} or another error type.
- */
-export declare function isStorageOpenTimeout(err: unknown): boolean;
-export interface OpenIDBOptions {
-    /** Called inside `onupgradeneeded` — mirrors `IDBOpenDBRequest.onupgradeneeded`. */
-    onUpgrade?: (request: IDBOpenDBRequest, event: IDBVersionChangeEvent) => void;
-    /** Max milliseconds to wait for the open request to resolve. Default 10_000. */
-    timeoutMs?: number;
-    /**
-     * Called when another context — a new tab, a page reload after a deploy, or
-     * this package's own {@link deleteIDBWithTimeout} recovery — needs to upgrade
-     * or delete the database and fires a `versionchange` event on this connection.
-     * The connection is always closed first, which is what lets the other
-     * context's upgrade or delete proceed instead of blocking on this one. Provide
-     * this callback to react after that close, for example to prompt the user to
-     * reload. Any error it throws is ignored.
-     */
-    onVersionChange?: () => void;
-}
-export declare function openIDBWithTimeout(name: string, version: number | undefined, options?: OpenIDBOptions): Promise<IDBDatabase>;
-/**
- * Deletes an IndexedDB database within a bounded time — the delete counterpart
- * to {@link openIDBWithTimeout}. It is used to recover from a wedged backing
- * store: when opening a database times out, the caller can delete it and start
- * fresh, which is safe for any database whose contents can be rebuilt on the
- * next load.
- *
- * Like an open request, a native delete can hang indefinitely — it fires a
- * blocked event and waits when another connection still holds the database, and
- * on a truly stuck store it fires no event at all. Both cases become a bounded,
- * resolved result here, so the caller never spins.
- *
- * Resolves to `true` on a clean delete and `false` when the delete was blocked
- * or timed out. Either way the caller can decide whether to retry the open; a
- * delete that did nothing leaves the store no worse off.
- */
-export declare function deleteIDBWithTimeout(name: string, timeoutMs?: number): Promise<boolean>;

package/dist/core/openIDBWithTimeout.js

@@ -1,153 +0,0 @@
-/**
- * The error raised when opening an IndexedDB database does not complete in a
- * bounded time. {@link openIDBWithTimeout} throws it in two situations: another
- * browser tab is holding an older version of the database open and blocking the
- * upgrade (`reason: 'blocked'`), or the open request produced no result at all
- * within the timeout (`reason: 'timeout'`).
- *
- * The native open request can otherwise hang indefinitely — when a blocking tab
- * never closes its connection, neither the success nor the error callback fires,
- * and any code awaiting the open waits forever. Turning that into a thrown error
- * lets the surrounding application show a recoverable failure instead of an
- * unbreakable spinner.
- */
-export class IDBOpenTimeoutError extends Error {
-    dbName;
-    reason;
-    /**
-     * A stable identifier for this failure, independent of the message text. When
-     * this error is wrapped into an {@link AbloError} by `toAbloError`, the string
-     * code is preserved, so error handlers can recognize a wedged-storage failure
-     * and offer a recovery path rather than matching on the message.
-     */
-    code = 'storage_open_timeout';
-    constructor(dbName, reason, message) {
-        super(message);
-        this.dbName = dbName;
-        this.reason = reason;
-        this.name = 'IDBOpenTimeoutError';
-    }
-}
-/**
- * Returns true when a caught value is the storage-open-timeout failure. It
- * detects the failure by its stable `code`, so it still matches after the error
- * has been wrapped into an {@link AbloError} or another error type.
- */
-export function isStorageOpenTimeout(err) {
-    return (typeof err === 'object' &&
-        err !== null &&
-        err.code === 'storage_open_timeout');
-}
-export function openIDBWithTimeout(name, version, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 10_000;
-    return new Promise((resolve, reject) => {
-        const request = version === undefined
-            ? indexedDB.open(name)
-            : indexedDB.open(name, version);
-        let settled = false;
-        const settle = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            fn();
-        };
-        if (options.onUpgrade) {
-            request.onupgradeneeded = (event) => {
-                options.onUpgrade(request, event);
-            };
-        }
-        request.onsuccess = () => {
-            // If we already timed out or were blocked and rejected, this is a late
-            // success: the native open eventually completed after we gave up. The
-            // resulting connection is orphaned — nothing up the stack holds it, so
-            // nothing will close it. A leaked open connection holds an IndexedDB lock
-            // that wedges every later open or delete of this database name, so close
-            // it here to keep a timed-out attempt from poisoning the store.
-            if (settled) {
-                try {
-                    request.result.close();
-                }
-                catch {
-                    // Best-effort — a half-open connection may already be unusable.
-                }
-                return;
-            }
-            const db = request.result;
-            // Required resilience handler per the IndexedDB specification: close this
-            // connection as soon as any other context wants to upgrade or delete the
-            // database. Without it, a connection that ignores `versionchange` blocks
-            // the other context's request indefinitely — a common cause of a database
-            // that stays wedged across reloads. Closing here makes the store release
-            // itself.
-            db.onversionchange = () => {
-                try {
-                    db.close();
-                }
-                catch {
-                    // Already closing/closed — nothing to do.
-                }
-                try {
-                    options.onVersionChange?.();
-                }
-                catch {
-                    // A consumer reaction must never break the close.
-                }
-            };
-            settle(() => { resolve(db); });
-        };
-        request.onerror = () => { settle(() => { reject(request.error); }); };
-        // The critical handler: another tab is blocking us. Native API leaves
-        // the request pending indefinitely; we fail fast with a clear error so
-        // the UI can tell the user to close other tabs.
-        request.onblocked = () => {
-            settle(() => {
-                reject(new IDBOpenTimeoutError(name, 'blocked', `IndexedDB \"${name}\" open blocked — another tab is holding an ` +
-                    `older version. Close other Ablo tabs and reload.`));
-            });
-        };
-        // Catch-all timeout: even without `onblocked`, some browsers in some
-        // storage states hang without firing any event. Bounded wait →
-        // deterministic error.
-        const timer = setTimeout(() => {
-            settle(() => {
-                reject(new IDBOpenTimeoutError(name, 'timeout', `IndexedDB \"${name}\" open did not resolve within ${timeoutMs}ms. ` +
-                    `Storage may be in a bad state — clearing site data and reloading ` +
-                    `usually fixes this.`));
-            });
-        }, timeoutMs);
-    });
-}
-/**
- * Deletes an IndexedDB database within a bounded time — the delete counterpart
- * to {@link openIDBWithTimeout}. It is used to recover from a wedged backing
- * store: when opening a database times out, the caller can delete it and start
- * fresh, which is safe for any database whose contents can be rebuilt on the
- * next load.
- *
- * Like an open request, a native delete can hang indefinitely — it fires a
- * blocked event and waits when another connection still holds the database, and
- * on a truly stuck store it fires no event at all. Both cases become a bounded,
- * resolved result here, so the caller never spins.
- *
- * Resolves to `true` on a clean delete and `false` when the delete was blocked
- * or timed out. Either way the caller can decide whether to retry the open; a
- * delete that did nothing leaves the store no worse off.
- */
-export function deleteIDBWithTimeout(name, timeoutMs = 5_000) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const settle = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve(value);
-        };
-        const request = indexedDB.deleteDatabase(name);
-        request.onsuccess = () => { settle(true); };
-        request.onerror = () => { settle(false); };
-        request.onblocked = () => { settle(false); };
-        const timer = setTimeout(() => { settle(false); }, timeoutMs);
-    });
-}