@pikku/cli 0.12.24 → 0.12.26

package/dist/src/functions/db/local-db.js

@@ -1,65 +1,125 @@
-import { DatabaseSync } from 'node:sqlite';
 import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { resolve, isAbsolute, relative, dirname, join } from 'node:path';
-import { createNodeSqliteKysely, createCoercionPlugin, } from '@pikku/kysely-node-sqlite';
-import { migrate } from './sql-migrator.js';
-import { generateSchemaTypes } from './sqlite-codegen.js';
+import { migrate } from './db-migrator.js';
+import { generateSchemaTypes } from './db-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
-import { seed as runSeed } from './seed.js';
+import { createCoercionPlugin } from './coercion-plugin.js';
+import { SqliteMigrationExecutor } from './sqlite/sqlite-migrator.js';
+import { SqliteIntrospector } from './sqlite/sqlite-introspector.js';
+import { createSqliteKysely } from './sqlite/sqlite-kysely.js';
+import { loadSqliteRuntime } from './sqlite/sqlite-runtime.js';
+import { seed as runSeed } from './sqlite/seed.js';
+import { PostgresMigrationExecutor } from './postgres/postgres-migrator.js';
+import { PostgresIntrospector } from './postgres/postgres-introspector.js';
+// ─── Resolution ───────────────────────────────────────────────────────────────
 /**
- * Resolve a DevDbConfig into absolute paths.
- * - dbFile lives under runtimeDir (default: <rootDir>/.pikku-runtime)
- * - schema/coercion/zod are generated into outDir/db
- * - migrations and seed are authored source under rootDir/db
+ * Resolve a UserConfigShape into an absolute-path descriptor.
+ * Returns null when neither sqliteDb nor postgresUrl is configured.
  */
-export function resolveLocalDb(config, rootDir, outDir, runtimeDir) {
-    if (!config)
-        return null;
-    const file = config === true ? undefined : config.file;
-    const resolvedRuntimeDir = runtimeDir ?? join(rootDir, '.pikku-runtime');
-    return {
-        dbFile: file
-            ? resolveAgainst(rootDir, file)
-            : join(resolvedRuntimeDir, 'dev.db'),
-        runtimeDir: resolvedRuntimeDir,
-        migrationsDir: resolveAgainst(rootDir, 'db/migrations'),
-        seedFile: resolveAgainst(rootDir, 'db/seed.sql'),
+export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
+    const base = (sub) => ({
+        migrationsDir: resolveAgainst(rootDir, sub),
         schemaFile: join(outDir, 'db', 'schema.d.ts'),
         coercionFile: join(outDir, 'db', 'coercion.gen.ts'),
+        manifestFile: join(outDir, 'db', 'classification.gen.ts'),
         zodFile: join(outDir, 'db', 'zod.gen.ts'),
         camelCase: true,
-    };
+    });
+    if (userConfig.postgresUrl && userConfig.sqliteDb) {
+        throw new Error('Both postgresUrl and sqliteDb are set. Configure exactly one database dialect.');
+    }
+    if (userConfig.postgresUrl) {
+        return {
+            dialect: 'postgres',
+            connectionString: userConfig.postgresUrl,
+            ...base('db/postgres'),
+        };
+    }
+    if (userConfig.sqliteDb) {
+        const resolvedRuntimeDir = runtimeDir
+            ? resolveAgainst(rootDir, runtimeDir)
+            : join(rootDir, '.pikku-runtime');
+        return {
+            dialect: 'sqlite',
+            dbFile: resolveAgainst(rootDir, userConfig.sqliteDb),
+            runtimeDir: resolvedRuntimeDir,
+            seedFile: resolveAgainst(rootDir, 'db/seed.sql'),
+            ...base('db/sqlite'),
+        };
+    }
+    return null;
+}
+/** @deprecated Use resolveDb(userConfig, ...) instead. */
+export function resolveLocalDb(sqliteDb, rootDir, outDir, runtimeDir) {
+    if (!sqliteDb)
+        return null;
+    const result = resolveDb({ sqliteDb }, rootDir, outDir, runtimeDir);
+    return result;
 }
 function resolveAgainst(root, p) {
     return isAbsolute(p) ? p : resolve(root, p);
 }
