uql-orm 0.20.2 → 0.22.0

package/dist/querier/decorator/injectQuerier.d.ts

@@ -1,4 +1,3 @@
 import type { Key, Type } from '../../type/index.js';
 export declare function InjectQuerier(): (proto: Record<PropertyKey, any>, key: string, index: number) => void;
 export declare function getInjectedQuerierIndex<S>(service: Type<S>, key: Key<S>): any;
-//# sourceMappingURL=injectQuerier.d.ts.map

package/dist/querier/decorator/injectQuerier.js

@@ -31,4 +31,3 @@ export function getInjectedQuerierIndex(service, key) {
         proto = Object.getPrototypeOf(proto);
     }
 }
-//# sourceMappingURL=injectQuerier.js.map

package/dist/querier/decorator/log.d.ts

@@ -30,4 +30,3 @@ export declare function enrichError(err: unknown, logger: LoggerWrapper | undefi
  * printed in full when the app already opted into it.
  */
 export declare function Log(): (_target: object, _key: string, propDescriptor: PropertyDescriptor) => void;
-//# sourceMappingURL=log.d.ts.map

package/dist/querier/decorator/log.js

@@ -50,4 +50,3 @@ export function Log() {
         };
     };
 }
-//# sourceMappingURL=log.js.map

package/dist/querier/decorator/serialized.d.ts

@@ -4,4 +4,3 @@
  * Note: The decorated class must extend AbstractQuerier or implement a compatible serialize method.
  */
 export declare function Serialized(): (_target: object, _key: string, propDescriptor: PropertyDescriptor) => void;
-//# sourceMappingURL=serialized.d.ts.map

package/dist/querier/decorator/serialized.js

@@ -11,4 +11,3 @@ export function Serialized() {
         };
     };
 }
-//# sourceMappingURL=serialized.js.map

package/dist/querier/decorator/transactional.d.ts

@@ -4,4 +4,3 @@ export declare function Transactional({ propagation, pool, isolationLevel, }?: {
     readonly pool?: QuerierPool;
     readonly isolationLevel?: IsolationLevel;
 }): (target: object, key: string, propDescriptor: PropertyDescriptor) => void;
-//# sourceMappingURL=transactional.d.ts.map

package/dist/querier/decorator/transactional.js

@@ -46,4 +46,3 @@ export function Transactional({ propagation = 'required', pool, isolationLevel,
         };
     };
 }
-//# sourceMappingURL=transactional.js.map

package/dist/querier/index.d.ts

@@ -3,4 +3,3 @@ export * from './abstractQuerierPool.js';
 export * from './abstractSqlQuerier.js';
 export * from './abstractSqlQuerierPool.js';
 export * from './decorator/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/querier/index.js

@@ -3,4 +3,3 @@ export * from './abstractQuerierPool.js';
 export * from './abstractSqlQuerier.js';
 export * from './abstractSqlQuerierPool.js';
 export * from './decorator/index.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/canonicalType.d.ts

@@ -7,25 +7,27 @@
  * - TypeScript types (for entity generation)
  */
 import type { AbstractDialect } from '../dialect/abstractDialect.js';
+import type { VectorCast } from '../dialect/vectorCast.js';
 import type { ColumnType, FieldOptions } from '../type/entity.js';
 import type { CanonicalType, TypeCategory } from './types.js';
-/** Type guard for all vector-family categories. */
-export declare function isVectorCategory(category: TypeCategory): boolean;
-/** Vector cast types supported by pgvector. */
-export type VectorCast = 'vector' | 'halfvec' | 'sparsevec';
-/**
- * Resolve the effective vector cast type from field options.
- * Follows the canonical type system priority: `columnType > type`.
- */
-export declare function resolveVectorCast(field: {
-    type?: unknown;
-    columnType?: unknown;
-} | undefined): VectorCast;
+/** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
+export declare function isVectorCategory(category: TypeCategory | undefined): category is VectorCast;
 /**
  * Parse a SQL type string into a canonical type.
  * Handles complex types like VARCHAR(255), DECIMAL(10,2), etc.
  */
 export declare function sqlToCanonical(sqlType: string): CanonicalType;
