@vibeorm/sql 5.9.0 → 5.10.0

package/dist/ast.d.ts

@@ -307,6 +307,8 @@ export type SqlExpr = {
     /** The tested columns, in the subquery's projection order. */
     readonly columns: readonly ColRef[];
     readonly select: SelectStatement;
+    /** The subquery yields at most one row: one column, rendered `"fk" = (SELECT …)`. */
+    readonly single?: true;
 } | {
     readonly kind: "like";
     readonly column: ColRef;
@@ -450,12 +452,20 @@ export type SqlExpr = {
  *
  * `one` renders the constant `1` — the conventional EXISTS projection; it
  * cannot be combined with a column list.
+ *
+ * `exists` asks whether the statement's own FROM and WHERE match a row:
+ * `SELECT EXISTS (SELECT 1 FROM … WHERE …) AS "alias"` — one row, one
+ * boolean-valued column (PostgreSQL `boolean`, SQLite and MySQL `0`/`1`). It
+ * takes no column list, aggregate, grouping, order, paging, lock or join.
  */
 export type SelectExpr = {
     readonly kind: "countAll";
     readonly alias?: string;
 } | {
     readonly kind: "one";
+} | {
+    readonly kind: "exists";
+    readonly alias: string;
 };
 /** Arithmetic applied to a column's current value in an UPDATE ... SET. */
 export type SetOperator = "increment" | "decrement" | "multiply" | "divide";
@@ -574,10 +584,18 @@ export type OrderTerm = OrderByColumn | OrderByAggregate | OrderBySubquery;
 export type LateralJoin = {
     /** Join alias (`__lat_0`) — the outer projection selects `alias.columnAlias`. */
     readonly alias: string;
-    /** Column the aggregated JSON value is exposed under (`__rel_posts`). */
+    /**
+     * Column the aggregated JSON value is exposed under (`__rel_posts`). An
+     * `aggregate` lateral exposes one column per entry of its select's
+     * `aggregates` instead, under each entry's alias.
+     */
     readonly columnAlias: string;
-    /** jsonArray: many rows; jsonObject: one row or NULL; count: a scalar COUNT(*) lateral. */
-    readonly agg: "jsonArray" | "jsonObject" | "count";
+    /**
+     * jsonArray: many rows; jsonObject: one row or NULL; count: a scalar COUNT(*)
+     * lateral; aggregate: one ungrouped row of `aggregates` (no columns), which
+     * an aggregate without GROUP BY returns even over zero rows.
+     */
+    readonly agg: "jsonArray" | "jsonObject" | "count" | "aggregate";
     /**
      * Object output is the SQL-layer default. Positional rows follow the exact
      * select.columns order, using explicit output names (never SELECT *).
@@ -586,6 +604,13 @@ export type LateralJoin = {
      * slot. Consumers must use the SAME projection to decode the payload.
      */
     readonly rowFormat?: "object" | "positional";
+    /**
+     * Positional rows only: output names of `select.columns` the subselect
+     * projects for the statement's own use (an order key the aggregate's ORDER
+     * BY reads, a key a nested lateral correlates on) but the JSON row leaves
+     * out. The row is the remaining columns in `select.columns` order.
+     */
+    readonly hidden?: readonly string[];
     /** The correlated child select — may reference outer columns via table-qualified refs. */
     readonly select: SelectStatement;
 };
@@ -1044,7 +1069,18 @@ export type ReturningColumn = string | {
 } | {
     readonly name: string;
     readonly transform: "jsonText";
-} | CaptureReturningColumn | OtherRowReturningColumn;
+} | CaptureReturningColumn | OtherRowReturningColumn | ServerVersionReturningColumn;
+/**
+ * The server's `server_version_num` as text, exposed as `alias`:
+ * `pg_catalog.current_setting('server_version_num') AS "alias"`. Rides a write
+ * whose client does not know the server version yet, so the next statement can
+ * take the form that version allows without a read of its own. Dialects with
+ * the `rowCapture` capability only (the version decides whether it applies).
+ */
+export type ServerVersionReturningColumn = {
+    readonly serverVersion: true;
+    readonly alias: string;
+};
 /**
  * A RETURNING column read from a row OTHER than the one the statement wrote,
  * exposed as `alias` and projected like the written row's own column
@@ -1201,6 +1237,42 @@ export type OnConflictUpdate = {
      * mysql's ODKU has no WHERE and refuses it (`VIBE_UNSUPPORTED_CAPABILITY`).
      */
     readonly updateWhere?: SqlExpr;
+    /**
+     * Skip-unchanged guard: the conflicting row is updated only when at least
+     * one of these columns' stored value differs, NULL counting as a value,
+     * from the value its `update` assignment would write (each column must have
+     * one). Rendered as the first member of the update arm's `WHERE`, AND-ed
+     * with {@link OnConflictUpdate.updateWhere}; a skipped row writes nothing
+     * and returns nothing. On ON DUPLICATE KEY UPDATE (no WHERE) the columns it
+     * leaves out are assigned first, keeping their stored value when nothing
+     * else would change, and the dialect itself skips the unchanged row.
+     * Needs `upsertSkipUnchanged`.
+     */
+    readonly skipUnchanged?: readonly UnchangedColumn[];
+    /**
+     * The table's native row-security predicate, RAW SQL without parameters
+     * (the managed policy's check, columns qualified by the target table's
+     * name). With a guard on the arm ({@link OnConflictUpdate.updateWhere} or
+     * {@link OnConflictUpdate.skipUnchanged}) the arm's `WHERE` becomes
+     * `(<policy>) IS NOT TRUE OR (<guard>)`: PostgreSQL evaluates that `WHERE`
+     * before its row-security check of the conflicting row, so a row the policy
+     * hides must always take the update path and fail that check, whatever its
+     * values. Ignored when the arm has no guard; refused by a dialect without
+     * `nativeRowLevelSecurity`.
+     */
+    readonly rowPolicy?: string;
+    /**
+     * MySQL only, a single-row statement: the duplicate arm also runs
+     * `` `column` = IF(LAST_INSERT_ID(flag), `t`.`column`, `t`.`column`) `` (a
+     * self-assignment, rendered last), so the statement reports `flag` as its
+     * insert id exactly when the row took the update arm — the one signal that
+     * tells an inserted row from an unchanged one when the driver reports no
+     * `Duplicates:` info. `flag` is a decimal literal.
+     */
+    readonly duplicateFlag?: {
+        readonly column: string;
+        readonly flag: string;
+    };
     /**
      * MySQL only (`upsertForm: "onDuplicateKey"`): append
      * `` `col` = LAST_INSERT_ID(`col`) `` to the update list so the UPDATE arm
@@ -1210,6 +1282,41 @@ export type OnConflictUpdate = {
      */
     readonly lastInsertIdColumn?: string;
 };
