uql-orm 0.20.2 → 0.22.0

package/dist/sqlite/bunSqliteAdapter.bun.js

@@ -0,0 +1,25 @@
+/**
+ * Presents a `bun:sqlite` handle as a {@link SqliteDatabase}.
+ *
+ * @remarks Its statements expose no `reader`, so without deriving one every `RETURNING` statement
+ * would take the `run()` path, which discards returned rows, and inserts would report no ids.
+ * `columnNames` is non-empty for exactly the statements better-sqlite3 marks as readers.
+ *
+ * Lives in a `.bun.ts` file because it only ever executes under Bun: the Node coverage run cannot
+ * reach it, and `sqliteQuerier.bun.test.ts` covers it under `test:bun` instead.
+ */
+export function adaptBunSqlite(db) {
+    return {
+        prepare: (sql) => {
+            const stmt = db.prepare(sql);
+            return {
+                reader: stmt.columnNames.length > 0,
+                all: (...values) => stmt.all(...values),
+                run: (...values) => stmt.run(...values),
+                iterate: (...values) => stmt.iterate(...values),
+            };
+        },
+        loadExtension: (path) => db.loadExtension(path),
+        close: () => db.close(),
+    };
+}

package/dist/sqlite/hranaQuerier.d.ts

@@ -0,0 +1,54 @@
+import type { ExtraOptions, TransactionOptions } from '../type/index.js';
+import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
+import type { SqliteDialect } from './sqliteDialect.js';
+/**
+ * Structural subset of the Hrana client API, the wire protocol shared by `@libsql/client` and
+ * `@tursodatabase/serverless/compat`. Declared here rather than imported so a querier works with
+ * any client of this shape (including `@libsql/client/web` and `@libsql/client-wasm`) without
+ * depending on vendor types.
+ */
+export type HranaInValue = SqliteBindValue | ArrayBuffer | Date;
+export type HranaResultSet = {
+    rows: unknown[];
+    rowsAffected: number;
+    lastInsertRowid?: bigint;
+};
+export type HranaExecutor = {
+    execute(stmt: {
+        sql: string;
+        args?: HranaInValue[];
+    }): Promise<HranaResultSet>;
+};
+export type HranaTransaction = HranaExecutor & {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+};
+export type HranaClient = HranaExecutor & {
+    transaction(mode?: 'write' | 'read' | 'deferred'): Promise<HranaTransaction>;
+    close(): void;
+};
+/** Connection lifecycle for a {@link HranaQuerier} (separate from {@link ExtraOptions}). */
+export type HranaQuerierConnectionOptions = {
+    /** When set, {@link release} closes {@link HranaQuerier.client} (one-shot migration connections). */
+    closeClientOnRelease?: boolean;
+};
+/**
+ * Querier for SQLite databases reached through a Hrana client.
+ *
+ * @remarks Transactions use the client's own session handle rather than `BEGIN`/`COMMIT` statements,
+ * because over plain HTTP consecutive requests need not share a connection.
+ */
+export declare class HranaQuerier extends AbstractSqliteQuerier {
+    readonly client: HranaClient;
+    readonly extra?: ExtraOptions | undefined;
+    private tx?;
+    private readonly closeClientOnRelease;
+    constructor(client: HranaClient, dialect: SqliteDialect, extra?: ExtraOptions | undefined, connection?: HranaQuerierConnectionOptions);
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
+    get hasOpenTransaction(): boolean;
+    beginTransaction(_opts?: TransactionOptions): Promise<void>;
+    commitTransaction(): Promise<void>;
+    rollbackTransaction(): Promise<void>;
+    internalRelease(): Promise<void>;
+}

package/dist/sqlite/hranaQuerier.js