+/**
+ * The canonical type for a column an engine reported, merging the metadata columns it reports beside
+ * the type name (`character_maximum_length` and friends) over whatever the name itself carried. This is
+ * the one place a SQL type string is parsed: everything downstream compares and renders canonical
+ * types, so no consumer has to know that `TINYINT(1)` means boolean on MySQL.
+ */
+export declare function canonicalColumnType(sqlType: string, reported?: {
+    length?: number;
+    precision?: number;
+    scale?: number;
+}): CanonicalType;
 /**
  * Convert a canonical type to a SQL type string for a specific dialect instance.
  */
@@ -51,4 +53,3 @@ export declare function isBreakingTypeChange(from: CanonicalType, to: CanonicalT
  * Get the UQL ColumnType that best matches a canonical type.
  */
 export declare function canonicalToColumnType(type: CanonicalType): ColumnType;
-//# sourceMappingURL=canonicalType.d.ts.map

package/dist/schema/canonicalType.js

@@ -9,22 +9,10 @@
 // ============================================================================
 // Vector Category Helpers
 // ============================================================================
-/** Type guard for all vector-family categories. */
+/** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
 export function isVectorCategory(category) {
     return category === 'vector' || category === 'halfvec' || category === 'sparsevec';
 }
-/**
- * Resolve the effective vector cast type from field options.
- * Follows the canonical type system priority: `columnType > type`.
- */
-export function resolveVectorCast(field) {
-    const raw = field?.columnType ?? field?.type;
-    if (raw === 'halfvec')
-        return 'halfvec';
-    if (raw === 'sparsevec')
-        return 'sparsevec';
-    return 'vector';
-}
 // Type Mapping Tables
 // ============================================================================
 /**
@@ -98,7 +86,15 @@ const SQL_TO_CANONICAL = {
     halfvec: { category: 'halfvec' },
     sparsevec: { category: 'sparsevec' },
 };
-const PG_TYPE_MAP = {
+/**
+ * pgvector is the only engine with three vector column types, so every other dialect maps all three
+ * canonical categories onto the single type it does have (see {@link MULTI_VECTOR_TYPE_DIALECTS}, the
+ * dialect-side half of the same fact).
+ */
+function withVectorType(scalars, vector) {
+    return { ...scalars, vector, halfvec: vector, sparsevec: vector };
+}
+const PG_SCALAR_MAP = {
     integer: 'INTEGER',
     float: 'REAL',
     decimal: 'NUMERIC',
@@ -110,22 +106,18 @@ const PG_TYPE_MAP = {
     json: 'JSONB',
     uuid: 'UUID',
     blob: 'BYTEA',
+};
+const PG_TYPE_MAP = {
+    ...PG_SCALAR_MAP,
     vector: 'VECTOR',
     halfvec: 'HALFVEC',
     sparsevec: 'SPARSEVEC',
 };
-// CockroachDB's VECTOR type is native (no extension), but it has no HALFVEC/SPARSEVEC types at
-// all - verified live: `CREATE TABLE t (v HALFVEC(3))` is a syntax error, not just unsupported at
-// runtime. Falls back to VECTOR, same as MariaDB (see its own halfvec/sparsevec below).
-const CRDB_TYPE_MAP = {
-    ...PG_TYPE_MAP,
-    halfvec: 'VECTOR',
-    sparsevec: 'VECTOR',
-};
 const CANONICAL_TO_SQL = {
     postgres: PG_TYPE_MAP,
-    cockroachdb: CRDB_TYPE_MAP,
-    mysql: {
+    // CockroachDB's VECTOR is native, no extension needed.
+    cockroachdb: withVectorType(PG_SCALAR_MAP, 'VECTOR'),
+    mysql: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -137,11 +129,11 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'JSON', // MySQL doesn't have native vector type
-        halfvec: 'JSON',
-        sparsevec: 'JSON',
-    },
-    sqlite: {
+    }, 
+    // MySQL 9.x does have a `VECTOR` type, but no distance function outside HeatWave and no vector
+    // index, so JSON keeps the column queryable with the JSON operators and needs no conversion.
+    'JSON'),
+    sqlite: withVectorType({
         integer: 'INTEGER',
         float: 'REAL',
         decimal: 'REAL',
@@ -153,11 +145,8 @@ const CANONICAL_TO_SQL = {
         json: 'TEXT',
         uuid: 'TEXT',
         blob: 'BLOB',
-        vector: 'TEXT',
-        halfvec: 'TEXT',
-        sparsevec: 'TEXT',
-    },
-    mariadb: {
+    }, 'TEXT'),
+    mariadb: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -169,12 +158,9 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'VECTOR',
-        halfvec: 'VECTOR', // MariaDB only supports VECTOR; no native halfvec/sparsevec
-        sparsevec: 'VECTOR',
-    },
+    }, 'VECTOR'),
     // MongoDB uses BSON types, not SQL types. These are placeholders for compatibility.
