zapo-js 0.1.0

package/dist/esm/store/providers/memory/thread.store.js

@@ -0,0 +1,34 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_THREAD_MEMORY_STORE_LIMITS = Object.freeze({
+    threads: 10000
+});
+export class WaThreadMemoryStore {
+    constructor(options = {}) {
+        this.threads = new Map();
+        this.maxThreads = resolvePositive(options.maxThreads, DEFAULT_THREAD_MEMORY_STORE_LIMITS.threads, 'WaThreadMemoryStoreOptions.maxThreads');
+    }
+    async upsert(record) {
+        setBoundedMapEntry(this.threads, record.jid, record, this.maxThreads);
+    }
+    async getByJid(jid) {
+        return this.threads.get(jid) ?? null;
+    }
+    async list(limit) {
+        const normalizedLimit = normalizeQueryLimit(limit, 100);
+        const out = [];
+        for (const thread of this.threads.values()) {
+            out.push(thread);
+            if (out.length >= normalizedLimit) {
+                break;
+            }
+        }
+        return out;
+    }
+    async deleteByJid(jid) {
+        return this.threads.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.threads.clear();
+    }
+}

package/dist/esm/store/providers/sqlite/BaseSqliteStore.js

@@ -0,0 +1,37 @@
+import { openSqliteConnection } from '../../providers/sqlite/connection.js';
+import { ensureSqliteMigrations } from '../../providers/sqlite/migrations.js';
+export class BaseSqliteStore {
+    constructor(options, migrationDomains) {
+        this.options = options;
+        this.migrationDomains = migrationDomains;
+        this.connectionPromise = null;
+    }
+    async getConnection() {
+        if (!this.connectionPromise) {
+            this.connectionPromise = openSqliteConnection(this.options).then((connection) => ensureSqliteMigrations(connection, this.migrationDomains).then(() => connection));
+        }
+        return this.connectionPromise;
+    }
+    async withTransaction(run) {
+        const db = await this.getConnection();
+        db.exec('BEGIN');
+        try {
+            const result = await run(db);
+            db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async destroy() {
+        const connectionPromise = this.connectionPromise;
+        this.connectionPromise = null;
+        if (!connectionPromise) {
+            return;
+        }
+        const connection = await connectionPromise;
+        connection.close();
+    }
+}

package/dist/esm/store/providers/sqlite/appstate.store.js

@@ -0,0 +1,169 @@
+import { APP_STATE_EMPTY_LT_HASH } from '../../../appstate/constants.js';
+import { decodeAppStateCollections, decodeAppStateFingerprint, decodeAppStateSyncKeys, encodeAppStateFingerprint } from '../../../appstate/store/sqlite.js';
+import { keyEpoch, pickActiveSyncKey } from '../../../appstate/utils.js';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { uint8Equal } from '../../../util/bytes.js';
+import { asBytes, asNumber, asString } from '../../../util/coercion.js';
+export class WaAppStateSqliteStore extends BaseSqliteStore {
+    constructor(options) {
+        super(options, ['appState']);
+    }
+    async exportData() {
+        const db = await this.getConnection();
+        const keyRows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const versionRows = db.all(`SELECT collection, version, hash
+             FROM appstate_collection_versions
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const valueRows = db.all(`SELECT collection, index_mac_hex, value_mac
+             FROM appstate_collection_index_values
+             WHERE session_id = ?`, [this.options.sessionId]);
+        return {
+            keys: decodeAppStateSyncKeys(keyRows),
+            collections: decodeAppStateCollections(versionRows, valueRows)
+        };
+    }
+    async upsertSyncKeys(keys) {
+        let inserted = 0;
+        await this.withTransaction((db) => {
+            for (const key of keys) {
+                const existing = db.get(`SELECT key_data
+                     FROM appstate_sync_keys
+                     WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, key.keyId]);
+                if (existing &&
+                    uint8Equal(asBytes(existing.key_data, 'appstate_sync_keys.key_data'), key.keyData)) {
+                    continue;
+                }
+                db.run(`INSERT INTO appstate_sync_keys (
+                        session_id,
+                        key_id,
+                        key_data,
+                        timestamp,
+                        fingerprint,
+                        key_epoch
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(session_id, key_id) DO UPDATE SET
+                        key_data=excluded.key_data,
+                        timestamp=excluded.timestamp,
+                        fingerprint=excluded.fingerprint,
+                        key_epoch=excluded.key_epoch`, [
+                    this.options.sessionId,
+                    key.keyId,
+                    key.keyData,
+                    key.timestamp,
+                    encodeAppStateFingerprint(key.fingerprint),
+                    keyEpoch(key.keyId)
+                ]);
+                inserted += 1;
+            }
+        });
+        return inserted;
+    }
+    async getSyncKey(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        if (!row) {
+            return null;
+        }
+        return {
+            keyId: asBytes(row.key_id, 'appstate_sync_keys.key_id'),
+            keyData: asBytes(row.key_data, 'appstate_sync_keys.key_data'),
+            timestamp: asNumber(row.timestamp, 'appstate_sync_keys.timestamp'),
+            fingerprint: decodeAppStateFingerprint(row.fingerprint)
+        };
+    }
+    async getSyncKeyData(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_data
+             FROM appstate_sync_keys
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        if (!row) {
+            return null;
+        }
+        return asBytes(row.key_data, 'appstate_sync_keys.key_data');
+    }
+    async getActiveSyncKey() {
+        const db = await this.getConnection();
+        const rows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const keys = [];
+        for (const row of rows) {
+            const key = {
+                keyId: asBytes(row.key_id, 'appstate_sync_keys.key_id'),
+                keyData: asBytes(row.key_data, 'appstate_sync_keys.key_data'),
+                timestamp: asNumber(row.timestamp, 'appstate_sync_keys.timestamp'),
+                fingerprint: decodeAppStateFingerprint(row.fingerprint)
+            };
+            keys.push(key);
+        }
+        return pickActiveSyncKey(keys);
+    }
+    async getCollectionState(collection) {
+        const db = await this.getConnection();
+        const versionRow = db.get(`SELECT version, hash
+             FROM appstate_collection_versions
+             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
+        if (!versionRow) {
+            return {
+                version: 0,
+                hash: APP_STATE_EMPTY_LT_HASH,
+                indexValueMap: new Map()
+            };
+        }
+        const valueRows = db.all(`SELECT index_mac_hex, value_mac
+             FROM appstate_collection_index_values
+             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
+        const indexValueMap = new Map();
+        for (const row of valueRows) {
+            indexValueMap.set(asString(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), asBytes(row.value_mac, 'appstate_collection_index_values.value_mac'));
+        }
+        return {
+            version: asNumber(versionRow.version, 'appstate_collection_versions.version'),
+            hash: asBytes(versionRow.hash, 'appstate_collection_versions.hash'),
+            indexValueMap
+        };
+    }
+    async setCollectionStates(updates) {
+        if (updates.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const update of updates) {
+                db.run(`INSERT INTO appstate_collection_versions (
+                        session_id,
+                        collection,
+                        version,
+                        hash
+                    ) VALUES (?, ?, ?, ?)
+                    ON CONFLICT(session_id, collection) DO UPDATE SET
+                        version=excluded.version,
+                        hash=excluded.hash`, [this.options.sessionId, update.collection, update.version, update.hash]);
+                db.run(`DELETE FROM appstate_collection_index_values
+                     WHERE session_id = ? AND collection = ?`, [this.options.sessionId, update.collection]);
+                for (const [indexMacHex, valueMac] of update.indexValueMap.entries()) {
+                    db.run(`INSERT INTO appstate_collection_index_values (
+                            session_id,
+                            collection,
+                            index_mac_hex,
+                            value_mac
+                        ) VALUES (?, ?, ?, ?)`, [this.options.sessionId, update.collection, indexMacHex, valueMac]);
+                }
+            }
+        });
+    }
+    async clear() {
+        await this.withTransaction((db) => {
+            db.run('DELETE FROM appstate_sync_keys WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM appstate_collection_versions WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
+            db.run('DELETE FROM appstate_collection_index_values WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
+        });
+    }
+}

package/dist/esm/store/providers/sqlite/auth.store.js

@@ -0,0 +1,176 @@
+import { proto } from '../../../proto.js';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, toBoolOrUndef } from '../../../util/coercion.js';
+export class WaAuthSqliteStore extends BaseSqliteStore {
+    constructor(options) {
+        super(options, ['auth']);
+    }
+    async load() {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT
+                noise_pub_key,
+                noise_priv_key,
+                registration_id,
+                identity_pub_key,
+                identity_priv_key,
+                signed_prekey_id,
+                signed_prekey_pub_key,
+                signed_prekey_priv_key,
+                signed_prekey_signature,
+                adv_secret_key,
+                signed_identity,
+                me_jid,
+                me_lid,
+                me_display_name,
+                companion_enc_static,
+                platform,
+                server_static_key,
+                server_has_prekeys,
+                routing_info,
+                last_success_ts,
+                props_version,
+                ab_props_version,
+                connection_location,
+                account_creation_ts
+            FROM auth_credentials
+            WHERE session_id = ?`, [this.options.sessionId]);
+        if (!row) {
+            return null;
+        }
+        const signedIdentityBytes = asOptionalBytes(row.signed_identity);
+        return {
+            noiseKeyPair: {
+                pubKey: asBytes(row.noise_pub_key, 'noise_pub_key'),
+                privKey: asBytes(row.noise_priv_key, 'noise_priv_key')
+            },
+            registrationInfo: {
+                registrationId: asNumber(row.registration_id, 'registration_id'),
+                identityKeyPair: {
+                    pubKey: asBytes(row.identity_pub_key, 'identity_pub_key'),
+                    privKey: asBytes(row.identity_priv_key, 'identity_priv_key')
+                }
+            },
+            signedPreKey: {
+                keyId: asNumber(row.signed_prekey_id, 'signed_prekey_id'),
+                keyPair: {
+                    pubKey: asBytes(row.signed_prekey_pub_key, 'signed_prekey_pub_key'),
+                    privKey: asBytes(row.signed_prekey_priv_key, 'signed_prekey_priv_key')
+                },
+                signature: asBytes(row.signed_prekey_signature, 'signed_prekey_signature'),
+                uploaded: false
+            },
+            advSecretKey: asBytes(row.adv_secret_key, 'adv_secret_key'),
+            signedIdentity: signedIdentityBytes
+                ? proto.ADVSignedDeviceIdentity.decode(signedIdentityBytes)
+                : undefined,
+            meJid: asOptionalString(row.me_jid),
+            meLid: asOptionalString(row.me_lid),
+            meDisplayName: asOptionalString(row.me_display_name),
+            companionEncStatic: asOptionalBytes(row.companion_enc_static),
+            platform: asOptionalString(row.platform),
+            serverStaticKey: asOptionalBytes(row.server_static_key),
+            serverHasPreKeys: toBoolOrUndef(row.server_has_prekeys),
+            routingInfo: asOptionalBytes(row.routing_info),
+            lastSuccessTs: asOptionalNumber(row.last_success_ts),
+            propsVersion: asOptionalNumber(row.props_version),
+            abPropsVersion: asOptionalNumber(row.ab_props_version),
+            connectionLocation: asOptionalString(row.connection_location),
+            accountCreationTs: asOptionalNumber(row.account_creation_ts)
+        };
+    }
+    async save(credentials) {
+        await this.withTransaction(async (db) => {
+            db.run(`INSERT INTO auth_credentials (
+                    session_id,
+                    noise_pub_key,
+                    noise_priv_key,
+                    registration_id,
+                    identity_pub_key,
+                    identity_priv_key,
+                    signed_prekey_id,
+                    signed_prekey_pub_key,
+                    signed_prekey_priv_key,
+                    signed_prekey_signature,
+                    adv_secret_key,
+                    signed_identity,
+                    me_jid,
+                    me_lid,
+                    me_display_name,
+                    companion_enc_static,
+                    platform,
+                    server_static_key,
+                    server_has_prekeys,
+                    routing_info,
+                    last_success_ts,
+                    props_version,
+                    ab_props_version,
+                    connection_location,
+                    account_creation_ts
+                ) VALUES (
+                    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+                )
+                ON CONFLICT(session_id) DO UPDATE SET
+                    noise_pub_key=excluded.noise_pub_key,
+                    noise_priv_key=excluded.noise_priv_key,
+                    registration_id=excluded.registration_id,
+                    identity_pub_key=excluded.identity_pub_key,
+                    identity_priv_key=excluded.identity_priv_key,
+                    signed_prekey_id=excluded.signed_prekey_id,
+                    signed_prekey_pub_key=excluded.signed_prekey_pub_key,
+                    signed_prekey_priv_key=excluded.signed_prekey_priv_key,
+                    signed_prekey_signature=excluded.signed_prekey_signature,
+                    adv_secret_key=excluded.adv_secret_key,
+                    signed_identity=excluded.signed_identity,
+                    me_jid=excluded.me_jid,
+                    me_lid=excluded.me_lid,
+                    me_display_name=excluded.me_display_name,
+                    companion_enc_static=excluded.companion_enc_static,
+                    platform=excluded.platform,
+                    server_static_key=excluded.server_static_key,
+                    server_has_prekeys=excluded.server_has_prekeys,
+                    routing_info=excluded.routing_info,
+                    last_success_ts=excluded.last_success_ts,
+                    props_version=excluded.props_version,
+                    ab_props_version=excluded.ab_props_version,
+                    connection_location=excluded.connection_location,
+                    account_creation_ts=excluded.account_creation_ts`, [
+                this.options.sessionId,
+                credentials.noiseKeyPair.pubKey,
+                credentials.noiseKeyPair.privKey,
+                credentials.registrationInfo.registrationId,
+                credentials.registrationInfo.identityKeyPair.pubKey,
+                credentials.registrationInfo.identityKeyPair.privKey,
+                credentials.signedPreKey.keyId,
+                credentials.signedPreKey.keyPair.pubKey,
+                credentials.signedPreKey.keyPair.privKey,
+                credentials.signedPreKey.signature,
+                credentials.advSecretKey,
+                credentials.signedIdentity
+                    ? proto.ADVSignedDeviceIdentity.encode(credentials.signedIdentity).finish()
+                    : null,
+                credentials.meJid ?? null,
+                credentials.meLid ?? null,
+                credentials.meDisplayName ?? null,
+                credentials.companionEncStatic ?? null,
+                credentials.platform ?? null,
+                credentials.serverStaticKey ?? null,
+                credentials.serverHasPreKeys === undefined
+                    ? null
+                    : credentials.serverHasPreKeys
+                        ? 1
+                        : 0,
+                credentials.routingInfo ?? null,
+                credentials.lastSuccessTs ?? null,
+                credentials.propsVersion ?? null,
+                credentials.abPropsVersion ?? null,
+                credentials.connectionLocation ?? null,
+                credentials.accountCreationTs ?? null
+            ]);
+        });
+    }
+    async clear() {
+        await this.withTransaction(async (db) => {
+            db.run('DELETE FROM auth_credentials WHERE session_id = ?', [this.options.sessionId]);
+        });
+    }
+}

package/dist/esm/store/providers/sqlite/connection.js

@@ -0,0 +1,240 @@
+import { toSafeNumber } from '../../../util/primitives.js';
+import { isBunRuntime } from '../../../util/runtime.js';
+const BETTER_SQLITE3_MODULE = 'better-sqlite3';
+const BUN_SQLITE_MODULE = 'bun:sqlite';
+const SQLITE_PRAGMA_TOKEN_PATTERN = /^[A-Za-z0-9_+-]+$/;
+const DEFAULT_SQLITE_PRAGMAS = Object.freeze({
+    journal_mode: 'WAL',
+    synchronous: 'normal',
+    busy_timeout: 5000
+});
+const ALLOWED_SQLITE_PRAGMAS = {
+    auto_vacuum: 'token_or_int',
+    busy_timeout: 'int',
+    cache_size: 'int',
+    foreign_keys: 'token_or_int',
+    journal_mode: 'token',
+    journal_size_limit: 'int',
+    legacy_alter_table: 'token_or_int',
+    locking_mode: 'token',
+    mmap_size: 'int',
+    page_size: 'int',
+    recursive_triggers: 'token_or_int',
+    secure_delete: 'token_or_int',
+    synchronous: 'token_or_int',
+    temp_store: 'token_or_int',
+    wal_autocheckpoint: 'int'
+};
+function asConstructor(loaded) {
+    if (typeof loaded === 'function') {
+        return loaded;
+    }
+    if (loaded && typeof loaded === 'object') {
+        const candidate = loaded.default;
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+    }
+    throw new Error('invalid sqlite driver export');
+}
+function statementFor(db, sql) {
+    const prepare = db.prepare ?? db.query;
+    if (!prepare) {
+        throw new Error('sqlite driver does not expose prepare/query method');
+    }
+    const statement = prepare.call(db, sql);
+    if (!statement ||
+        typeof statement.run !== 'function' ||
+        typeof statement.get !== 'function' ||
+        typeof statement.all !== 'function') {
+        throw new Error('invalid sqlite statement API');
+    }
+    return statement;
+}
+function wrapConnection(db, driver, onClose) {
+    const statementCache = new Map();
+    const cachedStatementFor = (sql) => {
+        const cached = statementCache.get(sql);
+        if (cached) {
+            return cached;
+        }
+        const statement = statementFor(db, sql);
+        statementCache.set(sql, statement);
+        return statement;
+    };
+    return {
+        driver,
+        exec(sql) {
+            db.exec(sql);
+        },
+        run(sql, params) {
+            const statement = cachedStatementFor(sql);
+            if (!params || params.length === 0) {
+                statement.run();
+                return;
+            }
+            statement.run(...params);
+        },
+        get(sql, params) {
+            const statement = cachedStatementFor(sql);
+            const row = !params || params.length === 0 ? statement.get() : statement.get(...params);
+            return row ?? null;
+        },
+        all(sql, params) {
+            const statement = cachedStatementFor(sql);
+            const rows = !params || params.length === 0 ? statement.all() : statement.all(...params);
+            return Array.isArray(rows) ? rows : [];
+        },
+        close() {
+            statementCache.clear();
+            try {
+                db.close();
+            }
+            finally {
+                onClose?.();
+            }
+        }
+    };
+}
+function pragmaEntries(options) {
+    return Object.entries(mergePragmas(options.pragmas));
+}
+function mergePragmas(pragmas) {
+    return {
+        ...DEFAULT_SQLITE_PRAGMAS,
+        ...(pragmas ?? {})
+    };
+}
+const ALLOWED_SQLITE_PRAGMA_LIST = Object.keys(ALLOWED_SQLITE_PRAGMAS).sort().join(', ');
+function normalizePragmaKey(rawKey) {
+    const key = rawKey.trim().toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(ALLOWED_SQLITE_PRAGMAS, key)) {
+        throw new Error(`unsupported sqlite pragma "${rawKey}". Allowed pragmas: ${ALLOWED_SQLITE_PRAGMA_LIST}`);
+    }
+    return key;
+}
+function normalizePragmaToken(key, rawValue) {
+    const value = rawValue.trim();
+    if (value.length === 0 || !SQLITE_PRAGMA_TOKEN_PATTERN.test(value)) {
+        throw new Error(`invalid sqlite pragma "${key}" value "${rawValue}". Allowed token pattern: ${SQLITE_PRAGMA_TOKEN_PATTERN}`);
+    }
+    return value;
+}
+function normalizePragmaValue(key, rawValue) {
+    const kind = ALLOWED_SQLITE_PRAGMAS[key];
+    if (kind === 'int') {
+        if (typeof rawValue !== 'number') {
+            throw new Error(`sqlite pragma "${key}" must be a number`);
+        }
+        return String(toSafeNumber(rawValue, `sqlite pragma "${key}"`));
+    }
+    if (kind === 'token') {
+        if (typeof rawValue !== 'string') {
+            throw new Error(`sqlite pragma "${key}" must be a string token`);
+        }
+        return normalizePragmaToken(key, rawValue);
+    }
+    if (typeof rawValue === 'number') {
+        return String(toSafeNumber(rawValue, `sqlite pragma "${key}"`));
+    }
+    return normalizePragmaToken(key, rawValue);
+}
+function applyPragmas(db, options) {
+    for (const [rawKey, rawValue] of pragmaEntries(options)) {
+        const key = normalizePragmaKey(rawKey);
+        const value = normalizePragmaValue(key, rawValue);
+        const statement = `${key}=${value}`;
+        if (db.pragma) {
+            db.pragma(statement);
+            continue;
+        }
+        db.exec(`PRAGMA ${statement}`);
+    }
+}
+function closeDatabaseSafely(db) {
+    try {
+        db.close();
+    }
+    catch {
+        return;
+    }
+}
+async function openBetterSqlite(options, onClose) {
+    let loaded;
+    try {
+        loaded = await import(BETTER_SQLITE3_MODULE);
+    }
+    catch {
+        throw new Error('optional dependency "better-sqlite3" is not installed. Install with: npm i better-sqlite3');
+    }
+    const Database = asConstructor(loaded);
+    const db = new Database(options.path);
+    try {
+        applyPragmas(db, options);
+    }
+    catch (error) {
+        closeDatabaseSafely(db);
+        throw error;
+    }
+    return wrapConnection(db, 'better-sqlite3', onClose);
+}
+async function openBunSqlite(options, onClose) {
+    let loaded;
+    try {
+        loaded = await import(BUN_SQLITE_MODULE);
+    }
+    catch {
+        throw new Error('bun runtime sqlite module "bun:sqlite" is unavailable. Run this in Bun or set storage.sqlite.driver to "better-sqlite3".');
+    }
+    if (!loaded || typeof loaded !== 'object') {
+        throw new Error('invalid bun sqlite module export');
+    }
+    const ctor = loaded.Database;
+    if (typeof ctor !== 'function') {
+        throw new Error('invalid bun sqlite module export');
+    }
+    const db = new ctor(options.path);
+    try {
+        applyPragmas(db, options);
+    }
+    catch (error) {
+        closeDatabaseSafely(db);
+        throw error;
+    }
+    return wrapConnection(db, 'bun', onClose);
+}
+function resolveDriver(requested) {
+    if (requested && requested !== 'auto') {
+        return requested;
+    }
+    return isBunRuntime() ? 'bun' : 'better-sqlite3';
+}
+export async function openSqliteConnection(options) {
+    const driver = resolveDriver(options.driver);
+    const normalizedOptions = {
+        ...options,
+        driver,
+        pragmas: mergePragmas(options.pragmas)
+    };
+    const cacheKey = `${driver}|${options.path}|${Object.entries(normalizedOptions.pragmas ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(';')}`;
+    const cached = SQLITE_CONNECTION_CACHE.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const onClose = () => {
+        SQLITE_CONNECTION_CACHE.delete(cacheKey);
+    };
+    const created = driver === 'bun'
+        ? openBunSqlite(normalizedOptions, onClose)
+        : openBetterSqlite(normalizedOptions, onClose);
+    const guarded = created.catch((error) => {
+        SQLITE_CONNECTION_CACHE.delete(cacheKey);
+        throw error;
+    });
+    SQLITE_CONNECTION_CACHE.set(cacheKey, guarded);
+    return guarded;
+}
+const SQLITE_CONNECTION_CACHE = new Map();