@@ -0,0 +1,90 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Serialized } from '../querier/decorator/index.js';
+import { throwNoPendingTransaction, throwPendingTransaction } from '../util/index.js';
+import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
+/**
+ * Querier for SQLite databases reached through a Hrana client.
+ *
+ * @remarks Transactions use the client's own session handle rather than `BEGIN`/`COMMIT` statements,
+ * because over plain HTTP consecutive requests need not share a connection.
+ */
+export class HranaQuerier extends AbstractSqliteQuerier {
+    client;
+    extra;
+    tx;
+    closeClientOnRelease;
+    constructor(client, dialect, extra, connection) {
+        super(dialect, extra);
+        this.client = client;
+        this.extra = extra;
+        this.closeClientOnRelease = connection?.closeClientOnRelease ?? false;
+    }
+    async internalAll(query, values) {
+        const target = this.tx || this.client;
+        const res = await target.execute({ sql: query, args: values });
+        return res.rows;
+    }
+    async internalRun(query, values) {
+        const target = this.tx || this.client;
+        const res = await target.execute({ sql: query, args: values });
+        const rows = res.rows;
+        // `rowsAffected` is unreliably 0 whenever the statement has a RETURNING clause, so prefer
+        // the actual row count when rows were returned.
+        return this.buildUpdateResult({ rows, changes: rows.length || res.rowsAffected, id: res.lastInsertRowid });
+    }
+    get hasOpenTransaction() {
+        return !!this.tx;
+    }
+    async beginTransaction(_opts) {
+        if (this.tx) {
+            throwPendingTransaction();
+        }
+        this.tx = await this.client.transaction('write');
+    }
+    async commitTransaction() {
+        if (!this.tx) {
+            throwNoPendingTransaction();
+        }
+        await this.tx.commit();
+        this.tx = undefined;
+    }
+    async rollbackTransaction() {
+        if (!this.tx) {
+            throwNoPendingTransaction();
+        }
+        await this.tx.rollback();
+        this.tx = undefined;
+    }
+    async internalRelease() {
+        await super.internalRelease();
+        if (this.closeClientOnRelease) {
+            this.client.close();
+        }
+    }
+}
+__decorate([
+    Serialized(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HranaQuerier.prototype, "beginTransaction", null);
+__decorate([
+    Serialized(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HranaQuerier.prototype, "commitTransaction", null);
+__decorate([
+    Serialized(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HranaQuerier.prototype, "rollbackTransaction", null);

package/dist/sqlite/hranaQuerierPool.d.ts

@@ -0,0 +1,21 @@
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import type { HranaClient, HranaQuerier, HranaQuerierConnectionOptions } from './hranaQuerier.js';
+import type { SqliteDialect } from './sqliteDialect.js';
+/**
+ * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
+ * `@tursodatabase/serverless/compat`).
+ *
+ * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. It is resolved on first use rather than in the
+ * constructor, so building a pool never throws when the optional driver peer is absent, which is what
+ * lets a Workers bundle construct one at module scope.
+ */
+export declare abstract class AbstractHranaQuerierPool<Q extends HranaQuerier, D extends SqliteDialect> extends AbstractSqlQuerierPool<Q, D> {
+    private client?;
+    /** False when the caller injected their own client, in which case they own its lifecycle. */
+    protected readonly ownsClient: boolean;
+    protected abstract openClient(): Promise<HranaClient>;
+    protected abstract buildQuerier(client: HranaClient, connection?: HranaQuerierConnectionOptions): Q;
+    getQuerier(): Promise<Q>;
+    end(): Promise<void>;
+}

package/dist/sqlite/hranaQuerierPool.js

@@ -0,0 +1,25 @@
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+/**
+ * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
+ * `@tursodatabase/serverless/compat`).
+ *
+ * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. It is resolved on first use rather than in the
+ * constructor, so building a pool never throws when the optional driver peer is absent, which is what
+ * lets a Workers bundle construct one at module scope.
+ */
+export class AbstractHranaQuerierPool extends AbstractSqlQuerierPool {
+    client;
+    /** False when the caller injected their own client, in which case they own its lifecycle. */
+    ownsClient = true;
+    async getQuerier() {
+        this.client ??= await this.openClient();
+        return this.buildQuerier(this.client);
+    }
+    async end() {
+        if (this.ownsClient) {
+            this.client?.close();
+        }
+        this.client = undefined;
+    }
+}

package/dist/sqlite/index.d.ts

@@ -1,6 +1,6 @@
 export * from './abstractSqliteQuerier.js';
-export * from './betterSqlite3Dialect.js';
+export * from './hranaQuerier.js';
+export * from './hranaQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';
 export * from './sqliteQuerierPool.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/sqlite/index.js

@@ -1,6 +1,6 @@
 export * from './abstractSqliteQuerier.js';
-export * from './betterSqlite3Dialect.js';
+export * from './hranaQuerier.js';
+export * from './hranaQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';
 export * from './sqliteQuerierPool.js';
-//# sourceMappingURL=index.js.map

package/dist/sqlite/sqliteDialect.d.ts

@@ -1,5 +1,5 @@
 import { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
-import type { DialectFeatures, FieldOptions, QueryComparisonOptions, QueryConflictPaths, QueryContext, QueryOptions, QuerySizeComparisonOps, Type, VectorDistance } from '../type/index.js';
+import type { DialectFeatures, EntityMeta, FieldOptions, QueryConflictPaths, QueryContext, QuerySizeComparisonOps, QueryTextSearchOptions, Type, VectorDistance } from '../type/index.js';
 export declare class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     protected readonly featureDefaults: DialectFeatures;
@@ -14,6 +14,11 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     readonly alterColumnSyntax = "none";
     readonly booleanLiteral = "integer";
     readonly insertIdSource = "returning";
+    /**
+     * The [sqlite-vec](https://github.com/asg017/sqlite-vec) functions, which need that extension
+     * loaded on the connection (see `Sqlite3QuerierPool`'s `extensions` option). libSQL and Turso ship
+     * their own vector functions instead, so `LibsqlDialect` overrides this.
+     */
     protected readonly vectorDistanceFns: ReadonlyMap<VectorDistance, string>;
     /**
      * SQLite does not support the `DEFAULT` keyword inside `VALUES`. Inline the metadata default
@@ -23,7 +28,11 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     protected ilikeExpr(f: string, ph: string): string;
     protected get neOp(): string;
     normalizeValue(value: unknown): unknown;
-    compare<E>(ctx: QueryContext, entity: Type<E>, key: string, val: unknown, opts?: QueryComparisonOptions): void;
+    /**
+     * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
+     * FTS5 virtual table (UQL does not create those; declare it outside your entities).
+     */
+    protected appendTextSearch<E>(ctx: QueryContext, entity: Type<E>, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
     /**
      * SQLite compares an exploded element as whole JSON text, so containment cannot express "this
      * element includes these keys" - `$elemMatch` always expands to per-field conditions.
@@ -43,7 +52,6 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     protected jsonElemRef(alias: string, field?: string, asJson?: boolean): string;
     protected getJsonPathScalarExpr(escapedColumn: string, jsonPathStr: string): string;
     protected numericCast(expr: string): string;
-    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
     upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[]): void;
     protected jsonCast(operand: string): string;
     /**
@@ -53,8 +61,13 @@ export declare class SqliteDialect extends AbstractSqlDialect {
      */
     protected jsonPullKey(ctx: QueryContext, expr: string, escapedCol: string, key: string, value: unknown): string;
     protected jsonSet(ctx: QueryContext, expr: string, set: Record<string, unknown>, field?: FieldOptions): string;
-    /** `[#]` appends, creating the array when the key is absent. */
+    /**
+     * `[#]` appends, creating the array when the key is absent.
+     *
+     * @remarks `json_set` rather than `json_insert`: the two are equivalent here because `[#]` always
+     * resolves past the end of the array, and Turso's engine implements `json_insert` as create-only,
+     * so it silently drops the element when the array already exists.
+     */
     protected jsonPush(ctx: QueryContext, expr: string, push: Record<string, unknown>): string;
     protected jsonUnset(_ctx: QueryContext, expr: string, unset: readonly string[]): string;
 }
-//# sourceMappingURL=sqliteDialect.d.ts.map

package/dist/sqlite/sqliteDialect.js

@@ -13,7 +13,7 @@ export class SqliteDialect extends AbstractSqlDialect {
         renameColumn: true,
         foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
         columnComment: false, // SQLite does not support column comments
-        vectorIndexStyle: 'create',
+        inlineVectorIndex: false,
         vectorSupportsLength: false,
         supportsTimestamptz: false,
         defaultStringAsText: true,
@@ -30,10 +30,15 @@ export class SqliteDialect extends AbstractSqlDialect {
     booleanLiteral = 'integer';
     // SQLite supports `RETURNING` (including on `INSERT ... ON CONFLICT`), so IDs are exact per row.
     insertIdSource = 'returning';
+    /**
+     * The [sqlite-vec](https://github.com/asg017/sqlite-vec) functions, which need that extension
+     * loaded on the connection (see `Sqlite3QuerierPool`'s `extensions` option). libSQL and Turso ship
+     * their own vector functions instead, so `LibsqlDialect` overrides this.
+     */
     vectorDistanceFns = new Map([
         ['cosine', 'vec_distance_cosine'],
         ['l2', 'vec_distance_L2'],
-        ['hamming', 'vec_distance_hamming'],
+        ['l1', 'vec_distance_L1'],
     ]);
     /**
      * SQLite does not support the `DEFAULT` keyword inside `VALUES`. Inline the metadata default
@@ -58,21 +63,14 @@ export class SqliteDialect extends AbstractSqlDialect {
             return value.getTime();
         return super.normalizeValue(value);
     }
-    compare(ctx, entity, key, val, opts) {
-        if (key === '$text') {
-            const meta = getMeta(entity);
-            const search = val;
-            const fields = search.$fields.map((fKey) => {
-                const field = meta.fields[fKey];
-                const columnName = this.resolveColumnName(fKey, field);
-                return this.escapeId(columnName);
-            });
-            const tableName = this.resolveTableName(entity, meta);
-            ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);
-            ctx.addValue(search.$value);
-            return;
-        }
-        super.compare(ctx, entity, key, val, opts);
+    /**
+     * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
+     * FTS5 virtual table (UQL does not create those; declare it outside your entities).
+     */
+    appendTextSearch(ctx, entity, meta, search) {
+        const columns = search.$fields.map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
+        ctx.append(`${this.escapeId(this.resolveTableName(entity, meta))} MATCH {${columns.join(' ')}} : `);
+        ctx.addValue(search.$value);
     }
     /**
      * SQLite compares an exploded element as whole JSON text, so containment cannot express "this
@@ -111,10 +109,6 @@ export class SqliteDialect extends AbstractSqlDialect {
     numericCast(expr) {
         return `CAST(${expr} AS REAL)`;
     }
-    insert(ctx, entity, payload, opts) {
-        super.insert(ctx, entity, payload, opts);
-        ctx.append(' ' + this.returningId(entity));
-    }
     upsert(ctx, entity, conflictPaths, payload) {
         const meta = getMeta(entity);
         const updateCtx = this.createContext();
@@ -123,7 +117,7 @@ export class SqliteDialect extends AbstractSqlDialect {
         const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
         // Use the base (non-RETURNING) insert here: the appended RETURNING below would otherwise
         // be doubled by `this.insert`'s own.
-        super.insert(ctx, entity, payload);
+        this.appendInsertValues(ctx, entity, payload);
         ctx.append(` ON CONFLICT (${keysStr}) ${onConflict} ${this.returningId(entity)}`);
         ctx.pushValue(...updateCtx.values);
     }
@@ -144,12 +138,17 @@ export class SqliteDialect extends AbstractSqlDialect {
     jsonSet(ctx, expr, set, field) {
         return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'json_set', jsonSetTarget(expr, field, `'{}'`), set);
     }
-    /** `[#]` appends, creating the array when the key is absent. */
+    /**
+     * `[#]` appends, creating the array when the key is absent.
+     *
+     * @remarks `json_set` rather than `json_insert`: the two are equivalent here because `[#]` always
+     * resolves past the end of the array, and Turso's engine implements `json_insert` as create-only,
+     * so it silently drops the element when the array already exists.
+     */
     jsonPush(ctx, expr, push) {
-        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'json_insert', expr, push, '[#]');
+        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'json_set', expr, push, '[#]');
     }
     jsonUnset(_ctx, expr, unset) {
         return jsonRemoveCall('json_remove', expr, unset);
     }
 }
-//# sourceMappingURL=sqliteDialect.js.map

package/dist/sqlite/sqliteQuerier.d.ts

@@ -1,14 +1,20 @@
-import type { Database } from 'better-sqlite3';
 import type { ExtraOptions } from '../type/index.js';
-import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
+import { PreparedSqliteQuerier, type SqlitePreparedStatement } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
-export declare class SqliteQuerier extends AbstractSqliteQuerier {
-    readonly db: Database;
+/**
+ * Structural subset of a synchronous better-sqlite3-compatible driver, declared locally so this
+ * querier carries no vendor type. A real `better-sqlite3` `Database` satisfies it directly;
+ * `bun:sqlite` is adapted to it by {@link Sqlite3QuerierPool}.
+ */
+export type SqliteDatabase = {
+    prepare(sql: string): SqlitePreparedStatement;
+    /** Installs a loadable extension (`sqlite-vec`, ...) into this connection. */
+    loadExtension(path: string): void;
+    close(): unknown;
+};
+export declare class SqliteQuerier extends PreparedSqliteQuerier {
+    readonly db: SqliteDatabase;
     readonly extra?: ExtraOptions | undefined;
-    constructor(db: Database, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
-    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    internalRelease(): Promise<void>;
+    constructor(db: SqliteDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
+    protected prepare(query: string): SqlitePreparedStatement;
 }
-//# sourceMappingURL=sqliteQuerier.d.ts.map

package/dist/sqlite/sqliteQuerier.js

@@ -1,6 +1,5 @@
-import { throwPendingTransaction } from '../util/index.js';
-import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
-export class SqliteQuerier extends AbstractSqliteQuerier {
+import { PreparedSqliteQuerier } from './abstractSqliteQuerier.js';
+export class SqliteQuerier extends PreparedSqliteQuerier {
     db;
     extra;
     constructor(db, dialect, extra) {
@@ -8,30 +7,7 @@ export class SqliteQuerier extends AbstractSqliteQuerier {
         this.db = db;
         this.extra = extra;
     }
-    async internalAll(query, values) {
-        return this.db.prepare(query).all(values || []);
-    }
-    async *internalStream(query, values) {
-        for (const row of this.db.prepare(query).iterate(values || [])) {
-            yield row;
-        }
-    }
-    async internalRun(query, values) {
-        const stmt = this.db.prepare(query);
-        // `reader` is true for any statement with a RETURNING clause; `.run()` silently discards
-        // returned rows, so those statements must go through `.all()` instead.
-        if (stmt.reader) {
-            const rows = stmt.all(values || []);
-            return this.buildUpdateResult({ rows });
-        }
-        const { changes, lastInsertRowid } = stmt.run(values || []);
-        return this.buildUpdateResult({ changes, id: lastInsertRowid });
-    }
-    async internalRelease() {
-        if (this.hasOpenTransaction) {
-            throwPendingTransaction();
-        }
-        // no-op
+    prepare(query) {
+        return this.db.prepare(query);
     }
 }
-//# sourceMappingURL=sqliteQuerier.js.map

package/dist/sqlite/sqliteQuerierPool.d.ts

@@ -1,19 +1,28 @@
 import type { Options } from 'better-sqlite3';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
-import { BetterSqlite3Dialect } from './betterSqlite3Dialect.js';
+import { SqliteDialect } from './sqliteDialect.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
-export declare class Sqlite3QuerierPool extends AbstractSqlQuerierPool<SqliteQuerier, BetterSqlite3Dialect> {
+/** Driver options, plus the loadable extensions to install on the connection. */
+export type Sqlite3PoolOptions = Options & {
+    /**
+     * Paths of loadable extensions to install when the connection opens - e.g. what `sqlite-vec`'s
+     * `getLoadablePath()` returns, which vector search needs because SQLite itself has no vector
+     * functions.
+     */
+    extensions?: readonly string[];
+};
+export declare class Sqlite3QuerierPool extends AbstractSqlQuerierPool<SqliteQuerier, SqliteDialect> {
     readonly filename: string | Buffer;
-    readonly opts?: Options | undefined;
+    readonly opts?: Sqlite3PoolOptions | undefined;
     private db?;
-    constructor(filename?: string | Buffer, opts?: Options | undefined, extra?: ExtraOptions);
+    constructor(filename?: string | Buffer, opts?: Sqlite3PoolOptions | undefined, extra?: ExtraOptions);
     /**
      * The database handle is shared (single connection), but each acquisition gets its own querier
      * so transaction state stays per unit of work.
      */
     getQuerier(): Promise<SqliteQuerier>;
     private openDb;
+    private openDriverDb;
     end(): Promise<void>;
 }
-//# sourceMappingURL=sqliteQuerierPool.d.ts.map

package/dist/sqlite/sqliteQuerierPool.js

@@ -1,12 +1,12 @@
 import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { BetterSqlite3Dialect } from './betterSqlite3Dialect.js';
+import { SqliteDialect } from './sqliteDialect.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
 export class Sqlite3QuerierPool extends AbstractSqlQuerierPool {
     filename;
     opts;
     db;
     constructor(filename = ':memory:', opts, extra) {
-        super(new BetterSqlite3Dialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new SqliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
         this.filename = filename;
         this.opts = opts;
     }
@@ -19,14 +19,25 @@ export class Sqlite3QuerierPool extends AbstractSqlQuerierPool {
         return new SqliteQuerier(this.db, this.dialect, this.extra);
     }
     async openDb() {
+        // `bun:sqlite` rejects option keys it does not know, and rejects an options object carrying no
+        // open flags, so `extensions` is stripped out and what remains of it collapses back to nothing.
+        const { extensions, ...driverOpts } = this.opts ?? {};
+        const db = await this.openDriverDb(Object.keys(driverOpts).length > 0 ? driverOpts : undefined);
+        for (const extension of extensions ?? []) {
+            db.loadExtension(extension);
+        }
+        return db;
+    }
+    async openDriverDb(opts) {
         if (typeof Bun !== 'undefined') {
             const { Database: BunDatabase } = await import('bun:sqlite');
-            const bunDb = new BunDatabase(this.filename, this.opts);
+            const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
+            const bunDb = new BunDatabase(this.filename, opts);
             bunDb.run('PRAGMA journal_mode = WAL');
-            return bunDb;
+            return adaptBunSqlite(bunDb);
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
-        const db = new BetterSqlite3(this.filename, this.opts);
+        const db = new BetterSqlite3(this.filename, opts);
         db.pragma('journal_mode = WAL');
         return db;
     }
@@ -35,4 +46,3 @@ export class Sqlite3QuerierPool extends AbstractSqlQuerierPool {
         this.db = undefined;
     }
 }
-//# sourceMappingURL=sqliteQuerierPool.js.map

package/dist/turso/index.d.ts

@@ -0,0 +1,3 @@
+export * from './tursoDialect.js';
+export * from './tursoQuerier.js';
+export * from './tursoQuerierPool.js';

package/dist/turso/index.js

@@ -0,0 +1,3 @@
+export * from './tursoDialect.js';
+export * from './tursoQuerier.js';
+export * from './tursoQuerierPool.js';

package/dist/turso/local.d.ts

@@ -0,0 +1,3 @@
+export * from './tursoDialect.js';
+export * from './tursoLocalQuerier.js';
+export * from './tursoLocalQuerierPool.js';

package/dist/turso/local.js

@@ -0,0 +1,3 @@
+export * from './tursoDialect.js';
+export * from './tursoLocalQuerier.js';
+export * from './tursoLocalQuerierPool.js';

package/dist/turso/tursoDialect.d.ts

@@ -0,0 +1,15 @@
+import { LibsqlDialect } from '../libsql/libsqlDialect.js';
+import type { VectorDistance } from '../type/index.js';
+/**
+ * SQLite Dialect specialization for Turso Database.
+ *
+ * @remarks Shared by `TursoQuerierPool` (remote, `@tursodatabase/serverless`) and
+ * `TursoLocalQuerierPool` (embedded, `@tursodatabase/database`). Built on `LibsqlDialect` because
+ * Turso is that engine's successor and keeps its SQL surface, vector functions included. Imports
+ * nothing vendor-specific, so the embedded entry point cannot pull native code into an edge bundle
+ * through it.
+ */
+export declare class TursoDialect extends LibsqlDialect {
+    /** The Rust engine adds a dot-product distance to libSQL's cosine and L2. */
+    protected readonly vectorDistanceFns: ReadonlyMap<VectorDistance, string>;
+}

package/dist/turso/tursoDialect.js

@@ -0,0 +1,18 @@
+import { LibsqlDialect } from '../libsql/libsqlDialect.js';
+/**
+ * SQLite Dialect specialization for Turso Database.
+ *
+ * @remarks Shared by `TursoQuerierPool` (remote, `@tursodatabase/serverless`) and
+ * `TursoLocalQuerierPool` (embedded, `@tursodatabase/database`). Built on `LibsqlDialect` because
+ * Turso is that engine's successor and keeps its SQL surface, vector functions included. Imports
+ * nothing vendor-specific, so the embedded entry point cannot pull native code into an edge bundle
+ * through it.
+ */
+export class TursoDialect extends LibsqlDialect {
+    /** The Rust engine adds a dot-product distance to libSQL's cosine and L2. */
+    vectorDistanceFns = new Map([
+        ['cosine', 'vector_distance_cos'],
+        ['l2', 'vector_distance_l2'],
+        ['inner', 'vector_distance_dot'],
+    ]);
+}

package/dist/turso/tursoLocalQuerier.d.ts

@@ -0,0 +1,25 @@
+import { PreparedSqliteQuerier, type SqlitePreparedStatement } from '../sqlite/abstractSqliteQuerier.js';
+import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
+import type { ExtraOptions } from '../type/index.js';
+/**
+ * Structural subset of the `@tursodatabase/database` API actually used here, declared locally so
+ * this package does not couple its published types to a pre-1.0 dependency.
+ */
+export type TursoDatabase = {
+    prepare(sql: string): Promise<SqlitePreparedStatement>;
+    pragma(source: string, options?: unknown): Promise<unknown[]>;
+    close(): Promise<void>;
+};
+/**
+ * Querier for the embedded Turso engine.
+ *
+ * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
+ * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
+ * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
+ */
+export declare class TursoLocalQuerier extends PreparedSqliteQuerier {
+    readonly db: TursoDatabase;
+    readonly extra?: ExtraOptions | undefined;
+    constructor(db: TursoDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
+    protected prepare(query: string): Promise<SqlitePreparedStatement>;
+}