@vibeorm/sql 5.9.0 → 5.11.0

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 = {
@@ -203,6 +210,55 @@ export type SqlDialect = {
          * where every adapter pins zone-less values to UTC (postgres).
          */
         readonly requiresUtcDateTimeWire: boolean;
+        /**
+         * How a dictionary of shared lists reads its distinct keys back out of
+         * the JSON the statement built (`SelectStatement.fromJsonKeys`).
+         * `"elements"`: one set-returning call per list on the way and a cast of
+         * the key text to the key-list's base type (postgres). `"jsonTable"`:
+         * one `JSON_TABLE` whose row path walks the lists, `JSON`-typed columns
+         * grouped as JSON and unquoted outside (MySQL; see
+         * `dialects/mysql-json-keys.ts` for why no other form is both right and
+         * indexed).
+         */
+        readonly keysFromJson: "elements" | "jsonTable";
+        /**
+         * How a common table is held to one evaluation (`CommonTable.materialized`):
+         * `"keyword"` — `AS MATERIALIZED (…)`; `"limit"` — the dialect has no such
+         * keyword and merges a common table into each reference unless its select
+         * is limited, so an unlimited select gets the largest `LIMIT` (MySQL).
+         */
+        readonly pinnedCommonTable: "keyword" | "limit";
+        /**
+         * Where a statement with carrier rows returns the lists it builds once
+         * per distinct target. `"firstRow"`: all of them as one JSON list on the
+         * statement's first row, built by an uncorrelated scalar subquery over the
+         * distinct keys (`SelectStatement.fromTableArrays`); PostgreSQL prices that
+         * subquery once, where it prices a lateral once per row of the statement
+         * and the estimate alone starts the JIT compiler from about 1 000 rows.
+         * `"carrierRow"`: each target's lists on the first row that reads it, from
+         * a lateral gated on that row (`SelectStatement.fromRow`); MySQL has no
+         * JIT compiler, runs the gated lateral once per target, and has no arrays
+         * to read the keys back through. The runtime builds `"carrierRow"` on a
+         * `"firstRow"` dialect too where a statement's root is proven to return
+         * a few rows: the estimate is bounded there and the statement is cheaper.
+         */
+        readonly carriedLists: "firstRow" | "carrierRow";
+        /**
+         * The server setting that caps one JSON value where the server can answer
+         * a larger one without failing the statement (MySQL `max_allowed_packet`,
+         * 64 MB by default). Measured on MySQL 26.7 with the statements the
+         * runtime builds: a carried row whose lists together pass the cap arrives
+         * as SQL NULL with warning 1301, a dictionary past it as its JSON text cut
+         * a little past the cap with the same warning, and one list past it fails
+         * the statement (errno 1301), which leaves a transaction open. The
+         * runtime reads a NULL or unparsable text where the statement always
+         * builds a JSON value as that overflow (`VIBE_RESULT_TOO_LARGE`), and the
+         * client answers a find that fails with that code under the `"query"`
+         * strategy. `null`: the server fails the statement itself and the error
+         * reaches the caller (PostgreSQL: 1 GB, and a failed statement aborts its
+         * transaction).
+         */
+        readonly silentSizeLimit: string | null;
     } | null;
     /**
      * The relation strategy a client uses when neither the call nor the client
@@ -218,8 +274,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 +546,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-json-keys.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MySQL's text for the two pieces of a dictionary of shared lists that it
+ * cannot share with PostgreSQL: the distinct keys read back out of the JSON a
+ * statement built (`SelectStatement.fromJsonKeys`), and a common table that
+ * must be evaluated once (`CommonTable.materialized`).
+ *
+ * Every choice below was measured on MySQL 26.7 (500 roots, 1 000 keys):
+ *
+ * - A `VARCHAR` column of `JSON_TABLE` takes the CONNECTION's collation with
+ *   implicit coercibility. Compared with a foreign-key column it fails
+ *   (`ER_CANT_AGGREGATE_2COLLATIONS`) whenever the two collations differ, and
+ *   mysql2 connects as `utf8mb4_unicode_ci` while MySQL creates columns as
+ *   `utf8mb4_0900_ai_ci`.
+ * - The same column declared `COLLATE utf8mb4_bin` runs, but the binary
+ *   collation wins the comparison and the foreign-key index is not used
+ *   (627 ms against 25 ms).
+ * - `JSON_UNQUOTE(<a JSON value>)` is coercible like a bound literal, also
+ *   through a materialized derived table, so the COLUMN's collation decides
+ *   the comparison and its index serves it: the key matches its children
+ *   exactly as `WHERE fk IN (?)` matches them.
+ * - `DISTINCT` on a `JSON` column compares the values exactly. On text under
+ *   `utf8mb4_bin` it pads (`'a'` and `'a '` are one key), which would lose an
+ *   entry where the key column's own collation does not pad.
+ */
+export {};
+//# sourceMappingURL=mysql-json-keys.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;

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

@@ -1,25 +1,2 @@
-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, 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 }: {
-    readonly definition: string;
-    readonly index: string;
-}): readonly IndexKeyOperand[] | undefined;
+export {};
 //# sourceMappingURL=sqlite-index-expressions.d.ts.map

