@vibeorm/sql 4.2.0 → 5.0.0

package/dist/dialect.d.ts

@@ -121,10 +121,146 @@ export type SqlDialect = {
      * member, so composite membership always chunks against `paramBudget`.
      */
     readonly tupleInStrategy: "rowValue" | "expand";
+    /**
+     * Key-list membership (`SqlExpr` `keyList`, the public `where: { IN }`).
+     * `unnest` binds ONE typed array per member — `("a", "b") IN (SELECT * FROM
+     * unnest($1::int8[], $2::text[]))` — so the text and its planning cost do
+     * not grow with the list (postgres 18.6, 1 000 two-column keys: planning
+     * 0.09 ms against 2.0 ms for the OR of conjunctions; 5 000 keys: 0.09 ms
+     * against 12.6 ms, and 10 ms against 285 ms execution). `rowValue` renders
+     * the row-constructor list `(a, b) IN ((?, ?), …)` (mysql: 3.9 ms for 1 000
+     * keys through an index range scan, equal to a VALUES derived table and
+     * without its numeric casts; every probed type compared exactly like `=`).
+     * `values` renders `("a", "b") IN (VALUES (?, ?), …)` (sqlite 3.51: 0.9 ms
+     * prepare + run for 1 000 keys against 1.9 ms for the row list; an OR of
+     * 1 000 conjunctions is refused there, "Expression tree is too large").
+     * The row forms bind one parameter per member, like scalar `IN (?, …)`.
+     */
+    readonly keyListStrategy: "unnest" | "rowValue" | "values";
+    /**
+     * The keyset seek (`after`, `findPage`, a compound `cursor`, graph pages;
+     * D-01). `rowValue`: where every key sorts in one direction and no key or
+     * position value is NULL, one row-value comparison `("a", "b") > ($1, $2)`
+     * (`SqlExpr` `rowCompare`) that an index on `(a, b)` bounds as a range;
+     * with mixed directions the OR expansion ANDed with the inclusive bound on
+     * the leading key (`"a" >= $1 AND (…)`). Measured: PostgreSQL 18.6 at
+     * 500 000 rows deep 25.4 ms → 0.013 ms, SQLite 3.51 at 490 000 rows 12.9 →
+     * 0.007 ms — the OR alone is a full index walk from the first row. `or`:
+     * the OR expansion alone — MySQL's range optimizer already turns it into
+     * index ranges (22 rows touched at any depth) and SCANS a row-value
+     * inequality (194 ms at 490 000 rows deep). Nullable keys keep the OR on
+     * every dialect.
+     */
+    readonly keysetSeekStrategy: "rowValue" | "or";
+    /**
+     * Fix lane Q1 (round 3, DB-01): how a paged include (`include: { rel: {
+     * orderBy, take, skip } }`) cuts each parent's page when an index proves the
+     * per-key form (`SelectStatement.keyPage`, `KeyPage`). `lateral`: one
+     * primary-key page per key in a `CROSS JOIN LATERAL` over the unnested key
+     * arrays — PostgreSQL 18.6, 1 000 000 children, 50 parents: 59.1 → 1.08 ms
+     * (the window sorted every child of every parent); the key-only page keeps
+     * an index-only scan the planner prefers at every `skip`, where a lateral
+     * fetching whole rows flipped to bitmap + sort and LOST (40 → 64 ms).
+     * `inLimit`: SQLite has no LATERAL — `(VALUES …)` keys joined to the child
+     * by `IN (SELECT key … LIMIT)`, a correlated list subquery per key (SQLite
+     * 3.51, 500 000 children, 50 parents: 75.2 → 0.47 ms). `window`: keep the
+     * `ROW_NUMBER()` window (MySQL: a lateral page still read every child).
+     */
+    readonly keyPageStrategy: "lateral" | "inLimit" | "window";
+    /**
+     * How the `"join"` relation strategy's lateral subselects build their JSON
+     * payload (`LateralJoin`), or `null` where the dialect has no LATERAL
+     * (`capabilities.lateralJoin` false). `rowArray` builds one positional row,
+     * `arrayAgg` aggregates the rows, `emptyArray` is the payload of a list
+     * level without rows. `order` says how a list level keeps its order:
+     * `"inAggregate"` — the aggregate takes the ORDER BY itself (postgres
+     * `json_agg(… ORDER BY …)`); `"positionSlot"` — the aggregate cannot order
+     * (MySQL `JSON_ARRAYAGG` has no ORDER BY and documents its element order as
+     * undefined), so an ordered level projects a `ROW_NUMBER()` position as
+     * its last positional slot and the runtime sorts the children by it.
+     * MySQL needs 8.0.14 or later (LATERAL and outer references in derived
+     * tables); MariaDB has no LATERAL.
+     */
+    readonly lateralJson: {
+        readonly rowArray: string;
+        readonly arrayAgg: string;
+        readonly emptyArray: string;
+        readonly order: "inAggregate" | "positionSlot";
+        /**
+         * Time-of-day values ride the payload as text (`CAST(… AS CHAR)`, the
+         * query path's form): MySQL 8.4.11 prints a TIME beyond a day inside JSON
+         * wrapped modulo 24 hours (`838:59:59` → `"06:59:59.000000"`), which would
+         * turn the query strategy's refusal into a wrong value.
+         */
+        readonly timeOfDayAsText: boolean;
+        /**
+         * Zone-less date-times (MySQL DATETIME / TIMESTAMP / DATE) ride the
+         * payload as the session's zone-less text, which the JSON transport
+         * decodes as UTC, while the query strategy's driver reads the same text
+         * in ITS configured zone (mysql2 `timezone`). `true`: the dialect default
+         * (`relationStrategyDefault`) joins only on an adapter whose wire declares
+         * `zoneLessDateTime: "utc"`; an explicit `"join"` is unaffected. `false`
+         * where every adapter pins zone-less values to UTC (postgres).
+         */
+        readonly requiresUtcDateTimeWire: boolean;
+    } | null;
+    /**
+     * The relation strategy a client uses when neither the call nor the client
+     * option names one (5.0 rule D-2). `"join"` only where `lateralJoin` holds.
+     * On MySQL (lane J, wave 3b) the runtime still loads `"query"` until the
+     * adapter knows its server runs LATERAL and declares a UTC date-time wire
+     * (`serverLateralJoins` in the runtime).
+     */
+    readonly relationStrategyDefault: "join" | "query";
+    /**
+     * Fix lane Q1 (round 3, DB-03): how a positive relation filter that pins ONE
+     * related row by a unique key renders. `exists`: the correlated `EXISTS` —
+     * PostgreSQL and MySQL turn it into a semi-join. `inSelect`: an uncorrelated
+     * `key IN (SELECT key …)` — SQLite runs a correlated `EXISTS` once per outer
+     * row (`post where author.email = x`: 134 → 0.15 ms, Post 500 000).
+     */
+    readonly relationFilterStrategy: "exists" | "inSelect";
+    /**
+     * DB-02: when a find with a TOTAL order (it ends with the full primary key)
+     * pages with `skip` ≥ `minSkip`, the runtime cuts the page as primary keys
+     * in a derived table (`SELECT pk FROM t WHERE … ORDER BY … LIMIT ? OFFSET ?`)
+     * and joins the rows back by primary key (`fromSelect` + `innerJoins`; MySQL
+     * refuses LIMIT inside `IN (subquery)`). MySQL 26.7 / 8.4 drop the index from
+     * skip ≈ 5 000 and sort the table (500 000 rows, skip 5 000: 116.6 → 1.21 ms;
+     * 100 000: 144 → 9.3 ms) — there it applies under that rule alone.
+     * PostgreSQL gains only when the key page is an index-only scan (`authorId =
+     * 1`, skip 4 000: 4.37 → 0.24 ms) and loses up to 15 % when the filter is not
+     * covered, so `requiresCoveringIndex` asks for one declared index that serves
+     * the filter, the order and the key. `null`: never (SQLite walks an index
+     * plus rowid lookups cheaply — skip 100 000: 1.02 ms).
+     */
+    readonly deferredJoinPage: {
+        readonly minSkip: number;
+        readonly requiresCoveringIndex: boolean;
+    } | null;
+    /**
+     * DB-07: where this engine sorts NULL when ORDER BY names no placement —
+     * `high`: above every value (postgres: last on ASC, first on DESC), `low`:
+     * below (sqlite, mysql: first on ASC, last on DESC). A b-tree stores NULLs in
+     * that position, so only the matching `nulls` placement is index order.
+     */
+    readonly nativeNullsOrder: "high" | "low";
+    /**
+     * DB-07: whether a paged find whose LEADING order key is nullable and asks
+     * for the non-native placement reads through a `UNION ALL` of two
+     * index-ordered branches (`SelectStatement.fromUnion`: the key's non-NULL
+     * rows, then its NULL rows, each limited to `skip + take`), re-ordered and
+     * paged outside. Today's statement sorts the whole table on every page:
+     * PostgreSQL 18 `desc nulls last` 34.8 → 0.075 ms, MySQL 26.7 `asc nulls
+     * last` 54.5 → 0.85 ms. SQLite 3.51 already walks the index for either
+     * placement (0.005 ms today, 0.020 ms as a union) — `false` there.
+     */
+    readonly nullsUnionPage: boolean;
     /**
      * Membership on a time-of-day column (`inArray` with `timeOfDay`): `in`
      * renders like any other membership; `equalities` renders an OR of `=`
-     * comparisons. MySQL 8.4 types a `?` inside a multi-value IN list against a
+     * comparisons (a key list with a time-of-day member: an OR of complete
+     * conjunctions). MySQL 8.4 types a `?` inside a multi-value IN list against a
      * TIME(n) column as TIME(6) and matches nothing unless n is 6 (live on
      * 8.4.11; 26.7 matches); `=` converts the parameter to the column's TIME on
      * every version.
@@ -150,11 +286,14 @@ export type SqlDialect = {
     };
     /**
      * Skip-conflicting-rows form. `onConflictDoNothing` appends
-     * `ON CONFLICT [(target)] DO NOTHING`; `insertIgnore` turns the statement into
-     * `INSERT IGNORE INTO` — which ignores a wider class of errors than a pure
-     * duplicate-key skip (see the catalog case).
+     * `ON CONFLICT [(target)] DO NOTHING`; `duplicateKeyKeep` appends
+     * `ON DUPLICATE KEY UPDATE k = t.k` — a self-assignment that skips ANY
+     * duplicate key and, unlike `INSERT IGNORE` (never emitted: it also turns NOT
+     * NULL, out-of-range and foreign-key errors into warnings), leaves every other
+     * error an error. A duplicate takes the update arm, so the table's UPDATE
+     * triggers fire (nothing changes).
      */
-    readonly doNothingForm: "onConflictDoNothing" | "insertIgnore";
+    readonly doNothingForm: "onConflictDoNothing" | "duplicateKeyKeep";
     /** Case-insensitive LIKE: native ILIKE or LOWER(col) LIKE LOWER(pattern). */
     readonly insensitiveLike: "ilike" | "lower";
     /**
@@ -243,6 +382,17 @@ export type SqlDialect = {
      * rows are grouped by column set into separate statements there (M4).
      */
     readonly rowDefaultKeyword: boolean;
+    /**
+     * How a multi-row INSERT whose rows all bind plain values may render
+     * (`InsertStatement.unnest`). `unnest` binds ONE typed array per column —
+     * `INSERT … SELECT … FROM unnest($1::text[], …) WITH ORDINALITY … ORDER BY`
+     * — so the text is constant and a statement binds one parameter per column
+     * (postgres and PGlite; the type table, efficiency campaign EPIC C, proved
+     * equal stored values and errors on adapter-pg, adapter-bun and PGlite).
+     * `values` keeps one parameter per value (mysql and sqlite have no typed
+     * array parameters); the renderer refuses an `unnest` statement there.
+     */
+    readonly bulkInsertForm: "unnest" | "values";
     /** How an INSERT that names no column renders ({@link EmptyInsertSyntax}). */
     readonly emptyInsert: EmptyInsertSyntax;
     /**

package/dist/dialects/migration-inventory.d.ts

@@ -1,5 +1,16 @@
 import type { SqlDialect } from "../dialect.ts";
 import type { RenderedQuery } from "../render.ts";
+/**
+ * Ends a MySQL catalog listing whose row count has no small bound (the
+ * migration inventory, the visibility proof). `sql_select_limit` (session or
+ * global, e.g. 1 000 under `mysql --safe-updates`) silently cuts the rows of a
+ * SELECT without its own LIMIT, and a cut listing reads its last objects (or
+ * grants) as missing; an explicit LIMIT takes precedence over it. After the
+ * last `UNION` branch (and its ORDER BY) the LIMIT applies to the whole union.
+ * The value is MySQL's largest row count, so nothing is ever cut. The batched
+ * object readers end the same way (`migration-objects.ts`, LEFTOVERS-01).
+ */
+export declare const MYSQL_NO_ROW_LIMIT: string;
 /** SQLite column metadata includes generated columns omitted by table_info. */
 export declare function renderSqliteColumnInventory(params: {
     dialect: SqlDialect;
@@ -12,11 +23,57 @@ export declare function renderSqliteForeignKeyInventory(params: {
     namespace: string;
     table: string;
 }): RenderedQuery;
+/**
+ * {@link renderSqliteColumnInventory} for many tables in one statement. Rows
+ * carry `vibe_request` = the table's index in `tables`, then the single query's
+ * columns in its order (`cid`). The table-valued pragma runs the same PRAGMA
+ * per table, with the same namespace argument. Every table answers at least one
+ * row (`LEFT JOIN`): one whose `name` is NULL when its PRAGMA has no rows, so a
+ * table missing from the answer was not read.
+ */
+export declare function renderSqliteColumnInventoryBatch(params: {
+    dialect: SqlDialect;
+    namespace: string;
+    tables: readonly string[];
+}): RenderedQuery;
+/** {@link renderSqliteForeignKeyInventory} for many tables in one statement; rows as in {@link renderSqliteColumnInventoryBatch} (no-row marker: `id` NULL), ordered `id, seq` per table. */
+export declare function renderSqliteForeignKeyInventoryBatch(params: {
+    dialect: SqlDialect;
+    namespace: string;
+    tables: readonly string[];
+}): RenderedQuery;
+/** A PRAGMA SQLite introspection reads once per table (`table_xinfo`, `index_list`, `foreign_key_list`) or per index (`index_xinfo`). */
+export type SqliteIntrospectionPragma = "table_xinfo" | "index_list" | "index_xinfo" | "foreign_key_list";
+/**
+ * `PRAGMA <pragma>("<name>")` for every name in one statement. Rows carry
+ * `vibe_request` = the name's index in `names`, then exactly the PRAGMA's own
+ * columns (a table-valued pragma's hidden `arg`/`schema` columns are not in
+ * `p.*`), per name in the order the PRAGMA emits them. No schema argument, as
+ * in the single statement: the table-valued pragma runs `PRAGMA <pragma>='name'`
+ * internally, with the same temp-then-main name lookup.
+ *
+ * Literal text with no bound values, like every statement SQLite introspection
+ * sends (the names list is one quoted string literal): an executor that runs a
+ * value-less statement without binding anything reads the same rows.
+ *
+ * Every name answers at least one row (`LEFT JOIN`): a name whose PRAGMA has no
+ * rows answers one row whose PRAGMA columns are all NULL, so a name missing
+ * from the answer was not read (and an empty answer is never "no rows").
+ */
+export declare function renderSqliteIntrospectionPragmaBatch(params: {
+    dialect: SqlDialect;
+    pragma: SqliteIntrospectionPragma;
+    names: readonly string[];
+}): RenderedQuery;
 /** Exact SQL needed to restore independently existing indexes and triggers during a rebuild. */
 export declare function renderSqliteRebuildObjects(params: {
     dialect: SqlDialect;
 }): RenderedQuery;
-/** Enumerate scoped catalog identities, including constraints and their backing indexes. */
+/**
+ * Enumerate scoped catalog identities, including constraints and their backing
+ * indexes. The MySQL listing ends with {@link MYSQL_NO_ROW_LIMIT}, so
+ * `sql_select_limit` cannot drop objects from it.
+ */
 export declare function renderMigrationInventory(params: {
     dialect: SqlDialect;
     namespace: string;

package/dist/dialects/migration-objects.d.ts

@@ -11,6 +11,42 @@ export declare function renderMysqlObjectMembers(params: {
     dialect: SqlDialect;
     identity: SqlObjectIdentity;
 }): RenderedQuery | undefined;
+/**
+ * One batched MySQL catalog read. Its rows carry `vibe_position` = i, the
+ * branch that answers for request position `positions[i]`; member reads also
+ * carry `vibe_ordinal`, the single query's ORDER BY column.
+ */
+export type MysqlObjectBatch = RenderedQuery & {
+    readonly positions: readonly number[];
+};
+/**
+ * MySQL facts reads in bounded statements, grouped by query shape in request
+ * order, 100 objects per statement. Each `UNION ALL` branch is the UNCHANGED
+ * single-object query as a derived table, so the server matches names with the
+ * single read's own `WHERE` and collation: the rows of a position are exactly the
+ * rows {@link renderMigrationObjectQuery} returns for it. An identity MySQL cannot
+ * inspect is in no batch; the caller reads it on its own (and gets its refusal).
+ * The statement ends with `LIMIT 18446744073709551615`, so `sql_select_limit`
+ * cannot cut it.
+ */
+export declare function renderMysqlObjectBatch(params: {
+    dialect: SqlDialect;
+    identities: readonly SqlObjectIdentity[];
+}): readonly MysqlObjectBatch[];
+/**
+ * MySQL member reads (function parameters, index and constraint columns) in
+ * bounded statements, grouped by kind in request order, 100 objects per
+ * statement. Each branch is the single member query's select list and `WHERE`
+ * plus its ORDER BY column as `vibe_ordinal`; MySQL ignores an ORDER BY inside a
+ * union branch, so the statement orders by `vibe_position, vibe_ordinal` (then
+ * `LIMIT 18446744073709551615`, so `sql_select_limit` cannot cut it). Rows
+ * of a position equal {@link renderMysqlObjectMembers}' rows in its order
+ * whenever that object's ordinals are distinct; the caller checks that.
+ */
+export declare function renderMysqlObjectMembersBatch(params: {
+    dialect: SqlDialect;
+    identities: readonly SqlObjectIdentity[];
+}): readonly MysqlObjectBatch[];
 /** PostgreSQL dependency addresses are returned as server-owned strings, never guessed from SQL. */
 export declare function renderMigrationDependencies(params: {
     dialect: SqlDialect;

package/dist/dialects/migration-visibility.d.ts

@@ -1,6 +1,11 @@
 import type { SqlDialect } from "../dialect.ts";
 import type { RenderedQuery } from "../render.ts";
-/** Direct grants needed to enumerate MySQL objects without privilege-filtered omissions. */
+/**
+ * Direct grants needed to enumerate MySQL objects without privilege-filtered
+ * omissions. Ends with {@link MYSQL_NO_ROW_LIMIT}: a `sql_select_limit` below
+ * the grant count would otherwise cut grants and refuse a namespace whose
+ * grants are complete.
+ */
 export declare function renderMigrationVisibility(params: {
     dialect: SqlDialect;
     namespace: string;

package/dist/dialects/mysql-check-probe.d.ts

@@ -5,6 +5,7 @@ export declare function renderMysqlCheckProbe(params: {
     dialect: SqlDialect;
     operation: "clone" | "add" | "read" | "drop";
     probe: string;
+    /** Source for clone, or qualified live table for a transient SHOW CREATE comparison. */
     table?: {
         readonly namespace: string;
         readonly name: string;

package/dist/dialects/mysql-generated-columns.d.ts

@@ -0,0 +1,43 @@
+import type { QualifiedSqlName } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { ExtractedGeneratedColumn, GeneratedColumnDeclaration } from "../generated-columns.ts";
+import type { RenderedQuery } from "../render.ts";
+/** MySQL stored syntax, placed after complete type/charset/collation information. */
+export declare function renderMysqlGeneratedColumnClause({ generated }: {
+    readonly generated: GeneratedColumnDeclaration;
+}): string;
+/** Temporary CREATE/DROP operations avoid ALTER's implicit-commit boundary. */
+export type MysqlGeneratedColumnProbe = {
+    readonly operation: "context";
+} | {
+    readonly operation: "clone";
+    readonly probe: string;
+    readonly table: QualifiedSqlName;
+} | {
+    readonly operation: "create";
+    readonly probe: string;
+    readonly definition: string;
+    readonly column: string;
+    readonly columnDefinition: string;
+    readonly backslashEscapes: boolean;
+    readonly after?: string;
+} | {
+    readonly operation: "read";
+    readonly probe: string;
+    readonly table?: QualifiedSqlName;
+} | {
+    readonly operation: "drop";
+    readonly probe: string;
+};
+/** Render scratch SQL from independently provisioned table definitions; migrate owns cleanup. */
+export declare function renderMysqlGeneratedColumnProbe({ dialect, probe }: {
+    readonly dialect: SqlDialect;
+    readonly probe: MysqlGeneratedColumnProbe;
+}): RenderedQuery;
+/** SHOW CREATE's own escaping rules apply; information_schema uses a different spelling channel. */
+export declare function extractMysqlGeneratedColumn({ definition, column, backslashEscapes }: {
+    readonly definition: string;
+    readonly column: string;
+    readonly backslashEscapes: boolean;
+}): ExtractedGeneratedColumn | undefined;
+//# sourceMappingURL=mysql-generated-columns.d.ts.map

package/dist/dialects/mysql-index-expressions.d.ts

@@ -0,0 +1,20 @@
+import type { IndexKeyTermIR } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { IndexExpressionProbeParams, IndexKeyOperand } from "../index-expressions.ts";
+import type { PredicateModel } from "../predicate.ts";
+import type { RenderedQuery } from "../render.ts";
+/** Qualify only expression-bearing keys through schema's shared width rule; never impose new bounds on ordinary indexes. */
+export declare function assertMysqlIndexKeyStorage({ model, terms }: {
+    readonly dialect: SqlDialect;
+    readonly model: PredicateModel;
+    readonly terms: readonly IndexKeyTermIR[];
+}): void;
+/** Recover SHOW CREATE key interiors, including exact CAST/charset/collation bytes. */
+export declare function extractMysqlIndexKeys({ definition, index, backslashEscapes }: {
+    readonly definition: string;
+    readonly index: string;
+    readonly backslashEscapes: boolean;
+}): readonly IndexKeyOperand[] | undefined;
+/** Reuse E's temporary-clone/read/drop operations, extending only CREATE's key replacement seam. */
+export declare function renderMysqlIndexExpressionProbe({ ...params }: IndexExpressionProbeParams): readonly RenderedQuery[];
+//# sourceMappingURL=mysql-index-expressions.d.ts.map

package/dist/dialects/mysql-row-rules.d.ts

@@ -0,0 +1,8 @@
+import type { SqlDialect } from "../dialect.ts";
+import type { EventRowRuleContext, RenderedRowRule } from "../row-rules.ts";
+/** Emit mode-safe SIGNAL diagnostics and one unfiltered BEFORE trigger per event. */
+export declare function renderMysqlRowRule({ dialect, context }: {
+    readonly dialect: SqlDialect;
+    readonly context: EventRowRuleContext;
+}): RenderedRowRule;
+//# sourceMappingURL=mysql-row-rules.d.ts.map

package/dist/dialects/mysql.d.ts

@@ -7,8 +7,9 @@
  * - Upserts use ON DUPLICATE KEY UPDATE (no conflict-target refinement).
  * - OFFSET requires LIMIT → the documented huge-limit idiom.
  * - No NULLS FIRST/LAST → `col IS NULL` emulation terms.
- * - No `ON CONFLICT ... DO NOTHING` → `INSERT IGNORE`, which is broader: it
- *   downgrades other row-level errors to warnings too.
+ * - No `ON CONFLICT ... DO NOTHING` → `ON DUPLICATE KEY UPDATE k = t.k` (a
+ *   no-op self-assignment on ANY duplicate key). Never `INSERT IGNORE`, which
+ *   also downgrades NOT NULL, range and foreign-key errors to warnings.
  */
 import type { SqlDialect } from "../dialect.ts";
 export declare const mysqlDialect: SqlDialect;

package/dist/dialects/postgres-generated-columns.d.ts

@@ -0,0 +1,30 @@
+import type { QualifiedSqlName } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { GeneratedColumnDeclaration } from "../generated-columns.ts";
+import type { RenderedQuery } from "../render.ts";
+/** PostgreSQL stored syntax; the public dispatcher performs declaration admission. */
+export declare function renderPostgresGeneratedColumnClause({ generated }: {
+    readonly generated: GeneratedColumnDeclaration;
+}): string;
+/** The migration owner creates the desired base context inside the private savepoint. */
+export type PostgresGeneratedColumnProbe = {
+    readonly operation: "savepoint" | "rollback" | "release";
+    readonly savepoint: string;
+} | {
+    readonly operation: "add";
+    readonly table: QualifiedSqlName;
+    readonly column: string;
+    readonly definition: string;
+};
+/** Render pinned-session scratch statements; this helper never executes or manages a session. */
+export declare function renderPostgresGeneratedColumnProbe({ dialect, probe }: {
+    readonly dialect: SqlDialect;
+    readonly probe: PostgresGeneratedColumnProbe;
+}): RenderedQuery;
+/** Approved stored-generated to ordinary conversion, retaining the present stored values. */
+export declare function renderPostgresDropGeneratedExpression({ dialect, table, column }: {
+    readonly dialect: SqlDialect;
+    readonly table: QualifiedSqlName;
+    readonly column: string;
+}): RenderedQuery;
+//# sourceMappingURL=postgres-generated-columns.d.ts.map

package/dist/dialects/postgres-index-expressions.d.ts

@@ -0,0 +1,10 @@
+import type { IndexExpressionProbeParams, IndexKeyOperand } from "../index-expressions.ts";
+import type { RenderedQuery } from "../render.ts";
+/** CREATE INDEX extraction is conservative; structured catalog rows remain authoritative. */
+export declare function extractPostgresIndexKeys({ definition, index }: {
+    readonly definition: string;
+    readonly index: string;
+}): readonly IndexKeyOperand[] | undefined;
+/** Caller owns a fixed search_path and rollback savepoint; no populated user table is indexed. */
+export declare function renderPostgresIndexExpressionProbe({ ...params }: IndexExpressionProbeParams): readonly RenderedQuery[];
+//# sourceMappingURL=postgres-index-expressions.d.ts.map

package/dist/dialects/postgres-index-keys.d.ts

@@ -1,10 +1,25 @@
 import type { QualifiedSqlName } from "@vibeorm/schema";
 import type { SqlDialect } from "../dialect.ts";
 import type { RenderedQuery } from "../render.ts";
+/**
+ * Turn JIT compilation off for the rest of the current transaction and return
+ * the previous `jit` value as `previous` (read before the change). The bulk
+ * index-key read costs far above `jit_above_cost`, and compiling it takes longer
+ * than running it. Transaction-local: outside a transaction block it changes nothing.
+ */
+export declare function renderPostgresJitSuspend(params: {
+    dialect: SqlDialect;
+}): RenderedQuery;
+/** Restore the transaction's `jit` value read by {@link renderPostgresJitSuspend}. */
+export declare function renderPostgresJitRestore(params: {
+    dialect: SqlDialect;
+    previous: string;
+}): RenderedQuery;
 /** Physical operands and unambiguous server-default evidence for actual type/access-method pairs. */
 export declare function renderPostgresIndexKeys(params: {
     dialect: SqlDialect;
     table?: QualifiedSqlName;
     namespaces?: readonly string[];
+    expressionMetadata?: boolean;
 }): RenderedQuery;
 //# sourceMappingURL=postgres-index-keys.d.ts.map

package/dist/dialects/postgres-rls.d.ts

@@ -57,11 +57,26 @@ export declare function renderRlsPolicy(params: {
     policyName?: string;
     targetSchema?: "public" | "pg_temp";
 }): RenderedQuery;
-/** Every declared setting, parameterized in declaration order and transaction-local. */
+/**
+ * Every declared setting, parameterized in declaration order and transaction-local.
+ *
+ * Optional parts travel in the SAME statement (statement-count pass, EPIC 1-2);
+ * without them the text is exactly the claims statement:
+ * - `role` (PGlite): binds the trusted runtime role FIRST, as {@link renderRlsRole} does;
+ * - `readOnly`: switches the transaction to READ ONLY after the claims (`$all` on a
+ *   verified connection; PostgreSQL accepts this switch at any point of a transaction);
+ * - `backend`: reports the backend as `"backendPid"` / `"backendStart"` text columns,
+ *   the readiness catalog read's own expressions (adapters that name no connection object).
+ *
+ * A context with zero keys is accepted only when one of these parts is present.
+ */
 export declare function renderRlsContext(params: {
     dialect: SqlDialect;
     context: RlsContextIR;
     values: Readonly<Record<string, string | null>>;
+    role?: string;
+    readOnly?: boolean;
+    backend?: boolean;
 }): RenderedQuery;
 /** First transaction statement on eligible PGlite only; server roles are login roles. */
 export declare function renderRlsRole(params: {

package/dist/dialects/postgres-row-rules.d.ts

@@ -0,0 +1,25 @@
+import type { FieldIR, QualifiedSqlName, RowRuleIR, SqlObjectIdentity } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { RenderedRowRule } from "../row-rules.ts";
+/** A finalized PostgreSQL comparison context, supplied by the canonical schema collector. */
+export type PostgresRowRuleContext = {
+    readonly model: string;
+    readonly table: QualifiedSqlName;
+    readonly rule: RowRuleIR;
+    readonly functionIdentity: Extract<SqlObjectIdentity, {
+        readonly kind: "function";
+    }>;
+    readonly triggerIdentity: {
+        readonly kind: "trigger";
+        readonly table: QualifiedSqlName;
+        readonly name: string;
+    };
+    readonly protectedFields: readonly FieldIR[];
+    readonly gateField?: FieldIR;
+};
+/** Emit one ordinary invoker function and an unfiltered BEFORE row trigger; no live objects are taken over. */
+export declare function renderPostgresRowRule({ dialect, context }: {
+    readonly dialect: SqlDialect;
+    readonly context: PostgresRowRuleContext;
+}): RenderedRowRule;
+//# sourceMappingURL=postgres-row-rules.d.ts.map

package/dist/dialects/sqlite-generated-columns.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractedGeneratedColumn, GeneratedColumnDeclaration } from "../generated-columns.ts";
+/** SQLite stored syntax; adding a stored column still requires the migrate rebuild path. */
+export declare function renderSqliteGeneratedColumnClause({ generated }: {
+    readonly generated: GeneratedColumnDeclaration;
+}): string;
+/** Shared source-slice extraction for SQLite source and MySQL SHOW CREATE, not SQL equivalence. */
+export declare function extractGenerationFromDefinition({ definition, column, backslashEscapes, mysql }: {
+    readonly definition: string;
+    readonly column: string;
+    readonly backslashEscapes?: boolean;
+    readonly mysql?: boolean;
+}): ExtractedGeneratedColumn | undefined;
+/** Recover the exact AS interior; omitted storage means virtual, never inferred stored. */
+export declare function extractSqliteGeneratedColumn({ definition, column }: {
+    readonly definition: string;
+    readonly column: string;
+}): ExtractedGeneratedColumn | undefined;
+//# sourceMappingURL=sqlite-generated-columns.d.ts.map

package/dist/dialects/sqlite-index-expressions.d.ts

@@ -0,0 +1,23 @@
+import type { IndexKeyOperand } from "../index-expressions.ts";
+import type { TableDefinitionToken } from "./sqlite-table-definition.ts";
+/** Exact outer-key slices shared by CREATE INDEX and MySQL table-key clauses. */
+export declare function extractIndexKeyList({ sql, open, close, tokens, wrapped, removeWrapper }: {
+    readonly sql: string;
+    readonly open: TableDefinitionToken;
+    readonly close: TableDefinitionToken;
+    readonly tokens: readonly TableDefinitionToken[];
+    readonly wrapped?: boolean;
+    readonly removeWrapper?: boolean;
+}): readonly IndexKeyOperand[] | undefined;
+/** Parse the CREATE INDEX header without interpreting any scalar expression. */
+export declare function extractStandaloneIndexKeys({ definition, index, postgres }: {
+    readonly definition: string;
+    readonly index: string;
+    readonly postgres?: boolean;
+}): readonly IndexKeyOperand[] | undefined;
+/** SQLite source spelling is the evidence; CAST alone never proves a plain Decimal key. */
+export declare function extractSqliteIndexKeys({ definition, index }: {
+    readonly definition: string;
+    readonly index: string;
+}): readonly IndexKeyOperand[] | undefined;
+//# sourceMappingURL=sqlite-index-expressions.d.ts.map

package/dist/dialects/sqlite-row-rules.d.ts

@@ -0,0 +1,8 @@
+import type { SqlDialect } from "../dialect.ts";
+import type { EventRowRuleContext, RenderedRowRule } from "../row-rules.ts";
+/** Emit literal-only ABORT diagnostics and one unfiltered BEFORE trigger per event. */
+export declare function renderSqliteRowRule({ dialect, context }: {
+    readonly dialect: SqlDialect;
+    readonly context: EventRowRuleContext;
+}): RenderedRowRule;
+//# sourceMappingURL=sqlite-row-rules.d.ts.map

package/dist/dialects/sqlite-table-definition.d.ts

@@ -8,12 +8,32 @@ export type TableDefinitionParts = {
     readonly clauses: readonly string[];
     readonly suffix: string;
 };
-/** Extract a CREATE TABLE list with a quote-aware delimiter walk, not an expression parser. */
-export declare function tableDefinitionParts(params: {
-    sql: string;
+/** A source token with balanced-parenthesis depth and original byte boundaries. */
+export type TableDefinitionToken = {
+    readonly value: string;
+    readonly kind: "word" | "quoted" | "literal" | "symbol";
+    readonly start: number;
+    readonly end: number;
+    readonly depth: number;
+};
+/** Scan SQL delimiters without looking inside quoted strings, identifiers or comments. */
+export declare function tableDefinitionTokens({ sql, backslashEscapes }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
+}): readonly TableDefinitionToken[];
+/** Extract a CREATE TABLE list with a quote/comment-aware delimiter walk. */
+export declare function tableDefinitionParts({ sql, backslashEscapes }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
 }): TableDefinitionParts;
+/** Read column names for SQLite source and MySQL SHOW CREATE using the same lexer. */
+export declare function tableColumnClauses({ sql, backslashEscapes, mysql }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
+    readonly mysql?: boolean;
+}): readonly SqliteColumnClause[];
 /** Return column clauses without rewriting any SQL inside them. */
-export declare function sqliteColumnClauses(params: {
-    sql: string;
+export declare function sqliteColumnClauses({ sql }: {
+    readonly sql: string;
 }): readonly SqliteColumnClause[];
 //# sourceMappingURL=sqlite-table-definition.d.ts.map