-    mongodb: {
+    mongodb: withVectorType({
         integer: 'int',
         float: 'double',
         decimal: 'decimal128',
@@ -186,10 +172,7 @@ const CANONICAL_TO_SQL = {
         json: 'object',
         uuid: 'binData',
         blob: 'binData',
-        vector: 'array',
-        halfvec: 'array',
-        sparsevec: 'array',
-    },
+    }, 'array'),
 };
 /**
  * Size variant modifiers for SQL types.
@@ -330,6 +313,21 @@ export function sqlToCanonical(sqlType) {
     }
     return result;
 }
+/**
+ * The canonical type for a column an engine reported, merging the metadata columns it reports beside
+ * the type name (`character_maximum_length` and friends) over whatever the name itself carried. This is
+ * the one place a SQL type string is parsed: everything downstream compares and renders canonical
+ * types, so no consumer has to know that `TINYINT(1)` means boolean on MySQL.
+ */
+export function canonicalColumnType(sqlType, reported = {}) {
+    const base = sqlToCanonical(sqlType);
+    return {
+        ...base,
+        length: reported.length ?? base.length,
+        precision: reported.precision ?? base.precision,
+        scale: reported.scale ?? base.scale,
+    };
+}
 /**
  * Convert a canonical type to a SQL type string for a specific dialect instance.
  */
@@ -576,4 +574,3 @@ export function canonicalToColumnType(type) {
             return 'varchar';
     }
 }
-//# sourceMappingURL=canonicalType.js.map

package/dist/schema/index.d.ts

@@ -22,5 +22,4 @@ export type { BuildFromEntitiesOptions } from './schemaASTBuilder.js';
 export { SchemaASTBuilder } from './schemaASTBuilder.js';
 export type { DiffOptions } from './schemaASTDiffer.js';
 export { diffSchemas, SchemaASTDiffer } from './schemaASTDiffer.js';
-export type { CanonicalType, ColumnDiff, ColumnNode, ConflictResolution, DetectedRelation, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, SyncDirection, SyncOptions, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';
-//# sourceMappingURL=index.d.ts.map
+export type { CanonicalType, ColumnDiff, ColumnNode, DetectedRelation, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';

package/dist/schema/index.js

@@ -24,4 +24,3 @@ export { SchemaAST } from './schemaAST.js';
 export { SchemaASTBuilder } from './schemaASTBuilder.js';
 // Differ
 export { diffSchemas, SchemaASTDiffer } from './schemaASTDiffer.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/schemaAST.d.ts

@@ -152,4 +152,3 @@ export declare class SchemaAST implements ISchemaAST {
      */
     toJSON(): object;
 }
-//# sourceMappingURL=schemaAST.d.ts.map

package/dist/schema/schemaAST.js

@@ -481,4 +481,3 @@ export class SchemaAST {
         };
     }
 }