-/**
- * Run the migrate routine (open → tracking-table → drift-check → apply →
- * codegen → close). Used by both `pikku db migrate` and `pikku dev` boot.
- */
-export function migrateAndCodegen(resolved) {
-    mkdirSync(dirname(resolved.dbFile), { recursive: true });
-    const db = new DatabaseSync(resolved.dbFile);
+export async function migrateAndCodegen(resolved) {
+    if (resolved.dialect === 'sqlite') {
+        mkdirSync(dirname(resolved.dbFile), { recursive: true });
+        const runtime = await loadSqliteRuntime();
+        const db = runtime.open(resolved.dbFile);
+        try {
+            const executor = new SqliteMigrationExecutor(db);
+            const migrateResult = await migrate(executor, resolved.migrationsDir);
+            const introspector = new SqliteIntrospector(db);
+            const codegenResult = await generateSchemaTypes(introspector, {
+                outFile: resolved.schemaFile,
+                coercionFile: resolved.coercionFile,
+                manifestFile: resolved.manifestFile,
+                camelCase: resolved.camelCase,
+                migrationsDir: resolved.migrationsDir,
+            });
+            const zodResult = generateZodTypes({
+                schemaFile: resolved.schemaFile,
+                outFile: resolved.zodFile,
+            });
+            return { migrate: migrateResult, codegen: codegenResult, zod: zodResult };
+        }
+        finally {
+            db.close();
+        }
+    }
+    // Postgres
+    const introspector = new PostgresIntrospector(resolved.connectionString);
+    await introspector.connect();
     try {
-        const migrateResult = migrate(db, resolved.migrationsDir);
-        const codegenResult = generateSchemaTypes(db, {
-            outFile: resolved.schemaFile,
-            coercionFile: resolved.coercionFile,
-            camelCase: resolved.camelCase,
-            migrationsDir: resolved.migrationsDir,
-        });
-        const zodResult = generateZodTypes({
-            schemaFile: resolved.schemaFile,
-            outFile: resolved.zodFile,
-        });
-        return { migrate: migrateResult, codegen: codegenResult, zod: zodResult };
+        const { Client } = await import('pg');
+        const client = new Client({ connectionString: resolved.connectionString });
+        await client.connect();
+        try {
+            const executor = new PostgresMigrationExecutor(client);
+            const migrateResult = await migrate(executor, resolved.migrationsDir);
+            const codegenResult = await generateSchemaTypes(introspector, {
+                outFile: resolved.schemaFile,
+                coercionFile: resolved.coercionFile,
+                manifestFile: resolved.manifestFile,
+                camelCase: resolved.camelCase,
+                migrationsDir: resolved.migrationsDir,
+            });
+            const zodResult = generateZodTypes({
+                schemaFile: resolved.schemaFile,
+                outFile: resolved.zodFile,
+            });
+            return { migrate: migrateResult, codegen: codegenResult, zod: zodResult };
+        }
+        finally {
+            await client.end();
+        }
     }
     finally {
-        db.close();
+        await introspector.close();
     }
 }
-export function seed(resolved) {
-    const db = new DatabaseSync(resolved.dbFile);
+// ─── SQLite-only operations ───────────────────────────────────────────────────
+export async function seed(resolved) {
+    const runtime = await loadSqliteRuntime();
+    const db = runtime.open(resolved.dbFile);
     try {
         return runSeed(db, resolved.seedFile);
     }
@@ -67,30 +127,21 @@ export function seed(resolved) {
         db.close();
     }
 }
-/**
- * Delete the dev DB file. Refuses if NODE_ENV is 'production' or the
- * resolved file lives outside the project root (defensive against
- * misconfigured absolute paths).
- */
 export function reset(resolved, rootDir) {
     if (process.env.NODE_ENV === 'production') {
         throw new Error(`pikku db reset refused: NODE_ENV=production. This command only runs in dev.`);
     }
     const rel = relative(resolved.runtimeDir, resolved.dbFile);
     if (rel.startsWith('..') || isAbsolute(rel)) {
-        throw new Error(`pikku db reset refused: resolved DB file (${resolved.dbFile}) is outside the runtime directory (${resolved.runtimeDir}). Override dev.db.file or set runtimeDir correctly.`);
+        throw new Error(`pikku db reset refused: resolved DB file (${resolved.dbFile}) is outside the runtime directory (${resolved.runtimeDir}). Override sqliteDb or set runtimeDir correctly.`);
     }
     if (existsSync(resolved.dbFile)) {
         rmSync(resolved.dbFile);
     }
 }
-/**
- * Construct the user-facing Kysely instance for the dev DB. Used by
- * `pikku dev` to populate inMemoryServices.kysely.
- * Wires the coercion plugin when db/coercion.gen.ts exists.
- */
 export async function createKysely(resolved) {
     mkdirSync(dirname(resolved.dbFile), { recursive: true });
+    const runtime = await loadSqliteRuntime();
     let coercionMap;
     try {
         const mod = await import(resolved.coercionFile);
@@ -99,8 +150,8 @@ export async function createKysely(resolved) {
     catch {
         // coercion.gen.ts not yet generated — run `pikku db migrate` first
     }
-    return createNodeSqliteKysely({
-        filename: resolved.dbFile,
+    return createSqliteKysely({
+        db: runtime.open(resolved.dbFile),
         camelCase: resolved.camelCase,
         plugins: coercionMap ? [createCoercionPlugin({ map: coercionMap })] : [],
     });

package/dist/src/functions/db/postgres/postgres-introspector.d.ts

@@ -0,0 +1,10 @@
+import { Client } from 'pg';
+import type { DbIntrospector, ColumnInfo } from '../db-introspector.js';
+export declare class PostgresIntrospector implements DbIntrospector {
+    private client;
+    constructor(connectionStringOrClient: string | Client);
+    connect(): Promise<void>;
+    listTables(): Promise<string[]>;
+    getColumns(table: string): Promise<ColumnInfo[]>;
+    close(): Promise<void>;
+}

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -0,0 +1,54 @@
+import { Client } from 'pg';
+export class PostgresIntrospector {
+    client;
+    constructor(connectionStringOrClient) {
+        this.client =
+            typeof connectionStringOrClient === 'string'
+                ? new Client({ connectionString: connectionStringOrClient })
+                : connectionStringOrClient;
+    }
+    async connect() {
+        await this.client.connect();
+    }
+    async listTables() {
+        const result = await this.client.query(`SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+       ORDER BY table_name`);
+        return result.rows.map((r) => r.table_name);
+    }
+    async getColumns(table) {
+        const result = await this.client.query(`SELECT
+         c.column_name,
+         c.data_type,
+         c.is_nullable,
+         c.column_default,
+         c.is_generated,
+         EXISTS(
+           SELECT 1
+           FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+            AND tc.table_name = kcu.table_name
+           WHERE tc.constraint_type = 'PRIMARY KEY'
+             AND tc.table_schema = 'public'
+             AND tc.table_name = $1
+             AND kcu.column_name = c.column_name
+         ) AS is_pk
+       FROM information_schema.columns c
+       WHERE c.table_schema = 'public' AND c.table_name = $1
+       ORDER BY c.ordinal_position`, [table]);
+        return result.rows.map((r) => ({
+            name: r.column_name,
+            type: r.data_type,
+            notNull: r.is_nullable === 'NO',
+            pk: Boolean(r.is_pk),
+            defaultValue: r.column_default,
+            generated: r.is_generated === 'ALWAYS',
+        }));
+    }
+    async close() {
+        await this.client.end();
+    }
+}

package/dist/src/functions/db/postgres/postgres-migrator.d.ts

@@ -0,0 +1,9 @@
+import type { Client } from 'pg';
+import type { MigrationExecutor, AppliedMigration } from '../db-migrator.js';
+export declare class PostgresMigrationExecutor implements MigrationExecutor {
+    private readonly client;
+    constructor(client: Client);
+    ensureTrackingTable(): Promise<void>;
+    getApplied(): Promise<AppliedMigration[]>;
+    runMigration(sql: string, name: string, hash: string): Promise<void>;
+}

package/dist/src/functions/db/postgres/postgres-migrator.js

@@ -0,0 +1,32 @@
+const TRACKING_TABLE = 'sql_migrations';
+export class PostgresMigrationExecutor {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async ensureTrackingTable() {
+        await this.client.query(`
+      CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE} (
+        name       TEXT PRIMARY KEY,
+        hash       TEXT NOT NULL,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    }
+    async getApplied() {
+        const { rows } = await this.client.query(`SELECT name, hash, applied_at FROM ${TRACKING_TABLE} ORDER BY name`);
+        return rows;
+    }
+    async runMigration(sql, name, hash) {
+        await this.client.query('BEGIN');
+        try {
+            await this.client.query(sql);
+            await this.client.query(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES ($1, $2)`, [name, hash]);
+            await this.client.query('COMMIT');
+        }
+        catch (err) {
+            await this.client.query('ROLLBACK');
+            throw err;
+        }
+    }
+}

package/dist/src/functions/db/{seed.d.ts → sqlite/seed.d.ts}

@@ -1,4 +1,4 @@
-import type { DatabaseSync } from 'node:sqlite';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
 export interface SeedResult {
     applied: boolean;
     bytes: number;
@@ -8,4 +8,4 @@ export interface SeedResult {
  * (e.g. `INSERT OR IGNORE`, upserts). Returns `applied: false` if the file
  * doesn't exist; throws on SQL errors.
  */
-export declare function seed(db: DatabaseSync, seedFile: string): SeedResult;
+export declare function seed(db: SyncSqliteDatabase, seedFile: string): SeedResult;

package/dist/src/functions/db/sqlite/sqlite-introspector.d.ts

@@ -0,0 +1,9 @@
+import type { DbIntrospector, ColumnInfo } from '../db-introspector.js';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+export declare class SqliteIntrospector implements DbIntrospector {
+    private readonly db;
+    constructor(db: SyncSqliteDatabase);
+    listTables(): Promise<string[]>;
+    getColumns(table: string): Promise<ColumnInfo[]>;
+    close(): Promise<void>;
+}

package/dist/src/functions/db/sqlite/sqlite-introspector.js

@@ -0,0 +1,35 @@
+const SKIP_TABLES = new Set(['sqlite_sequence', 'sql_migrations']);
+export class SqliteIntrospector {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listTables() {
+        const rows = this.db
+            .prepare(`SELECT name FROM sqlite_master
+           WHERE type = 'table'
+             AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+           ORDER BY name`)
+            .all();
+        return rows.map((r) => r.name).filter((n) => !SKIP_TABLES.has(n));
+    }
+    async getColumns(table) {
+        const escaped = `"${table.replace(/"/g, '""')}"`;
+        const rows = this.db
+            .prepare(`PRAGMA table_xinfo(${escaped})`)
+            .all();
+        return rows
+            .filter((c) => c.hidden !== 1)
+            .map((c) => ({
+            name: c.name,
+            type: c.type,
+            notNull: Boolean(c.notnull),
+            pk: c.pk > 0,
+            defaultValue: c.dflt_value != null ? String(c.dflt_value) : null,
+            generated: c.hidden === 2 || c.hidden === 3,
+        }));
+    }
+    async close() {
+        this.db.close();
+    }
+}

package/dist/src/functions/db/sqlite/sqlite-kysely.d.ts

@@ -0,0 +1,8 @@
+import { Kysely, type KyselyPlugin } from 'kysely';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+export interface CreateSqliteKyselyOptions {
+    db: SyncSqliteDatabase;
+    camelCase?: boolean;
+    plugins?: KyselyPlugin[];
+}
+export declare function createSqliteKysely<DB>(options: CreateSqliteKyselyOptions): Kysely<DB>;

package/dist/src/functions/db/sqlite/sqlite-kysely.js

@@ -0,0 +1,62 @@
+import { Kysely, SqliteDialect, CamelCasePlugin, } from 'kysely';
+function coerce(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (v instanceof Uint8Array)
+        return v;
+    if (typeof v === 'object')
+        return JSON.stringify(v);
+    return v;
+}
+class RuntimeSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt) {
+        this.stmt = stmt;
+        this.reader = Boolean(stmt.reader);
+    }
+    all(parameters) {
+        return this.stmt.all(...parameters.map(coerce));
+    }
+    *iterate(parameters) {
+        for (const row of this.stmt.iterate(...parameters.map(coerce))) {
+            yield row;
+        }
+    }
+    run(parameters) {
+        const result = this.stmt.run(...parameters.map(coerce));
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class RuntimeSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    prepare(sql) {
+        return new RuntimeSqliteStatement(this.db.prepare(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function createSqliteKysely(options) {
+    const plugins = [];
+    if (options.camelCase ?? true)
+        plugins.push(new CamelCasePlugin());
+    if (options.plugins)
+        plugins.push(...options.plugins);
+    return new Kysely({
+        dialect: new SqliteDialect({
+            database: new RuntimeSqliteDatabase(options.db),
+        }),
+        plugins,
+    });
+}

package/dist/src/functions/db/sqlite/sqlite-migrator.d.ts

@@ -0,0 +1,10 @@
+import type { MigrationExecutor, AppliedMigration } from '../db-migrator.js';
+import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+export declare class SqliteMigrationExecutor implements MigrationExecutor {
+    private readonly db;
+    constructor(db: SyncSqliteDatabase);
+    ensureTrackingTable(): Promise<void>;
+    getApplied(): Promise<AppliedMigration[]>;
+    runMigration(sql: string, name: string, hash: string): Promise<void>;
+}
+export declare function dropTrackingTable(db: SyncSqliteDatabase): void;

package/dist/src/functions/db/sqlite/sqlite-migrator.js

@@ -0,0 +1,36 @@
+const TRACKING_TABLE = 'sql_migrations';
+export class SqliteMigrationExecutor {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async ensureTrackingTable() {
+        this.db.exec(`CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE} (
+         name       TEXT PRIMARY KEY,
+         hash       TEXT NOT NULL,
+         applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+       )`);
+    }
+    async getApplied() {
+        return this.db
+            .prepare(`SELECT name, hash, applied_at FROM ${TRACKING_TABLE} ORDER BY name`)
+            .all();
+    }
+    async runMigration(sql, name, hash) {
+        this.db.exec('BEGIN');
+        try {
+            this.db.exec(sql);
+            this.db
+                .prepare(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES (?, ?)`)
+                .run(name, hash);
+            this.db.exec('COMMIT');
+        }
+        catch (err) {
+            this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+}
+export function dropTrackingTable(db) {
+    db.exec(`DROP TABLE IF EXISTS ${TRACKING_TABLE}`);
+}

package/dist/src/functions/db/sqlite/sqlite-runtime-bun.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteRuntime } from './sqlite-runtime.js';
+export declare const bunSqliteRuntime: SqliteRuntime;

package/dist/src/functions/db/sqlite/sqlite-runtime-bun.js

@@ -0,0 +1,52 @@
+import { Database } from 'bun:sqlite';
+class BunSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt, reader) {
+        this.stmt = stmt;
+        this.reader = reader;
+    }
+    all(...parameters) {
+        return this.stmt.all(...parameters);
+    }
+    get(...parameters) {
+        return this.stmt.get(...parameters) ?? null;
+    }
+    iterate(...parameters) {
+        return this.stmt.iterate(...parameters);
+    }
+    run(...parameters) {
+        const result = this.stmt.run(...parameters);
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class BunSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        return new BunSqliteStatement(this.db.prepare(sql), isReaderSql(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+function isReaderSql(sql) {
+    const normalized = sql.trimStart().toUpperCase();
+    return (normalized.startsWith('SELECT') ||
+        normalized.startsWith('WITH') ||
+        normalized.startsWith('PRAGMA') ||
+        normalized.startsWith('EXPLAIN'));
+}
+export const bunSqliteRuntime = {
+    open(filename) {
+        return new BunSqliteDatabase(new Database(filename));
+    },
+};

package/dist/src/functions/db/sqlite/sqlite-runtime-node.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteRuntime } from './sqlite-runtime.js';
+export declare function createNodeSqliteRuntime(): Promise<SqliteRuntime>;

package/dist/src/functions/db/sqlite/sqlite-runtime-node.js

@@ -0,0 +1,51 @@
+class NodeSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt) {
+        this.stmt = stmt;
+        this.reader = Boolean(stmt.reader);
+    }
+    all(...parameters) {
+        return this.stmt.all(...parameters);
+    }
+    get(...parameters) {
+        return this.stmt.get(...parameters) ?? null;
+    }
+    iterate(...parameters) {
+        return this.stmt.iterate(...parameters);
+    }
+    run(...parameters) {
+        const result = this.stmt.run(...parameters);
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class NodeSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        return new NodeSqliteStatement(this.db.prepare(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+async function importNodeSqlite() {
+    const dynamicImport = new Function('return import("node:sqlite")');
+    return dynamicImport();
+}
+export async function createNodeSqliteRuntime() {
+    const { DatabaseSync } = await importNodeSqlite();
+    return {
+        open(filename) {
+            return new NodeSqliteDatabase(new DatabaseSync(filename));
+        },
+    };
+}

package/dist/src/functions/db/sqlite/sqlite-runtime.d.ts

@@ -0,0 +1,20 @@
+export interface SyncSqliteChanges {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface SyncSqliteStatement {
+    reader: boolean;
+    all(...parameters: unknown[]): unknown[];
+    get(...parameters: unknown[]): unknown | null;
+    iterate(...parameters: unknown[]): IterableIterator<unknown>;
+    run(...parameters: unknown[]): SyncSqliteChanges;
+}
+export interface SyncSqliteDatabase {
+    exec(sql: string): void;
+    prepare(sql: string): SyncSqliteStatement;
+    close(): void;
+}
+export interface SqliteRuntime {
+    open(filename: string): SyncSqliteDatabase;
+}
+export declare function loadSqliteRuntime(): Promise<SqliteRuntime>;

package/dist/src/functions/db/sqlite/sqlite-runtime.js

@@ -0,0 +1,13 @@
+let runtimePromise;
+export async function loadSqliteRuntime() {
+    runtimePromise ??= (async () => {
+        const isBunRuntime = typeof globalThis.Bun !== 'undefined';
+        if (isBunRuntime) {
+            const { bunSqliteRuntime } = await import('./sqlite-runtime-bun.js');
+            return bunSqliteRuntime;
+        }
+        const { createNodeSqliteRuntime } = await import('./sqlite-runtime-node.js');
+        return createNodeSqliteRuntime();
+    })();
+    return runtimePromise;
+}