package/dist/dialects/sqlite-json-equality.d.ts

@@ -1,15 +1,2 @@
-import type { SqlDialect } from "../dialect.ts";
-/**
- * Compare both JSON trees by decoded key/index paths, node type and atomic value.
- * Object order and JSON escape spelling do not matter; array positions do.
- * Container nodes retain empty-object/array distinctions, and multiplicity stops
- * duplicate object members from disappearing as they would in a set difference.
- * SQL NULL remains unknown. The tree input is guarded against non-JSON scalar
- * text even when SQLite evaluates this expression before the outer type guard.
- */
-export declare function renderSqliteJsonEquality(params: {
-    dialect: SqlDialect;
-    left: string;
-    right: string;
-}): string;
+export {};
 //# sourceMappingURL=sqlite-json-equality.d.ts.map

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

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

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

@@ -8,30 +8,11 @@ export type TableDefinitionParts = {
     readonly clauses: readonly string[];
     readonly suffix: 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({ sql }: {
     readonly sql: string;

package/dist/dialects/test-databases.d.ts

@@ -0,0 +1,96 @@
+import type { Dialect } from "@vibeorm/schema";
+import type { SqlDialect } from "../dialect.ts";
+import type { RenderedQuery } from "../render.ts";
+/**
+ * Which dialects can copy a migrated database on the server. PostgreSQL clones
+ * a template database (`CREATE DATABASE … TEMPLATE`). MySQL has no template
+ * databases, and its only server-side copy (`CREATE TABLE … LIKE`) leaves the
+ * foreign keys behind; SQLite copies files and sends no SQL for it.
+ */
+export declare const TEST_DATABASE_CAPABILITIES: Readonly<Record<Dialect, Readonly<{
+    templateDatabases: boolean;
+}>>>;
+/**
+ * A caller's test-database prefix: lower-case, a plain identifier start, and
+ * the word `test` in it, so a prefix cannot name an application's databases.
+ */
+export declare const TEST_DATABASE_PREFIX_PATTERN: RegExp;
+/** What a test-database name is, by its shape under one prefix. */
+export type TestDatabaseKind = "template" | "clone";
+/** `undefined` for a valid prefix, else why it is refused. */
+export declare function testDatabasePrefixIssue(params: {
+    prefix: unknown;
+}): string | undefined;
+/** The kind of a database name under `prefix`, or `undefined` for every other name. */
+export declare function testDatabaseKind(params: {
+    prefix: string;
+    name: string;
+}): TestDatabaseKind | undefined;
+/** When a clone was created (ms since the epoch, the creating process's clock), read from its name. */
+export declare function testCloneCreatedAt(params: {
+    prefix: string;
+    name: string;
+}): number | undefined;
+/** The template marker's creation time (server milliseconds), or `undefined` for any other comment. */
+export declare function parseTestTemplateMarker(params: {
+    text: unknown;
+}): number | undefined;
+/** Test-database statements on the administration connection. */
+export type TestDatabaseOperation = 
+/**
+ * One row whether or not the database exists: its template flag (null when
+ * absent), its comment, the sessions connected to it other than this one, and
+ * the server clock in milliseconds.
+ */
+{
+    readonly kind: "state";
+    readonly prefix: string;
+    readonly name: string;
+}
+/** An empty database to build a template in. */
+ | {
+    readonly kind: "createTemplate";
+    readonly prefix: string;
+    readonly name: string;
+}
+/** The template's creation time (server milliseconds), as its database comment. */
+ | {
+    readonly kind: "markTemplate";
+    readonly prefix: string;
+    readonly name: string;
+    readonly created: number;
+}
+/**
+ * Set: the build's last step and the ready signal — a template that refuses
+ * connections, because one connection to it blocks every clone. Cleared before
+ * a template is dropped.
+ */
+ | {
+    readonly kind: "flagTemplate";
+    readonly prefix: string;
+    readonly name: string;
+    readonly template: boolean;
+} | {
+    readonly kind: "clone";
+    readonly prefix: string;
+    readonly name: string;
+    readonly template: string;
+}
+/** `force` (PostgreSQL 13+) ends the sessions still connected; only a clone may be forced. */
+ | {
+    readonly kind: "drop";
+    readonly prefix: string;
+    readonly name: string;
+    readonly force?: boolean;
+}
+/** Every database whose name starts with the prefix, its template flag, comment and other sessions, and the server clock. */
+ | {
+    readonly kind: "list";
+    readonly prefix: string;
+};
+/** Render one test-database statement; dialects without template databases refuse. */
+export declare function renderTestDatabaseOperation(params: {
+    dialect: SqlDialect;
+    operation: TestDatabaseOperation;
+}): RenderedQuery;
+//# sourceMappingURL=test-databases.d.ts.map

package/dist/expr-fragment.d.ts

@@ -0,0 +1,13 @@
+import type { SqlExpr } from "./ast.ts";
+import type { SqlFragment } from "./composable.ts";
+import type { SqlDialect } from "./dialect.ts";
+/**
+ * A compiled boolean expression as an opaque fragment for the caller's own
+ * statement: the text the dialect renders, every bound value a fragment
+ * value, so the enclosing statement numbers the placeholders.
+ */
+export declare function exprToFragment(params: {
+    dialect: SqlDialect;
+    expr: SqlExpr;
+}): SqlFragment;
+//# sourceMappingURL=expr-fragment.d.ts.map

package/dist/identifiers.d.ts

@@ -7,8 +7,5 @@
  * containing one is not an identifier at all. Refused at render time, the
  * earliest point every path (IR, raw `sql.ident`, extension DDL) shares.
  */
-/** Return `name` unchanged, or throw `VIBE_VALIDATION` when it contains a NUL. */
-export declare function assertNoNul(params: {
-    name: string;
-}): string;
+export {};
 //# sourceMappingURL=identifiers.d.ts.map

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { cloneTimestampDate, compareTimestampDates, timestampIdentityKey, timestampIdentityText } from "./timestamp-identity.ts";
+export { parsePlainTimestampText } from "./timestamp-text.ts";
 export { nativeEnumArrayParameter, isNativeEnumArrayParameter } from "./native-enum-parameter.ts";
 export type { NativeEnumArrayParameter } from "./native-enum-parameter.ts";
 export { isJsonListParameter, jsonListParameter } from "./json-list-parameter.ts";
@@ -21,12 +22,15 @@ export { renderReplayCoverageGaps } from "./dialects/migration-replay-coverage.t
 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 { TEST_DATABASE_CAPABILITIES, TEST_DATABASE_PREFIX_PATTERN, parseTestTemplateMarker, renderTestDatabaseOperation, testCloneCreatedAt, testDatabaseKind, testDatabasePrefixIssue } from "./dialects/test-databases.ts";
+export type { TestDatabaseKind, TestDatabaseOperation } from "./dialects/test-databases.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";
 export { SQLITE_SESSION_SQL } from "./dialects/sqlite-session.ts";
-export { sql, isSqlFragment, renderSqlFragment, compileSql, sqlUsesIncoming, mapConflictColumns } from "./composable.ts";
+export { sql, isSqlFragment, renderSqlFragment, compileSql, sqlUsesIncoming, mapConflictColumns, captureSqlTemplate, compileSqlTemplate, PlainSqlTemplate } from "./composable.ts";
 export { registerSqlHandleCheck } from "./sql-handles.ts";
+export { exprToFragment } from "./expr-fragment.ts";
 export type { SqlFragment, SqlTag } from "./composable.ts";
 export { createSqlQuery, createSqlCommand, isSqlQuery, isSqlCommand, compileSqlQuery, compileSqlCommand } from "./query-plan.ts";
 export type { SqlQuery, SqlCommand, SqlPlanRender, CompiledSqlQuery, CompiledSqlCommand, ReusableSqlQuery, ReusableSqlCommand } from "./query-plan.ts";
@@ -35,7 +39,7 @@ export { isSqlParam, createSqlInput, sqlInputContract, createSqlInputScope, seal
 export type { SqlParam, SqlInput, SqlInputMap, SqlInputValue, SqlInputValues, SqlInputTokens, SqlExecutionParams, SqlInputContract, SqlInputScope } from "./sql-input.ts";
 export { isSqlBindingCollector, recordSqlBinding, recordSqlBindingCheck } from "./sql-bindings.ts";
 export type { SqlBindingSource, SqlParameterTransport, SqlBindingEncoder } from "./sql-bindings.ts";
-export { decode, encode, resultScalarContract, sameResultDecoder } from "./result-decoder.ts";
+export { decode, decodeResultColumn, encode, resultScalarContract, sameResultDecoder } from "./result-decoder.ts";
 export type { ResultDecoder, ResultReadDecoder, ResultParameterEncoder, ResultScalarContract, Decoded, ExtendedDateTime } from "./result-decoder.ts";
 /**
  * @vibeorm/sql — dialect-aware SQL layer for VibeORM v2.
@@ -44,7 +48,7 @@ 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, 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 type { AdvisoryLockKey, AdvisoryLockStatement, AdvisoryLocksStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainCapture, CaptureReturningColumn, CaptureCascade, CaptureCascadeReturningColumn, CaptureCell, CaptureHop, OtherRowReturningColumn, ServerVersionReturningColumn, 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, UnchangedColumn, UnchangedExactness, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, RowSourceColumn, CommonTable, FirstRowList, JsonKeyColumn, JsonKeys, TableArrays, JsonSlot, JsonStep, WindowColumn, 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";
@@ -54,7 +58,8 @@ export { sqliteDialect } from "./dialects/sqlite.ts";
 export { mysqlDialect } from "./dialects/mysql.ts";
 export { SQL_DIALECTS, getSqlDialect } from "./dialects/registry.ts";
 export { tableDefinitionParts } from "./dialects/sqlite-table-definition.ts";
-export { keyListBindsUntypedRows, postgresBulkInsertArrayCastOf, postgresKeyListElementTypeOf } from "./key-list.ts";
+export { jsonKeyTokenCast, jsonKeysTyped, keyListBindsUntypedRows, mysqlJsonKeyTypeOf, postgresBulkInsertArrayCastOf, postgresKeyListElementTypeOf } from "./key-list.ts";
+export type { MysqlJsonKeyType } from "./key-list.ts";
 export { renderPredicate, renderSchemaExpression } from "./predicate.ts";
 export { renderLocalDateCheck } from "./local-date.ts";
 export { isTimeZoneName, renderDateTruncation } from "./date-truncation.ts";
@@ -70,8 +75,8 @@ export { renderRowRule } from "./row-rules.ts";
 export type { RenderedRowRule, RowRuleStatement, RowRuleTriggerPlacement } from "./row-rules.ts";
 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 { DIALECT_CODECS, MYSQL_CODECS, POSTGRES_CODECS, SQLITE_CODECS, dateTimeTextLayoutError, decodeIsNoop, decodedDateTimeRefusal, undecodableDateTimeText, enumMembershipCodec, float32Codec, localDateCodec, parseDateTimeText, parseExtendedDateTimeText, parseJsonText, postgresArrayElementFromText, shortestFloat32, timeOfDayCodec, dateOnlyCodec, dateTimeZoneKey, mysqlBoundTimestampText, parseZoneLessDateTime, zonedCodec, } from "./codecs.ts";
+export type { CodecTable, DateTimeZone, ScalarCodec, WireFidelity } from "./codecs.ts";
 export { isRollupChain, renderExpr, renderFragment, renderProjection, renderStatement } from "./render.ts";
 export type { RenderedQuery } from "./render.ts";
 export { snapshotSqlValue } from "./parameter-snapshot.ts";