@vibeorm/sql 5.8.0 → 5.9.0

package/README.md

@@ -18,6 +18,7 @@ Most users never install this directly — it ships as a dependency of [`vibeorm
 - **Dialects**: `postgresDialect`, `sqliteDialect`, `mysqlDialect`, the `SqlDialect` type, and the registry `SQL_DIALECTS` / `getSqlDialect`. A dialect carries `quoteIdent` plus the strategy switches: `= ANY` versus `IN` expansion, `ILIKE` versus `LOWER(...) LIKE LOWER(...)`, the upsert form, `ESCAPE` clause presence, `RETURNING` availability.
 - **Capability tables**: `DIALECT_CAPABILITIES`, `POSTGRES_CAPABILITIES`, `SQLITE_CAPABILITIES`, `MYSQL_CAPABILITIES` — frozen objects consumed by the runtime, migrate, the generator and the E2E harness. A feature a dialect cannot express throws `VIBE_UNSUPPORTED_CAPABILITY` rather than degrading.
 - **Codec tables**: `DIALECT_CODECS`, `POSTGRES_CODECS`, `SQLITE_CODECS`, `MYSQL_CODECS`, `decodeIsNoop`, and the `CodecTable` / `ScalarCodec` / `WireFidelity` types. All per-dialect value encode and decode lives here, in one place, instead of scattered through query builders.
+- **Column types**: `canonicalColumnType({ dialect, scalar, nativeType })` names the column type migrate creates for a field, in the one spelling migrate compares column types by (`"integer"` for `Int`, `@db.Int4` and `@db.Integer` on PostgreSQL); `normalizePostgresNativeType` / `normalizeMysqlNativeType`, the tables `POSTGRES_SCALAR_COLUMN_TYPES`, `MYSQL_SCALAR_COLUMN_TYPES`, `SQLITE_SCALAR_STORAGE_CLASSES` and `POSTGRES_EXACT_EQUIVALENTS` are the pieces. `describeSchema` (`@vibeorm/runtime`) reports each field's `nativeType` with it.
 - **Rendering**: `renderStatement({ dialect, statement })` returns `RenderedQuery` (`{ text, values, returning }`); `renderExpr` and `renderFragment` render sub-parts against a shared `ParamCollector`. Placeholders always come from `ParamCollector`, never from hand-written `$1` or `?`.
 - **LIKE helpers**: `escapeLikePattern`, `escapeGlobPattern`, `containsPattern`, `startsWithPattern`, `endsWithPattern`, `strictMatchPattern`.
 

package/dist/ast.d.ts

@@ -66,6 +66,25 @@ export type ColRef = {
      * without the `dateTruncation` capability refuse it when rendering.
      */
     readonly truncate?: DateTruncation;
+    /**
+     * A `groupBy` expression key read from the column ({@link GroupKeyExpression}):
+     * the text at a JSON path, or a string's leading characters. Like
+     * {@link ColRef.truncate} it is set on the projection (with `alias`, the
+     * key's result name), GROUP BY and ORDER BY refs of one key, which repeat
+     * the identical text: every operand is a validated literal, never a bound
+     * parameter, so PostgreSQL and MySQL match the GROUP BY expression.
+     */
+    readonly groupKey?: GroupKeyExpression;
+    /**
+     * The first non-NULL of these references — `COALESCE("a", "b")` — instead
+     * of the column `name`: the value of an `orderBy: { _coalesce: … }` term.
+     * Each member renders as its own reference, casts included (a sqlite
+     * Decimal member as `CAST(… AS REAL)`, a mysql native enum as its member
+     * index). Set on ORDER BY and comparison refs only. `name` is then
+     * {@link COALESCE_REF_NAME}, never a column of a table, so a reader that
+     * looks a column up by name finds none.
+     */
+    readonly coalesce?: readonly ColRef[];
     /**
      * Projection alias: renders `ref AS "alias"`. PROJECTION-ONLY — filter,
      * order and correlation refs never set it (the renderer ignores it outside
@@ -74,6 +93,15 @@ export type ColRef = {
      */
     readonly alias?: string;
 };
+/**
+ * The `name` of a {@link ColRef.coalesce} reference. The `__vibe_` column
+ * prefix is reserved by schema validation, so no model column carries it.
+ */
+export declare const COALESCE_REF_NAME: string;
+/** A {@link ColRef.coalesce} reference over `members`. */
+export declare function coalesceRef(params: {
+    members: readonly ColRef[];
+}): ColRef;
 /** A {@link ColRef.truncate} request: the calendar unit, the zone that defines the calendar, and the column's storage form. */
 export type DateTruncation = {
     readonly unit: DateTruncationUnit;
@@ -81,6 +109,24 @@ export type DateTruncation = {
     readonly timeZone: string;
     readonly storage: DateTruncationStorage;
 };
+/**
+ * A {@link ColRef.groupKey} expression.
+ *
+ * - `jsonPathText`: the text at an object-key path of a JSON column — a JSON
+ *   string unquoted, a number or boolean in its JSON spelling, JSON `null` and
+ *   a missing path SQL NULL, an object or array its JSON text. Each step reads
+ *   an object member only. `storage: "json"` marks a postgres `json` column,
+ *   read through jsonb like the JSON filters.
+ * - `prefix`: the first `length` characters of a string column.
+ */
+export type GroupKeyExpression = {
+    readonly kind: "jsonPathText";
+    readonly path: readonly string[];
+    readonly storage?: "json";
+} | {
+    readonly kind: "prefix";
+    readonly length: number;
+};
 export type TableRef = {
     readonly name: string;
     /** Explicit fixed PostgreSQL placement; absence preserves existing SQL. */
@@ -92,11 +138,19 @@ export type AggFn = "count" | "avg" | "sum" | "min" | "max";
 /** Reference to an aggregate expression: `COUNT(*)` or `FN("col")`. */
 export type AggRef = {
     readonly fn: "countAll";
+    readonly filter?: SqlExpr;
 } | {
     readonly fn: AggFn;
     readonly column: ColRef;
     /** Native enum MIN/MAX: projections and HAVING return the database label; order keys keep its ordinal. */
     readonly enumOrder?: "value" | "ordinal";
+    /**
+     * Aggregate only the rows the predicate admits: `AGG(x) FILTER (WHERE …)`
+     * or `AGG(CASE WHEN … THEN x END)` per the dialect's
+     * `filteredAggregates` capability. Its parameters bind each time the
+     * aggregate renders (projection, HAVING, ORDER BY), in text order.
+     */
+    readonly filter?: SqlExpr;
 };
 /**
  * One aggregate projection: `FN("col") AS "alias"`. The alias is part of the
@@ -111,10 +165,13 @@ export type AggSelect = {
 };
 /**
  * JSON path predicates (Prisma's Json filter surface). `not` is `equals` with
- * `negate` — there is no separate op. Which ops a dialect can express is
+ * `negate` — there is no separate op. `exists` takes a boolean `value`: the
+ * member at the path (object keys only) is present (its value may be JSON
+ * `null`) or, for `false`, the document is present and the member is not; a
+ * SQL NULL column is unknown for both. Which ops a dialect can express is
  * declared on `SqlDialect.supportedJsonOps` and enforced at render time too.
  */
-export type JsonFilterOp = "equals" | "string_contains" | "string_starts_with" | "string_ends_with" | "array_contains" | "array_starts_with" | "array_ends_with";
+export type JsonFilterOp = "equals" | "exists" | "string_contains" | "string_starts_with" | "string_ends_with" | "array_contains" | "array_starts_with" | "array_ends_with";
 export type ComparisonOp = "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
 /**
  * The column facts one member of a {@link SqlExpr} `keyList` tuple needs to
@@ -771,6 +828,20 @@ export type KeyRows = {
     /** Encoded tuples; never empty, each exactly `columns.length` long. */
     readonly rows: readonly (readonly unknown[])[];
 };
+/**
+ * `GROUP BY GROUPING SETS (…)` over a select's `groupBy` columns. Each set
+ * lists indexes into `groupBy`; `()` is the grand total. The projection gains
+ * `CASE GROUPING(<every groupBy column>) WHEN <mask> THEN <set index> … END AS
+ * "<indexAlias>"` after the aggregates, so a row names the set that produced
+ * it, and an ORDER BY term may name `indexAlias` as a bare column (an output
+ * column). Dialect `groupingSets` capability: `"groupingSets"` renders any
+ * list, `"rollup"` only the rollup chain of `groupBy` in order (`GROUP BY a,
+ * b WITH ROLLUP`), `"none"` refuses.
+ */
+export type GroupingSets = {
+    readonly sets: readonly (readonly number[])[];
+    readonly indexAlias: string;
+};
 export type SelectStatement = {
     readonly kind: "select";
     readonly table: TableRef;
@@ -850,6 +921,8 @@ export type SelectStatement = {
     readonly fromKeys?: KeyRows;
     readonly where?: SqlExpr;
     readonly groupBy?: readonly ColRef[];
+    /** Grouping sets over `groupBy` — see {@link GroupingSets}. */
+    readonly groupingSets?: GroupingSets;
     /** HAVING predicate — grouped selects; may contain `aggCmp` expressions. */
     readonly having?: SqlExpr;
     readonly orderBy?: readonly OrderTerm[];
@@ -971,7 +1044,26 @@ export type ReturningColumn = string | {
 } | {
     readonly name: string;
     readonly transform: "jsonText";
-} | CaptureReturningColumn;
+} | CaptureReturningColumn | OtherRowReturningColumn;
+/**
+ * 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
+ * (`projection`), so one codec decodes both:
+ *
+ * - `from: "old"` — the row as it was before the statement (capability
+ *   `rowCapture`, PostgreSQL 18): `old."col" AS "alias"`, NULL in every column
+ *   for a row the statement inserted;
+ * - `from: { source }` — the joined source of an `UPDATE … FROM` by its alias
+ *   (capability `returningReadsJoinedSource`): `"source"."col" AS "alias"`.
+ */
+export type OtherRowReturningColumn = {
+    readonly from: "old" | {
+        readonly source: string;
+    };
+    readonly name: string;
+    readonly alias: string;
+    readonly projection?: "castText" | "jsonText";
+};
 /**
  * A row-capture RETURNING column (`$transaction(…, { capture })`, dialects with
  * the `rowCapture` capability: PostgreSQL 18, where RETURNING names the row
@@ -982,15 +1074,71 @@ export type ReturningColumn = string | {
  *   inserted row, `new` for a deleted one);
  * - `"inserted"`: `(old."col" IS NULL) AS "alias"` — the arm of an `INSERT …
  *   ON CONFLICT DO UPDATE` row, true when it was inserted (`col` must be a
- *   column no stored row holds NULL in: a primary-key column).
+ *   column no stored row holds NULL in: a primary-key column);
+ * - `"old"` / `"new"` with `hop`: the related row's column, read in the same
+ *   statement — `(SELECT "__vibe_h"."col"::text FROM "Related" AS "__vibe_h"
+ *   WHERE "__vibe_h"."id" = new."relatedId") AS "alias"` (see {@link CaptureHop});
+ * - `"key"`: `old."col" AS "alias"` in the column's own type, for a chain's
+ *   {@link CaptureCascade} to match child rows on;
+ * - `"cascade"` ({@link CaptureCascadeReturningColumn}): the images of the
+ *   child rows a referential action of this row changes.
  */
 export type CaptureReturningColumn = {
-    readonly capture: "old" | "new" | "inserted";
+    readonly capture: "old" | "new" | "inserted" | "key";
+    readonly name: string;
+    readonly alias: string;
+    /** With `"old"` / `"new"`: read `name` from the related row instead of this one. */
+    readonly hop?: CaptureHop;
+} | CaptureCascadeReturningColumn;
+/**
+ * A to-one hop of a capture cell: the row of `table` whose `on[i].target`
+ * columns equal the reading row's `on[i].source` columns. The target columns
+ * must be a unique key (a scalar subquery that found two rows would fail the
+ * statement); no row, or a NULL source column, reads NULL.
+ */
+export type CaptureHop = {
+    readonly table: TableRef;
+    readonly on: readonly {
+        readonly target: string;
+        readonly source: string;
+    }[];
+};
+/** One cell of a {@link CaptureCascade} image: a child column, or a column of its related row. */
+export type CaptureCell = {
     readonly name: string;
+    readonly hop?: CaptureHop;
+};
+/**
+ * The distinct images of the child rows of `table` whose `on[i].child` columns
+ * equal a written parent row's `on[i].parent` columns: `(SELECT
+ * array_agg("__vibe_i")::text FROM (SELECT DISTINCT ARRAY[<cells>] AS "__vibe_i"
+ * FROM "Child" AS "__vibe_c" WHERE <match> LIMIT $n) AS "__vibe_d")`, NULL when
+ * no child matched. Read inside the parent's statement, whose snapshot still
+ * holds the rows its foreign keys' referential actions remove or rewrite at
+ * the statement's end. `limit` is bound as a parameter.
+ */
+export type CaptureCascade = {
+    readonly table: TableRef;
+    readonly on: readonly {
+        readonly child: string;
+        readonly parent: string;
+    }[];
+    readonly cells: readonly CaptureCell[];
+    readonly limit: number;
+};
+/**
+ * A per-row {@link CaptureCascade} in RETURNING: `parent` columns are read from
+ * `old.` (`"__vibe_c"."child" = old."parent"`).
+ */
+export type CaptureCascadeReturningColumn = {
+    readonly capture: "cascade";
     readonly alias: string;
+    readonly cascade: CaptureCascade;
 };
 /** The column name a {@link ReturningColumn} exposes in the result row. */
 export declare function returningColumnName(column: ReturningColumn): string;
+/** Is this RETURNING column read from another row ({@link OtherRowReturningColumn})? */
+export declare function isOtherRowReturningColumn(column: ReturningColumn): column is OtherRowReturningColumn;
 /** Is this RETURNING column a row-capture column ({@link CaptureReturningColumn})? */
 export declare function isCaptureReturningColumn(column: ReturningColumn): column is CaptureReturningColumn;
 export type InsertStatement = {
@@ -1236,11 +1384,24 @@ export declare function stepColumnRef(params: {
     column: string;
 }): StepColumnRef;
 /** The joined relation of an {@link UpdateStatement}: its table, alias and join condition. */
-export type UpdateSource = {
+export type UpdateSource = UpdateTableSource | UpdateSelectSource;
+/** A joined table: `FROM "table" AS alias` (`updateMany({ from })`). */
+export type UpdateTableSource = {
     readonly table: TableRef;
     readonly alias: string;
     readonly on: SqlExpr;
 };
+/**
+ * A joined subquery: `FROM (SELECT …) AS alias`, PostgreSQL only. With a
+ * locking read of the target table it is the row as it was before the write,
+ * and an {@link OtherRowReturningColumn} `from: { source: alias }` returns its
+ * values (`update({ previous })`, capability `returningReadsJoinedSource`).
+ */
+export type UpdateSelectSource = {
+    readonly select: SelectStatement;
+    readonly alias: string;
+    readonly on: SqlExpr;
+};
 /** An UPDATE set value read from the joined source's `column` (`UPDATE … FROM`). */
 export type SourceColumnRef = {
     readonly __sourceColumn: true;
@@ -1412,6 +1573,13 @@ export type ChainCapture = {
     readonly after?: readonly string[];
     /** The most distinct images one image column returns: a positive safe integer, bound as a parameter. */
     readonly limit: number;
+    /**
+     * Child images of the step's rows, one result column `<alias>_c<j>` each: a
+     * {@link CaptureCascade} whose `parent` columns name columns the step
+     * RETURNS, matched by `EXISTS (SELECT 1 FROM "step" AS "__vibe_k" WHERE
+     * "__vibe_k"."parent" = "__vibe_c"."child")`.
+     */
+    readonly cascades?: readonly CaptureCascade[];
 };
 /**
  * Fail the statement when `step` returned no row; `token` names the veto in the

package/dist/dialect.d.ts

@@ -450,11 +450,16 @@ export type SqlDialect = {
     renderEnumOrdinal(params: {
         column: string;
     }): string;
-    /** Render native enum MIN/MAX in database declaration order, returning its label or an order key. */
+    /**
+     * Render native enum MIN/MAX in database declaration order, returning its
+     * label or an order key. `when` (a rendered predicate) is a filtered
+     * aggregate on a `caseWhen` dialect: only the rows it admits are aggregated.
+     */
     renderEnumMinMax(params: {
         fn: "min" | "max";
         column: string;
         result: "value" | "ordinal";
+        when?: string;
     }): string;
     /** Positional placeholder for the 1-based parameter index ($n or ?). */
     placeholder(params: {

package/dist/dialects/diagnostics.d.ts

@@ -3,7 +3,7 @@ import type { RenderedQuery } from "../render.ts";
 import type { SqlStatement, TableRef } from "../ast.ts";
 import type { PostgresExplainOptions, PostgresWorkloadQuery } from "./postgres-diagnostics.ts";
 /** Fixed, parameterless diagnostics whose text never varies. */
-export type FixedDiagnosticQuery = "postgresJsonWire" | "sqliteTriggers";
+export type FixedDiagnosticQuery = "postgresJsonWire" | "postgresServerVersion" | "sqliteTriggers";
 /** One table of row capture's readiness read: the table as write statements name it, and the columns capture returns. */
 export type CaptureReadinessTable = {
     readonly table: TableRef;

package/dist/dialects/migration-shadow-marker.d.ts

@@ -0,0 +1,65 @@
+import type { Dialect } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { RenderedQuery } from "../render.ts";
+/**
+ * Which dialects can label an automatic shadow database with its creator, so
+ * a later run can tell a leaked shadow from one still in use. PostgreSQL
+ * stores the label as the database comment; MySQL has no database comment,
+ * and SQLite and PGlite shadows never outlive their process.
+ */
+export declare const SHADOW_MARKER_CAPABILITIES: Readonly<Record<Dialect, Readonly<{
+    databaseMarker: boolean;
+}>>>;
+/** Exactly the names automatic shadow provisioning generates. */
+export declare const AUTOMATIC_SHADOW_NAME_PATTERN: string;
+/**
+ * The creator of one automatic shadow. `adminPid` and `adminStarted` identify
+ * the administration session that created it and holds it for the run's whole
+ * life (a backend pid with its start time never repeats); `adminStarted` is
+ * null when the server did not show the session's start. Times are server
+ * microseconds since the epoch, as decimal text; `host` and `pid` name the
+ * creating process for people reading a prune report.
+ */
+export type AutomaticShadowMarker = {
+    readonly database: string;
+    readonly adminPid: number;
+    readonly adminStarted: string | null;
+    readonly created: string;
+    readonly host: string;
+    readonly pid: number;
+};
+/** Automatic shadow bookkeeping on the administration connection. */
+export type AutomaticShadowOperation = 
+/** The administration session's pid, its start and the server's clock, before a marker is written. */
+{
+    readonly kind: "session";
+} | {
+    readonly kind: "mark";
+    readonly marker: AutomaticShadowMarker;
+}
+/** Every database with an automatic shadow name: its comment, its connected sessions and the server's clock. */
+ | {
+    readonly kind: "list";
+}
+/** Every server session's pid and start. */
+ | {
+    readonly kind: "backends";
+};
+/**
+ * The marker text. Every field is validated against a closed character set, so
+ * the text is safe inside a string literal whatever `standard_conforming_strings`
+ * says (COMMENT accepts no bound parameter).
+ */
+export declare function automaticShadowMarkerText(params: {
+    marker: AutomaticShadowMarker;
+}): string;
+/** Read a database comment back as a marker; anything but the exact format is no marker. */
+export declare function parseAutomaticShadowMarker(params: {
+    text: unknown;
+}): AutomaticShadowMarker | undefined;
+/** Render marker writes and prune reads; dialects without a database marker refuse. */
+export declare function renderAutomaticShadowOperation(params: {
+    dialect: SqlDialect;
+    operation: AutomaticShadowOperation;
+}): RenderedQuery;
+//# sourceMappingURL=migration-shadow-marker.d.ts.map

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

@@ -1,9 +1,11 @@
 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 }: {
+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[];

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

@@ -10,10 +10,12 @@ export declare function extractIndexKeyList({ sql, open, close, tokens, wrapped,
     readonly removeWrapper?: boolean;
 }): readonly IndexKeyOperand[] | undefined;
 /** Parse the CREATE INDEX header without interpreting any scalar expression. */
-export declare function extractStandaloneIndexKeys({ definition, index, postgres }: {
+export declare function extractStandaloneIndexKeys({ definition, index, postgres, included }: {
     readonly definition: string;
     readonly index: string;
     readonly postgres?: boolean;
+    /** PostgreSQL INCLUDE columns the caller read from the catalog (default none). */
+    readonly included?: number;
 }): readonly IndexKeyOperand[] | undefined;
 /** SQLite source spelling is the evidence; CAST alone never proves a plain Decimal key. */
 export declare function extractSqliteIndexKeys({ definition, index }: {

package/dist/index-expressions.d.ts

@@ -44,12 +44,18 @@ export declare function renderIndexKeys({ dialect, keys, unique }: {
     readonly keys: readonly IndexKeyOperand[];
     readonly unique: boolean;
 }): readonly string[];
-/** Recover raw physical terms without inventing typed logical expressions or Decimal origin. */
-export declare function extractIndexKeys({ dialect, definition, index, backslashEscapes }: {
+/**
+ * Recover raw physical terms without inventing typed logical expressions or Decimal origin.
+ * A PostgreSQL `INCLUDE (…)` clause makes the result undefined unless the caller read
+ * that many included columns from the catalog itself (`included`), so a covering list
+ * can never disappear behind recovered keys.
+ */
+export declare function extractIndexKeys({ dialect, definition, index, backslashEscapes, included }: {
     readonly dialect: Dialect;
     readonly definition: string;
     readonly index: string;
     readonly backslashEscapes?: boolean;
+    readonly included?: number;
 }): readonly IndexKeyOperand[] | undefined;
 /** Render a real expression-index normalization host, never a scalar CHECK surrogate. */
 export declare function renderIndexExpressionProbe({ ...params }: IndexExpressionProbeParams): readonly RenderedQuery[];

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { nativeEnumArrayParameter, isNativeEnumArrayParameter } from "./native-e
 export type { NativeEnumArrayParameter } from "./native-enum-parameter.ts";
 export { isJsonListParameter, jsonListParameter } from "./json-list-parameter.ts";
 export type { JsonListParameter, JsonListStorage } from "./json-list-parameter.ts";
+export { isJsonPatchOperation, jsonPatchVetoOf, planJsonPatch } from "./json-patch.ts";
+export type { JsonPatchCheck, JsonPatchConflict, JsonPatchFoundType, JsonPatchOperation, JsonPatchPlan, JsonPatchStep, JsonPatchVeto } from "./json-patch.ts";
 export { renderExternalOwnershipCatalog } from "./dialects/external-ownership.ts";
 export { renderExternalDependents } from "./dialects/external-dependents.ts";
 export type { ExternalDependentTarget } from "./dialects/external-dependents.ts";
@@ -17,6 +19,8 @@ export { renderModuleDependencyQuery } from "./dialects/module-dependency.ts";
 export type { ModuleDependencyOperation } from "./dialects/module-dependency.ts";
 export { renderReplayCoverageGaps } from "./dialects/migration-replay-coverage.ts";
 export { SHADOW_DATABASE, SHADOW_CAPABILITIES, renderShadowOperation } from "./dialects/migration-shadow.ts";
+export { AUTOMATIC_SHADOW_NAME_PATTERN, SHADOW_MARKER_CAPABILITIES, automaticShadowMarkerText, parseAutomaticShadowMarker, renderAutomaticShadowOperation } from "./dialects/migration-shadow-marker.ts";
+export type { AutomaticShadowMarker, AutomaticShadowOperation } from "./dialects/migration-shadow-marker.ts";
 export type { ShadowOperation } from "./dialects/migration-shadow.ts";
 export { MODULE_JOURNAL_COLUMN, renderModuleJournal } from "./module-journal.ts";
 export { renderSqliteFtsUpdateTrigger, sqliteFtsUpdateUpgrade } from "./dialects/sqlite-fts.ts";
@@ -40,8 +44,8 @@ export type { ResultDecoder, ResultReadDecoder, ResultParameterEncoder, ResultSc
  * lives in this package; see the root sql-catalog.md for the reviewable surface.
  */
 export { compileExclusion, renderExclusionSetup, renderExclusionDdl, renderExclusionCatalog, renderExclusionProbe } from "./exclusion.ts";
-export type { AdvisoryLockKey, AdvisoryLockStatement, AdvisoryLocksStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainCapture, CaptureReturningColumn, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, DateTruncation, CountSubquery, ScalarSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyListMember, KeyPage, KeyRows, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, LeftJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, SourceColumnRef, UpdateSource, TableRef, UpdateStatement, } from "./ast.ts";
-export { ADVISORY_LOCK_RESULT_COLUMN, CHAIN_VETO_PREFIX, CHAIN_VETO_TOKEN_PATTERN, SQL_DEFAULT_CELL, SQL_KEEP_CELL, chainVetoToken, dbNowMarker, excludedRef, isDbNowMarker, isExcludedRef, isJsonParamCell, isListSetOperation, isSetOperation, isSqlDefaultCell, isSqlKeepCell, isStepColumnRef, isSourceColumnRef, sourceColumnRef, isCaptureReturningColumn, jsonParamCell, returningColumnName, stepColumnRef, } from "./ast.ts";
+export type { AdvisoryLockKey, AdvisoryLockStatement, AdvisoryLocksStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainCapture, CaptureReturningColumn, CaptureCascade, CaptureCascadeReturningColumn, CaptureCell, CaptureHop, OtherRowReturningColumn, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, DateTruncation, GroupKeyExpression, GroupingSets, CountSubquery, ScalarSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyListMember, KeyPage, KeyRows, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, LeftJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, SourceColumnRef, UpdateSource, UpdateTableSource, UpdateSelectSource, TableRef, UpdateStatement, } from "./ast.ts";
+export { ADVISORY_LOCK_RESULT_COLUMN, CHAIN_VETO_PREFIX, CHAIN_VETO_TOKEN_PATTERN, COALESCE_REF_NAME, SQL_DEFAULT_CELL, SQL_KEEP_CELL, chainVetoToken, coalesceRef, dbNowMarker, excludedRef, isDbNowMarker, isExcludedRef, isJsonParamCell, isListSetOperation, isSetOperation, isSqlDefaultCell, isSqlKeepCell, isStepColumnRef, isSourceColumnRef, sourceColumnRef, isCaptureReturningColumn, isOtherRowReturningColumn, jsonParamCell, returningColumnName, stepColumnRef, } from "./ast.ts";
 export type { AdvisoryLockFunctions, AdvisoryLockModeFunctions, RowLockSyntax, EmptyInsertSyntax, SqlDialect, } from "./dialect.ts";
 export { ADVISORY_KEY_BOUNDS, describeRowLock, renderAdvisoryLock, renderAdvisoryLocks, renderRowLockClause } from "./locks.ts";
 export { JSON_TRANSPORT, projectionOutputName } from "./json-transport.ts";
@@ -54,6 +58,7 @@ export { keyListBindsUntypedRows, postgresBulkInsertArrayCastOf, postgresKeyList
 export { renderPredicate, renderSchemaExpression } from "./predicate.ts";
 export { renderLocalDateCheck } from "./local-date.ts";
 export { isTimeZoneName, renderDateTruncation } from "./date-truncation.ts";
+export { MYSQL_SCALAR_COLUMN_TYPES, POSTGRES_EXACT_EQUIVALENTS, POSTGRES_NATIVE_ALIASES, POSTGRES_SCALAR_COLUMN_TYPES, SQLITE_SCALAR_STORAGE_CLASSES, canonicalColumnType, normalizeMysqlNativeType, normalizePostgresNativeType, } from "./native-types.ts";
 export { renderGeneratedColumnClause } from "./generated-columns.ts";
 export type { GeneratedColumnDeclaration, ExtractedGeneratedColumn } from "./generated-columns.ts";
 export { renderPostgresGeneratedColumnProbe, renderPostgresDropGeneratedExpression } from "./dialects/postgres-generated-columns.ts";
@@ -67,7 +72,7 @@ export type { PredicateModel, PredicateUsage } from "./predicate.ts";
 export { DIALECT_CAPABILITIES, MYSQL_CAPABILITIES, POSTGRES_CAPABILITIES, SQLITE_CAPABILITIES, } from "./capabilities.ts";
 export { DIALECT_CODECS, MYSQL_CODECS, POSTGRES_CODECS, SQLITE_CODECS, decodeIsNoop, decodedDateTimeRefusal, enumMembershipCodec, float32Codec, localDateCodec, parseDateTimeText, parseExtendedDateTimeText, parseJsonText, postgresArrayElementFromText, shortestFloat32, timeOfDayCodec, } from "./codecs.ts";
 export type { CodecTable, ScalarCodec, WireFidelity } from "./codecs.ts";
-export { renderExpr, renderFragment, renderProjection, renderStatement } from "./render.ts";
+export { isRollupChain, renderExpr, renderFragment, renderProjection, renderStatement } from "./render.ts";
 export type { RenderedQuery } from "./render.ts";
 export { snapshotSqlValue } from "./parameter-snapshot.ts";
 export { ParamCollector } from "./params.ts";