uql-orm 0.65.1 → 0.67.0

package/dist/schema/schemaASTDiffer.js

@@ -1,12 +1,3 @@
-/**
- * SchemaAST Differ
- *
- * Compares two SchemaAST instances and produces a detailed diff.
- * Used for:
- * - Migration generation (entity vs database)
- * - Drift detection (expected vs actual)
- * - Schema synchronization
- */
 import { areTypesEqual, isBreakingTypeChange } from './canonicalType.js';
 import { describeIndexDifferences, indexNameStem } from './indexDifferences.js';
 import { DEFAULT_FOREIGN_KEY_ACTION } from './types.js';
@@ -45,14 +36,7 @@ function matchByKey(source, target, key) {
 function relationEnds(relation) {
     return { name: relation.name, fromTable: relation.from.table.name, toTable: relation.to.table.name };
 }
-/**
- * Compare two schemas and return the differences.
- *
- * @param source - The "expected" or "desired" schema (e.g., from entities)
- * @param target - The "actual" or "current" schema (e.g., from database)
- * @param options - Diff options
- * @returns Detailed diff result
- */
+/** The differences between the expected schema (the entities) and the actual one (the database). */
 export function diffSchemas(source, target, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const normalizeName = nameNormalizer(opts);
@@ -89,13 +73,7 @@ export function diffSchemas(source, target, options = {}) {
         hasBreakingChanges,
     };
 }
-/**
- * Compare two tables and return the differences.
- *
- * Exported because it is also how a migration is planned: the generator diffs one entity's table
- * against the one the database reported, then projects the result into a `SchemaDiff`. One
- * comparison serves both, so drift and migrations can no longer disagree about what has changed.
- */
+/** The differences between two tables, shared by migrations and drift detection so they cannot disagree. */
 export function diffTable(source, target, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const columnDiffs = diffTableColumns(source, target, opts);
@@ -106,13 +84,7 @@ export function diffTable(source, target, options = {}) {
     }
     return { name: source.name, type: 'alter', columnDiffs, indexDiffs, primaryKeyDiff };
 }
-/**
- * The two keys, where they hold different columns.
- *
- * Compared by columns and in order. Not by name: the engine named the constraint on every table that
- * already exists, so matching on one would report every table as drifted the moment the convention
- * that derives names changes.
- */
+/** The two keys where they hold different columns, compared in order and never by the name the engine gave them. */
 function diffPrimaryKey(source, target) {
     const expected = source.primaryKey.map((column) => column.name);
     const actual = target.primaryKey.map((column) => column.name);
@@ -167,14 +139,8 @@ function diffTableIndexes(source, target, opts) {
  */
 function diffColumn(tableName, source, target, opts) {
     const differences = [];
-    // Two things a key column implies rather than states, and catalogues report inconsistently: its
-    // type, which is the dialect's serial spelling rather than one the entity chose and does not round
-    // trip (`BIGINT AUTO_INCREMENT` reads back as `BIGINT(20)`), and its nullability,
-    // which is NOT NULL in every engine whatever is reported - SQLite's `PRAGMA table_info` says
-    // `notnull: 0` for the `INTEGER PRIMARY KEY` that is the table's own rowid. Comparing either asked
-    // to rewrite the column on every sync, and on SQLite, which cannot alter one at all, failed
-    // outright. Everything else about a key column is still compared, which the blanket "never alter a
-    // key column" rule these two replace used to hide.
+    // A key column's type and nullability are implied, not stated, and catalogues report them
+    // inconsistently (`BIGINT(20)`, SQLite's `notnull: 0` rowid), so neither is compared.
     const generatedType = source.isAutoIncrement && target.isAutoIncrement;
     const impliedNotNull = source.isPrimaryKey && target.isPrimaryKey;
     const typeChanged = !generatedType && !areTypesEqual(opts.normalizeType(source.type), opts.normalizeType(target.type));
@@ -196,14 +162,8 @@ function diffColumn(tableName, source, target, opts) {
     if (source.isUnique !== target.isUnique) {
         differences.push(`unique: ${target.isUnique} -> ${source.isUnique}`);
     }
-    // Four things are deliberately not compared, all for one reason: a difference here could only be
-    // reported, never settled, because no statement this generator emits would change it.
-    //   - `isAutoIncrement`: no engine makes a column an identity, or unmakes one, without rewriting the
-    //     table, and the alter emitted for it is a bare `ALTER COLUMN TYPE`.
-    //   - `enum`: a check, and a database reprints one from its parse tree. See the roadmap.
-    //   - `generatedAs`: only Postgres 17 and the MySQL family can rewrite an expression in place.
-    //   - `comment`: fixable on every engine but SQLite, and the only one of the four worth revisiting.
-    // The same rule `describeIndexDifferences` follows for what it cannot read.
+    // Not compared, since no statement this generator emits could settle a difference: `isAutoIncrement`,
+    // `enum` (a check the database reprints), `generatedAs`, and `comment`.
     // Compare default values (if both defined)
     if (!opts.defaultsEqual(source.defaultValue, target.defaultValue)) {
         differences.push(`default: ${target.defaultValue ?? 'NULL'} -> ${source.defaultValue ?? 'NULL'}`);
@@ -241,15 +201,7 @@ function diffIndex(tableName, source, target, facets) {
         description: differences.join(', '),
     };
 }
-/**
- * Compare two lists of relationships.
- *
- * Lists rather than whole schemas, because a migration diffs one table: its two sides are that
- * table's `outgoingRelations`, where `diffSchemas` passes the schema's every relationship.
- *
- * Matched by columns, never by name - the engine named every constraint that already exists, so
- * pairing on names would report every hand-named one as a drop and an add.
- */
+/** The differences between two lists of foreign keys, matched by their columns and never by the name the engine gave them. */
 export function diffRelationshipNodes(source, target, opts = {}) {
     const normalizeName = nameNormalizer({ ...DEFAULT_OPTIONS, ...opts });
     const { created, dropped, matched } = matchByKey(source, target, (relation) => getRelationshipKey(relation, normalizeName));

package/dist/schema/types.d.ts

@@ -1,9 +1,3 @@
-/**
- * Schema AST Types
- *
- * 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 { IndexSchema } from '../type/migration.js';
 /**
  * Type categories universal across SQL dialects.
@@ -36,10 +30,9 @@ export interface CanonicalType {
     /** Whether this type has timezone info (for timestamp types) */
     readonly withTimezone?: boolean;
 }
-/**
- * Actions for foreign key ON DELETE and ON UPDATE clauses.
- */
-export type ForeignKeyAction = 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+/** Actions for foreign key ON DELETE and ON UPDATE clauses. */
+export declare const FOREIGN_KEY_ACTIONS: readonly ['CASCADE', 'SET NULL', 'SET DEFAULT', 'RESTRICT', 'NO ACTION'];
+export type ForeignKeyAction = (typeof FOREIGN_KEY_ACTIONS)[number];
 /**
  * The values a column accepts, rendered as `CHECK (col IN (...))`.
  *
@@ -47,14 +40,7 @@ export type ForeignKeyAction = 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRIC
  * dialect's own literal rules, so a number stays bare where a string is quoted.
  */
 export type EnumValues = readonly (string | number)[];
-/**
- * A `CHECK` constraint as the schema holds it, its expression already text. Declared here rather
- * than beside the entity types because a table node also comes from introspection, where there is
- * no entity to have authored one.
- *
- * Only ever compared by presence, never by content: a check is SQL text, and a database reprints
- * text from its parse tree, so `CHECK ("balance" >= 0)` reads back as `CHECK ((balance >= (0)::numeric))`.
- */
+/** A `CHECK` as the schema holds it, compared by presence only: the database reprints its expression. */
 export interface CheckSchema {
     /** Absent when nothing named it, which the generator fills in with `derivedCheckName`. */
     readonly name?: string;
@@ -68,23 +54,11 @@ export declare const DEFAULT_FOREIGN_KEY_ACTION: ForeignKeyAction;
  * Relationship cardinality types.
  */
 export type RelationshipType = 'OneToOne' | 'OneToMany' | 'ManyToOne' | 'ManyToMany';
-/**
- * Source of how a relationship was detected.
- */
-export type RelationshipSource = 'explicit_fk' | 'entity_decorator' | 'naming_pattern' | 'junction_table' | 'unique_fk';
 /**
  * Index algorithm/type supported by various databases.
  */
 export declare const INDEX_TYPES: readonly ['btree', 'hash', 'gin', 'gist', 'brin', 'fulltext', 'hnsw', 'ivfflat', 'vector', 'vectorSearch'];
 export type IndexType = (typeof INDEX_TYPES)[number];
-/**
- * Source of where an index was defined.
- */
-export type IndexSource = 'entity' | 'database' | 'both';
-/**
- * Sync status for indexes.
- */
-export type IndexSyncStatus = 'in_sync' | 'entity_only' | 'db_only' | 'mismatch';
 /**
  * Column node in the schema graph.
  * Represents a single column in a database table.
@@ -179,10 +153,6 @@ export interface RelationshipNode {
     readonly onDelete?: ForeignKeyAction;
     /** Action on update of referenced row */
     readonly onUpdate?: ForeignKeyAction;
-    /** Confidence level (0-1) for inferred relationships */
-    readonly confidence?: number;
-    /** How this relationship was detected */
-    readonly inferredFrom?: RelationshipSource;
 }
 /**
  * Index node in the schema graph.
@@ -191,10 +161,6 @@ export interface RelationshipNode {
 export type IndexNode = IndexSchema & {
     /** Reference to the table this index belongs to */
     readonly table: TableNode;
-    /** Where this index was defined */
-    readonly source?: IndexSource;
-    /** Current sync status */
-    readonly syncStatus?: IndexSyncStatus;
 };
 /**
  * Root of the schema graph.
@@ -208,14 +174,7 @@ export interface SchemaAST {
     /** All indexes (also accessible via TableNode.indexes) */
     readonly indexes: IndexNode[];
 }
-/**
- * Difference between two column definitions.
- *
- * A union rather than one shape with two optional sides, so which node is present follows from the
- * kind of difference: an added column has only the `expected` one, a dropped column only the
- * `actual` one, and an altered column both. Stated as optionals, every reader had to assert its way
- * past a `undefined` the kind had already ruled out.
- */
+/** How two columns differ, a union so which side is present follows from the kind of difference. */
 export type ColumnDiff = ColumnDiffBase & ({
     readonly type: 'add';
     readonly expected: ColumnNode;
@@ -320,21 +279,6 @@ export interface SchemaDiffResult {
     /** Whether any changes are breaking (could cause data loss) */
     readonly hasBreakingChanges: boolean;
 }
-/**
- * Type of schema validation error.
- */
-export type ValidationErrorType = 'missing_fk_target' | 'circular_dependency' | 'orphan_column' | 'duplicate_index' | 'invalid_type';
-/**
- * Schema validation error.
- */
-export interface ValidationError {
-    readonly type: ValidationErrorType;
-    readonly message: string;
-    readonly table?: TableNode;
-    readonly column?: ColumnNode;
-    readonly relationship?: RelationshipNode;
-    readonly tables?: TableNode[];
-}
 /**
  * Severity level for schema drift issues.
  */

package/dist/schema/types.js

@@ -1,9 +1,6 @@
-/**
- * Schema AST Types
- *
- * A unified graph representation of database schema with relationships as first-class citizens.
- * Enables reliable diffing, smart relation detection, and dialect-agnostic schema operations.
- */
+// A database schema as a graph, whichever side it came from: the entities or the database itself.
+/** Actions for foreign key ON DELETE and ON UPDATE clauses. */
+export const FOREIGN_KEY_ACTIONS = ['CASCADE', 'SET NULL', 'SET DEFAULT', 'RESTRICT', 'NO ACTION'];
 /**
  * Default action for foreign key ON DELETE and ON UPDATE clauses.
  */

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,13 +1,6 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
 import type { RawRow } from '../type/index.js';
-/**
- * Values every SQLite driver accepts as a bound parameter.
- *
- * @remarks No `boolean`: SQLite has no boolean storage class, and both `better-sqlite3` ("SQLite3 can
- * only bind numbers, strings, bigints, buffers, and null") and `node:sqlite` reject one outright. The
- * dialect already binds booleans as integers (`booleanLiteral: 'integer'`), so nothing reaches a
- * driver as one; leaving `boolean` here only invited a runtime throw that is now a compile error.
- */
+/** What every SQLite driver binds. No `boolean`, which the drivers refuse and the dialect writes as an integer. */
 export type SqliteBindValue = null | string | number | bigint | Uint8Array;
 /** What a statement came back with on a SQLite driver: the rows it read, and how many rows it changed. */
 export type SqliteExecution = {

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -27,13 +27,7 @@ export type LocalSqliteDatabase = {
 export declare function adaptSqlite<S extends Omit<SqlitePreparedStatement, 'reader'>>(db: Omit<LocalSqliteDatabase, 'prepare'> & {
     prepare(sql: string): S;
 }, reads: (stmt: S) => boolean): LocalSqliteDatabase;
-/**
- * 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.
- *
- * 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`.
- */
+/** A pool for a SQLite file opened in this process, configured the same way whichever driver's {@link createDb} opens it. */
 export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSharedHandleQuerierPool<LocalSqliteDatabase, SqliteQuerier, SqliteDialect> {
     readonly opts?: O | undefined;
     constructor(opts?: O | undefined, extra?: ExtraOptions);

package/dist/sqlite/localSqliteQuerierPool.js

@@ -22,13 +22,7 @@ export function adaptSqlite(db, reads) {
         close: () => db.close(),
     };
 }
-/**
- * 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.
- *
- * 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`.
- */
+/** A pool for a SQLite file opened in this process, configured the same way whichever driver's {@link createDb} opens it. */
 export class AbstractLocalSqliteQuerierPool extends AbstractSharedHandleQuerierPool {
     opts;
     constructor(opts, extra) {

package/dist/sqlite/nodeSqliteQuerierPool.d.ts

@@ -12,13 +12,8 @@ export type NodeSqlitePoolOptions = LocalSqlitePoolOptions & {
     readonly timeout?: number;
 };
 /**
- * Pool backed by Node's built-in `node:sqlite`, so SQLite works with **no dependency at all** rather
- * than requiring the `better-sqlite3` native build. Use {@link Sqlite3QuerierPool} instead when you
- * want `better-sqlite3`, or are on Bun.
- *
- * @remarks `node:sqlite` needs no CLI flag from Node 22.13, and is still a release candidate
- * (stability 1.2) as of Node 26, so `better-sqlite3` via {@link Sqlite3QuerierPool} remains the
- * faster option for read-heavy work.
+ * A pool over Node's built-in `node:sqlite`, needing no dependency at all. {@link Sqlite3QuerierPool} is the
+ * faster choice for read-heavy work, and the one on Bun.
  */
 export declare class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool<NodeSqlitePoolOptions> {
     readonly filename: string;

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -1,12 +1,7 @@
 import { AbstractLocalSqliteQuerierPool, adaptSqlite, } from './localSqliteQuerierPool.js';
 /**
- * Pool backed by Node's built-in `node:sqlite`, so SQLite works with **no dependency at all** rather
- * than requiring the `better-sqlite3` native build. Use {@link Sqlite3QuerierPool} instead when you
- * want `better-sqlite3`, or are on Bun.
- *
- * @remarks `node:sqlite` needs no CLI flag from Node 22.13, and is still a release candidate
- * (stability 1.2) as of Node 26, so `better-sqlite3` via {@link Sqlite3QuerierPool} remains the
- * faster option for read-heavy work.
+ * A pool over Node's built-in `node:sqlite`, needing no dependency at all. {@link Sqlite3QuerierPool} is the
+ * faster choice for read-heavy work, and the one on Bun.
  */
 export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
     filename;

package/dist/sqlite/sqliteDialect.d.ts

@@ -1,20 +1,18 @@
 import { AbstractSqlDialect, type DerivedRelation, type HydrateKind, type RelationRows } from '../dialect/abstractSqlDialect.js';
-import type { DialectFeatures, EntityMeta, FieldOptions, QueryContext, QueryPager, QuerySizeComparisonOps, QueryTextSearchOptions, Type, VectorDistance, VectorMetric } from '../type/index.js';
+import type { EntityMeta, FieldOptions, QueryContext, QueryPager, QuerySizeComparisonOps, QueryTextSearchOptions, SqlDialectFeatures, Type, VectorDistance, VectorMetric } from '../type/index.js';
+/** What SQLite and the engines derived from it have. */
+export declare const SQLITE_FEATURES: SqlDialectFeatures;
 export declare class SqliteDialect extends AbstractSqlDialect {
-    /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
-    protected readonly featureDefaults: DialectFeatures;
+    readonly features: SqlDialectFeatures;
     readonly dialectName = "sqlite";
     readonly escapeIdChar = "`";
     readonly autoIncrementSuffix = "PRIMARY KEY AUTOINCREMENT";
-    readonly serialDeclaresPrimaryKey = true;
     readonly tableOptions = "";
     readonly beginTransactionCommand = "BEGIN TRANSACTION";
     readonly commitTransactionCommand = "COMMIT";
     readonly rollbackTransactionCommand = "ROLLBACK";
     readonly isolationLevelStrategy = "none";
     readonly alterColumnSyntax = "none";
-    /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
-    readonly supportsRowLocks = false;
     readonly booleanLiteral = "integer";
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     readonly maxFunctionArgs: number;
@@ -60,13 +58,6 @@ export declare class SqliteDialect extends AbstractSqlDialect {
      * 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.
-     */
-    protected readonly jsonContainmentIsPartial = false;
-    /** `JSON_EACH` exposes a JSON boolean as `0`/`1` and a number as a number - already comparable. */
-    protected readonly jsonScalarElemKeepsType = true;
     /**
      * Each element is read back as JSON text through `->` at its own `fullkey`, so it compares
      * correctly whatever its type. `JSON_EACH`'s `value` column would not: it unquotes strings (`a`
@@ -87,13 +78,7 @@ 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.
-     *
-     * @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.
-     */
+    /** `[#]` appends, creating the array where it is absent: `JSON_SET`, since Turso's `JSON_INSERT` will not touch an existing array. */
     protected jsonPush(ctx: QueryContext, expr: string, push: Record<string, unknown>): string;
     protected jsonUnset(_ctx: QueryContext, expr: string, unset: readonly string[]): string;
 }

package/dist/sqlite/sqliteDialect.js

@@ -4,37 +4,44 @@ import { BYTES_PREFIX } from '../dialect/hydrateColumn.js';
 import { chainedCall, groupsPerCall, jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget, } from '../dialect/jsonSql.js';
 import { textSearchFields } from '../util/dialect.util.js';
 import { columnFamily, isIntegerColumn } from '../util/field.util.js';
+/** What SQLite and the engines derived from it have. */
+export const SQLITE_FEATURES = {
+    ifNotExists: true,
+    indexIfNotExists: true,
+    schemas: false, // SQLite's namespaces are attached database files, not declared objects
+    dropTableCascade: false,
+    foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
+    primaryKeyAlter: false, // nor changing a key: the only route is rebuilding the table
+    generatedColumnAdd: false, // accepted in a CREATE TABLE, rejected in an ALTER
+    commentSyntax: 'none',
+    vectorIndexRequiresNotNull: false,
+    vectorSupportsLength: false,
+    supportsTimestamptz: false,
+    stringSizing: 'text',
+    supportsUnsigned: false,
+    serverSideCursors: false,
+    rowLocks: false,
+    rowLockWithWindow: true,
+    rowLockOf: true,
+    orderedUpsertReturning: true,
+    orderedJsonAggregates: true,
+    partialJsonContainment: false,
+    typedJsonElements: true,
+    narrowVectorTypes: false,
+    vectorTuningNeedsTransaction: false,
+    serialDeclaresPrimaryKey: true,
+};
 export class SqliteDialect extends AbstractSqlDialect {
-    /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
-    featureDefaults = {
-        ifNotExists: true,
-        indexIfNotExists: true,
-        schemas: false, // SQLite's namespaces are attached database files, not declared objects
-        dropTableCascade: false,
-        foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
-        primaryKeyAlter: false, // nor changing a key: the only route is rebuilding the table
-        generatedColumnAdd: false, // accepted in a CREATE TABLE, rejected in an ALTER
-        commentSyntax: 'none',
-        vectorIndexRequiresNotNull: false,
-        vectorSupportsLength: false,
-        supportsTimestamptz: false,
-        stringSizing: 'text',
-        supportsUnsigned: false,
-        serverSideCursors: false,
-    };
+    features = SQLITE_FEATURES;
     dialectName = 'sqlite';
     escapeIdChar = '`';
     autoIncrementSuffix = 'PRIMARY KEY AUTOINCREMENT';
-    // `AUTOINCREMENT` is only legal in that exact phrase, so the key cannot be lifted to table level.
-    serialDeclaresPrimaryKey = true;
     tableOptions = '';
     beginTransactionCommand = 'BEGIN TRANSACTION';
     commitTransactionCommand = 'COMMIT';
     rollbackTransactionCommand = 'ROLLBACK';
     isolationLevelStrategy = 'none';
     alterColumnSyntax = 'none';
-    /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
-    supportsRowLocks = false;
     booleanLiteral = 'integer';
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     maxFunctionArgs = 127;
@@ -119,13 +126,6 @@ export class SqliteDialect extends AbstractSqlDialect {
         ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
         ctx.addValue(search.$value);
     }
-    /**
-     * 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.
-     */
-    jsonContainmentIsPartial = false;
-    /** `JSON_EACH` exposes a JSON boolean as `0`/`1` and a number as a number - already comparable. */
-    jsonScalarElemKeepsType = true;
     /**
      * Each element is read back as JSON text through `->` at its own `fullkey`, so it compares
      * correctly whatever its type. `JSON_EACH`'s `value` column would not: it unquotes strings (`a`
@@ -173,13 +173,7 @@ export class SqliteDialect extends AbstractSqlDialect {
     jsonSet(ctx, expr, set, field) {
         return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', jsonSetTarget(expr, field, `'{}'`), set, this.maxFunctionArgs);
     }
-    /**
-     * `[#]` 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.
-     */
+    /** `[#]` appends, creating the array where it is absent: `JSON_SET`, since Turso's `JSON_INSERT` will not touch an existing array. */
     jsonPush(ctx, expr, push) {
         return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', expr, push, this.maxFunctionArgs, '[#]');
     }

package/dist/turso/tursoDialect.d.ts

@@ -1,12 +1,10 @@
 import { LibsqlDialect } from '../libsql/libsqlDialect.js';
+import type { SqlDialectFeatures } from '../type/index.js';
 /**
- * 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 Imports nothing vendor-specific, so no entry point can pull a driver in through it.
+ * Turso Cloud, as every database there accepts: libSQL's vector functions and argument cap, and no
+ * `ORDER BY` inside an aggregate, which its Rust engine lacks. Imports no driver.
  */
 export declare class TursoDialect extends LibsqlDialect {
     /** The Rust engine takes no `ORDER BY` inside an aggregate. */
-    protected readonly orderedAggregates = false;
+    readonly features: SqlDialectFeatures;
 }

package/dist/turso/tursoDialect.js

@@ -1,12 +1,10 @@
 import { LibsqlDialect } from '../libsql/libsqlDialect.js';
+import { SQLITE_FEATURES } from '../sqlite/sqliteDialect.js';
 /**
- * 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 Imports nothing vendor-specific, so no entry point can pull a driver in through it.
+ * Turso Cloud, as every database there accepts: libSQL's vector functions and argument cap, and no
+ * `ORDER BY` inside an aggregate, which its Rust engine lacks. Imports no driver.
  */
 export class TursoDialect extends LibsqlDialect {
     /** The Rust engine takes no `ORDER BY` inside an aggregate. */
-    orderedAggregates = false;
+    features = { ...SQLITE_FEATURES, orderedJsonAggregates: false };
 }

package/dist/turso/tursoLocalQuerierPool.d.ts

@@ -5,13 +5,7 @@ import type { ExtraOptions } from '../type/index.js';
 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.
- *
- * @remarks Kept on the `uql-orm/turso/local` entry point rather than `uql-orm/turso`, because this
- * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
- * bundle targeting Workers never reaches the native import.
- */
+/** A pool for the embedded Turso engine, on `uql-orm/turso/local` so its native binaries stay out of edge bundles. */
 export declare class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool<SqliteDatabase, SqliteQuerier, TursoLocalDialect> {
     readonly filename: string;
     readonly opts?: TursoLocalOptions | undefined;

package/dist/turso/tursoLocalQuerierPool.js

@@ -3,13 +3,7 @@ import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandle
 import { applySqlitePragmas } from '../sqlite/sqlitePragmas.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.
- *
- * @remarks Kept on the `uql-orm/turso/local` entry point rather than `uql-orm/turso`, because this
- * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
- * bundle targeting Workers never reaches the native import.
- */
+/** A pool for the embedded Turso engine, on `uql-orm/turso/local` so its native binaries stay out of edge bundles. */
 export class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool {
     filename;
     opts;

package/dist/turso/tursoQuerierPool.d.ts

@@ -6,12 +6,8 @@ import { TursoSessionQuerier } from './tursoSessionQuerier.js';
 /** Connection settings for Turso Cloud: `@tursodatabase/serverless`'s own, `requestHeaders` included. */
 export type TursoConfig = Config;
 /**
- * Pool for Turso Cloud, over `@tursodatabase/serverless`, which speaks HTTP through `fetch()`.
- *
- * @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.
+ * A pool for Turso Cloud over `@tursodatabase/serverless`: a stream per querier, the driver imported on first
+ * use. A `@libsql/client/web` client goes to `LibsqlQuerierPool` instead.
  */
 export declare class TursoQuerierPool extends AbstractSqlQuerierPool<TursoSessionQuerier, TursoDialect> {
     private readonly conf;

package/dist/turso/tursoQuerierPool.js

@@ -3,12 +3,8 @@ import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { TursoDialect } from './tursoDialect.js';
 import { TursoSessionQuerier } from './tursoSessionQuerier.js';
 /**
- * Pool for Turso Cloud, over `@tursodatabase/serverless`, which speaks HTTP through `fetch()`.
- *
- * @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.
+ * A pool for Turso Cloud over `@tursodatabase/serverless`: a stream per querier, the driver imported on first
+ * use. A `@libsql/client/web` client goes to `LibsqlQuerierPool` instead.
  */
 export class TursoQuerierPool extends AbstractSqlQuerierPool {
     conf;

package/dist/turso/tursoSessionQuerier.d.ts

@@ -36,13 +36,7 @@ export type TursoSession = {
     }>;
     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.
- */
+/** A Turso Cloud querier on a stream of its own, which holds its transaction and which `release` closes. */
 export declare class TursoSessionQuerier extends AbstractSqliteQuerier {
     readonly session: TursoSession;
     readonly extra?: ExtraOptions | undefined;

package/dist/turso/tursoSessionQuerier.js

@@ -1,11 +1,5 @@
 import { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.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.
- */
+/** A Turso Cloud querier on a stream of its own, which holds its transaction and which `release` closes. */
 export class TursoSessionQuerier extends AbstractSqliteQuerier {
     session;
     extra;