uql-orm 0.62.0 → 0.64.0

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) {

package/dist/sqlite/sqliteQuerier.d.ts

@@ -1,20 +1,39 @@
-import type { ExtraOptions } from '../type/index.js';
-import { PreparedSqliteQuerier, type SqlitePreparedStatement } from './abstractSqliteQuerier.js';
+import type { ExtraOptions, RawRow } from '../type/index.js';
+import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
+/** What uql reads of a driver's `run()`: the row count. An inserted id comes back through `RETURNING`. */
+export type SqliteRunResult = {
+    changes: number;
+};
+/** A prepared statement with better-sqlite3 semantics, answering at once or with a promise. */
+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>;
+};
 /**
- * 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}.
+ * A SQLite driver that prepares statements. `better-sqlite3` and the embedded Turso engine satisfy it
+ * as they are, `bun:sqlite` and `node:sqlite` through their adapters.
  */
 export type SqliteDatabase = {
-    prepare(sql: string): SqlitePreparedStatement;
-    /** Installs a loadable extension (`sqlite-vec`, ...) into this connection. */
-    loadExtension(path: string): void;
+    prepare(sql: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
     close(): unknown;
 };
-export declare class SqliteQuerier extends PreparedSqliteQuerier {
+/**
+ * Querier for the SQLite drivers that prepare statements: `better-sqlite3`, `bun:sqlite`, `node:sqlite`
+ * and the embedded Turso engine. They differ only in whether preparing and stepping answer at once or
+ * with a promise, which `await` and `for await` absorb.
+ */
+export declare class SqliteQuerier extends AbstractSqliteQuerier {
     readonly db: SqliteDatabase;
     readonly extra?: ExtraOptions | undefined;
     constructor(db: SqliteDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected prepare(query: string): SqlitePreparedStatement;
+    /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
+    protected execute(query: string, values?: unknown[]): Promise<{
+        rows: RawRow[];
+        changes: number;
+    }>;
+    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
 }

package/dist/sqlite/sqliteQuerier.js

@@ -1,5 +1,11 @@
-import { PreparedSqliteQuerier } from './abstractSqliteQuerier.js';
-export class SqliteQuerier extends PreparedSqliteQuerier {
+import { decodeBigInts } from '../util/wideNumber.js';
+import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
+/**
+ * Querier for the SQLite drivers that prepare statements: `better-sqlite3`, `bun:sqlite`, `node:sqlite`
+ * and the embedded Turso engine. They differ only in whether preparing and stepping answer at once or
+ * with a promise, which `await` and `for await` absorb.
+ */
+export class SqliteQuerier extends AbstractSqliteQuerier {
     db;
     extra;
     constructor(db, dialect, extra) {
@@ -7,7 +13,23 @@ export class SqliteQuerier extends PreparedSqliteQuerier {
         this.db = db;
         this.extra = extra;
     }
-    prepare(query) {
-        return this.db.prepare(query);
+    /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
+    async execute(query, values) {
+        const stmt = await this.db.prepare(query);
+        const bound = toBindValues(values);
+        if (stmt.reader) {
+            return { rows: (await stmt.all(...bound)), changes: 0 };
+        }
+        return { rows: [], changes: (await stmt.run(...bound)).changes };
     }
+    async *internalStream(query, values) {
+        const stmt = await this.db.prepare(query);
+        for await (const row of stmt.iterate(...toBindValues(values))) {
+            yield decodeBigInts(row);
+        }
+    }
+}
+/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
+function toBindValues(values) {
+    return (values ?? []);
 }

package/dist/sqlite/sqliteQuerierPool.d.ts

@@ -1,7 +1,6 @@
 import type { Options } from 'better-sqlite3';
 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';
 /** Driver options, plus the loadable extensions to install on the connection. */
 export type Sqlite3PoolOptions = Options & LocalSqlitePoolOptions;
 /**
@@ -11,5 +10,10 @@ export type Sqlite3PoolOptions = Options & LocalSqlitePoolOptions;
 export declare class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool<Sqlite3PoolOptions> {
     readonly filename: string | Buffer;
     constructor(filename?: string | Buffer, opts?: Sqlite3PoolOptions, extra?: ExtraOptions);
-    protected createDb(): Promise<SqliteDatabase>;
+    /**
+     * Both drivers read integers as `bigint`, which the querier decodes exactly past 2^53. `bun:sqlite`
+     * rejects option keys it does not know, so `extensions` is stripped out, and opens only a path, so a
+     * serialized database - which better-sqlite3 takes as its filename - is deserialized there instead.
+     */
+    protected createDb(): Promise<LocalSqliteDatabase>;
 }

package/dist/sqlite/sqliteQuerierPool.js

@@ -1,5 +1,4 @@
-import { hasKeys } from '../util/object.util.js';
-import { AbstractLocalSqliteQuerierPool } from './localSqliteQuerierPool.js';
+import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
 /**
  * Pool for `better-sqlite3`, or `bun:sqlite` when running under Bun - the same file, through whichever
  * driver the runtime provides.
@@ -10,17 +9,22 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         super(opts, extra);
         this.filename = filename;
     }
+    /**
+     * Both drivers read integers as `bigint`, which the querier decodes exactly past 2^53. `bun:sqlite`
+     * rejects option keys it does not know, so `extensions` is stripped out, and opens only a path, so a
+     * serialized database - which better-sqlite3 takes as its filename - is deserialized there instead.
+     */
     async createDb() {
-        // `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 opts = hasKeys(driverOpts) ? driverOpts : undefined;
         if (typeof Bun !== 'undefined') {
-            const { Database: BunDatabase } = await import('bun:sqlite');
+            const { Database } = await import('bun:sqlite');
             const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
-            return adaptBunSqlite(new BunDatabase(this.filename, opts));
+            const bunOpts = { ...driverOpts, safeIntegers: true };
+            return adaptBunSqlite(typeof this.filename === 'string'
+                ? new Database(this.filename, bunOpts)
+                : Database.deserialize(this.filename, bunOpts));
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
-        return new BetterSqlite3(this.filename, opts);
+        return new BetterSqlite3(this.filename, driverOpts).defaultSafeIntegers(true);
     }
 }

package/dist/turso/index.d.ts

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

package/dist/turso/index.js

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

package/dist/turso/local.d.ts

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

package/dist/turso/local.js

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

package/dist/turso/tursoDialect.d.ts

@@ -1,17 +1,12 @@
 import { LibsqlDialect } from '../libsql/libsqlDialect.js';
-import type { VectorDistance, VectorMetric } from '../type/index.js';
 /**
- * SQLite Dialect specialization for Turso Database.
+ * SQLite Dialect specialization for Turso Cloud: what every Turso Cloud database accepts, since one runs
+ * libSQL unless it was created as `tursodb`, which runs the Rust engine. libSQL's vector functions and
+ * argument cap hold on both, and so does the Rust engine's missing `ORDER BY` inside an aggregate.
  *
- * @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.
+ * @remarks Imports nothing vendor-specific, so no entry point can pull a driver in through it.
  */
 export declare class TursoDialect extends LibsqlDialect {
-    /** The Rust engine adds a dot-product distance to libSQL's cosine and L2. */
-    readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
     /** The Rust engine takes no `ORDER BY` inside an aggregate. */
     protected readonly orderedAggregates = false;
 }

package/dist/turso/tursoDialect.js

@@ -1,20 +1,12 @@
 import { LibsqlDialect } from '../libsql/libsqlDialect.js';
 /**
- * SQLite Dialect specialization for Turso Database.
+ * SQLite Dialect specialization for Turso Cloud: what every Turso Cloud database accepts, since one runs
+ * libSQL unless it was created as `tursodb`, which runs the Rust engine. libSQL's vector functions and
+ * argument cap hold on both, and so does the Rust engine's missing `ORDER BY` inside an aggregate.
  *
- * @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.
+ * @remarks Imports nothing vendor-specific, so no entry point can pull a driver in through it.
  */
 export class TursoDialect extends LibsqlDialect {
-    /** The Rust engine adds a dot-product distance to libSQL's cosine and L2. */
-    vectorMetrics = new Map([
-        ['cosine', { fn: 'vector_distance_cos' }],
-        ['l2', { fn: 'vector_distance_l2' }],
-        ['inner', { fn: 'vector_distance_dot' }],
-    ]);
     /** The Rust engine takes no `ORDER BY` inside an aggregate. */
     orderedAggregates = false;
 }

package/dist/turso/tursoLocalDialect.d.ts

@@ -0,0 +1,10 @@
+import type { VectorDistance, VectorMetric } from '../type/index.js';
+import { TursoDialect } from './tursoDialect.js';
+/**
+ * SQLite Dialect specialization for the embedded Turso engine, the Rust engine alone: it adds a
+ * dot-product distance to libSQL's cosine and L2, and caps no function call.
+ */
+export declare class TursoLocalDialect extends TursoDialect {
+    readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
+    readonly maxFunctionArgs: number;
+}

package/dist/turso/tursoLocalDialect.js

@@ -0,0 +1,13 @@
+import { TursoDialect } from './tursoDialect.js';
+/**
+ * SQLite Dialect specialization for the embedded Turso engine, the Rust engine alone: it adds a
+ * dot-product distance to libSQL's cosine and L2, and caps no function call.
+ */
+export class TursoLocalDialect extends TursoDialect {
+    vectorMetrics = new Map([
+        ['cosine', { fn: 'vector_distance_cos' }],
+        ['l2', { fn: 'vector_distance_l2' }],
+        ['inner', { fn: 'vector_distance_dot' }],
+    ]);
+    maxFunctionArgs = Infinity;
+}

package/dist/turso/tursoLocalQuerierPool.d.ts

@@ -1,15 +1,10 @@
+import type { connect } from '@tursodatabase/database';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
+import { type SqliteDatabase, SqliteQuerier } from '../sqlite/sqliteQuerier.js';
 import type { ExtraOptions } from '../type/index.js';
-import { TursoDialect } from './tursoDialect.js';
-import { type TursoDatabase, TursoLocalQuerier } from './tursoLocalQuerier.js';
-/** Subset of `DatabaseOpts` from `@tursodatabase/database`, declared locally to avoid the coupling. */
-export type TursoLocalOptions = {
-    readonly?: boolean;
-    fileMustExist?: boolean;
-    timeout?: number;
-    defaultQueryTimeout?: number;
-    tracing?: 'info' | 'debug' | 'trace';
-};
+import { TursoLocalDialect } from './tursoLocalDialect.js';
+/** The engine's own options: `readonly`, `timeout`, `encryption`, `experimental` and the rest. */
+export type TursoLocalOptions = NonNullable<Parameters<typeof connect>[1]>;
 /**
  * Pool for the embedded Turso engine (`@tursodatabase/database`), the Rust rewrite of SQLite.
  *
@@ -17,10 +12,10 @@ export type TursoLocalOptions = {
  * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
  * bundle targeting Workers never reaches the native import.
  */
-export declare class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool<TursoDatabase, TursoLocalQuerier, TursoDialect> {
+export declare class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool<SqliteDatabase, SqliteQuerier, TursoLocalDialect> {
     readonly filename: string;
     readonly opts?: TursoLocalOptions | undefined;
     constructor(filename?: string, opts?: TursoLocalOptions | undefined, extra?: ExtraOptions);
-    protected openDb(): Promise<TursoDatabase>;
-    protected buildQuerier(db: TursoDatabase): TursoLocalQuerier;
+    protected openDb(): Promise<SqliteDatabase>;
+    protected buildQuerier(db: SqliteDatabase): SqliteQuerier;
 }

package/dist/turso/tursoLocalQuerierPool.js

@@ -1,8 +1,8 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { applySqlitePragmas } from '../sqlite/sqlitePragmas.js';
-import { TursoDialect } from './tursoDialect.js';
-import { TursoLocalQuerier } from './tursoLocalQuerier.js';
+import { SqliteQuerier } from '../sqlite/sqliteQuerier.js';
+import { TursoLocalDialect } from './tursoLocalDialect.js';
 /**
  * Pool for the embedded Turso engine (`@tursodatabase/database`), the Rust rewrite of SQLite.
  *
@@ -14,18 +14,19 @@ export class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool {
     filename;
     opts;
     constructor(filename = ':memory:', opts, extra) {
-        super(new TursoDialect(dialectOptionsFrom(extra)), extra);
+        super(new TursoLocalDialect(dialectOptionsFrom(extra)), extra);
         this.filename = filename;
         this.opts = opts;
     }
     async openDb() {
         const { connect } = await import('@tursodatabase/database');
-        // Annotated rather than cast, so the structural contract is checked against the real driver.
         const db = await connect(this.filename, this.opts);
+        // Integers as `bigint`, which the querier decodes exactly past 2^53.
+        db.defaultSafeIntegers(true);
         await applySqlitePragmas(db);
         return db;
     }
     buildQuerier(db) {
-        return new TursoLocalQuerier(db, this.dialect, this.extra);
+        return new SqliteQuerier(db, this.dialect, this.extra);
     }
 }

package/dist/turso/tursoQuerierPool.d.ts

@@ -1,37 +1,22 @@
-import type { HranaClient } from '../sqlite/hranaQuerier.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
+import type { Config } from '@tursodatabase/serverless';
+import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
 import { TursoDialect } from './tursoDialect.js';
+import { TursoSessionQuerier } from './tursoSessionQuerier.js';
+/** Connection settings for Turso Cloud: `@tursodatabase/serverless`'s own, `requestHeaders` included. */
+export type TursoConfig = Config;
 /**
- * Connection settings for Turso Cloud, mirroring `@tursodatabase/serverless`.
+ * Pool for Turso Cloud, over `@tursodatabase/serverless`, which speaks HTTP through `fetch()`.
  *
- * @remarks Declared here rather than imported so this package does not couple its published types
- * to a pre-1.0 dependency.
+ * @remarks Every querier opens a session of its own, one server stream, so queriers never wait on each
+ * other and a transaction spans one stream. The driver is imported on first use, so a pool built at
+ * module scope in a Worker loads nothing until a request needs it. A client built with
+ * `@libsql/client/web` goes to `LibsqlQuerierPool` instead.
  */
-export type TursoConfig = {
-    /** `libsql://<db>.turso.io` or `https://<db>.turso.io`. */
-    url: string;
-    authToken?: string;
-    remoteEncryptionKey?: string;
-    /** Extra HTTP headers attached to every request, e.g. for routing through a gateway. */
-    requestHeaders?: Record<string, string>;
-};
-/**
- * Pool for remote Turso Cloud databases, driven by `@tursodatabase/serverless/compat`.
- *
- * @remarks The compat entry point is required rather than the native one: the native
- * `conn.transaction()` takes a callback, which cannot satisfy the explicit
- * `beginTransaction`/`commitTransaction` contract, and issuing a bare `BEGIN` is not an option
- * because over plain HTTP consecutive requests need not share a connection. Compat's session-backed
- * transaction handle is the piece that makes it work.
- */
-export declare class TursoQuerierPool extends AbstractHranaQuerierPool<TursoDialect> {
-    protected readonly ownsClient: boolean;
+export declare class TursoQuerierPool extends AbstractSqlQuerierPool<TursoSessionQuerier, TursoDialect> {
     private readonly conf;
-    /**
-     * Accepts either connection settings or an already-built client. The latter covers any driver
-     * with the same shape: `@libsql/client/web`, `@libsql/client-wasm`, or a test double.
-     */
-    constructor(conf: TursoConfig | HranaClient, extra?: ExtraOptions);
-    protected openClient(): Promise<HranaClient>;
+    constructor(conf: TursoConfig, extra?: ExtraOptions);
+    getQuerier(): Promise<TursoSessionQuerier>;
+    /** Nothing to close: every querier closes its own session. */
+    end(): Promise<void>;
 }

package/dist/turso/tursoQuerierPool.js

@@ -1,35 +1,25 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
+import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { TursoDialect } from './tursoDialect.js';
-function isClient(conf) {
-    return typeof conf.execute === 'function';
-}
+import { TursoSessionQuerier } from './tursoSessionQuerier.js';
 /**
- * Pool for remote Turso Cloud databases, driven by `@tursodatabase/serverless/compat`.
+ * Pool for Turso Cloud, over `@tursodatabase/serverless`, which speaks HTTP through `fetch()`.
  *
- * @remarks The compat entry point is required rather than the native one: the native
- * `conn.transaction()` takes a callback, which cannot satisfy the explicit
- * `beginTransaction`/`commitTransaction` contract, and issuing a bare `BEGIN` is not an option
- * because over plain HTTP consecutive requests need not share a connection. Compat's session-backed
- * transaction handle is the piece that makes it work.
+ * @remarks Every querier opens a session of its own, one server stream, so queriers never wait on each
+ * other and a transaction spans one stream. The driver is imported on first use, so a pool built at
+ * module scope in a Worker loads nothing until a request needs it. A client built with
+ * `@libsql/client/web` goes to `LibsqlQuerierPool` instead.
  */
-export class TursoQuerierPool extends AbstractHranaQuerierPool {
-    ownsClient;
+export class TursoQuerierPool extends AbstractSqlQuerierPool {
     conf;
-    /**
-     * Accepts either connection settings or an already-built client. The latter covers any driver
-     * with the same shape: `@libsql/client/web`, `@libsql/client-wasm`, or a test double.
-     */
     constructor(conf, extra) {
         super(new TursoDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
-        this.ownsClient = !isClient(conf);
     }
-    async openClient() {
-        if (isClient(this.conf)) {
-            return this.conf;
-        }
-        const { createClient } = await import('@tursodatabase/serverless/compat');
-        return createClient(this.conf);
+    async getQuerier() {
+        const { Session } = await import('@tursodatabase/serverless');
+        return new TursoSessionQuerier(new Session(this.conf), this.dialect, this.extra);
     }
+    /** Nothing to close: every querier closes its own session. */
+    async end() { }
 }

package/dist/turso/tursoSessionQuerier.d.ts

@@ -0,0 +1,57 @@
+import { AbstractSqliteQuerier, type SqliteBindValue } from '../sqlite/abstractSqliteQuerier.js';
+import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
+import type { ExtraOptions, RawRow } from '../type/index.js';
+/** What a statement comes back with on a session: each row an array of its values, named by `columns`. */
+export type TursoResultSet = {
+    columns: string[];
+    rows: unknown[][];
+    rowsAffected: number;
+};
+/** A value as the server encodes it on a cursor, which the driver's `decodeValue` reads. */
+export type TursoValue = {
+    type: 'null' | 'integer' | 'float' | 'text' | 'blob';
+    value?: string | number;
+    base64?: string;
+};
+/** One entry of a statement's cursor: its columns, a row, the end of a step, or an error. */
+export type TursoCursorEntry = {
+    type: 'step_begin' | 'step_end' | 'step_error' | 'row' | 'error';
+    cols?: {
+        name: string;
+    }[];
+    row?: TursoValue[];
+    error?: {
+        message: string;
+        code?: string;
+    };
+};
+/**
+ * The part of a `@tursodatabase/serverless` `Session` the querier uses: one server stream, which every
+ * statement on it shares, since each request carries the baton of the response before it.
+ */
+export type TursoSession = {
+    execute(sql: string, args: SqliteBindValue[], safeIntegers: boolean): Promise<TursoResultSet>;
+    executeRaw(sql: string, args: SqliteBindValue[]): Promise<{
+        entries: AsyncIterable<TursoCursorEntry>;
+    }>;
+    close(): Promise<void>;
+};
+/**
+ * Querier for Turso Cloud on a session of its own.
+ *
+ * @remarks The stream is what makes a transaction plain `BEGIN`/`COMMIT`, left to the base class, and
+ * what `release` closes. A row comes back an array carrying its column names as hidden properties, so it
+ * is rebuilt as the object every querier answers.
+ */
+export declare class TursoSessionQuerier extends AbstractSqliteQuerier {
+    readonly session: TursoSession;
+    readonly extra?: ExtraOptions | undefined;
+    constructor(session: TursoSession, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
+    protected execute(query: string, values?: unknown[]): Promise<{
+        rows: RawRow[];
+        changes: number;
+    }>;
+    /** Row by row off the statement's cursor, as the server steps it, each decoded as `execute` decodes one. */
+    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    internalRelease(): Promise<void>;
+}

package/dist/turso/tursoSessionQuerier.js

@@ -0,0 +1,50 @@
+import { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
+import { decodeBigInts } from '../util/wideNumber.js';
+/**
+ * Querier for Turso Cloud on a session of its own.
+ *
+ * @remarks The stream is what makes a transaction plain `BEGIN`/`COMMIT`, left to the base class, and
+ * what `release` closes. A row comes back an array carrying its column names as hidden properties, so it
+ * is rebuilt as the object every querier answers.
+ */
+export class TursoSessionQuerier extends AbstractSqliteQuerier {
+    session;
+    extra;
+    constructor(session, dialect, extra) {
+        super(dialect, extra);
+        this.session = session;
+        this.extra = extra;
+    }
+    async execute(query, values) {
+        const { columns, rows, rowsAffected } = await this.session.execute(query, toBindValues(values), true);
+        return { rows: rows.map((row) => toRow(columns, row)), changes: rowsAffected };
+    }
+    /** Row by row off the statement's cursor, as the server steps it, each decoded as `execute` decodes one. */
+    async *internalStream(query, values) {
+        const { DatabaseError, decodeValue } = await import('@tursodatabase/serverless');
+        const { entries } = await this.session.executeRaw(query, toBindValues(values));
+        let columns = [];
+        for await (const entry of entries) {
+            if (entry.type === 'step_error' || entry.type === 'error') {
+                throw new DatabaseError(entry.error?.message ?? 'SQL execution failed', entry.error?.code);
+            }
+            if (entry.cols) {
+                columns = entry.cols.map(({ name }) => name);
+            }
+            if (entry.row) {
+                yield decodeBigInts(toRow(columns, entry.row.map((value) => decodeValue(value, true))));
+            }
+        }
+    }
+    async internalRelease() {
+        await this.session.close();
+    }
+}
+/** A row the driver answers as an array of values, named by the statement's columns. */
+function toRow(columns, values) {
+    return Object.fromEntries(columns.map((column, at) => [column, values[at]]));
+}
+/** Bound parameters reach a driver as `unknown[]` from the compiler; a session binds them as they are. */
+function toBindValues(values) {
+    return (values ?? []);
+}