+/**
+ * One column a skip-unchanged conflict arm compares. `json`: a Json column,
+ * compared as `jsonb` on postgres (its `json` type has no equality operator;
+ * `"list"` for a Json list).
+ */
+export type UnchangedColumn = {
+    readonly column: string;
+    readonly json?: "scalar" | "list";
+    /**
+     * A column whose SQL equality can be coarser than "the stored value would
+     * not change"; the renderer compares it exactly where the dialect needs it.
+     * See {@link UnchangedExactness}.
+     */
+    readonly bytes?: UnchangedExactness;
+    /**
+     * A text column the schema declares with a folding type or collation
+     * (`citext`, a `@collation` that is not byte-ordered): its equality may call
+     * `'x'` and `'X'` equal on any dialect, not only under MySQL's default.
+     */
+    readonly folds?: true;
+    /** The column is a list of `bytes`'s kind (a postgres array). */
+    readonly list?: true;
+};
+/**
+ * Why a compared column's own equality may call two different stored values
+ * equal:
+ * - `"text"`: a text column; MySQL's default `_ai_ci` collation folds case
+ *   and accents (and see `folds`).
+ * - `"decimal"`: a Decimal column without a declared scale (PostgreSQL's bare
+ *   `numeric` keeps `1.50` and `1.5` apart, its equality does not).
+ * - `"float"`: a float column (`-0` equals `0`).
+ * - `"other"`: a Json or list column, or a text-like column of another
+ *   declared type, compared by its bytes on MySQL.
+ */
+export type UnchangedExactness = "text" | "decimal" | "float" | "other";
 /**
  * Conflicting rows are skipped (`createMany({ skipDuplicates: true })`).
  * An empty/absent target means "any conflict" — the mysql form
@@ -1528,6 +1635,15 @@ export type ChainResult = {
      * guard, so it is evaluated exactly once, on the one guaranteed result row.
      */
     readonly veto?: readonly ChainVeto[];
