@vibeorm/sql 2.5.0 → 3.0.0

package/dist/index.js

@@ -7,6 +7,14 @@ function nativeEnumArrayParameter(params) {
 function isNativeEnumArrayParameter(value) {
   return typeof value === "object" && value !== null && NATIVE_ENUM_ARRAY_PARAMETER in value;
 }
+// packages/sql/src/json-list-parameter.ts
+var JSON_LIST_PARAMETER = Symbol("vibeorm.jsonListParameter");
+function jsonListParameter(params) {
+  return { [JSON_LIST_PARAMETER]: true, value: params.value, storage: params.storage };
+}
+function isJsonListParameter(value) {
+  return typeof value === "object" && value !== null && JSON_LIST_PARAMETER in value;
+}
 // packages/sql/src/dialects/external-ownership.ts
 import { unsupportedCapability } from "@vibeorm/schema";
 function renderExternalOwnershipCatalog(params) {
@@ -49,6 +57,13 @@ class ParamCollector {
       this.values.push(value.value);
       return `${this.dialect.placeholder({ index: this.values.length })}::${this.dialect.quoteIdent({ name: value.type.namespace })}.${this.dialect.quoteIdent({ name: value.type.name })}[]`;
     }
+    if (isJsonListParameter(value)) {
+      if (!this.dialect.capabilities.scalarArrays)
+        throw unsupportedCapability2({ dialect: this.dialect.name, feature: "scalarArrays" });
+      const whole = typeof value.value !== "string";
+      this.values.push(whole ? [...value.value] : value.value);
+      return `${this.dialect.placeholder({ index: this.values.length })}::text::${value.storage}${whole ? "[]" : ""}`;
+    }
     this.values.push(value);
     return this.dialect.placeholder({ index: this.values.length });
   }
@@ -131,7 +146,7 @@ function renderPostgresPhysicalCatalog(params) {
       text = `SELECT c.conname AS constraint_name, cl.relname AS table_name, att.attname AS column_name, fn.nspname AS foreign_namespace, fcl.relname AS foreign_table_name, fatt.attname AS foreign_column_name, c.confdeltype AS on_delete_char, c.confupdtype AS on_update_char, c.convalidated AS validated, c.condeferrable AS deferrable, (SELECT bool_and(t.tgenabled IN ('O', 'A')) FROM pg_catalog.pg_trigger t WHERE t.tgconstraint = c.oid) AS triggers_enabled FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace JOIN pg_catalog.pg_class fcl ON fcl.oid = c.confrelid JOIN pg_catalog.pg_namespace fn ON fn.oid = fcl.relnamespace JOIN unnest(c.conkey) WITH ORDINALITY AS lk(attnum, ord) ON true JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = lk.attnum JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum WHERE c.contype = 'f' AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname, lk.ord`;
       break;
     case "enums":
-      text = `SELECT t.typname AS type_name, n.nspname AS type_namespace, e.enumlabel AS enum_value, e.enumsortorder AS sort_order FROM pg_type t JOIN pg_enum e ON t.oid = e.enumtypid JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} ORDER BY t.typname, e.enumsortorder`;
+      text = `SELECT t.typname AS type_name, n.nspname AS type_namespace, e.enumlabel AS enum_value, e.enumsortorder AS sort_order FROM pg_type t JOIN pg_enum e ON t.oid = e.enumtypid JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_type'::regclass AND d.objid = t.oid AND d.deptype = 'e') ORDER BY t.typname, e.enumsortorder`;
       break;
     case "indexes":
       text = `SELECT tablename AS table_name, indexname AS index_name, indexdef AS index_def, con.conname AS backing_constraint, con.contype AS backing_constraint_type, health.indisvalid AS valid, health.indisready AS ready, health.indimmediate AS immediate, health.indexprs IS NULL AS plain_columns, health.indnkeyatts AS key_count, health.indnatts AS attribute_count FROM pg_indexes ix JOIN pg_catalog.pg_namespace ns ON ns.nspname = ix.schemaname JOIN pg_catalog.pg_class idx ON idx.relnamespace = ns.oid AND idx.relname = ix.indexname JOIN pg_catalog.pg_index health ON health.indexrelid = idx.oid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = idx.oid AND con.contype IN ('p', 'u', 'x') WHERE schemaname = ${namespace} ORDER BY tablename, indexname`;
@@ -146,7 +161,7 @@ function renderPostgresIndexKeys(params) {
   if (dialect.name !== "postgres")
     throw unsupportedCapability5({ dialect: dialect.name, feature: "indexOperatorClasses" });
   const collector = new ParamCollector(dialect);
-  const scope = params.table === undefined ? "n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'" : `n.nspname = ${collector.add(params.table.namespace)} AND c.relname = ${collector.add(params.table.name)}`;
+  const scope = params.table !== undefined ? `n.nspname = ${collector.add(params.table.namespace)} AND c.relname = ${collector.add(params.table.name)}` : params.namespaces === undefined ? "n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'" : params.namespaces.length === 0 ? "false" : `n.nspname IN (${[...new Set(params.namespaces)].map((namespace) => collector.add(namespace)).join(", ")})`;
   const defaultResolution = `LEFT JOIN LATERAL (WITH RECURSIVE input_types AS (SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t WHERE t.oid = a.atttypid UNION ALL SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t JOIN input_types previous ON t.oid = previous.typbasetype WHERE previous.typtype = 'd'), candidates AS (SELECT candidate.oid, CASE WHEN candidate.opcintype = input.oid THEN 0 WHEN class_input.typispreferred AND class_input.typcategory = input.typcategory THEN 1 ELSE 2 END AS priority FROM pg_catalog.pg_opclass candidate JOIN pg_catalog.pg_type class_input ON class_input.oid = candidate.opcintype CROSS JOIN input_types input WHERE input.typtype <> 'd' AND candidate.opcdefault AND candidate.opcmethod = idx.relam AND (candidate.opcintype = input.oid OR EXISTS (SELECT 1 FROM pg_catalog.pg_cast cast_entry WHERE cast_entry.castsource = input.oid AND cast_entry.casttarget = candidate.opcintype AND cast_entry.castmethod = 'b' AND cast_entry.castcontext = 'i') OR input.typtype = 'e' AND candidate.opcintype = 'pg_catalog.anyenum'::regtype OR input.typelem <> 0 AND candidate.opcintype = 'pg_catalog.anyarray'::regtype)) SELECT (array_agg(candidate.oid))[1] AS oid FROM candidates candidate WHERE candidate.priority = (SELECT min(priority) FROM candidates) HAVING count(*) = 1) resolved_default ON true`;
   return {
     text: `SELECT n.nspname AS table_namespace, c.relname AS table_name, idx.relname AS index_name, am.amname AS method, i.indisunique AS unique, pg_catalog.pg_get_expr(i.indpred, i.indrelid, false) AS predicate, i.indnullsnotdistinct AS nulls_not_distinct, k.ordinality AS ordinal, a.attname AS column_name, (i.indoption[k.ordinality - 1] & 1) <> 0 AS descending, opn.nspname AS operator_namespace, op.opcname AS operator_name, COALESCE(op.oid = resolved_default.oid, false) AS exact_default FROM pg_catalog.pg_index i JOIN pg_catalog.pg_class c ON c.oid = i.indrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace JOIN pg_catalog.pg_class idx ON idx.oid = i.indexrelid JOIN pg_catalog.pg_am am ON am.oid = idx.relam CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY k(attnum, ordinality) LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum JOIN pg_catalog.pg_opclass op ON op.oid = i.indclass[k.ordinality - 1] JOIN pg_catalog.pg_namespace opn ON opn.oid = op.opcnamespace ${defaultResolution} WHERE ${scope} AND k.ordinality <= i.indnkeyatts ORDER BY n.nspname, c.relname, idx.relname, k.ordinality`,
@@ -334,6 +349,209 @@ function renderModuleJournal(params) {
   }
   return { text, values: collector.values };
 }
+// packages/sql/src/capabilities.ts
+import {
+  DIALECT_CAPABILITIES,
+  POSTGRES_CAPABILITIES,
+  SQLITE_CAPABILITIES,
+  MYSQL_CAPABILITIES
+} from "@vibeorm/schema";
+
+// packages/sql/src/identifiers.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+function assertNoNul(params) {
+  if (params.name.includes("\x00")) {
+    throw new VibeError2({
+      code: "VIBE_VALIDATION",
+      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
+      meta: { name: params.name.replaceAll("\x00", "\\0") }
+    });
+  }
+  return params.name;
+}
+
+// packages/sql/src/dialects/sqlite.ts
+var sqliteDialect = {
+  name: "sqlite",
+  capabilities: SQLITE_CAPABILITIES,
+  inArrayStrategy: "expand",
+  tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
+  upsertForm: "onConflict",
+  conflictKeyEquality: {
+    foldingScalars: [],
+    textIsBinaryByDefault: true,
+    duplicatesInOneStatement: "lastWriteWins"
+  },
+  excludedRowRef: { form: "keyword", name: "excluded" },
+  doNothingForm: "onConflictDoNothing",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "glob",
+  greatestForm: "frame",
+  orderByNullsMode: "native",
+  offsetRequiresLimit: { limitText: "-1" },
+  likeEscapeClause: " ESCAPE '\\'",
+  jsonPathMode: "sqliteExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  lastInsertIdSql: null,
+  rowLockSyntax: null,
+  advisoryLockFunctions: null,
+  rowDefaultKeyword: false,
+  statementChain: null,
+  paramBudget: 900,
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
+  },
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("'", "''")}'`;
+  },
+  placeholder() {
+    return "?";
+  },
+  renderDbNow({ offsetSeconds, collector }) {
+    if (offsetSeconds === 0)
+      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
+  }
+};
+
+// packages/sql/src/dialects/sqlite-table-definition.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+function tableDefinitionParts(params) {
+  const sql = params.sql;
+  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
+    throw unavailable();
+  const parts = [];
+  let start = -1;
+  let depth = 0;
+  let quote;
+  for (let index = 0;index < sql.length; index++) {
+    const char = sql[index];
+    if (quote !== undefined) {
+      if (char === quote) {
+        if (quote !== "]" && sql[index + 1] === quote)
+          index++;
+        else
+          quote = undefined;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "[") {
+      quote = "]";
+      continue;
+    }
+    if (char === "-" && sql[index + 1] === "-") {
+      const end = sql.indexOf(`
+`, index + 2);
+      if (end < 0)
+        break;
+      index = end;
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0)
+        break;
+      index = end + 1;
+      continue;
+    }
+    if (char === "(") {
+      if (depth === 0)
+        start = index + 1;
+      depth++;
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        parts.push(sql.slice(start, index).trim());
+        return { clauses: parts, suffix: sql.slice(index + 1) };
+      }
+    } else if (char === "," && depth === 1) {
+      parts.push(sql.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  throw unavailable();
+}
+function unavailable() {
+  return new VibeError3({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
+}
+function sqliteColumnClauses(params) {
+  const columns = [];
+  for (const part of tableDefinitionParts(params).clauses) {
+    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
+    if (token === null)
+      throw unavailable();
+    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
+      continue;
+    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
+    columns.push({ name, sql: part });
+  }
+  return columns;
+}
+
+// packages/sql/src/dialects/sqlite-fts.ts
+function updateStatements(params) {
+  const quote = (name) => sqliteDialect.quoteIdent({ name });
+  const columns = params.columns.map((column) => quote(column)).join(", ");
+  const oldValues = params.columns.map((column) => `old.${quote(column)}`).join(", ");
+  const newValues = params.columns.map((column) => `new.${quote(column)}`).join(", ");
+  const changes = [
+    "old.rowid IS NOT new.rowid",
+    ...params.columns.map((column) => `old.${quote(column)} COLLATE BINARY IS NOT new.${quote(column)} COLLATE BINARY`)
+  ].join(" OR ");
+  const target = `${quote(`${params.ftsTable}_au`)} AFTER UPDATE ON ${quote(params.table)}`;
+  const body = `BEGIN
+  INSERT INTO ${quote(params.ftsTable)}(${quote(params.ftsTable)}, rowid, ${columns}) VALUES ('delete', old.rowid, ${oldValues});
+  INSERT INTO ${quote(params.ftsTable)}(rowid, ${columns}) VALUES (new.rowid, ${newValues});
+END`;
+  const tail = `${target} WHEN (${changes}) ${body}`;
+  return {
+    create: `CREATE TRIGGER IF NOT EXISTS ${tail};`,
+    definition: `CREATE TRIGGER ${tail}`,
+    legacyDefinition: `CREATE TRIGGER ${target} ${body}`
+  };
+}
+function renderSqliteFtsUpdateTrigger(params) {
+  const { create, definition } = updateStatements(params);
+  return { create, definition };
+}
+function sqliteFtsUpdateUpgrade(params) {
+  const quoted = '"(?:[^"]|"")+"';
+  const body = new RegExp(`BEGIN\\n  INSERT INTO (${quoted})\\((${quoted}), rowid, (${quoted}(?:, ${quoted})*)\\) VALUES \\('delete', old\\.rowid, `, "g");
+  for (const match of params.create.matchAll(body)) {
+    const ftsTable = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[1]})` })[0].name;
+    const columns = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[3]})` }).map((column) => column.name);
+    if (params.name !== `${ftsTable}_au`)
+      continue;
+    const statements = updateStatements({ table: params.table, ftsTable, columns });
+    if (params.create !== statements.create)
+      continue;
+    const installed = params.installed === statements.legacyDefinition ? "legacy" : params.installed === statements.definition ? "current" : undefined;
+    if (installed === undefined)
+      continue;
+    if (params.tableDefinition === undefined)
+      return { kind: "tableRequired", ftsTable };
+    const tableTail = `${sqliteDialect.quoteIdent({ name: ftsTable })} USING fts5(${columns.map((name) => sqliteDialect.quoteIdent({ name })).join(", ")}, content=${sqliteDialect.quoteStringLiteral({ value: params.table })})`;
+    if (params.tableDefinition !== `CREATE VIRTUAL TABLE ${tableTail}` && params.tableDefinition !== `CREATE VIRTUAL TABLE IF NOT EXISTS ${tableTail};`)
+      continue;
+    return { kind: "recognized", ftsTable, legacyDefinition: statements.legacyDefinition, currentDefinition: statements.definition, drop: `DROP TRIGGER IF EXISTS ${sqliteDialect.quoteIdent({ name: `${ftsTable}_au` })};`, installed };
+  }
+  return;
+}
 // packages/sql/src/dialects/sqlite-session.ts
 var SQLITE_SESSION_SQL = Object.freeze({
   lockingMode: "PRAGMA main.locking_mode",
@@ -346,10 +564,10 @@ var SQLITE_SESSION_SQL = Object.freeze({
   foreignKeysOn: "PRAGMA foreign_keys = ON"
 });
 // packages/sql/src/composable.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError4 } from "@vibeorm/schema";
 var fragments = new WeakMap;
 function invalid(message) {
-  throw new VibeError2({ code: "VIBE_VALIDATION", message });
+  throw new VibeError4({ code: "VIBE_VALIDATION", message });
 }
 function construct(parts) {
   const snapshot = Object.freeze([...parts]);
@@ -365,6 +583,9 @@ function isSqlFragment(value) {
 function partsOf(value) {
   return fragments.get(value) ?? invalid("Expected a constructed SQL fragment");
 }
+function containsGreatest(fragment) {
+  return partsOf(fragment).some((part) => typeof part !== "string" && ("greatest" in part));
+}
 function identifier(parts) {
   if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => typeof part !== "string" || part.length === 0 || part.includes("\x00"))) {
     invalid("SQL identifiers require non-empty, NUL-free name components");
@@ -427,14 +648,25 @@ var sql = Object.freeze(Object.assign(template, {
 function renderSqlFragment(params) {
   const { dialect, collector, conflict } = params;
   const render = (fragment) => renderSqlFragment({ ...params, fragment });
+  const encode = (part) => {
+    if (part.value === undefined)
+      invalid("SQL parameters cannot be undefined; use null explicitly");
+    return part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name });
+  };
+  const frameOperand = (fragment) => {
+    const parts = partsOf(fragment).filter((part) => part !== "");
+    const only = parts.length === 1 ? parts[0] : undefined;
+    const value = only !== undefined && typeof only !== "string" && "value" in only ? { encoded: encode(only) } : undefined;
+    if (value !== undefined && value.encoded === null)
+      return "NULL";
+    const text = value === undefined ? render(fragment) : collector.add(value.encoded);
+    return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+  };
   return partsOf(params.fragment).map((part) => {
     if (typeof part === "string")
       return part;
-    if ("value" in part) {
-      if (part.value === undefined)
-        invalid("SQL parameters cannot be undefined; use null explicitly");
-      return collector.add(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
-    }
+    if ("value" in part)
+      return collector.add(encode(part));
     if ("ident" in part)
       return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
     if ("row" in part) {
@@ -447,7 +679,14 @@ function renderSqlFragment(params) {
       const qualifier = part.row === "existing" ? dialect.quoteIdent({ name: conflict.table }) : ref.form === "keyword" ? ref.name : dialect.quoteIdent({ name: ref.alias });
       return `${qualifier}.${dialect.quoteIdent({ name })}`;
     }
-    return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    if (dialect.greatestForm === "native")
+      return `GREATEST(${part.greatest.map(render).join(", ")})`;
+    if (!part.greatest.some(containsGreatest)) {
+      return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    }
+    const [left, right] = part.greatest.map(frameOperand);
+    const [a, b, frame] = ["a", "b", "g"].map((name) => dialect.quoteIdent({ name }));
+    return `(SELECT CASE WHEN ${a} IS NULL THEN ${b} WHEN ${b} IS NULL THEN ${a} WHEN ${a} >= ${b} THEN ${a} ELSE ${b} END FROM (SELECT ${left} AS ${a}, ${right} AS ${b}) AS ${frame})`;
   }).join("");
 }
 function mapConflictColumns(params) {
@@ -474,7 +713,7 @@ function sqlUsesIncoming(params) {
   return partsOf(params.fragment).some((part) => typeof part !== "string" && (("row" in part) && part.row === "incoming" || ("greatest" in part) && part.greatest.some((fragment) => sqlUsesIncoming({ fragment }))));
 }
 // packages/sql/src/result-decoder.ts
-import { VibeError as VibeError4 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 
 // packages/sql/src/pg-array.ts
 var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
@@ -489,7 +728,7 @@ function toPgArrayLiteral(params) {
   return `{${parts.join(",")}}`;
 }
 function parsePgArrayLiteral(params) {
-  const { literal } = params;
+  const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
   if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
     return null;
   const inner = literal.slice(1, -1);
@@ -527,9 +766,63 @@ function parsePgArrayLiteral(params) {
   }
   return out;
 }
+function parsePgArrayLiteralNested(params) {
+  const text = params.literal.replace(/^(?:\[-?\d+:-?\d+\])+=/, "");
+  const cursor = { index: 0 };
+  const parsed = parseDimension({ text, cursor });
+  return parsed !== null && cursor.index === text.length ? parsed : null;
+}
+function parseDimension(params) {
+  const { text, cursor } = params;
+  if (text[cursor.index] !== "{")
+    return null;
+  cursor.index++;
+  const out = [];
+  if (text[cursor.index] === "}") {
+    cursor.index++;
+    return out;
+  }
+  while (cursor.index < text.length) {
+    if (text[cursor.index] === "{") {
+      const nested = parseDimension({ text, cursor });
+      if (nested === null)
+        return null;
+      out.push(nested);
+    } else if (text[cursor.index] === '"') {
+      let element = "";
+      cursor.index++;
+      while (cursor.index < text.length && text[cursor.index] !== '"') {
+        if (text[cursor.index] === "\\")
+          cursor.index++;
+        element += text[cursor.index] ?? "";
+        cursor.index++;
+      }
+      if (text[cursor.index] !== '"')
+        return null;
+      cursor.index++;
+      out.push(element);
+    } else {
+      let element = "";
+      while (cursor.index < text.length && text[cursor.index] !== "," && text[cursor.index] !== "}") {
+        element += text[cursor.index];
+        cursor.index++;
+      }
+      out.push(element === "NULL" ? null : element);
+    }
+    if (text[cursor.index] === ",") {
+      cursor.index++;
+      continue;
+    }
+    if (text[cursor.index] !== "}")
+      return null;
+    cursor.index++;
+    return out;
+  }
+  return null;
+}
 
 // packages/sql/src/codecs.ts
-import { VibeError as VibeError3, invalidStoredData } from "@vibeorm/schema";
+import { VibeError as VibeError5, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
 function enumMembershipCodec(params) {
   const { model, field, enum: enumName } = params;
   const members = new Set(params.members);
@@ -537,7 +830,7 @@ function enumMembershipCodec(params) {
     encode: (value) => {
       if (typeof value === "string" && members.has(value))
         return value;
-      throw new VibeError3({
+      throw new VibeError5({
         code: "VIBE_VALIDATION",
         message: `Invalid value for enum ${enumName} on ${model}.${field}`,
         meta: { model, field, enum: enumName }
@@ -577,7 +870,7 @@ var bigIntCodec = {
       return BigInt(value.trim());
     if (typeof value === "number" && Number.isSafeInteger(value))
       return BigInt(value);
-    throw new VibeError3({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
+    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
   }
 };
 var decimalCodec = {
@@ -594,6 +887,7 @@ var mysqlDecimalCodec = {
   }
 };
 var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
 function parseDateTimeText(params) {
   const trimmed = params.text.trim();
   if (ZONE_LESS_DATETIME.test(trimmed)) {
@@ -601,13 +895,20 @@ function parseDateTimeText(params) {
     if (!Number.isNaN(asUtc.getTime()))
       return asUtc;
   }
+  const zoned = PG_ZONED_DATETIME.exec(trimmed);
+  if (zoned !== null) {
+    const [, date, time, fraction, hours, minutes] = zoned;
+    const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
+    if (!Number.isNaN(iso.getTime()))
+      return iso;
+  }
   const parsed = new Date(trimmed);
   return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
 var dateNativeCodec = {
   encode: (value) => {
     if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
-      throw new VibeError3({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
+      throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
     }
     return value;
   },
@@ -615,7 +916,7 @@ var dateNativeCodec = {
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
     if (date !== undefined && Number.isFinite(date.getTime()))
       return date;
-    throw new VibeError3({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
   }
 };
 var dateTextCodec = {
@@ -624,7 +925,7 @@ var dateTextCodec = {
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
     if (date !== undefined && Number.isFinite(date.getTime()))
       return date.toISOString();
-    throw new VibeError3({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+    throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
   },
   decode: dateNativeCodec.decode
 };
@@ -645,6 +946,44 @@ var mysqlDateCodec = {
   },
   decode: dateNativeCodec.decode
 };
+var MILLISECONDS_PER_DAY = 86400000;
+var TIME_OF_DAY_TEXT = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
+var pad = (value, width) => String(value).padStart(width, "0");
+var utcMillisecondOfDay = (date) => (date.getTime() % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY;
+var timeOfDayText = (millisecond) => `${pad(Math.floor(millisecond / 3600000), 2)}:${pad(Math.floor(millisecond / 60000) % 60, 2)}:${pad(Math.floor(millisecond / 1000) % 60, 2)}.${pad(millisecond % 1000, 3)}`;
+function makeTimeOfDayCodec(params) {
+  const suffix = params.zoned ? "+00" : "";
+  return Object.freeze({
+    encode: (value) => {
+      dateNativeCodec.encode(value);
+      const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+      if (date === undefined || !Number.isFinite(date.getTime())) {
+        throw new VibeError5({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
+      }
+      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
+    },
+    decode: (value) => {
+      if (value instanceof Date && Number.isFinite(value.getTime()))
+        return new Date(utcMillisecondOfDay(value));
+      const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
+      if (match !== null) {
+        const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
+        const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
+        const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
+        if (millisecond <= MILLISECONDS_PER_DAY) {
+          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+        }
+      }
+      throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
+    }
+  });
+}
+var timeCodec = makeTimeOfDayCodec({ zoned: false });
+var timetzCodec = makeTimeOfDayCodec({ zoned: true });
+function timeOfDayCodec(params) {
+  const type = timeOfDayType({ nativeType: params.nativeType });
+  return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
+}
 var booleanIntCodec = {
   encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
   decode: (value) => typeof value === "number" ? value !== 0 : value
@@ -661,7 +1000,7 @@ var jsonCodec = {
     try {
       return JSON.parse(value);
     } catch (cause) {
-      throw new VibeError3({
+      throw new VibeError5({
         code: "VIBE_INTERNAL",
         message: "a Json column returned text that is not valid JSON",
         meta: { value },
@@ -670,6 +1009,39 @@ var jsonCodec = {
     }
   }
 };
+function shortestFloat32(params) {
+  const { value } = params;
+  if (value === 0 || !Number.isFinite(value))
+    return value;
+  const target = Math.fround(value);
+  for (let precision = 1;precision <= 9; precision++) {
+    const candidate = Number(value.toPrecision(precision));
+    if (Math.fround(candidate) === target)
+      return candidate;
+  }
+  return value;
+}
+var float32Codec = {
+  encode: identity,
+  decode: (value) => {
+    const number = typeof value === "string" ? Number(value) : value;
+    return typeof number === "number" ? shortestFloat32({ value: number }) : number;
+  }
+};
+var booleanFromText = (text) => text === "t" ? true : text === "f" ? false : text;
+var bytesFromText = (text) => /^\\x(?:[0-9a-fA-F]{2})*$/.test(text) ? new Uint8Array(Buffer.from(text.slice(2), "hex")) : text;
+function postgresArrayElementFromText(params) {
+  switch (params.scalarType) {
+    case "Boolean":
+      return booleanFromText;
+    case "Bytes":
+      return bytesFromText;
+    case "Json":
+      return jsonCodec.decode;
+    default:
+      return null;
+  }
+}
 var POSTGRES_CODECS = {
   String: passthroughCodec,
   Boolean: passthroughCodec,
@@ -711,7 +1083,7 @@ var DIALECT_CODECS = {
 
 // packages/sql/src/result-decoder.ts
 function refuse(encoding, message) {
-  throw new VibeError4({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
+  throw new VibeError6({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
 }
 function scalar(type, valid) {
   const convert = (params, encoding) => {
@@ -757,7 +1129,7 @@ var extendedDecoder = Object.freeze({
   encode: (params) => {
     if (params.value === "infinity" || params.value === "-infinity") {
       if (params.dialect !== "postgres")
-        throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
+        throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
       return params.value;
     }
     return dateDecoder.encode(params);
@@ -815,10 +1187,10 @@ var decode = Object.freeze({
   }
 });
 // packages/sql/src/exclusion.ts
-import { VibeError as VibeError6, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { VibeError as VibeError8, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 
 // packages/sql/src/predicate.ts
-import { VibeError as VibeError5, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError7, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 function renderPredicate(params) {
   if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
     throw unsupportedCapability8({ dialect: params.dialect.name, feature: "exclusionConstraints" });
@@ -858,7 +1230,7 @@ var INT64_MIN = -(2n ** 63n);
 var INT64_MAX = 2n ** 63n - 1n;
 function refuse2(params) {
   const { context, rule, message } = params;
-  throw new VibeError5({
+  throw new VibeError7({
     code: "VIBE_SCHEMA_INVALID",
     message: `${context.site} on "${context.model.name}": ${message}`,
     meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
@@ -1122,7 +1494,7 @@ function describe(params) {
 
 // packages/sql/src/exclusion.ts
 function invalid2(rule) {
-  throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+  throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
 }
 function compileExclusion(params) {
   const { exclusion: spec, model, dialect } = params;
@@ -1245,7 +1617,7 @@ function isSqlDefaultCell(value) {
   return value === SQL_DEFAULT_CELL;
 }
 function jsonParamCell(params) {
-  return { __jsonParam: true, text: params.text };
+  return params.storage === "json" ? { __jsonParam: true, text: params.text, storage: "json" } : { __jsonParam: true, text: params.text };
 }
 function isJsonParamCell(value) {
   return typeof value === "object" && value !== null && value.__jsonParam === true;
@@ -1256,7 +1628,30 @@ function excludedRef(params) {
 function isExcludedRef(value) {
   return typeof value === "object" && value !== null && value.__excluded === true;
 }
+function returningColumnName(column) {
+  return typeof column === "string" ? column : column.name;
+}
 var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
+function stepColumnRef(params) {
+  return { __stepColumn: true, step: params.step, column: params.column };
+}
+function isStepColumnRef(value) {
+  return typeof value === "object" && value !== null && value.__stepColumn === true;
+}
+var CHAIN_VETO_PREFIX = "__vibe_veto:";
+var CHAIN_VETO_TOKEN_PATTERN = /^[a-z][a-z0-9_]*$/;
+function chainVetoToken(params) {
+  const { message, nonce } = params;
+  if (nonce === "")
+    return;
+  for (let start = message.indexOf(CHAIN_VETO_PREFIX);start >= 0; start = message.indexOf(CHAIN_VETO_PREFIX, start + 1)) {
+    const rest = message.slice(start + CHAIN_VETO_PREFIX.length);
+    const match = /^([a-z][a-z0-9_]*):/.exec(rest);
+    if (match !== null && rest.startsWith(`${nonce}:`, match[0].length))
+      return match[1];
+  }
+  return;
+}
 // packages/sql/src/locks.ts
 import { internalError, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
@@ -1346,33 +1741,13 @@ function projectionOutputName(params) {
   const { column } = params;
   return column.transform === undefined ? column.alias ?? column.name : column.name;
 }
-// packages/sql/src/capabilities.ts
-import {
-  DIALECT_CAPABILITIES,
-  POSTGRES_CAPABILITIES,
-  SQLITE_CAPABILITIES,
-  MYSQL_CAPABILITIES
-} from "@vibeorm/schema";
-
-// packages/sql/src/identifiers.ts
-import { VibeError as VibeError7 } from "@vibeorm/schema";
-function assertNoNul(params) {
-  if (params.name.includes("\x00")) {
-    throw new VibeError7({
-      code: "VIBE_VALIDATION",
-      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
-      meta: { name: params.name.replaceAll("\x00", "\\0") }
-    });
-  }
-  return params.name;
-}
-
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
   name: "postgres",
   capabilities: POSTGRES_CAPABILITIES,
   inArrayStrategy: "any",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
   upsertForm: "onConflict",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1383,6 +1758,7 @@ var postgresDialect = {
   doNothingForm: "onConflictDoNothing",
   insensitiveLike: "ilike",
   strictMatchStrategy: "native",
+  greatestForm: "native",
   orderByNullsMode: "native",
   offsetRequiresLimit: null,
   likeEscapeClause: null,
@@ -1419,6 +1795,7 @@ var postgresDialect = {
     keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
   },
   rowDefaultKeyword: true,
+  statementChain: "dataModifyingCte",
   paramBudget: 30000,
   booleanLiteral: { true: "true", false: "false" },
   quoteIdent({ name }) {
@@ -1436,63 +1813,13 @@ var postgresDialect = {
     return `(now() + make_interval(secs => ${collector.add(offsetSeconds)}))`;
   }
 };
-// packages/sql/src/dialects/sqlite.ts
-var sqliteDialect = {
-  name: "sqlite",
-  capabilities: SQLITE_CAPABILITIES,
-  inArrayStrategy: "expand",
-  tupleInStrategy: "rowValue",
-  upsertForm: "onConflict",
-  conflictKeyEquality: {
-    foldingScalars: [],
-    textIsBinaryByDefault: true,
-    duplicatesInOneStatement: "lastWriteWins"
-  },
-  excludedRowRef: { form: "keyword", name: "excluded" },
-  doNothingForm: "onConflictDoNothing",
-  insensitiveLike: "lower",
-  strictMatchStrategy: "glob",
-  orderByNullsMode: "native",
-  offsetRequiresLimit: { limitText: "-1" },
-  likeEscapeClause: " ESCAPE '\\'",
-  jsonPathMode: "sqliteExtract",
-  supportedJsonOps: [
-    "equals",
-    "string_contains",
-    "string_starts_with",
-    "string_ends_with",
-    "array_contains",
-    "array_starts_with",
-    "array_ends_with"
-  ],
-  jsonParamCast: "",
-  lastInsertIdSql: null,
-  rowLockSyntax: null,
-  advisoryLockFunctions: null,
-  rowDefaultKeyword: false,
-  paramBudget: 900,
-  booleanLiteral: { true: "1", false: "0" },
-  quoteIdent({ name }) {
-    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
-  },
-  quoteStringLiteral({ value }) {
-    return `'${value.replaceAll("'", "''")}'`;
-  },
-  placeholder() {
-    return "?";
-  },
-  renderDbNow({ offsetSeconds, collector }) {
-    if (offsetSeconds === 0)
-      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
-  }
-};
 // packages/sql/src/dialects/mysql.ts
 var mysqlDialect = {
   name: "mysql",
   capabilities: MYSQL_CAPABILITIES,
   inArrayStrategy: "expand",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "equalities",
   upsertForm: "onDuplicateKey",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1504,6 +1831,7 @@ var mysqlDialect = {
   doNothingForm: "insertIgnore",
   insensitiveLike: "lower",
   strictMatchStrategy: "binary",
+  greatestForm: "wrapped-frame",
   orderByNullsMode: "emulate",
   offsetRequiresLimit: { limitText: "18446744073709551615" },
   likeEscapeClause: null,
@@ -1525,6 +1853,7 @@ var mysqlDialect = {
   },
   advisoryLockFunctions: null,
   rowDefaultKeyword: true,
+  statementChain: null,
   paramBudget: 1e4,
   booleanLiteral: { true: "1", false: "0" },
   quoteIdent({ name }) {
@@ -1551,83 +1880,6 @@ var SQL_DIALECTS = {
 function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
-// packages/sql/src/dialects/sqlite-table-definition.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
-function tableDefinitionParts(params) {
-  const sql = params.sql;
-  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
-    throw unavailable();
-  const parts = [];
-  let start = -1;
-  let depth = 0;
-  let quote;
-  for (let index = 0;index < sql.length; index++) {
-    const char = sql[index];
-    if (quote !== undefined) {
-      if (char === quote) {
-        if (quote !== "]" && sql[index + 1] === quote)
-          index++;
-        else
-          quote = undefined;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"' || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "[") {
-      quote = "]";
-      continue;
-    }
-    if (char === "-" && sql[index + 1] === "-") {
-      const end = sql.indexOf(`
-`, index + 2);
-      if (end < 0)
-        break;
-      index = end;
-      continue;
-    }
-    if (char === "/" && sql[index + 1] === "*") {
-      const end = sql.indexOf("*/", index + 2);
-      if (end < 0)
-        break;
-      index = end + 1;
-      continue;
-    }
-    if (char === "(") {
-      if (depth === 0)
-        start = index + 1;
-      depth++;
-    } else if (char === ")") {
-      depth--;
-      if (depth === 0 && start >= 0) {
-        parts.push(sql.slice(start, index).trim());
-        return { clauses: parts, suffix: sql.slice(index + 1) };
-      }
-    } else if (char === "," && depth === 1) {
-      parts.push(sql.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  throw unavailable();
-}
-function unavailable() {
-  return new VibeError8({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
-}
-function sqliteColumnClauses(params) {
-  const columns = [];
-  for (const part of tableDefinitionParts(params).clauses) {
-    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
-    if (token === null)
-      throw unavailable();
-    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
-      continue;
-    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
-    columns.push({ name, sql: part });
-  }
-  return columns;
-}
 // packages/sql/src/dialects/diagnostics.ts
 import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
@@ -2108,6 +2360,8 @@ function renderStatement(params) {
       return renderUpdate({ dialect, statement, collector });
     case "delete":
       return renderDelete({ dialect, statement, collector });
+    case "chain":
+      return renderChain({ dialect, statement, collector });
     case "rlsReadiness":
       return renderRlsReadinessQuery({ dialect, ...statement });
     case "rlsProbeTable":
@@ -2141,8 +2395,29 @@ function quoteCol(dialect, column) {
     }
     return `CAST(${ref} AS REAL)`;
   }
+  if (column.castJsonb !== undefined) {
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "ColRef.castJsonb is a postgres json construct" });
+    }
+    return `${ref}::${column.castJsonb}`;
+  }
   return ref;
 }
+function typedOrderRef(params) {
+  const { statement, column } = params;
+  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined)
+    return column;
+  const renamed = statement.columns.some((projected) => (projected.alias ?? projected.name) === column.name && (projected.transform !== undefined || projected.alias !== undefined));
+  return renamed ? { ...column, table: statement.table.alias ?? statement.table.name } : column;
+}
+function jsonCellCast(dialect, cell) {
+  if (cell.storage !== "json" || dialect.jsonParamCast === "")
+    return dialect.jsonParamCast;
+  if (dialect.name !== "postgres") {
+    throw internalError2({ message: "JsonParamCell storage json is a postgres construct" });
+  }
+  return "::text::json";
+}
 function quoteProjection(dialect, column) {
   if (column.transform === undefined) {
     const base = quoteCol(dialect, column);
@@ -2151,7 +2426,7 @@ function quoteProjection(dialect, column) {
     return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
   }
   if (dialect.name !== "postgres") {
-    throw internalError2({ message: "ColRef.transform is a postgres lateral-join construct" });
+    throw internalError2({ message: "ColRef.transform is a postgres construct" });
   }
   const ref = quoteCol(dialect, column);
   const alias = dialect.quoteIdent({ name: column.name });
@@ -2159,6 +2434,10 @@ function quoteProjection(dialect, column) {
     return `${ref}::text AS ${alias}`;
   return `encode(${ref}, 'base64') AS ${alias}`;
 }
+function renderProjection(params) {
+  const { dialect, columns } = params;
+  return columns.map((column) => quoteProjection(dialect, column)).join(", ");
+}
 function renderTable(dialect, table) {
   if (table.namespace !== undefined)
     assertSqlNamespace2({ namespace: table.namespace, dialect: dialect.name });
@@ -2219,7 +2498,8 @@ function renderExpr(params) {
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
       }
-      return `${quoteCol(dialect, expr.column)} ${op} ${collector.add(expr.value)}`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      return `${compared.column} ${op} ${compared.operand}`;
     }
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
@@ -2235,6 +2515,10 @@ function renderExpr(params) {
         return expr.negate === true ? "1 = 1" : "1 = 0";
       }
       const column = quoteCol(dialect, expr.column);
+      if (expr.timeOfDay === true && dialect.timeOfDayInStrategy === "equalities") {
+        const equalities = collector.addMany(expr.values).map((placeholder) => `${column} = ${placeholder}`);
+        return `${expr.negate === true ? "NOT " : ""}(${equalities.join(" OR ")})`;
+      }
       if (dialect.inArrayStrategy === "any") {
         const base = `${column} = ANY(${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)})`;
         return expr.negate === true ? `NOT (${base})` : base;
@@ -2328,16 +2612,21 @@ function renderExpr(params) {
     }
     case "arrayHas": {
       assertScalarArrays(dialect, 'the scalar-list filter "has"');
-      const base = `${collector.add(expr.value)} = ANY(${quoteCol(dialect, expr.column)})`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      const base = `${compared.operand} = ANY(${compared.column})`;
       return expr.negate === true ? `NOT (${base})` : base;
     }
     case "arrayContainsAll": {
       assertScalarArrays(dialect, 'the scalar-list filter "hasEvery"');
-      return `${quoteCol(dialect, expr.column)} @> ${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)}`;
+      const values = Array.isArray(expr.values) ? [...expr.values] : expr.values;
+      const compared = listComparison({ dialect, column: expr.column, value: values, collector });
+      return `${compared.column} @> ${compared.operand}`;
     }
     case "arrayOverlaps": {
       assertScalarArrays(dialect, 'the scalar-list filter "hasSome"');
-      return `${quoteCol(dialect, expr.column)} && ${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)}`;
+      const values = Array.isArray(expr.values) ? [...expr.values] : expr.values;
+      const compared = listComparison({ dialect, column: expr.column, value: values, collector });
+      return `${compared.column} && ${compared.operand}`;
     }
     case "arrayIsEmpty": {
       assertScalarArrays(dialect, 'the scalar-list filter "isEmpty"');
@@ -2385,6 +2674,16 @@ function jsonPathString(path) {
   }
   return out;
 }
+function listComparison(params) {
+  const { dialect, column, value, collector } = params;
+  if (isJsonListParameter(value) && value.storage === "json") {
+    return {
+      column: `${quoteCol(dialect, column)}::jsonb[]`,
+      operand: collector.add(jsonListParameter({ value: value.value, storage: "jsonb" }))
+    };
+  }
+  return { column: quoteCol(dialect, column), operand: collector.add(value) };
+}
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
@@ -2422,19 +2721,22 @@ function renderJsonFilter(params) {
   if (dialect.jsonPathMode === "operators") {
     const column = quoteCol(dialect, expr.column);
     const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
+    const extracted = expr.storage === "json" ? `(${column} #> ${pathParam})::jsonb` : `(${column} #> ${pathParam})`;
     switch (expr.op) {
       case "equals":
-        return `(${column} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "string_contains":
       case "string_starts_with":
-      case "string_ends_with":
-        return renderJsonLike({ dialect, target: `(${column} #>> ${pathParam})`, expr, collector });
+      case "string_ends_with": {
+        const target = expr.storage === "json" ? `(${extracted} #>> '{}')` : `(${column} #>> ${pathParam})`;
+        return renderJsonLike({ dialect, target, expr, collector });
+      }
       case "array_contains":
-        return `(${column} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_starts_with":
-        return `(${column} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_ends_with":
-        return `(${column} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
     }
   }
   if (dialect.jsonPathMode === "sqliteExtract") {
@@ -2578,7 +2880,14 @@ function renderLateralJoin(params) {
     const terms = join.select.orderBy;
     const columnTerms = terms.filter((term) => ("column" in term));
     if (columnTerms.length === terms.length && columnTerms.every((term) => projected.has(term.column.name))) {
-      const rendered = columnTerms.map((term) => renderOrderTerm({ dialect, term: { ...term, column: { table: "__sub", name: term.column.name } }, collector }));
+      const rendered = columnTerms.map((term) => renderOrderTerm({
+        dialect,
+        term: {
+          ...term,
+          column: { table: "__sub", name: term.column.name, ...term.column.castJsonb === undefined ? {} : { castJsonb: term.column.castJsonb } }
+        },
+        collector
+      }));
       aggOrder = ` ORDER BY ${rendered.join(", ")}`;
     }
   }
@@ -2587,6 +2896,15 @@ function renderLateralJoin(params) {
   const alias = dialect.quoteIdent({ name: join.alias });
   return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
 }
+function renderCountSubquery(params) {
+  const { dialect, subquery, collector } = params;
+  const select = subquery.select;
+  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
+    throw internalError2({ message: "count subquery must be one ungrouped COUNT(*)" });
+  }
+  const inner = renderSelect({ dialect, statement: select, collector });
+  return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
+}
 function applyReturning(params) {
   const { dialect, requested } = params;
   if (requested === undefined || requested.length === 0) {
@@ -2595,9 +2913,65 @@ function applyReturning(params) {
   if (!dialect.capabilities.returning) {
     return { suffix: "", status: "omitted" };
   }
-  const columns = requested.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const columns = requested.map((column) => {
+    if (typeof column === "string")
+      return dialect.quoteIdent({ name: column });
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "a castText RETURNING column is a postgres construct" });
+    }
+    const name = dialect.quoteIdent({ name: column.name });
+    return `${name}::text AS ${name}`;
+  }).join(", ");
   return { suffix: ` RETURNING ${columns}`, status: "native" };
 }
+function renderKeyTableJoin(params) {
+  const { dialect, join, collector } = params;
+  const postgresMember = (member) => member.kind === "citext" || member.kind === "text" || member.kind === "integer";
+  const admitted = dialect.name === "mysql" ? join.members.every((member) => member.kind !== "citext" && member.kind !== "text") : dialect.name === "postgres" && join.members.every(postgresMember);
+  if (!admitted) {
+    throw unsupportedCapability15({
+      dialect: dialect.name,
+      feature: "relation key table",
+      hint: "the key-table join is mysql's relation association \u2014 this dialect compares relation keys by value"
+    });
+  }
+  if (join.columns.length === 0 || join.columns.length !== join.members.length) {
+    throw internalError2({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+  }
+  if (join.rows.length === 0)
+    throw internalError2({ message: "key table needs at least one key row" });
+  for (const member of join.members) {
+    if (member.kind === "decimal" && !(Number.isInteger(member.scale) && member.scale >= 0 && member.scale <= 30)) {
+      throw internalError2({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+    }
+  }
+  const alias = dialect.quoteIdent({ name: join.alias });
+  const memberNames = join.members.map((_, index) => dialect.quoteIdent({ name: `__vibe_k${index}` }));
+  const rows = join.rows.map((row, ordinal) => {
+    if (row.length !== join.members.length) {
+      throw internalError2({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+    }
+    const cells = row.map((value, index) => {
+      const placeholder = collector.add(value);
+      const member = join.members[index];
+      switch (member.kind) {
+        case "integer":
+          return dialect.name === "mysql" ? `CAST(${placeholder} AS SIGNED)` : `CAST(${placeholder} AS bigint)`;
+        case "decimal":
+          return `CAST(${placeholder} AS DECIMAL(65,${member.scale}))`;
+        case "citext":
+          return `CAST(${placeholder} AS citext)`;
+        case "text":
+          return `CAST(${placeholder} AS text)`;
+        default:
+          return placeholder;
+      }
+    });
+    return dialect.name === "mysql" ? `ROW(${cells.join(", ")}, ${ordinal})` : `(${cells.join(", ")}, ${ordinal})`;
+  });
+  const on = join.columns.map((column, index) => `${quoteCol(dialect, column)} = ${alias}.${memberNames[index]}`).join(" AND ");
+  return `INNER JOIN (VALUES ${rows.join(", ")}) AS ${alias} (${[...memberNames, dialect.quoteIdent({ name: join.ordinalAlias })].join(", ")}) ON ${on}`;
+}
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
@@ -2615,6 +2989,11 @@ function renderSelect(params) {
       columnList.push(`${renderAggRef(dialect, selection.agg)} AS ${dialect.quoteIdent({ name: selection.alias })}`);
     }
   }
+  if (statement.countSubqueries !== undefined) {
+    for (const subquery of statement.countSubqueries) {
+      columnList.push(renderCountSubquery({ dialect, subquery, collector }));
+    }
+  }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0) {
@@ -2633,7 +3012,7 @@ function renderSelect(params) {
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
       });
     }
-    distinctPrefix = `DISTINCT ON (${statement.distinctOn.map((column) => quoteCol(dialect, column)).join(", ")}) `;
+    distinctPrefix = `DISTINCT ON (${statement.distinctOn.map((column) => quoteCol(dialect, typedOrderRef({ statement, column }))).join(", ")}) `;
   }
   const columns = columnList.length === 0 ? "*" : columnList.join(", ");
   let from;
@@ -2656,6 +3035,9 @@ function renderSelect(params) {
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
     }
   }
+  if (statement.keyTable !== undefined) {
+    text += ` ${renderKeyTableJoin({ dialect, join: statement.keyTable, collector })}`;
+  }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
       throw unsupportedCapability15({
@@ -2678,7 +3060,7 @@ function renderSelect(params) {
     text += ` HAVING ${renderExpr({ dialect, expr: statement.having, collector })}`;
   }
   if (statement.orderBy !== undefined && statement.orderBy.length > 0) {
-    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term, collector }));
+    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term: "column" in term ? { ...term, column: typedOrderRef({ statement, column: term.column }) } : term, collector }));
     text += ` ORDER BY ${terms.join(", ")}`;
   }
   if (statement.limit !== undefined) {
@@ -2720,7 +3102,7 @@ function renderInsert(params) {
   const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const rowsSql = statement.rows.map((row) => `(${row.map((value) => {
     if (isJsonParamCell(value))
-      return `${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     if (isDbNowMarker(value)) {
       return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
     }
@@ -2852,7 +3234,7 @@ function renderAssignments(params) {
       return `${column} = ${renderIncomingRowColumn({ dialect, column: value.column })}`;
     }
     if (isJsonParamCell(value)) {
-      return `${column} = ${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${column} = ${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     }
     if (isSetOperation(value)) {
       const operand = collector.add(value.value);
@@ -2881,6 +3263,172 @@ function renderDelete(params) {
   const returning = applyReturning({ dialect, requested: statement.returning });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
+var CHAIN_ROWS_ALIAS = "__vibe_rows";
+var CHAIN_ONE_ALIAS = "__vibe_one";
+function renderChain(params) {
+  const { dialect, statement, collector } = params;
+  if (dialect.statementChain === null) {
+    throw unsupportedCapability15({
+      dialect: dialect.name,
+      feature: "a statement chain (data-modifying WITH steps)",
+      hint: "this dialect accepts only SELECT inside WITH \u2014 gate on SqlDialect.statementChain and keep the multi-statement path"
+    });
+  }
+  if (statement.steps.length === 0)
+    throw internalError2({ message: "a statement chain needs at least one step" });
+  const defined = new Set;
+  const steps = [];
+  for (const step of statement.steps) {
+    if (step.name === CHAIN_ROWS_ALIAS || step.name === CHAIN_ONE_ALIAS || defined.has(step.name)) {
+      throw internalError2({ message: `chain step name "${step.name}" is reserved or repeated` });
+    }
+    const body = renderChainStep({ dialect, statement: step.statement, collector, earlier: defined });
+    steps.push(`${dialect.quoteIdent({ name: step.name })} AS (${body})`);
+    defined.add(step.name);
+  }
+  const result = statement.result;
+  if (result.rowsFrom.length === 0 || result.columns.length === 0) {
+    throw internalError2({ message: "a chain result needs at least one source step and one column" });
+  }
+  for (const name of result.rowsFrom) {
+    if (!defined.has(name))
+      throw internalError2({ message: `chain result reads undefined step "${name}"` });
+  }
+  const columnList = result.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const union = result.rowsFrom.map((name) => `SELECT ${columnList} FROM ${dialect.quoteIdent({ name })}`).join(" UNION ALL ");
+  let select = union;
+  if (result.verdict !== undefined || result.tally !== undefined || result.veto !== undefined && result.veto.length > 0) {
+    const extra = [];
+    for (const alias of [result.verdict?.alias, result.tally?.alias]) {
+      if (alias !== undefined && result.columns.includes(alias)) {
+        throw internalError2({ message: `chain result alias "${alias}" collides with a result column` });
+      }
+    }
+    const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
+    const projected = result.columns.map((name) => `${rows}.${dialect.quoteIdent({ name })}`);
+    if (result.verdict !== undefined) {
+      extra.push(`${renderExpr({ dialect, expr: result.verdict.expr, collector })} AS ${dialect.quoteIdent({ name: result.verdict.alias })}`);
+    }
+    if (result.tally !== undefined || result.veto !== undefined && result.veto.length > 0) {
+      extra.push(renderTallyColumn({ dialect, result, defined, collector }));
+    }
+    select = `SELECT ${[...projected, ...extra].join(", ")} FROM (SELECT 1) AS ${dialect.quoteIdent({ name: CHAIN_ONE_ALIAS })}` + ` LEFT JOIN (${union}) AS ${rows} ON TRUE`;
+  }
+  return { text: `WITH ${steps.join(", ")} ${select}`, values: collector.values, returning: "none" };
+}
+function renderChainStep(params) {
+  const { dialect, statement, collector } = params;
+  switch (statement.kind) {
+    case "select":
+      return renderSelect({ dialect, statement, collector }).text;
+    case "insert":
+      return renderInsert({ dialect, statement, collector }).text;
+    case "insertSelect":
+      return renderInsertSelect({ dialect, statement, collector, earlier: params.earlier });
+    case "update":
+      return renderUpdate({ dialect, statement, collector }).text;
+    case "delete":
+      return renderDelete({ dialect, statement, collector }).text;
+  }
+}
+function renderSelectCell(params) {
+  const { dialect, value, collector } = params;
+  if (isJsonParamCell(value))
+    return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
+  if (isDbNowMarker(value))
+    return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
+  if (isSqlDefaultCell(value)) {
+    throw internalError2({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
+  }
+  return collector.add(value);
+}
+function renderRowSource(params) {
+  const { dialect, source, collector } = params;
+  if (source.columns.length === 0 || source.rows.length === 0) {
+    throw internalError2({ message: "a row source needs at least one column and one row" });
+  }
+  const typedBy = renderTable(dialect, source.typedBy);
+  const columns = source.columns.map((name) => dialect.quoteIdent({ name }));
+  const rows = [`(${columns.map((column) => `(SELECT ${column} FROM ${typedBy} WHERE FALSE)`).join(", ")})`];
+  for (const row of source.rows) {
+    if (row.length !== source.columns.length) {
+      throw internalError2({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
+    }
+    rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
+  }
+  const alias = dialect.quoteIdent({ name: source.alias });
+  const columnList = columns.join(", ");
+  return `(SELECT ${columnList} FROM (VALUES ${rows.join(", ")}) AS ${alias} (${columnList}) OFFSET 1) AS ${alias}`;
+}
+function renderTallyColumn(params) {
+  const { dialect, result, defined, collector } = params;
+  const tally = result.tally;
+  if (tally === undefined)
+    throw internalError2({ message: "a chain veto needs a tally column to guard" });
+  if (tally.steps.length === 0)
+    throw internalError2({ message: "a chain tally needs at least one step" });
+  const step = (name) => {
+    if (!defined.has(name))
+      throw internalError2({ message: `chain tally or veto reads undefined step "${name}"` });
+    return dialect.quoteIdent({ name });
+  };
+  const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
+  const sum = tally.steps.map(count).join(" + ");
+  const vetoes = result.veto ?? [];
+  if (vetoes.length === 0)
+    return `${sum} AS ${dialect.quoteIdent({ name: tally.alias })}`;
+  const arms = vetoes.map((veto) => {
+    if (!CHAIN_VETO_TOKEN_PATTERN.test(veto.token))
+      throw internalError2({ message: `chain veto token "${veto.token}" is not a lower-case word` });
+    if (typeof veto.nonce !== "string" || veto.nonce === "")
+      throw internalError2({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
+    const minRows = veto.minRows ?? 1;
+    if (!Number.isSafeInteger(minRows) || minRows < 1)
+      throw internalError2({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
+    const when = minRows === 1 ? `WHEN NOT EXISTS (SELECT 1 FROM ${step(veto.step)})` : `WHEN ${count(veto.step)} < ${minRows}`;
+    return `${when} THEN CAST('${CHAIN_VETO_PREFIX}${veto.token}:' || ${collector.add(veto.nonce)} || ':' || ${count(veto.step)} AS integer)`;
+  });
+  return `CASE ${arms.join(" ")} ELSE ${sum} END AS ${dialect.quoteIdent({ name: tally.alias })}`;
+}
+function renderInsertSelect(params) {
+  const { dialect, statement, collector } = params;
+  if (statement.columns.length === 0)
+    throw internalError2({ message: "insert requires at least one column" });
+  if (statement.cells.length !== statement.columns.length) {
+    throw internalError2({
+      message: `insert row has ${statement.cells.length} values but ${statement.columns.length} columns`
+    });
+  }
+  const from = statement.from ?? [];
+  for (const name of from) {
+    if (!params.earlier.has(name))
+      throw internalError2({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
+  }
+  const source = statement.source;
+  if (source !== undefined && (params.earlier.has(source.alias) || from.includes(source.alias))) {
+    throw internalError2({ message: `row source alias "${source.alias}" collides with a chain step` });
+  }
+  const cells = statement.cells.map((value) => {
+    if (isStepColumnRef(value)) {
+      if (!from.includes(value.step) && value.step !== source?.alias) {
+        throw internalError2({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
+      }
+      return `${dialect.quoteIdent({ name: value.step })}.${dialect.quoteIdent({ name: value.column })}`;
+    }
+    return renderSelectCell({ dialect, value, collector });
+  });
+  const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+  let text = `INSERT INTO ${renderTable(dialect, statement.table)} (${columnList}) SELECT ${cells.join(", ")}`;
+  const relations = from.map((name) => dialect.quoteIdent({ name }));
+  if (source !== undefined)
+    relations.push(renderRowSource({ dialect, source, collector }));
+  if (relations.length > 0)
+    text += ` FROM ${relations.join(" CROSS JOIN ")}`;
+  if (statement.where !== undefined) {
+    text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
+  }
+  return text + applyReturning({ dialect, requested: statement.returning }).suffix;
+}
 // packages/sql/src/dialects/postgres-type-identity.ts
 import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
 var IDENTIFIER = '(?:"(?:[^"\\x00]|"")+"|[a-zA-Z_][a-zA-Z_0-9$]*)';
@@ -3410,6 +3958,8 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
 export {
   ADVISORY_KEY_BOUNDS,
   ADVISORY_LOCK_RESULT_COLUMN,
+  CHAIN_VETO_PREFIX,
+  CHAIN_VETO_TOKEN_PATTERN,
   DIALECT_CAPABILITIES,
   DIALECT_CODECS,
   JSON_TRANSPORT,
@@ -3431,6 +3981,7 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  chainVetoToken,
   compileExclusion,
   compileSql,
   containsPattern,
@@ -3443,23 +3994,29 @@ export {
   escapeGlobPattern,
   escapeLikePattern,
   excludedRef,
+  float32Codec,
   getSqlDialect,
   isDbNowMarker,
   isExcludedRef,
   isFixedDiagnostic,
+  isJsonListParameter,
   isJsonParamCell,
   isListSetOperation,
   isNativeEnumArrayParameter,
   isSetOperation,
   isSqlDefaultCell,
   isSqlFragment,
+  isStepColumnRef,
+  jsonListParameter,
   jsonParamCell,
   mapConflictColumns,
   mysqlDialect,
   nativeEnumArrayParameter,
   parseDateTimeText,
   parsePgArrayLiteral,
+  parsePgArrayLiteralNested,
   parsePostgresTypeName,
+  postgresArrayElementFromText,
   postgresDialect,
   projectionOutputName,
   renderAdvisoryLock,
@@ -3501,6 +4058,7 @@ export {
   renderPostgresTypeName,
   renderPostgresWorkload,
   renderPredicate,
+  renderProjection,
   renderRelationStateQuery,
   renderReplayCoverageGaps,
   renderRlsColumnType,
@@ -3521,17 +4079,23 @@ export {
   renderSqlFragment,
   renderSqliteColumnInventory,
   renderSqliteForeignKeyInventory,
+  renderSqliteFtsUpdateTrigger,
   renderSqliteRebuildObjects,
   renderStatement,
+  returningColumnName,
+  shortestFloat32,
   sql,
   sqlUsesIncoming,
   sqliteColumnClauses,
   sqliteDialect,
+  sqliteFtsUpdateUpgrade,
   sqliteTableConstraints,
   startsWithPattern,
+  stepColumnRef,
   strictMatchPattern,
   tableDefinitionParts,
+  timeOfDayCodec,
   toPgArrayLiteral
 };
 
-//# debugId=55E18657169AA23764756E2164756E21
+//# debugId=67799F9417158D9264756E2164756E21