@vibeorm/sql 5.8.0 → 5.10.0

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
@@ -450,11 +463,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: {
@@ -479,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/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-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/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/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,10 +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 }: {
-    readonly definition: string;
-    readonly index: string;
-}): readonly IndexKeyOperand[] | undefined;
-/** Caller owns a fixed search_path and rollback savepoint; no populated user table is indexed. */
-export declare function renderPostgresIndexExpressionProbe({ ...params }: IndexExpressionProbeParams): readonly RenderedQuery[];
+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,23 +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 }: {
-    readonly definition: string;
-    readonly index: string;
-    readonly postgres?: boolean;
-}): readonly IndexKeyOperand[] | undefined;
-/** SQLite source spelling is the evidence; CAST alone never proves a plain Decimal key. */
-export declare function extractSqliteIndexKeys({ definition, index }: {
-    readonly definition: string;
-    readonly index: string;
-}): readonly IndexKeyOperand[] | undefined;
+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-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[];