-//# sourceMappingURL=schemaAST.js.map

package/dist/schema/schemaASTBuilder.d.ts

@@ -71,8 +71,14 @@ export declare class SchemaASTBuilder {
      */
     private addRelationshipsFromEntity;
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     private addIndexesFromEntity;
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    private addCompositeIndex;
 }
-//# sourceMappingURL=schemaASTBuilder.d.ts.map

package/dist/schema/schemaASTBuilder.js

@@ -160,8 +160,12 @@ export class SchemaASTBuilder {
             const relatedTable = this.ast.getTable(relatedTableName);
             if (!relatedTable)
                 continue;
-            // Only create FK for owning side (m1 and owner side of 11)
-            if (relation.cardinality === 'm1' || (relation.cardinality === '11' && relation.references)) {
+            // Only the owning side gets the FK. `mappedBy` marks the inverse side of a one-to-one, whose
+            // `references` describe how to join back (its own primary key against the owner's FK column) -
+            // reading those as a foreign key emitted a reversed constraint (`User(id) REFERENCES
+            // user_profile(creatorId)`), which SQLite rejects outright as a foreign key mismatch.
+            const ownsForeignKey = relation.cardinality === 'm1' || (relation.cardinality === '11' && !!relation.references && !relation.mappedBy);
+            if (ownsForeignKey) {
                 const references = relation.references ?? [{ local: `${key}Id`, foreign: relatedMeta.id }];
                 const localPropName = references[0].local;
                 const foreignPropName = references[0].foreign;
@@ -192,68 +196,72 @@ export class SchemaASTBuilder {
         }
     }
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     addIndexesFromEntity(entity, meta, resolveTableName, resolveColumnName) {
         const tableName = resolveTableName(entity, meta);
         const table = this.ast.getTable(tableName);
         if (!table)
             return;
-        // 1. Single column indexes from @Field({ index: true })
-        const indexFields = meta.fields;
-        for (const key of Object.keys(indexFields)) {
-            const field = indexFields[key];
+        for (const key of Object.keys(meta.fields)) {
+            const field = meta.fields[key];
             if (!field?.index)
                 continue;
-            const columnName = resolveColumnName(key, field);
-            const column = table.columns.get(columnName);
+            const column = table.columns.get(resolveColumnName(key, field));
             if (!column)
                 continue;
-            const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
-            const indexNode = {
-                name: indexName,
+            this.ast.addIndex({
+                name: typeof field.index === 'string' ? field.index : `idx_${tableName}_${column.name}`,
                 table,
                 columns: [column],
                 unique: field.unique ?? false,
                 source: 'entity',
                 syncStatus: 'entity_only',
-            };
-            this.ast.addIndex(indexNode);
+            });
         }
-        // 2. Composite indexes from @Index([...])
-        if (meta.indexes) {
-            for (const idxMeta of meta.indexes) {
-                const columns = [];
-                for (const propName of idxMeta.columns) {
-                    const field = meta.fields[propName];
-                    if (!field)
-                        continue;
-                    const colName = resolveColumnName(propName, field);
-                    const column = table.columns.get(colName);
-                    if (column) {
-                        columns.push(column);
-                    }
-                }
-                if (columns.length > 0) {
-                    const indexName = idxMeta.name ?? `idx_${tableName}_${columns.map((c) => c.name).join('_')}`;
-                    const indexNode = {
-                        name: indexName,
-                        table,
-                        columns,
-                        unique: idxMeta.unique ?? false,
-                        type: idxMeta.type,
-                        where: idxMeta.where,
-                        distance: idxMeta.distance,
-                        m: idxMeta.m,
-                        efConstruction: idxMeta.efConstruction,
-                        lists: idxMeta.lists,
-                        source: 'entity',
-                        syncStatus: 'entity_only',
-                    };
-                    this.ast.addIndex(indexNode);
-                }
-            }
+        for (const idxMeta of meta.indexes ?? []) {
+            this.addCompositeIndex(table, meta, idxMeta, resolveColumnName);
         }
     }
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    addCompositeIndex(table, meta, idxMeta, resolveColumnName) {
+        // An entry survives if it is an expression (nothing to resolve) or names a column that exists;
+        // an index left with none is dropped, the same as one naming only unknown columns always was.
+        const entries = idxMeta.columns
+            .map((entry) => {
+            if (entry.expression)
+                return entry;
+            const field = meta.fields[entry.column];
+            const column = field && resolveColumnName(entry.column, field);
+            return column && table.columns.has(column) ? { ...entry, column } : undefined;
+        })
+            .filter((entry) => entry !== undefined);
+        if (!entries.length)
+            return;
+        const columns = entries
+            .map((entry) => (entry.expression ? undefined : table.columns.get(entry.column)))
+            .filter((column) => column !== undefined);
+        const named = columns.length ? columns.map((column) => column.name) : entries.map((_, at) => `expr${at}`);
+        this.ast.addIndex({
+            name: idxMeta.name ?? `idx_${table.name}_${named.join('_')}`,
+            table,
+            columns,
+            entries,
+            include: idxMeta.include,
+            unique: idxMeta.unique ?? false,
+            type: idxMeta.type,
+            where: idxMeta.where,
+            distance: idxMeta.distance,
+            m: idxMeta.m,
+            efConstruction: idxMeta.efConstruction,
+            lists: idxMeta.lists,
+            source: 'entity',
+            syncStatus: 'entity_only',
+        });
+    }
 }
-//# sourceMappingURL=schemaASTBuilder.js.map

package/dist/schema/schemaASTDiffer.d.ts

@@ -81,4 +81,3 @@ export declare class SchemaASTDiffer {
  * Convenience function for one-off comparisons.
  */
 export declare function diffSchemas(source: SchemaAST, target: SchemaAST, options?: DiffOptions): SchemaDiffResult;
-//# sourceMappingURL=schemaASTDiffer.d.ts.map

package/dist/schema/schemaASTDiffer.js

@@ -428,4 +428,3 @@ export function diffSchemas(source, target, options) {
     const differ = new SchemaASTDiffer();
     return differ.diff(source, target, options);
 }
-//# sourceMappingURL=schemaASTDiffer.js.map

package/dist/schema/types.d.ts

@@ -4,7 +4,8 @@
  * A unified graph representation of database schema with relationships as first-class citizens.
  * Enables reliable diffing, smart relation detection, and dialect-agnostic schema operations.
  */
-import type { VectorIndexOptions } from '../type/vector.js';
+import type { IndexColumnSchema } from '../type/entity.js';
+import type { IndexSchema } from '../type/migration.js';
 /**
  * Type categories universal across SQL dialects.
  * These represent logical/semantic types, not specific SQL types.
@@ -148,24 +149,21 @@ export interface RelationshipNode {
  * Index node in the schema graph.
  * Represents a database index on one or more columns.
  */
-export type IndexNode = {
-    /** Index name */
-    readonly name: string;
+export type IndexNode = Omit<IndexSchema, 'columns'> & {
     /** Reference to the table this index belongs to */
     readonly table: TableNode;
-    /** Columns included in the index (order matters) */
+    /** Columns included in the index (order matters). Empty for an index over expressions only. */
     readonly columns: ColumnNode[];
-    /** Whether this is a unique index */
-    readonly unique: boolean;
-    /** Index algorithm/type */
-    readonly type?: IndexType;
-    /** Partial index condition (WHERE clause) */
-    readonly where?: string;
+    /**
+     * The index as authored, with names resolved: expressions, prefix lengths and per-column order that
+     * a `ColumnNode` cannot represent. The generator renders these; `columns` is what diffing compares.
+     */
+    readonly entries?: readonly IndexColumnSchema[];
     /** Where this index was defined */
     readonly source?: IndexSource;
     /** Current sync status */
     readonly syncStatus?: IndexSyncStatus;
-} & VectorIndexOptions;
+};
 /**
  * Root of the schema graph.
  * Contains all tables, relationships, and provides graph operations.
@@ -320,29 +318,3 @@ export interface DriftReport {
         readonly info: number;
     };
 }
-/**
- * Direction for schema synchronization.
- */
-export type SyncDirection = 'bidirectional' | 'entity-to-db' | 'db-to-entity';
-/**
- * Strategy for resolving conflicts in bidirectional sync.
- */
-export type ConflictResolution = 'prompt' | 'entity-wins' | 'db-wins' | 'skip';
-/**
- * Options for sync operations.
- */
-export interface SyncOptions {
-    /** Direction of synchronization */
-    readonly direction?: SyncDirection;
-    /** How to resolve conflicts (for bidirectional) */
-    readonly conflictResolution?: ConflictResolution;
-    /** Prevent destructive changes (DROP, type narrowing) */
-    readonly safe?: boolean;
-    /** Include indexes in sync */
-    readonly includeIndexes?: boolean;
-    /** Include foreign keys in sync */
-    readonly includeForeignKeys?: boolean;
-    /** Dry run - report changes without applying */
-    readonly dryRun?: boolean;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/schema/types.js

@@ -8,4 +8,3 @@
  * Default action for foreign key ON DELETE and ON UPDATE clauses.
  */
 export const DEFAULT_FOREIGN_KEY_ACTION = 'NO ACTION';
-//# sourceMappingURL=types.js.map

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,4 +1,42 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+/** Values every SQLite driver accepts as a bound parameter. */
+export type SqliteBindValue = null | string | number | bigint | boolean | Uint8Array;
+/** Header a SQLite driver returns for a statement without a `RETURNING` clause. */
+export type SqliteRunResult = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/** 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.
+ */
+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 {
+    /**
+     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
+     * a querier returns nothing; it only asserts the unit of work was finished. 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>;
 }
-//# sourceMappingURL=abstractSqliteQuerier.d.ts.map

package/dist/sqlite/abstractSqliteQuerier.js

@@ -1,4 +1,47 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+import { throwPendingTransaction } from '../util/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; it only asserts the unit of work was finished. Drivers owning a
+     * closable per-querier connection override this.
+     */
+    async internalRelease() {
+        if (this.hasOpenTransaction) {
+            throwPendingTransaction();
+        }
+    }
+}
+/**
+ * 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 class PreparedSqliteQuerier extends AbstractSqliteQuerier {
+    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;
+        }
+    }
+    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 });
+    }
 }
-//# sourceMappingURL=abstractSqliteQuerier.js.map

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

@@ -0,0 +1,26 @@
+import type { SqliteBindValue, SqliteRunResult } from './abstractSqliteQuerier.js';
+import type { SqliteDatabase } from './sqliteQuerier.js';
+/** A `bun:sqlite` statement: better-sqlite3-shaped, except it reports columns instead of `reader`. */
+type BunStatement = {
+    columnNames: string[];
+    all(...values: SqliteBindValue[]): unknown[];
+    run(...values: SqliteBindValue[]): SqliteRunResult;
+    iterate(...values: SqliteBindValue[]): Iterable<unknown>;
+};
+type BunDatabase = {
+    prepare(sql: string): BunStatement;
+    loadExtension(path: string): void;
+    close(): unknown;
+};
+/**
+ * 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 declare function adaptBunSqlite(db: BunDatabase): SqliteDatabase;
+export {};