+    /**
+     * A step whose rows every veto depends on: when it returned no row, no veto
+     * is checked and the statement succeeds, answering the one guaranteed row
+     * with NULL columns and the tally (rendered as the first CASE arm, `WHEN NOT
+     * EXISTS (SELECT 1 FROM "step") THEN <tally>`). A nested write whose
+     * missing parent is an answer, not an error, gates its children's vetoes on
+     * the parent step this way. Requires `tally` and at least one veto.
+     */
+    readonly vetoGate?: string;
     /**
      * One column `alias` on every result row: the number of rows the listed
      * data-modifying steps returned (their RETURNING rows = their direct

package/dist/codecs.d.ts

@@ -76,15 +76,30 @@ export type WireFidelity = {
      */
     readonly bytes?: "buffer";
     /**
-     * Zone-less date-time text (MySQL DATETIME / TIMESTAMP / DATE) is read as a
-     * UTC instant by the driver (`"utc"`: mysql2 with `timezone: "Z"`). Absent
-     * means another or an unknown zone (another `timezone` option, an injected
-     * pool). Never prunes a decoder: the runtime reads it to decide whether a
-     * dialect default of `"join"` keeps value identity — the JSON transport
-     * decodes that text as UTC (`lateralJson.requiresUtcDateTimeWire`, lane J).
+     * The zone the driver reads zone-less date-time text in (MySQL DATETIME /
+     * TIMESTAMP / DATE): `"utc"` (mysql2 with `timezone: "Z"`), a fixed offset
+     * in minutes east of UTC, or `"local"` (the process zone, read the way
+     * mysql2 builds a local `Date`). The MySQL DateTime decoders read the same
+     * text in the same zone wherever it arrives as text (the join strategy's
+     * JSON, a page key, `exactDates`), so one stored cell is one instant on every
+     * path; the adapter writes a bound parameter in it. Absent reads as UTC.
+     * Never prunes a decoder. `"utc"` alone also lets a dialect default of
+     * `"join"` apply (`lateralJson.requiresUtcDateTimeWire`): it is declared only
+     * where the zone is known to be UTC.
      */
-    readonly zoneLessDateTime?: "utc";
+    readonly zoneLessDateTime?: DateTimeZone;
 };
