zapo-js 0.1.2 → 0.3.0

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

@@ -1,250 +0,0 @@
-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 { bytesToHex, uint8Equal } from '../../../util/bytes.js';
-import { asBytes, asNumber, asString } from '../../../util/coercion.js';
-function repeatSqlToken(token, count, separator) {
-    if (count <= 1) {
-        return token;
-    }
-    let out = token;
-    for (let index = 1; index < count; index += 1) {
-        out += separator + token;
-    }
-    return out;
-}
-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 getSyncKeyDataBatch(keyIds) {
-        if (keyIds.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const uniqueKeyIds = [
-            ...new Map(keyIds.map((keyId) => [bytesToHex(keyId), keyId])).values()
-        ];
-        const placeholders = repeatSqlToken('?', uniqueKeyIds.length, ', ');
-        const params = [this.options.sessionId, ...uniqueKeyIds];
-        const rows = db.all(`SELECT key_id, key_data
-             FROM appstate_sync_keys
-             WHERE session_id = ? AND key_id IN (${placeholders})`, params);
-        const byKeyHex = new Map();
-        for (const row of rows) {
-            byKeyHex.set(bytesToHex(asBytes(row.key_id, 'appstate_sync_keys.key_id')), asBytes(row.key_data, 'appstate_sync_keys.key_data'));
-        }
-        return keyIds.map((keyId) => byKeyHex.get(bytesToHex(keyId)) ?? null);
-    }
-    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 {
-                initialized: false,
-                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 {
-            initialized: true,
-            version: asNumber(versionRow.version, 'appstate_collection_versions.version'),
-            hash: asBytes(versionRow.hash, 'appstate_collection_versions.hash'),
-            indexValueMap
-        };
-    }
-    async getCollectionStates(collections) {
-        if (collections.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const uniqueCollections = [...new Set(collections)];
-        const placeholders = repeatSqlToken('?', uniqueCollections.length, ', ');
-        const params = [this.options.sessionId, ...uniqueCollections];
-        const versionRows = db.all(`SELECT collection, version, hash
-             FROM appstate_collection_versions
-             WHERE session_id = ? AND collection IN (${placeholders})`, params);
-        const valueRows = db.all(`SELECT collection, index_mac_hex, value_mac
-             FROM appstate_collection_index_values
-             WHERE session_id = ? AND collection IN (${placeholders})`, params);
-        const versionsByCollection = new Map();
-        for (const row of versionRows) {
-            const collection = asString(row.collection, 'appstate_collection_versions.collection');
-            versionsByCollection.set(collection, {
-                version: asNumber(row.version, 'appstate_collection_versions.version'),
-                hash: asBytes(row.hash, 'appstate_collection_versions.hash')
-            });
-        }
-        const indexValueMaps = new Map();
-        for (const row of valueRows) {
-            const collection = asString(row.collection, 'appstate_collection_index_values.collection');
-            const map = indexValueMaps.get(collection);
-            const targetMap = map ?? new Map();
-            targetMap.set(asString(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), asBytes(row.value_mac, 'appstate_collection_index_values.value_mac'));
-            if (!map) {
-                indexValueMaps.set(collection, targetMap);
-            }
-        }
-        return collections.map((collection) => {
-            const version = versionsByCollection.get(collection);
-            if (!version) {
-                return {
-                    initialized: false,
-                    version: 0,
-                    hash: APP_STATE_EMPTY_LT_HASH,
-                    indexValueMap: new Map()
-                };
-            }
-            return {
-                initialized: true,
-                version: version.version,
-                hash: version.hash,
-                indexValueMap: indexValueMaps.get(collection) ?? new Map()
-            };
-        });
-    }
-    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

@@ -1,176 +0,0 @@
-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

@@ -1,245 +0,0 @@
-import { createSqliteTableNameSqlResolver, resolveSqliteTableNames, serializeSqliteTableNames } from '../../providers/sqlite/table-names.js';
-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, resolveSql, onClose) {
-    const statementCache = new Map();
-    const cachedStatementFor = (sql) => {
-        const resolvedSql = resolveSql(sql);
-        const cached = statementCache.get(resolvedSql);
-        if (cached) {
-            return cached;
-        }
-        const statement = statementFor(db, resolvedSql);
-        statementCache.set(resolvedSql, statement);
-        return statement;
-    };
-    return {
-        driver,
-        exec(sql) {
-            db.exec(resolveSql(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, resolveSql, 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', resolveSql, onClose);
-}
-async function openBunSqlite(options, resolveSql, 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', resolveSql, 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 resolvedTableNames = resolveSqliteTableNames(options.tableNames);
-    const resolveSql = createSqliteTableNameSqlResolver(resolvedTableNames);
-    const normalizedOptions = {
-        ...options,
-        driver,
-        pragmas: mergePragmas(options.pragmas),
-        tableNames: resolvedTableNames
-    };
-    const cacheKey = `${driver}|${options.path}|${Object.entries(normalizedOptions.pragmas ?? {})
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, value]) => `${key}=${String(value)}`)
-        .join(';')}|${serializeSqliteTableNames(resolvedTableNames)}`;
-    const cached = SQLITE_CONNECTION_CACHE.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const onClose = () => {
-        SQLITE_CONNECTION_CACHE.delete(cacheKey);
-    };
-    const created = driver === 'bun'
-        ? openBunSqlite(normalizedOptions, resolveSql, onClose)
-        : openBetterSqlite(normalizedOptions, resolveSql, 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();