uql-orm 0.62.0 → 0.63.0

package/dist/libsql/libsqlQuerierPool.js

@@ -1,39 +1,51 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { HranaQuerier } from '../sqlite/hranaQuerier.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { LibsqlDialect } from './libsqlDialect.js';
-/** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
-export function libsqlUseRemoteForMigrations(config) {
-    return Boolean(config.syncUrl && config.url.startsWith('file:'));
-}
-/** Remote-only client: same options as the replica, but `url` is `syncUrl` and embedded-replica fields are dropped. */
-function remoteMigrationClientConfig(config) {
-    const { syncUrl, url: _localUrl, ...rest } = config;
-    return { ...rest, url: syncUrl };
-}
-export class LibsqlQuerierPool extends AbstractHranaQuerierPool {
+/**
+ * Pool for libSQL. One client serves every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. The pool builds that client from `@libsql/client`'s
+ * `Config`, or shares one the caller built (`@libsql/client/web`, `@libsql/client-wasm`), which stays
+ * theirs to close.
+ */
+export class LibsqlQuerierPool extends AbstractSharedHandleQuerierPool {
     conf;
     constructor(conf, extra) {
         super(new LibsqlDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
     }
-    openClient() {
-        return this.createClient(this.conf);
+    async openDb() {
+        return 'execute' in this.conf ? this.conf : this.createClient(this.conf);
+    }
+    buildQuerier(client) {
+        return new HranaQuerier(client, this.dialect, this.extra);
+    }
+    async end() {
+        if (!('execute' in this.conf)) {
+            await super.end();
+        }
     }
     /**
-     * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * For an embedded replica - a `file:` url with a `syncUrl` - a querier on the sync url, so migrations
+     * reach sqld, its client closing with it. Anything else migrates like any other querier.
      */
     async getMigrationQuerier() {
-        if (!libsqlUseRemoteForMigrations(this.conf)) {
+        if ('execute' in this.conf) {
             return this.getQuerier();
         }
-        const remote = await this.createClient(remoteMigrationClientConfig(this.conf));
-        return new HranaQuerier(remote, this.dialect, this.extra, { closeClientOnRelease: true });
+        const { syncUrl, url, ...remote } = this.conf;
+        if (!syncUrl || !url.startsWith('file:')) {
+            return this.getQuerier();
+        }
+        const client = await this.createClient({ ...remote, url: syncUrl });
+        return new HranaQuerier(client, this.dialect, this.extra, { closeClientOnRelease: true });
     }
-    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    /**
+     * Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed.
+     * Integers read as `bigint` whatever the config asks, so the querier decodes one past 2^53 exactly.
+     */
     async createClient(conf) {
         const { createClient } = await import('@libsql/client');
-        return createClient(conf);
+        return createClient({ ...conf, intMode: 'bigint' });
     }
 }

package/dist/migrate/codegen/index.d.ts

@@ -5,4 +5,4 @@
  */
 export { createEntityCodeGenerator, EntityCodeGenerator, type EntityCodeGeneratorOptions, type GeneratedEntity, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, type SqlMigrationModuleOptions, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, } from './migrationFile.js';

package/dist/migrate/codegen/index.js

@@ -6,4 +6,4 @@
 // Entity code generator
 export { createEntityCodeGenerator, EntityCodeGenerator, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';

package/dist/migrate/codegen/indexDecoratorSource.d.ts

@@ -7,7 +7,7 @@ import type { IndexNode } from '../../schema/types.js';
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string, param: string): string;

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,3 +1,4 @@
+import { isVectorIndexType } from '../../type/index.js';
 import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
@@ -54,12 +55,12 @@ export function isPlainFieldIndex(index) {
 }
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export function buildIndexDecoratorSource(index, propertyName, param) {
     const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
-    const isVector = index.type === 'hnsw' || index.type === 'ivfflat';
+    const isVector = isVectorIndexType(index.type);
     const distance = isVector ? vectorDistance(index) : undefined;
     const options = [];
     if (index.name)
@@ -88,12 +89,7 @@ export function indexNeedsRaw(index) {
     return Boolean(index.where) || index.entries.some((entry) => entry.expression);
 }
 function indexEntrySource(entry, propertyName, param) {
-    if (entry.expression) {
-        const expression = `() => ${rawTag(entry.column)}`;
-        const modifiers = significantModifiers(entry);
-        return modifiers.length === 0 ? expression : `{ column: ${expression}, ${modifiers.join(', ')} }`;
-    }
-    const column = memberSource(param, propertyName(entry.column));
+    const column = entry.expression ? rawTag(entry.column) : memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);
     return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
 }

package/dist/migrate/codegen/migrationFile.d.ts

@@ -15,8 +15,6 @@ export type MigrationModuleOptions = {
     /** Indented body inside `async down` (including newlines). */
     downInner: string;
 };
-/** @deprecated Use {@link MigrationModuleOptions}. */
-export type SqlMigrationModuleOptions = MigrationModuleOptions;
 /**
  * Emit one `await querier.run(...)` line for entity-generated migrations.
  * Uses `JSON.stringify` so SQL with backticks (SQLite/LibSQL), quotes, `${`, etc. stays valid TS source.
@@ -47,5 +45,3 @@ export declare const migrationSource: {
  * Full contents of a `export default { async up/down(querier) { ... } }` migration module.
  */
 export declare function buildMigrationModule(options: MigrationModuleOptions): string;
-/** @deprecated Use {@link buildMigrationModule}. */
-export declare const buildSqlQuerierMigrationModule: typeof buildMigrationModule;

package/dist/migrate/codegen/migrationFile.js

@@ -65,5 +65,3 @@ ${options.downInner}
 };
 `;
 }
-/** @deprecated Use {@link buildMigrationModule}. */
-export const buildSqlQuerierMigrationModule = buildMigrationModule;

package/dist/querier/abstractSharedHandleQuerierPool.d.ts

@@ -2,13 +2,13 @@ import type { AbstractSqlDialect } from '../dialect/index.js';
 import type { SqlQuerier } from '../type/index.js';
 import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
 /**
- * Base pool for an engine that gives one connection per database and keeps it open for the pool's
- * lifetime: every local SQLite driver, the embedded Turso engine, and PGlite.
+ * Base pool for a handle opened once and kept for the pool's lifetime: the one connection every local
+ * SQLite driver, the embedded Turso engine and PGlite give per database, or libSQL's client.
  *
  * The handle is shared, but each acquisition gets its own querier, so transaction state stays per unit
- * of work. That state is not *isolated*, which is the one way these differ from a real pool: there is a
- * single connection under every querier, so two of them cannot hold independent transactions, and a
- * unit of work that needs one needs its own pool and therefore its own database.
+ * of work. On a single connection that state is not *isolated*, which is the one way these differ from
+ * a real pool: two queriers cannot hold independent transactions, and a unit of work that needs one needs
+ * its own pool and therefore its own database. libSQL's client opens a session per transaction instead.
  *
  * What a second `BEGIN` then does is the engine's, not this class's: SQLite and the embedded Turso
  * engine both refuse it ("cannot start a transaction within a transaction"), while PGlite accepts it

package/dist/querier/abstractSharedHandleQuerierPool.js

@@ -1,12 +1,12 @@
 import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
 /**
- * Base pool for an engine that gives one connection per database and keeps it open for the pool's
- * lifetime: every local SQLite driver, the embedded Turso engine, and PGlite.
+ * Base pool for a handle opened once and kept for the pool's lifetime: the one connection every local
+ * SQLite driver, the embedded Turso engine and PGlite give per database, or libSQL's client.
  *
  * The handle is shared, but each acquisition gets its own querier, so transaction state stays per unit
- * of work. That state is not *isolated*, which is the one way these differ from a real pool: there is a
- * single connection under every querier, so two of them cannot hold independent transactions, and a
- * unit of work that needs one needs its own pool and therefore its own database.
+ * of work. On a single connection that state is not *isolated*, which is the one way these differ from
+ * a real pool: two queriers cannot hold independent transactions, and a unit of work that needs one needs
+ * its own pool and therefore its own database. libSQL's client opens a session per transaction instead.
  *
  * What a second `BEGIN` then does is the engine's, not this class's: SQLite and the embedded Turso
  * engine both refuse it ("cannot start a transaction within a transaction"), while PGlite accepts it

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,4 +1,5 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+import type { RawRow } from '../type/index.js';
 /**
  * Values every SQLite driver accepts as a bound parameter.
  *
@@ -8,41 +9,23 @@ import { AbstractSqlQuerier } from '../querier/index.js';
  * driver as one; leaving `boolean` here only invited a runtime throw that is now a compile error.
  */
 export type SqliteBindValue = null | string | number | bigint | Uint8Array;
-/** Header a SQLite driver returns for a statement without a `RETURNING` clause. */
-export type SqliteRunResult = {
-    changes: number;
-    lastInsertRowid: number | bigint;
+/** What a statement came back with on a SQLite driver: the rows it read, and how many rows it changed. */
+export type SqliteExecution = {
+    readonly rows: RawRow[];
+    readonly changes: number;
 };
-/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
-export declare function toSqliteBindValues(values?: unknown[]): SqliteBindValue[];
 /**
- * A prepared statement from a driver with better-sqlite3 semantics. `better-sqlite3` and `bun:sqlite`
- * answer synchronously, `@tursodatabase/database` with promises, and {@link PreparedSqliteQuerier}
- * awaits either.
+ * Querier for every SQLite driver. Each supplies one hook, {@link execute}; what they share - the
+ * wide-integer decode, and a RETURNING statement counted by its rows - is written once here.
  */
-export type SqlitePreparedStatement = {
-    /** True for any statement returning rows, including one with a `RETURNING` clause. */
-    readonly reader: boolean;
-    all(...values: SqliteBindValue[]): unknown[] | Promise<unknown[]>;
-    run(...values: SqliteBindValue[]): SqliteRunResult | Promise<SqliteRunResult>;
-    iterate(...values: SqliteBindValue[]): Iterable<unknown> | AsyncIterable<unknown>;
-};
 export declare abstract class AbstractSqliteQuerier extends AbstractSqlQuerier {
+    /** Runs one statement, answering its rows as the driver read them. */
+    protected abstract execute(query: string, values?: unknown[]): Promise<SqliteExecution>;
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
     /**
      * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
      * a querier returns nothing at all. Drivers owning a closable per-querier connection override this.
      */
     internalRelease(): Promise<void>;
 }
-/**
- * Querier for the SQLite drivers that expose prepared statements: `better-sqlite3`, `bun:sqlite`
- * (through `adaptBunSqlite`) and the embedded Turso engine. They differ only in whether preparing and
- * stepping are synchronous, which `await` and `for await` absorb, so the read/write/stream logic -
- * including the `reader` rule below, whose loss silently drops inserted ids - is written once.
- */
-export declare abstract class PreparedSqliteQuerier extends AbstractSqliteQuerier {
-    protected abstract prepare(query: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
-    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>;
-}

package/dist/sqlite/abstractSqliteQuerier.js

@@ -1,41 +1,22 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
-/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
-export function toSqliteBindValues(values) {
-    return (values || []);
-}
-export class AbstractSqliteQuerier extends AbstractSqlQuerier {
-    /**
-     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
-     * a querier returns nothing at all. Drivers owning a closable per-querier connection override this.
-     */
-    async internalRelease() { }
-}
+import { decodeBigInts } from '../util/wideNumber.js';
 /**
- * Querier for the SQLite drivers that expose prepared statements: `better-sqlite3`, `bun:sqlite`
- * (through `adaptBunSqlite`) and the embedded Turso engine. They differ only in whether preparing and
- * stepping are synchronous, which `await` and `for await` absorb, so the read/write/stream logic -
- * including the `reader` rule below, whose loss silently drops inserted ids - is written once.
+ * Querier for every SQLite driver. Each supplies one hook, {@link execute}; what they share - the
+ * wide-integer decode, and a RETURNING statement counted by its rows - is written once here.
  */
-export class PreparedSqliteQuerier extends AbstractSqliteQuerier {
+export class AbstractSqliteQuerier extends AbstractSqlQuerier {
     async internalAll(query, values) {
-        const stmt = await this.prepare(query);
-        return (await stmt.all(...toSqliteBindValues(values)));
-    }
-    async *internalStream(query, values) {
-        const stmt = await this.prepare(query);
-        for await (const row of stmt.iterate(...toSqliteBindValues(values))) {
-            yield row;
-        }
+        const { rows } = await this.execute(query, values);
+        return rows.map(decodeBigInts);
     }
     async internalRun(query, values) {
-        const stmt = await this.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 = (await stmt.all(...toSqliteBindValues(values)));
-            return this.buildUpdateResult({ rows });
-        }
-        const { changes, lastInsertRowid } = await stmt.run(...toSqliteBindValues(values));
-        return this.buildUpdateResult({ changes, id: lastInsertRowid });
+        const { rows, changes } = await this.execute(query, values);
+        // A driver's own count is unreliable for a RETURNING statement (Hrana answers 0), so its rows answer.
+        return this.buildUpdateResult({ rows: rows.map(decodeBigInts), changes: rows.length || changes });
     }
+    /**
+     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
+     * a querier returns nothing at all. Drivers owning a closable per-querier connection override this.
+     */
+    async internalRelease() { }
 }

package/dist/sqlite/bunSqliteAdapter.bun.d.ts

@@ -1,5 +1,6 @@
-import type { SqliteBindValue, SqliteRunResult } from './abstractSqliteQuerier.js';
-import type { SqliteDatabase } from './sqliteQuerier.js';
+import type { SqliteBindValue } from './abstractSqliteQuerier.js';
+import type { LocalSqliteDatabase } from './localSqliteQuerierPool.js';
+import type { SqliteRunResult } from './sqliteQuerier.js';
 /** A `bun:sqlite` statement: better-sqlite3-shaped, except it reports columns instead of `reader`. */
 type BunStatement = {
     columnNames: string[];
@@ -13,7 +14,7 @@ type BunDatabase = {
     close(): unknown;
 };
 /**
- * Presents a `bun:sqlite` handle as a {@link SqliteDatabase}.
+ * Presents a `bun:sqlite` handle as a {@link LocalSqliteDatabase}.
  *
  * @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.
@@ -22,5 +23,5 @@ type BunDatabase = {
  * 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 declare function adaptBunSqlite(db: BunDatabase): SqliteDatabase;
+export declare function adaptBunSqlite(db: BunDatabase): LocalSqliteDatabase;
 export {};

package/dist/sqlite/bunSqliteAdapter.bun.js

@@ -1,5 +1,5 @@
 /**
- * Presents a `bun:sqlite` handle as a {@link SqliteDatabase}.
+ * Presents a `bun:sqlite` handle as a {@link LocalSqliteDatabase}.
  *
  * @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.

package/dist/sqlite/hranaQuerier.d.ts

@@ -1,4 +1,4 @@
-import type { ExtraOptions } from '../type/index.js';
+import type { ExtraOptions, RawRow } from '../type/index.js';
 import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
 /**
@@ -11,7 +11,6 @@ export type HranaInValue = SqliteBindValue | ArrayBuffer | Date;
 export type HranaResultSet = {
     rows: unknown[];
     rowsAffected: number;
-    lastInsertRowid?: bigint;
 };
 export type HranaExecutor = {
     execute(stmt: {
@@ -44,8 +43,11 @@ export declare class HranaQuerier extends AbstractSqliteQuerier {
     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>;
+    /** Runs on the open transaction's handle when there is one. */
+    protected execute(query: string, values?: unknown[]): Promise<{
+        rows: RawRow[];
+        changes: number;
+    }>;
     protected internalBegin(): Promise<void>;
     /**
      * Both drop the handle before the call, not after: one that outlived a failed commit would carry

package/dist/sqlite/hranaQuerier.js

@@ -16,18 +16,10 @@ export class HranaQuerier extends AbstractSqliteQuerier {
         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 });
+    /** Runs on the open transaction's handle when there is one. */
+    async execute(query, values) {
+        const res = await (this.tx ?? this.client).execute({ sql: query, args: values });
+        return { rows: res.rows, changes: res.rowsAffected };
     }
     async internalBegin() {
         this.tx = await this.client.transaction('write');
@@ -47,7 +39,6 @@ export class HranaQuerier extends AbstractSqliteQuerier {
         await tx?.rollback();
     }
     async internalRelease() {
-        await super.internalRelease();
         if (this.closeClientOnRelease) {
             this.client.close();
         }

package/dist/sqlite/index.d.ts

@@ -1,6 +1,5 @@
 export * from './abstractSqliteQuerier.js';
 export * from './hranaQuerier.js';
-export * from './hranaQuerierPool.js';
 export * from './nodeSqliteQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';

package/dist/sqlite/index.js

@@ -1,6 +1,5 @@
 export * from './abstractSqliteQuerier.js';
 export * from './hranaQuerier.js';
-export * from './hranaQuerierPool.js';
 export * from './nodeSqliteQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -1,7 +1,7 @@
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { SqliteDialect } from './sqliteDialect.js';
-import { type SqliteDatabase, SqliteQuerier } from './sqliteQuerier.js';
+import { type SqlitePreparedStatement, SqliteQuerier } from './sqliteQuerier.js';
 /** What every local SQLite pool accepts on top of its driver's own options. */
 export type LocalSqlitePoolOptions = {
     /**
@@ -11,6 +11,15 @@ export type LocalSqlitePoolOptions = {
      */
     extensions?: readonly string[];
 };
+/**
+ * A database opened in this process by a driver that answers at once, and installs loadable extensions
+ * (`sqlite-vec`, ...) into its connection.
+ */
+export type LocalSqliteDatabase = {
+    prepare(sql: string): SqlitePreparedStatement;
+    loadExtension(path: string): void;
+    close(): unknown;
+};
 /**
  * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
  * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
@@ -18,11 +27,11 @@ export type LocalSqlitePoolOptions = {
  * Subclasses supply only {@link createDb}: configuring the connection on the way up - the pragmas,
  * then the extensions - is the same for `better-sqlite3`, `bun:sqlite` and `node:sqlite`.
  */
-export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSharedHandleQuerierPool<SqliteDatabase, SqliteQuerier, SqliteDialect> {
+export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSharedHandleQuerierPool<LocalSqliteDatabase, SqliteQuerier, SqliteDialect> {
     readonly opts?: O | undefined;
     constructor(opts?: O | undefined, extra?: ExtraOptions);
     /** Opens the driver's database, and nothing more: the caller configures it. */
-    protected abstract createDb(): Promise<SqliteDatabase>;
-    protected openDb(): Promise<SqliteDatabase>;
-    protected buildQuerier(db: SqliteDatabase): SqliteQuerier;
+    protected abstract createDb(): Promise<LocalSqliteDatabase>;
+    protected openDb(): Promise<LocalSqliteDatabase>;
+    protected buildQuerier(db: LocalSqliteDatabase): SqliteQuerier;
 }

package/dist/sqlite/nodeSqliteAdapter.d.ts

@@ -1,5 +1,5 @@
 import type { SqliteBindValue } from './abstractSqliteQuerier.js';
-import type { SqliteDatabase } from './sqliteQuerier.js';
+import type { LocalSqliteDatabase } from './localSqliteQuerierPool.js';
 /**
  * A `node:sqlite` statement: better-sqlite3-shaped, except it describes columns instead of reporting
  * `reader`, and types `changes` as possibly `bigint` where better-sqlite3 always answers a `number`.
@@ -9,7 +9,6 @@ type NodeSqliteStatement = {
     all(...values: SqliteBindValue[]): unknown[];
     run(...values: SqliteBindValue[]): {
         changes: number | bigint;
-        lastInsertRowid: number | bigint;
     };
     iterate(...values: SqliteBindValue[]): Iterable<unknown>;
 };
@@ -23,12 +22,12 @@ export type NodeSqliteDatabase = {
     close(): void;
 };
 /**
- * Presents a `node:sqlite` handle as a {@link SqliteDatabase}.
+ * Presents a `node:sqlite` handle as a {@link LocalSqliteDatabase}.
  *
  * @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.
  * `columns()` is non-empty for exactly the statements better-sqlite3 marks as readers, including
  * `INSERT ... RETURNING` and `DELETE ... RETURNING`.
  */
-export declare function adaptNodeSqlite(db: NodeSqliteDatabase): SqliteDatabase;
+export declare function adaptNodeSqlite(db: NodeSqliteDatabase): LocalSqliteDatabase;
 export {};

package/dist/sqlite/nodeSqliteAdapter.js

@@ -1,5 +1,5 @@
 /**
- * Presents a `node:sqlite` handle as a {@link SqliteDatabase}.
+ * Presents a `node:sqlite` handle as a {@link LocalSqliteDatabase}.
  *
  * @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.
@@ -14,11 +14,8 @@ export function adaptNodeSqlite(db) {
                 reader: stmt.columns().length > 0,
                 all: (...values) => stmt.all(...values),
                 // `changes` is narrowed to `number` to match every other driver; a row count cannot exceed
-                // the safe-integer range, so nothing is lost. `lastInsertRowid` keeps its `bigint` arm.
-                run: (...values) => {
-                    const { changes, lastInsertRowid } = stmt.run(...values);
-                    return { changes: Number(changes), lastInsertRowid };
-                },
+                // the safe-integer range, so nothing is lost.
+                run: (...values) => ({ changes: Number(stmt.run(...values).changes) }),
                 iterate: (...values) => stmt.iterate(...values),
             };
         },

package/dist/sqlite/nodeSqliteQuerierPool.d.ts

@@ -1,6 +1,5 @@
 import type { ExtraOptions } from '../type/index.js';
-import { AbstractLocalSqliteQuerierPool, type LocalSqlitePoolOptions } from './localSqliteQuerierPool.js';
-import type { SqliteDatabase } from './sqliteQuerier.js';
+import { AbstractLocalSqliteQuerierPool, type LocalSqliteDatabase, type LocalSqlitePoolOptions } from './localSqliteQuerierPool.js';
 /**
  * The `DatabaseSync` options worth surfacing, plus the loadable extensions to install. Declared here
  * rather than imported from `node:sqlite` so this module needs no ambient Node types; unknown keys
@@ -24,5 +23,5 @@ export type NodeSqlitePoolOptions = LocalSqlitePoolOptions & {
 export declare class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool<NodeSqlitePoolOptions> {
     readonly filename: string;
     constructor(filename?: string, opts?: NodeSqlitePoolOptions, extra?: ExtraOptions);
-    protected createDb(): Promise<SqliteDatabase>;
+    protected createDb(): Promise<LocalSqliteDatabase>;
 }

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -1,4 +1,4 @@
-import { AbstractLocalSqliteQuerierPool } from './localSqliteQuerierPool.js';
+import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
 import { adaptNodeSqlite } from './nodeSqliteAdapter.js';
 /**
  * Pool backed by Node's built-in `node:sqlite`, so SQLite works with **no dependency at all** rather
@@ -20,6 +20,8 @@ export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
         const { extensions, ...driverOpts } = this.opts ?? {};
         const nodeDb = new DatabaseSync(this.filename, {
             ...driverOpts,
+            // Integers as `bigint`, which the querier decodes exactly past 2^53.
+            readBigInts: true,
             // `node:sqlite` refuses `loadExtension` unless the database was opened with this on.
             ...(extensions?.length ? { allowExtension: true } : undefined),
         });

package/dist/sqlite/sqliteDialect.d.ts

@@ -16,7 +16,7 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
     readonly supportsRowLocks = false;
     readonly booleanLiteral = "integer";
-    /** A function call takes 127 arguments before SQLite 3.48, as libSQL and Turso embed. */
+    /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     readonly maxFunctionArgs: number;
     readonly insertIdSource = "returning";
     /**

package/dist/sqlite/sqliteDialect.js

@@ -39,7 +39,7 @@ export class SqliteDialect extends AbstractSqlDialect {
     /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
     supportsRowLocks = false;
     booleanLiteral = 'integer';
-    /** A function call takes 127 arguments before SQLite 3.48, as libSQL and Turso embed. */
+    /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     maxFunctionArgs = 127;
     // SQLite supports `RETURNING` (including on `INSERT ... ON CONFLICT`), so IDs are exact per row.
     insertIdSource = 'returning';

package/dist/sqlite/sqlitePragmas.d.ts

@@ -1,12 +1,3 @@
-import type { SqlitePreparedStatement } from './abstractSqliteQuerier.js';
-/**
- * How every local SQLite connection opens. WAL, so a reader does not wait on the writer, and
- * `foreign_keys`, which SQLite ships off per connection for backward compatibility: without it the
- * constraints uql's own DDL declares are decorative - a declared `onDelete: 'CASCADE'` silently does
- * nothing and a dangling reference is accepted.
- */
-export declare const SQLITE_PRAGMAS: readonly ['journal_mode = WAL', 'foreign_keys = ON'];
+import type { SqliteDatabase } from './sqliteQuerier.js';
 /** Runs {@link SQLITE_PRAGMAS} through a driver's own statements, whether it answers now or later. */
-export declare function applySqlitePragmas(db: {
-    prepare(sql: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
-}): Promise<void>;
+export declare function applySqlitePragmas(db: Pick<SqliteDatabase, 'prepare'>): Promise<void>;

package/dist/sqlite/sqlitePragmas.js

@@ -4,7 +4,7 @@
  * constraints uql's own DDL declares are decorative - a declared `onDelete: 'CASCADE'` silently does
  * nothing and a dangling reference is accepted.
  */
-export const SQLITE_PRAGMAS = ['journal_mode = WAL', 'foreign_keys = ON'];
+const SQLITE_PRAGMAS = ['journal_mode = WAL', 'foreign_keys = ON'];
 /** Runs {@link SQLITE_PRAGMAS} through a driver's own statements, whether it answers now or later. */
 export async function applySqlitePragmas(db) {
     for (const pragma of SQLITE_PRAGMAS) {