+/** A zone zone-less date-time text is read in: UTC, a fixed offset in minutes east of UTC, or the process's local zone. */
+export type DateTimeZone = "utc" | "local" | {
+    readonly offsetMinutes: number;
+};
+/**
+ * The cache-key fragment of a wire's date-time zone: `""` when zone-less text
+ * reads as UTC, so every UTC plan keeps its key; else `"local"` or the offset.
+ */
+export declare function dateTimeZoneKey(params: {
+    wire: WireFidelity | undefined;
+}): string;
 /**
  * Is this scalar type's DECODE a no-op under the declared wire fidelity?
  * Provable against the decode implementations in this file, identically on
@@ -115,7 +130,8 @@ export declare function decodeIsNoop(params: {
     wire: WireFidelity | undefined;
 }): boolean;
 /**
- * Parse date-time text into a `Date`, reading ZONE-LESS text as **UTC**.
+ * Parse date-time text into a `Date`, reading ZONE-LESS text as **UTC** — for
+ * text a CALLER wrote (a filter or data value, a validator's check).
  *
  * ECMA-262 reads `2026-01-15T12:00:00` as process-LOCAL time, so the same
  * stored value would decode to a different instant on every host time zone,
@@ -124,9 +140,12 @@ export declare function decodeIsNoop(params: {
  * that yields ONE instant everywhere (MYSQL-2, live-proven; the postgres
  * `timestamp` case is proven by apps/tests `timestamp-zones.e2e`). Text with
  * an explicit `Z`/offset and date-only text parse as ECMA-262 already reads
- * them (as written / UTC midnight); anything unparseable is `undefined` so the
- * caller keeps its own fallback. Fractions beyond milliseconds are truncated —
- * `Date` has no finer resolution and engines differ on longer fractions.
+ * them (as written / UTC midnight); any other form the engine reads
+ * (`Jan 15 2026 12:00 GMT`) is accepted as the engine reads it, and
+ * anything unparseable is `undefined` so the caller keeps its own fallback.
+ * Fractions beyond milliseconds are truncated — `Date` has no finer
+ * resolution and engines differ on longer fractions. Text from the DATABASE
+ * never takes that last, guessing step ({@link parseDatabaseDateTime}).
  */
 export declare function parseDateTimeText(params: {
     text: string;
@@ -144,11 +163,14 @@ export declare function parseDateTimeText(params: {
  * milliseconds, an offset with seconds applied exactly.
  *
  * `undefined` for every other text — a 4-digit AD value keeps the parse it
- * had — and for an instant outside the `Date` range. Exported for the adapters
+ * had, unless `anyYear` (the database-text parser, after its other forms
+ * declined: an offset with seconds) — and for an instant outside the `Date`
+ * range. Exported for the adapters
  * whose zone-less driver parsers fall back to it (one rule, rule 6).
  */
 export declare function parseExtendedDateTimeText(params: {
     text: string;
+    anyYear?: boolean;
 }): Date | undefined;
 /**
  * The decode refusal of a non-finite or unparseable DateTime — one error for
@@ -157,6 +179,78 @@ export declare function parseExtendedDateTimeText(params: {
  * reports exactly this error.
  */
 export declare function decodedDateTimeRefusal(): VibeError;
+/**
+ * The refusal of database date-time text no decoder reads, by its cause —
+ * each with its own `meta.reason`, so the message names the right remedy:
+ *
+ * - `"zero-date"`: a MySQL zero date or a zero month or day, which has no
+ *   instant (mysql2 renders a binary zero `DATETIME` as `undefined 00:00:00`);
+ * - `"datetime-out-of-range"`: ISO-shaped text with no `Date` (a year past
+ *   ±275760, `294276-12-31` in PostgreSQL, or a day the calendar lacks);
+ * - `"datetime-text-layout"`: any other layout; on PostgreSQL its cause is a
+ *   `DateStyle` other than ISO, and the error names that remedy
+ *   ({@link dateTimeTextLayoutError}).
+ *
+ * The text itself is never included.
+ */
+export declare function undecodableDateTimeText(params: {
+    text: string;
+    dialect: Dialect;
+}): VibeError;
+/**
+ * The refusal for database DateTime text outside the ISO layouts. On
+ * PostgreSQL its cause is a `DateStyle` other than ISO, set by the server,
+ * the database or the role; the message and `meta.fix` name the remedies.
+ * The text itself is never included.
+ */
+export declare function dateTimeTextLayoutError(): VibeError;
+/**
+ * The codec of a DateTime field whose native type is a date-only column on
+ * `dialect`, or `undefined` (the DateTime table row applies): MySQL's
+ * `@db.Date` ({@link mysqlDateOnlyCodec}). PostgreSQL's `date` input and
+ * SQLite's text need none.
+ */
+export declare function dateOnlyCodec(params: {
+    dialect: Dialect;
+    nativeType: string | undefined;
+}): ScalarCodec | undefined;
+/**
+ * The instant of zone-less date-time text a MySQL server printed (`DATETIME`,
+ * `DATE`, a `TIMESTAMP` in the session zone), read in `zone`, the zone mysql2
+ * reads the same cell in; the years 0-99 keep their year. `undefined` for any
+ * other text. For the adapter's raw path; ORM reads take the codec table.
+ */
+export declare function parseZoneLessDateTime(params: {
+    text: string;
+    zone: DateTimeZone | undefined;
+}): Date | undefined;
+/**
+ * `codec` as it reads under the adapter's declared zone
+ * (`wire.zoneLessDateTime`): a MySQL DateTime or date-only codec reads
+ * zone-less text in that zone when it is not UTC; every other codec, and every
+ * codec under UTC, is returned unchanged. Encode is never changed: a `Date`
+ * goes to the driver, which writes it in the same zone.
+ */
+export declare function zonedCodec(params: {
+    dialect: Dialect;
+    codec: ScalarCodec;
+    wire: WireFidelity | undefined;
+}): ScalarCodec;
+/**
+ * The text a MySQL adapter writes for a parameter the DateTime codec bound
+ * exactly (a `Date` read from the server's text, which carries more fraction
+ * digits than a `Date` holds): the wall clock it was read from when that text,
+ * read in `zone`, is this instant (so a wall clock in a daylight-saving gap
+ * under `"local"` addresses its own cell); else the instant's wall clock in
+ * `zone` (text with an offset, or read in another zone). Every fraction digit
+ * is kept, and at least three are written. `undefined` for every other value,
+ * which the driver writes as it always did. A keyset position over such a
+ * value carries the same text.
+ */
+export declare function mysqlBoundTimestampText(params: {
+    value: unknown;
+    zone: DateTimeZone | undefined;
+}): string | undefined;
 /**
  * The time-of-day codec for a DateTime field's native type, or `undefined`
  * when the native type is not `time`/`timetz` (the DateTime table row

package/dist/composable.d.ts

@@ -21,10 +21,22 @@ export type SqlTag = {
         value: NoInfer<T>;
         decoder?: ResultDecoder<T>;
     }) => SqlFragment;
-    readonly join: (params: {
-        items: readonly unknown[];
-        separator?: SqlFragment;
-    }) => SqlFragment;
+    /**
+     * A list: fragments spliced, anything else bound as one value each, joined
+     * by `separator` (default `, `). `sql.join(items, separator)` and
+     * `sql.join({ items, separator })` are the same call.
+     */
+    readonly join: {
+        (items: readonly unknown[], separator?: SqlFragment): SqlFragment;
+        (params: {
+            items: readonly unknown[];
+            separator?: SqlFragment;
+        }): SqlFragment;
+    };
+    /** Every condition must hold: `(a) AND (b)`, each part in parentheses; `undefined` parts are skipped, and none left is `TRUE`. */
+    readonly and: (parts: readonly (SqlFragment | undefined)[]) => SqlFragment;
+    /** Any condition may hold: `(a) OR (b)`, each part in parentheses; `undefined` parts are skipped, and none left is `FALSE`. */
+    readonly or: (parts: readonly (SqlFragment | undefined)[]) => SqlFragment;
     readonly existing: (params: {
         column: string;
     }) => SqlFragment;
@@ -62,6 +74,34 @@ export declare function compileSql(params: {
     text: string;
     values: unknown[];
 };
+/**
+ * A tagged template whose every interpolated value binds as one plain
+ * parameter (no fragment, no typed array or JSON-list parameter), captured
+ * without building a fragment. Its values are snapshotted when captured, as
+ * `sql` snapshots them; `compileSqlTemplate` renders it.
+ */
+export declare class PlainSqlTemplate {
+    readonly strings: TemplateStringsArray;
+    readonly values: readonly unknown[];
+    constructor(strings: TemplateStringsArray, values: readonly unknown[]);
+}
+/**
+ * What `sql` builds for a template, except that a template whose
+ * values all bind as plain parameters comes back as a `PlainSqlTemplate`:
+ * the same text and values once compiled, without a fragment per call.
+ */
+export declare function captureSqlTemplate(params: {
+    strings: TemplateStringsArray;
+    values: readonly unknown[];
+}): SqlFragment | PlainSqlTemplate;
+/** `compileSql` over what `captureSqlTemplate` returned. */
+export declare function compileSqlTemplate(params: {
+    dialect: SqlDialect;
+    query: SqlFragment | PlainSqlTemplate;
+}): {
+    text: string;
+    values: unknown[];
+};
 /** Whether a nested SQL fragment reads the incoming row (MySQL alias declaration). */
 export declare function sqlUsesIncoming(params: {
     fragment: SqlFragment;

package/dist/dialect.d.ts

@@ -20,6 +20,13 @@ import type { ParamCollector } from "./params.ts";
 export type RowLockSyntax = {
     readonly strengths: Readonly<Partial<Record<RowLockStrength, string>>>;
     readonly wait: Readonly<Partial<Record<RowLockWaitPolicy, string>>>;
+    /**
+     * The spelling of a strength when the lock names no `OF` table and no wait
+     * policy, where it differs from `strengths`: a form more servers of the
+     * family parse (MySQL's `LOCK IN SHARE MODE`, which MariaDB and MySQL before
+     * 8.0.1 accept while `FOR SHARE` is a syntax error there).
+     */
+    readonly plain?: Readonly<Partial<Record<RowLockStrength, string>>>;
 };
 /** The blocking and try function names for one advisory-lock mode. */
 export type AdvisoryLockModeFunctions = {
@@ -218,8 +225,14 @@ export type SqlDialect = {
      * 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).
+     * `eqSelect`: a to-one through ONE foreign-key column pinned this way renders
+     * `fk = (SELECT key …)`, every other shape the correlated `EXISTS` —
+     * PostgreSQL plans the semi-join as a loop into all of the parent's children
+     * and sorts them for a page, but reads a page of `fk = (SELECT …)` in index
+     * order (newest 20 of 4 000 orders of one person: 889 → 11 buffers,
+     * 1.16 → 0.01 ms; an `IN (SELECT …)` keeps the semi-join plan).
      */
-    readonly relationFilterStrategy: "exists" | "inSelect";
+    readonly relationFilterStrategy: "exists" | "inSelect" | "eqSelect";
     /**
      * 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
@@ -484,5 +497,15 @@ export type SqlDialect = {
         offsetSeconds: number;
         collector: ParamCollector;
     }): string;
+    /**
+     * True when any pair of the two equally long lists of rendered expressions
+     * differs, NULL counting as a value: `IS DISTINCT FROM` on postgres, `IS
+     * NOT` on sqlite, `NOT (… <=> …)` on mysql. One pair compares the two
+     * expressions; several compare row constructors.
+     */
+    renderRowsDiffer(params: {
+        left: readonly string[];
+        right: readonly string[];
+    }): string;
 };
 //# sourceMappingURL=dialect.d.ts.map

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

@@ -1,16 +1,5 @@
 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;

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

@@ -1,11 +1,7 @@
 import type { QualifiedSqlName } from "@vibeorm/schema";
 import type { SqlDialect } from "../dialect.ts";
-import type { ExtractedGeneratedColumn, GeneratedColumnDeclaration } from "../generated-columns.ts";
+import type { ExtractedGeneratedColumn } 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";

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

@@ -1,20 +1,2 @@
-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[];
+export {};
 //# sourceMappingURL=mysql-index-expressions.d.ts.map

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

@@ -1,8 +1,2 @@
-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;
+export {};
 //# sourceMappingURL=mysql-row-rules.d.ts.map

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

@@ -1,11 +1,6 @@
 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";

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

@@ -1,12 +1,2 @@
-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, included }: {
-    readonly definition: string;
-    readonly index: string;
-    /** INCLUDE columns the caller read from the catalog; an INCLUDE clause of another length is refused. */
-    readonly included?: number;
-}): 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[];
+export {};
 //# sourceMappingURL=postgres-index-expressions.d.ts.map

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

@@ -2,8 +2,6 @@ import type { SqlDialect } from "../dialect.ts";
 import type { RenderedQuery } from "../render.ts";
 /** Throwaway policy identity; never installed on a live table by readiness. */
 export declare const NATIVE_RLS_PROBE_POLICY: "vibeorm_probe";
-/** The reads `catalog` folds, in the order their JSON columns appear. */
-export declare const RLS_READINESS_CATALOG_KEYS: readonly ("identity" | "elevatedRoles" | "schemaControl" | "tables" | "policies" | "views" | "routines" | "triggers")[];
 /** Read-only catalog SQL; exported for exact statement routing in adapter tests. */
 export declare const RLS_READINESS_SQL: {
     readonly identity: string;

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

@@ -43,11 +43,17 @@ export declare function renderRlsColumnType(params: {
     dialect: SqlDialect;
     field: FieldIR;
 }): string;
-/** Desired predicate only, for drift probes; it is NOT server-canonical deparse. */
+/**
+ * Desired predicate only, for drift probes; it is NOT server-canonical deparse.
+ * `qualify` names the table a `where` rule's columns are read from, for a
+ * statement with another relation in scope (`excluded` in `ON CONFLICT … DO
+ * UPDATE`); the policy itself and the drift probes render them bare.
+ */
 export declare function renderRlsPredicate(params: {
     dialect: SqlDialect;
     schema: SchemaIR;
     model: string;
+    qualify?: string;
 }): string;
 /** One PERMISSIVE ALL/PUBLIC policy with equal existing/proposed-row checks. */
 export declare function renderRlsPolicy(params: {

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

@@ -1,25 +1,2 @@
-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;
+export {};
 //# sourceMappingURL=postgres-row-rules.d.ts.map

package/dist/dialects/sqlite-fts.d.ts

@@ -1,4 +1,4 @@
-/** @internal SQLite FTS synchronization SQL and its independently verifiable catalog spelling. */
+/** SQLite FTS synchronization SQL and its independently verifiable catalog spelling. */
 export declare function renderSqliteFtsUpdateTrigger(params: {
     table: string;
     ftsTable: string;
@@ -7,7 +7,7 @@ export declare function renderSqliteFtsUpdateTrigger(params: {
     readonly create: string;
     readonly definition: string;
 };
-/** @internal Recognize only complete generated legacy/current triggers and their external-content FTS5 table. */
+/** Recognize only complete generated legacy/current triggers and their external-content FTS5 table. */
 export declare function sqliteFtsUpdateUpgrade(params: {
     create: string;
     installed: string;

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

@@ -1,15 +1,4 @@
-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;
+import type { ExtractedGeneratedColumn } from "../generated-columns.ts";
 /** Recover the exact AS interior; omitted storage means virtual, never inferred stored. */
 export declare function extractSqliteGeneratedColumn({ definition, column }: {
     readonly definition: string;