@vibeorm/sql 4.2.0 → 4.3.0

package/dist/index.js

@@ -1,16 +1,27 @@
 // @bun
 // packages/sql/src/timestamp-identity.ts
 var identities = new WeakMap;
+function canonicalKey(params) {
+  const fraction = /\.(\d+)/.exec(params.text)?.[1] ?? "";
+  const remainder = fraction.slice(3).replace(/0+$/, "");
+  const canonical = Date.prototype.toISOString.call(new Date(params.milliseconds)).replace(/(\.\d{3})Z$/, `$1${remainder}Z`);
+  return `date:${canonical}`;
+}
+function identityKey(identity) {
+  if (identity.key === undefined)
+    identity.key = canonicalKey({ milliseconds: identity.milliseconds, text: identity.text });
+  return identity.key;
+}
 function rememberTimestampIdentity(params) {
   const { date, text } = params;
-  const fraction = /\.(\d+)/.exec(text)?.[1] ?? "";
-  const remainder = fraction.slice(3).replace(/0+$/, "");
-  const canonical = Date.prototype.toISOString.call(date).replace(/(\.\d{3})Z$/, `$1${remainder}Z`);
+  const milliseconds = Date.prototype.getTime.call(date);
+  if (!Number.isFinite(milliseconds))
+    Date.prototype.toISOString.call(date);
   identities.set(date, {
-    milliseconds: Date.prototype.getTime.call(date),
+    milliseconds,
     text,
-    ...params.numeric === undefined ? {} : { numeric: params.numeric },
-    key: params.key ?? `date:${canonical}`,
+    numeric: params.numeric,
+    key: params.key,
     kind: params.kind ?? "timestamp"
   });
   return date;
@@ -24,7 +35,8 @@ function identityOf(params) {
   return stored;
 }
 function timestampIdentityKey(params) {
-  return identityOf(params)?.key ?? `date:${Number.isFinite(Date.prototype.getTime.call(params.date)) ? Date.prototype.toISOString.call(params.date) : "invalid"}`;
+  const identity = identityOf(params);
+  return identity !== undefined ? identityKey(identity) : `date:${Number.isFinite(Date.prototype.getTime.call(params.date)) ? Date.prototype.toISOString.call(params.date) : "invalid"}`;
 }
 function timestampIdentityText(params) {
   const identity = identityOf(params);
@@ -44,7 +56,7 @@ function compareTimestampDates(params) {
     return left?.numeric !== undefined && right?.numeric !== undefined ? rank(left.numeric, right.numeric) : null;
   }
   const clock = (identity) => {
-    const [, hours, minutes, seconds, offset] = identity.key.split(":");
+    const [, hours, minutes, seconds, offset] = identityKey(identity).split(":");
     const [whole, fraction = ""] = seconds.split(".");
     const local = BigInt(Number(hours) * 3600 + Number(minutes) * 60 + Number(whole)) * 1000000000n + BigInt(fraction.padEnd(9, "0"));
     const zone = Number(offset);
@@ -142,39 +154,43 @@ function toPgArrayLiteral(params) {
 }
 function parsePgArrayLiteral(params) {
   const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
-  if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
+  if (literal.length < 2 || literal.charCodeAt(0) !== 123 || literal.charCodeAt(literal.length - 1) !== 125)
     return null;
-  const inner = literal.slice(1, -1);
-  if (inner.length === 0)
+  const end = literal.length - 1;
+  if (end === 1)
     return [];
   const out = [];
-  let index = 0;
-  while (index < inner.length) {
-    if (inner[index] === '"') {
+  let index = 1;
+  while (index < end) {
+    if (literal.charCodeAt(index) === 34) {
       let text = "";
       index++;
-      while (index < inner.length) {
-        const char = inner[index];
-        if (char === "\\") {
-          text += inner[index + 1] ?? "";
+      let run = index;
+      while (index < end) {
+        const code = literal.charCodeAt(index);
+        if (code === 92) {
+          text += literal.slice(run, index) + (index + 1 < end ? literal[index + 1] : "");
           index += 2;
+          run = index;
           continue;
         }
-        index++;
-        if (char === '"')
+        if (code === 34)
           break;
-        text += char;
+        index++;
       }
+      text += literal.slice(run, Math.min(index, end));
+      if (index < end)
+        index++;
       out.push(text);
     } else {
-      let text = "";
-      while (index < inner.length && inner[index] !== ",") {
-        text += inner[index];
-        index++;
-      }
+      let stop = literal.indexOf(",", index);
+      if (stop === -1 || stop > end)
+        stop = end;
+      const text = literal.slice(index, stop);
       out.push(text === "NULL" ? null : text);
+      index = stop;
     }
-    if (inner[index] === ",")
+    if (literal.charCodeAt(index) === 44)
       index++;
   }
   return out;
@@ -235,7 +251,7 @@ function parseDimension(params) {
 }
 
 // packages/sql/src/codecs.ts
-import { VibeError, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
+import { VibeError, invalidStoredData, isCanonicalLocalDate, timeOfDayType } from "@vibeorm/schema";
 function enumMembershipCodec(params) {
   const { model, field, enum: enumName } = params;
   const members = new Set(params.members);
@@ -303,20 +319,33 @@ 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();
+  const date = parseDateTimeInstant({ trimmed });
+  return date === undefined ? undefined : rememberTimestampIdentity({ date, text: trimmed });
+}
+function parseDateTimeInstant(params) {
+  const { trimmed } = params;
+  const length = trimmed.length;
+  if (length > 0 && trimmed.charCodeAt(length - 1) === 90 || (length === 25 || length === 29 && trimmed.charCodeAt(19) === 46) && trimmed.charCodeAt(10) === 84 && trimmed.charCodeAt(length - 3) === 58 && (trimmed.charCodeAt(length - 6) === 43 || trimmed.charCodeAt(length - 6) === 45)) {
+    const parsed = new Date(trimmed);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+  }
   if (ZONE_LESS_DATETIME.test(trimmed)) {
     const asUtc = new Date(`${trimmed.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z`);
     if (!Number.isNaN(asUtc.getTime()))
-      return rememberTimestampIdentity({ date: asUtc, text: trimmed });
+      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 rememberTimestampIdentity({ date: iso, text: trimmed });
+      return iso;
   }
   const parsed = new Date(trimmed);
-  return Number.isNaN(parsed.getTime()) ? undefined : rememberTimestampIdentity({ date: parsed, text: trimmed });
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function invalidDecodedDateTime() {
+  throw new VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
 }
 var dateNativeCodec = {
   encode: (value) => {
@@ -329,7 +358,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 VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+    return invalidDecodedDateTime();
   }
 };
 var dateTextCodec = {
@@ -341,10 +370,16 @@ var dateTextCodec = {
     throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
   },
   decode: (value) => {
+    if (typeof value === "string") {
+      const date = parseDateTimeInstant({ trimmed: value.trim() });
+      if (date === undefined || !Number.isFinite(date.getTime()))
+        return invalidDecodedDateTime();
+      return rememberTimestampIdentity({ date, text: value, key: `date:${value}`, kind: "sqlite" });
+    }
     const date = dateNativeCodec.decode(value);
     if (typeof value === "number")
       return rememberTimestampIdentity({ date, text: date.toISOString(), numeric: value, key: `epoch:${value}`, kind: "sqlite" });
-    return typeof value === "string" ? rememberTimestampIdentity({ date, text: value, key: `date:${value}`, kind: "sqlite" }) : date;
+    return date;
   }
 };
 var mysqlDateCodec = {
@@ -416,6 +451,28 @@ function timeOfDayCodec(params) {
   const type = timeOfDayType({ nativeType: params.nativeType });
   return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
 }
+var localDateCodec = Object.freeze({
+  encode: (value) => {
+    const candidate = { value };
+    if (isCanonicalLocalDate(candidate))
+      return candidate.value;
+    throw new VibeError({
+      code: "VIBE_VALIDATION",
+      message: "A local date requires canonical YYYY-MM-DD text for a real date in years 0001\u20139999",
+      meta: { value }
+    });
+  },
+  decode: (value) => {
+    const candidate = { value };
+    if (isCanonicalLocalDate(candidate))
+      return candidate.value;
+    throw new VibeError({
+      code: "VIBE_DATA_INVALID",
+      message: "A local-date column returned noncanonical or out-of-domain calendar-day text",
+      meta: { value }
+    });
+  }
+});
 var booleanIntCodec = {
   encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
   decode: (value) => typeof value === "number" ? value !== 0 : value
@@ -1096,7 +1153,7 @@ function renderPostgresPhysicalCatalog(params) {
       text = `SELECT table_name FROM information_schema.views WHERE table_schema = ${namespace} AND ${extensionOwnedFilter} ORDER BY table_name`;
       break;
     case "columns":
-      text = `SELECT table_name, column_name, data_type, udt_name, udt_schema, is_nullable, is_identity, is_generated, collation_name, column_default, datetime_precision, character_maximum_length, numeric_precision, numeric_scale, ordinal_position, (SELECT format_type(a.atttypid, a.atttypmod) FROM pg_attribute a JOIN pg_class c ON c.oid = a.attrelid JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND c.relname = columns.table_name AND a.attname = columns.column_name) AS full_type FROM information_schema.columns AS columns WHERE table_schema = ${namespace} ORDER BY table_name, ordinal_position`;
+      text = `SELECT table_name, column_name, data_type, udt_name, udt_schema, is_nullable, is_identity, is_generated, collation_name, column_default, datetime_precision, character_maximum_length, numeric_precision, numeric_scale, ordinal_position, catalog.full_type, catalog.generated_kind, catalog.generation_expression FROM information_schema.columns AS columns LEFT JOIN LATERAL (SELECT pg_catalog.format_type(a.atttypid, a.atttypmod) AS full_type, a.attgenerated::text AS generated_kind, CASE WHEN a.attgenerated <> '' THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid, false) ELSE NULL END AS generation_expression FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_class c ON c.oid = a.attrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum WHERE n.nspname = ${namespace} AND c.relname = columns.table_name AND a.attname = columns.column_name AND a.attnum > 0 AND NOT a.attisdropped) catalog ON true WHERE table_schema = ${namespace} ORDER BY table_name, ordinal_position`;
       break;
     case "constraints":
       text = `SELECT c.conname AS constraint_name, CASE c.contype WHEN 'p' THEN 'PRIMARY KEY' ELSE 'UNIQUE' END AS constraint_type, cl.relname AS table_name, att.attname AS column_name 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 unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord) ON true JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = k.attnum WHERE c.contype IN ('p', 'u') AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname, k.ord`;
@@ -1118,15 +1175,28 @@ function renderPostgresPhysicalCatalog(params) {
 }
 // packages/sql/src/dialects/postgres-index-keys.ts
 import { unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+function renderPostgresJitSuspend(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "indexOperatorClasses" });
+  return { text: "SELECT setting.previous, pg_catalog.set_config('jit', 'off', true) AS current FROM (SELECT pg_catalog.current_setting('jit') AS previous OFFSET 0) setting", values: [], returning: "none" };
+}
+function renderPostgresJitRestore(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "indexOperatorClasses" });
+  const collector = new ParamCollector(params.dialect);
+  return { text: `SELECT pg_catalog.set_config('jit', ${collector.add(params.previous)}, true) AS current`, values: collector.values, returning: "none" };
+}
 function renderPostgresIndexKeys(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
     throw unsupportedCapability6({ dialect: dialect.name, feature: "indexOperatorClasses" });
   const collector = new ParamCollector(dialect);
-  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`;
+  const scope = params.table !== undefined ? `${params.expressionMetadata && params.table.namespace === "pg_temp" ? "n.oid = pg_catalog.pg_my_temp_schema()" : `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 = ${params.expressionMetadata ? "key_attribute.atttypid" : "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`;
+  const expressionColumns = params.expressionMetadata ? `, CASE WHEN k.attnum = 0 THEN pg_catalog.pg_get_indexdef(i.indexrelid, k.ordinality::integer, false) ELSE NULL END AS expression, pg_catalog.pg_get_indexdef(i.indexrelid, 0, false) AS index_definition, pg_catalog.format_type(key_attribute.atttypid, key_attribute.atttypmod) AS result_type, (i.indoption[k.ordinality - 1] & 2) <> 0 AS nulls_first, ((i.indoption[k.ordinality - 1] & 2) <> 0) = ((i.indoption[k.ordinality - 1] & 1) <> 0) AS default_null_order, i.indcollation[k.ordinality - 1] AS collation_oid, CASE WHEN k.attnum = 0 THEN NULL ELSE i.indcollation[k.ordinality - 1] = a.attcollation END AS default_collation, i.indisvalid AS valid, i.indisready AS ready, i.indimmediate AS immediate, i.indnkeyatts AS key_count, i.indnatts AS attribute_count` : "";
+  const expressionJoins = params.expressionMetadata ? ` JOIN pg_catalog.pg_attribute key_attribute ON key_attribute.attrelid = idx.oid AND key_attribute.attnum = k.ordinality` : "";
   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`,
+    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${expressionColumns} 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${expressionJoins} 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`,
     values: collector.values,
     returning: "none"
   };
@@ -1149,159 +1219,1078 @@ function renderIndexColumns(params) {
     return `${dialect.quoteIdent({ name: column.name })}${ops}${column.desc ? " DESC" : ""}`;
   });
 }
-// packages/sql/src/dialects/module-dependency.ts
-function renderModuleDependencyQuery(params) {
-  const { dialect, operation } = params;
-  if (operation.kind === "visibility")
-    return dialect.name === "mysql" ? { text: "SHOW GRANTS FOR CURRENT_USER", values: [], returning: "none" } : undefined;
-  if (dialect.name === "sqlite" || operation.tables.length === 0)
-    return;
-  const collector = new ParamCollector(dialect);
-  const owned = operation.tables.map((table, index) => `SELECT ${collector.add(operation.namespace)}${index === 0 ? " AS namespace" : ""}, ${collector.add(table)}${index === 0 ? " AS table_name" : ""}`).join(" UNION ALL ");
-  const pg = dialect.name === "postgres";
-  const nameKey = ({ column }) => pg ? column : `CAST(IF(@@lower_case_table_names = 0, ${column}, LOWER(${column})) AS BINARY)`;
-  const isOwned = ({ namespace, table }) => `EXISTS (SELECT 1 FROM owned_tables o WHERE ${nameKey({ column: namespace })} = ${nameKey({ column: "o.namespace" })} AND ${nameKey({ column: table })} = ${nameKey({ column: "o.table_name" })})`;
-  const sourceNamespace = pg ? "sn.nspname" : "fk.CONSTRAINT_SCHEMA";
-  const sourceTable = pg ? "s.relname" : "fk.TABLE_NAME";
-  const targetNamespace = pg ? "tn.nspname" : "fk.UNIQUE_CONSTRAINT_SCHEMA";
-  const targetTable = pg ? "t.relname" : "fk.REFERENCED_TABLE_NAME";
-  const from = pg ? "pg_catalog.pg_constraint fk JOIN pg_catalog.pg_class s ON s.oid = fk.conrelid JOIN pg_catalog.pg_namespace sn ON sn.oid = s.relnamespace JOIN pg_catalog.pg_class t ON t.oid = fk.confrelid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.relnamespace WHERE fk.contype = 'f'" : "information_schema.REFERENTIAL_CONSTRAINTS fk";
-  return {
-    text: `WITH owned_tables AS (${owned})
-SELECT * FROM (SELECT ${pg ? "fk.conname" : "fk.CONSTRAINT_NAME"} AS constraint_name, ${sourceNamespace} AS source_namespace, ${sourceTable} AS source_table, ${targetNamespace} AS target_namespace, ${targetTable} AS target_table, ${isOwned({ namespace: sourceNamespace, table: sourceTable })} AS source_owned, ${isOwned({ namespace: targetNamespace, table: targetTable })} AS target_owned FROM ${from}) dependencies
-WHERE source_owned OR target_owned
-ORDER BY source_namespace, source_table, constraint_name`,
-    values: collector.values,
-    returning: "none"
+// packages/sql/src/index-expressions.ts
+import { VibeError as VibeError11, indexKeyDefinitionKey, indexKeyTerms, isExpressionIndex, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+
+// packages/sql/src/predicate.ts
+import { VibeError as VibeError7, assertPredicateCapabilities, fieldTypeIdentity, isCanonicalLocalDate as isCanonicalLocalDate2, isEnumType, isLocalDateField, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+function renderPredicate(params) {
+  assertPredicateCapabilities({ predicate: params.predicate, dialect: params.dialect.name, usage: params.usage, model: params.model });
+  if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
+    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+  if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
+    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "partialIndexes" });
+  }
+  const context = {
+    model: params.model,
+    dialect: params.dialect,
+    enums: params.enums ?? [],
+    usage: params.usage,
+    site: params.site
   };
+  return renderNode({ node: params.predicate, context });
 }
-// packages/sql/src/dialects/migration-replay-coverage.ts
-var extensionMember = (classid, objid) => `EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = '${classid}'::regclass AND d.objid = ${objid} AND d.deptype = 'e')`;
-var extensionOwnedNamespace = `(EXISTS (SELECT 1 FROM pg_catalog.pg_extension e WHERE e.extnamespace = n.oid) OR ${extensionMember("pg_namespace", "n.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.relnamespace = n.oid AND c.relkind IN ('r', 'p', 'v', 'm', 'f', 'S') AND NOT ${extensionMember("pg_class", "c.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_proc p WHERE p.pronamespace = n.oid AND NOT ${extensionMember("pg_proc", "p.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_type t WHERE t.typnamespace = n.oid AND (t.typrelid = 0 AND t.typelem = 0 OR t.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c')) AND NOT ${extensionMember("pg_type", "t.oid")})`;
-function renderReplayCoverageGaps(params) {
-  const { dialect } = params;
-  const collector = new ParamCollector(dialect);
-  const namespace = collector.add(params.namespace);
-  if (dialect.name === "postgres")
-    return { text: `SELECT 'type' AS kind, t.typname::text AS name, n.nspname::text AS namespace, NULL::text AS parent FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND (t.typtype IN ('b', 'd', 'r', 'm') AND t.typelem = 0 OR t.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c')) 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')
-UNION ALL SELECT 'routine', p.proname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.prokind <> 'f' AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_proc'::regclass AND d.objid = p.oid AND d.deptype = 'e')
-UNION ALL SELECT 'relation-layout', c.relname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND (c.relkind IN ('p', 'f') OR c.relispartition OR EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid)) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'e')
-UNION ALL SELECT 'rule', r.rulename::text, n.nspname::text, c.relname::text FROM pg_catalog.pg_rewrite r JOIN pg_catalog.pg_class c ON c.oid = r.ev_class JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND r.rulename <> '_RETURN' AND NOT ${extensionMember("pg_class", "c.oid")}
-UNION ALL SELECT 'namespace', n.nspname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_namespace n WHERE n.nspname <> ${namespace} AND n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND NOT (${extensionOwnedNamespace})${params.privateNamespace === undefined ? "" : ` AND n.nspname <> ${collector.add(params.privateNamespace)}`}`, values: collector.values, returning: "none" };
-  if (dialect.name === "mysql")
-    return { text: `SELECT 'procedure' AS kind, ROUTINE_NAME AS name, ROUTINE_SCHEMA AS namespace, NULL AS parent FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_TYPE = 'PROCEDURE'
-UNION ALL SELECT 'event', EVENT_NAME, EVENT_SCHEMA, NULL FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ${collector.add(params.namespace)}
-UNION ALL SELECT DISTINCT 'partition', TABLE_NAME, TABLE_SCHEMA, NULL FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = ${collector.add(params.namespace)} AND PARTITION_NAME IS NOT NULL`, values: collector.values, returning: "none" };
-  return { text: `SELECT 'table-options' AS kind, name, schema AS namespace, NULL AS parent FROM pragma_table_list WHERE schema = ${namespace} AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND (type = 'virtual' OR wr <> 0 OR strict <> 0)`, values: collector.values, returning: "none" };
+function renderSchemaExpression({ expression, model, dialect, enums = [], usage, site }) {
+  assertPredicateCapabilities({ expression, dialect: dialect.name, usage, model });
+  const context = { model, dialect, enums, usage, site };
+  const { text, resultType } = renderExpression({ expression, context });
+  return { text, resultType };
 }
-// packages/sql/src/dialects/migration-shadow.ts
-import { assertSqlNamespace, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
-var SHADOW_DATABASE = Object.freeze({ schema: "_vibeorm_shadow", table: "_vibe_shadow", lock: 1447645267, timeoutSeconds: 60 });
-var SHADOW_CAPABILITIES = Object.freeze({
-  postgres: Object.freeze({ serverProvisioning: true, dedicated: true }),
-  mysql: Object.freeze({ serverProvisioning: true, dedicated: true }),
-  sqlite: Object.freeze({ serverProvisioning: false, dedicated: false })
-});
-function renderShadowOperation(params) {
-  const { dialect, operation } = params;
-  if (!SHADOW_CAPABILITIES[dialect.name].serverProvisioning)
-    throw unsupportedCapability8({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
-  const pg = dialect.name === "postgres";
-  const collector = new ParamCollector(dialect);
-  const marker = pg ? `${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}.${dialect.quoteIdent({ name: SHADOW_DATABASE.table })}` : dialect.quoteIdent({ name: SHADOW_DATABASE.table });
-  const result = (text) => [{ text, values: collector.values, returning: "none" }];
-  switch (operation.kind) {
-    case "createDatabase":
-      return result(`CREATE DATABASE ${dialect.quoteIdent({ name: operation.name })}${pg ? " TEMPLATE template0" : ""}`);
-    case "dropDatabase":
-      return result(`DROP DATABASE ${dialect.quoteIdent({ name: operation.name })}`);
-    case "identity":
-      return result(pg ? `SELECT current_database()::text AS database, (SELECT oid::text FROM pg_catalog.pg_database WHERE datname = current_database()) AS database_id, current_schema()::text AS namespace` : `SELECT DATABASE() AS \`database\`, @@lower_case_table_names AS name_folding, @@server_uuid AS server_id`);
-    case "lock":
-      return result(pg ? `SELECT pg_catalog.pg_advisory_lock(${collector.add(SHADOW_DATABASE.lock)})` : `SELECT GET_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}, ${collector.add(SHADOW_DATABASE.timeoutSeconds)}) AS acquired`);
-    case "unlock":
-      return result(pg ? `SELECT pg_catalog.pg_advisory_unlock(${collector.add(SHADOW_DATABASE.lock)}) AS released` : `SELECT RELEASE_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}) AS released`);
-    case "markerExists":
-      return result(pg ? `SELECT c.relname AS name FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${collector.add(SHADOW_DATABASE.schema)} AND c.relname = ${collector.add(SHADOW_DATABASE.table)}` : `SELECT TABLE_NAME AS name FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)}`);
-    case "markerRead":
-      return result(`SELECT payload FROM ${marker}`);
-    case "markerColumns":
-      return result(`SELECT column_name AS name, data_type AS type, is_nullable AS nullable FROM information_schema.columns AS marker_column WHERE table_schema = ${pg ? collector.add(SHADOW_DATABASE.schema) : "DATABASE()"} AND table_name = ${collector.add(SHADOW_DATABASE.table)} AND ${pg ? `EXISTS (SELECT 1 FROM pg_catalog.pg_class r JOIN pg_catalog.pg_namespace n ON n.oid = r.relnamespace WHERE n.nspname = marker_column.table_schema AND r.relname = marker_column.table_name AND r.relkind = 'r' AND r.relpersistence = 'p' AND NOT r.relrowsecurity AND NOT r.relforcerowsecurity AND NOT r.relhasrules AND NOT r.relhastriggers AND NOT r.relispartition AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attrdef a WHERE a.adrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_constraint c WHERE c.conrelid = r.oid AND c.contype <> 'n') AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_index i WHERE i.indrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = r.oid OR i.inhparent = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attribute a WHERE a.attrelid = r.oid AND (a.attisdropped OR a.attidentity <> '' OR a.attgenerated <> '')))` : `EXISTS (SELECT 1 FROM information_schema.TABLES t WHERE t.TABLE_SCHEMA = marker_column.table_schema AND t.TABLE_NAME = marker_column.table_name AND t.TABLE_TYPE = 'BASE TABLE' AND t.ENGINE = 'InnoDB') AND NOT EXISTS (SELECT 1 FROM information_schema.COLUMNS c WHERE c.TABLE_SCHEMA = marker_column.table_schema AND c.TABLE_NAME = marker_column.table_name AND (c.COLUMN_DEFAULT IS NOT NULL OR c.EXTRA <> '')) AND NOT EXISTS (SELECT 1 FROM information_schema.TRIGGERS t WHERE t.EVENT_OBJECT_SCHEMA = DATABASE() AND t.EVENT_OBJECT_TABLE = ${collector.add(SHADOW_DATABASE.table)}) AND NOT EXISTS (SELECT 1 FROM information_schema.TABLE_CONSTRAINTS c WHERE c.TABLE_SCHEMA = DATABASE() AND c.TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)})`}
-ORDER BY ordinal_position`);
-    case "grants": {
-      if (pg)
-        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
-      return result("SHOW GRANTS FOR CURRENT_USER");
+var PRECEDENCE = {
+  or: 1,
+  and: 2,
+  not: 3,
+  compare: 4,
+  inList: 4,
+  isNull: 4,
+  isTrue: 4
+};
+var COMPARISON_SQL = {
+  eq: "=",
+  ne: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var EXACT_INTEGER = /^-?(0|[1-9]\d*)$/;
+var EXACT_DECIMAL = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+var INT32_MIN = -2147483648n;
+var INT32_MAX = 2147483647n;
+var INT64_MIN = -(2n ** 63n);
+var INT64_MAX = 2n ** 63n - 1n;
+function refuse2(params) {
+  const { context, rule, message } = params;
+  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 ?? {} }
+  });
+}
+function renderChild(params) {
+  const { node, parent, context } = params;
+  if ((node.kind === "and" || node.kind === "or") && node.operands.length === 1) {
+    return renderChild({ node: node.operands[0], parent, context });
+  }
+  const text = renderNode({ node, context });
+  return PRECEDENCE[node.kind] < PRECEDENCE[parent] ? `(${text})` : text;
+}
+function renderNode(params) {
+  const { node, context } = params;
+  switch (node.kind) {
+    case "and":
+    case "or": {
+      if (node.operands.length === 0) {
+        refuse2({
+          context,
+          rule: "predicate-empty",
+          message: `${node.kind === "and" ? "and()" : "or()"} has no operands \u2014 an empty boolean group has no honest SQL spelling`
+        });
+      }
+      if (node.operands.length === 1)
+        return renderNode({ node: node.operands[0], context });
+      const separator = node.kind === "and" ? " AND " : " OR ";
+      return node.operands.map((operand) => renderChild({ node: operand, parent: node.kind, context })).join(separator);
     }
-    case "markerCreate":
-      return pg ? [{ text: `CREATE SCHEMA ${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}`, values: [], returning: "none" }, { text: `CREATE TABLE ${marker} (payload text NOT NULL)`, values: [], returning: "none" }] : result(`CREATE TABLE ${marker} (payload LONGTEXT NOT NULL) ENGINE=InnoDB`);
-    case "markerWrite":
-      return result(operation.insert ? `INSERT INTO ${marker} (payload) VALUES (${collector.add(operation.value)})` : `UPDATE ${marker} SET payload = ${collector.add(operation.value)}`);
-    case "journal":
-      return result(`SELECT name, checksum, statement_index, error FROM ${dialect.quoteIdent({ name: "_vibe_migrations" })} ORDER BY name`);
-    case "inventory":
-      return result(pg ? `SELECT 'namespace' AS kind, nspname::text AS name, nspname::text AS namespace FROM pg_catalog.pg_namespace WHERE nspname NOT IN ('public', 'information_schema') AND nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
-UNION ALL SELECT 'relation', c.relname::text, n.nspname::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
-UNION ALL SELECT 'routine', p.proname::text, n.nspname::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
-UNION ALL SELECT 'type', t.typname::text, n.nspname::text FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND t.typrelid = 0 AND t.typelem = 0
-UNION ALL SELECT 'extension', e.extname::text, n.nspname::text FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE e.extname <> 'plpgsql'
-UNION ALL SELECT 'marker-dependency', d.objid::text, '${SHADOW_DATABASE.schema}' FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON d.classid = 'pg_class'::regclass AND d.objid = c.oid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}' AND d.deptype NOT IN ('i', 'a') AND d.refclassid <> 'pg_namespace'::regclass
-UNION ALL SELECT 'marker-trigger', t.tgname::text, n.nspname::text FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}'
-UNION ALL SELECT 'namespace-object', o.name::text, n.nspname::text FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_namespace n ON d.refclassid = 'pg_namespace'::regclass AND d.refobjid = n.oid CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.classid, d.objid, d.objsubid) o WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND d.classid NOT IN ('pg_class'::regclass, 'pg_proc'::regclass, 'pg_type'::regclass, 'pg_extension'::regclass)
-UNION ALL SELECT 'database-object', evtname::text, '' FROM pg_catalog.pg_event_trigger
-UNION ALL SELECT 'database-object', pubname::text, '' FROM pg_catalog.pg_publication
-UNION ALL SELECT 'database-object', subname::text, '' FROM pg_catalog.pg_subscription WHERE subdbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = current_database())
-UNION ALL SELECT 'database-object', srvname::text, '' FROM pg_catalog.pg_foreign_server
-UNION ALL SELECT 'database-object', fdwname::text, '' FROM pg_catalog.pg_foreign_data_wrapper
-UNION ALL SELECT 'database-object', c.oid::text, '' FROM pg_catalog.pg_cast c JOIN pg_catalog.pg_type s ON s.oid = c.castsource JOIN pg_catalog.pg_type t ON t.oid = c.casttarget LEFT JOIN pg_catalog.pg_proc p ON p.oid = c.castfunc WHERE s.typnamespace <> 'pg_catalog'::regnamespace OR t.typnamespace <> 'pg_catalog'::regnamespace OR p.pronamespace <> 'pg_catalog'::regnamespace` : `SELECT TABLE_TYPE AS kind, TABLE_NAME AS name, TABLE_SCHEMA AS namespace FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()
-UNION ALL SELECT ROUTINE_TYPE, ROUTINE_NAME, ROUTINE_SCHEMA FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = DATABASE()
-UNION ALL SELECT 'EVENT', EVENT_NAME, EVENT_SCHEMA FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE()
-UNION ALL SELECT 'TRIGGER', TRIGGER_NAME, TRIGGER_SCHEMA FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = DATABASE()
-UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME), CONSTRAINT_SCHEMA FROM information_schema.REFERENTIAL_CONSTRAINTS WHERE UNIQUE_CONSTRAINT_SCHEMA = DATABASE() AND CAST(CONSTRAINT_SCHEMA AS BINARY) <> CAST(DATABASE() AS BINARY)`);
-    case "resetPostgres":
-    case "resetDedicatedPostgres": {
-      if (!pg)
-        throw unsupportedCapability8({ dialect: dialect.name, feature: "postgresShadowReset" });
-      const owned = operation.kind === "resetDedicatedPostgres" ? operation.ownedNamespaces : [];
-      for (const namespace of owned)
-        assertSqlNamespace({ namespace, dialect: "postgres", allowPublic: false });
-      return [
-        ...owned.map((namespace) => ({ text: `DROP SCHEMA IF EXISTS ${dialect.quoteIdent({ name: namespace })} CASCADE`, values: [], returning: "none" })),
-        { text: 'DROP SCHEMA "public" CASCADE', values: [], returning: "none" },
-        { text: 'CREATE SCHEMA "public"', values: [], returning: "none" }
-      ];
+    case "not":
+      return `NOT ${renderChild({ node: node.operand, parent: "not", context })}`;
+    case "isTrue":
+      return `COALESCE(${renderNode({ node: node.operand, context })}, FALSE)`;
+    case "isNull": {
+      const field = resolveField({ name: node.field.name, context, nullTest: true });
+      return `${quoteColumn({ field, context })} IS ${node.negate === true ? "NOT NULL" : "NULL"}`;
     }
-    case "mysqlForeignKeys": {
-      if (pg)
-        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
-      return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
+    case "compare": {
+      const left = renderExpression({ expression: node.left, context });
+      const right = renderOperand({ operand: node.right, left, context });
+      return `${left.text} ${COMPARISON_SQL[node.op]} ${right}`;
     }
-    case "dropMysqlObject": {
-      if (pg)
-        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
-      return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
+    case "inList": {
+      if (node.values.length === 0) {
+        refuse2({
+          context,
+          rule: "predicate-empty",
+          message: `inList("${node.field.name}") has no values \u2014 an empty IN list is UNKNOWN on every row and never what an author means`,
+          meta: { field: node.field.name }
+        });
+      }
+      const field = resolveField({ name: node.field.name, context });
+      const values = node.values.map((value) => renderLiteral({ value, resultType: fieldResultType({ field, context }), fieldName: field.name, context })).join(", ");
+      return `${compareColumn({ field, context })} ${node.negate === true ? "NOT IN" : "IN"} (${values})`;
     }
   }
 }
-// packages/sql/src/module-journal.ts
-var MODULE_JOURNAL_COLUMN = "module_origin";
-function renderModuleJournal(params) {
-  const { dialect, operation } = params;
-  const q = (name) => dialect.quoteIdent({ name });
-  const table = q(params.table);
-  const column = q(MODULE_JOURNAL_COLUMN);
-  const collector = new ParamCollector(dialect);
-  let text;
-  switch (operation.kind) {
-    case "columns":
-      text = dialect.name === "sqlite" ? `PRAGMA table_info(${table})` : `SELECT column_name AS name FROM information_schema.columns WHERE table_schema = ${dialect.name === "postgres" ? "current_schema()" : "DATABASE()"} AND table_name = ${collector.add(params.table)}`;
-      break;
-    case "addColumn":
-      text = `ALTER TABLE ${table} ADD COLUMN ${column} ${dialect.name === "mysql" ? "LONGTEXT" : "TEXT"}`;
-      break;
-    case "read":
-      text = `SELECT * FROM ${table} ORDER BY ${q("id")}`;
-      break;
+function resolveField(params) {
+  const { name, context } = params;
+  const field = context.model.fields.find((candidate) => candidate.name === name);
+  if (field === undefined) {
+    refuse2({
+      context,
+      rule: "predicate-unknown-field",
+      message: `references field "${name}", which the model does not declare`,
+      meta: { field: name }
+    });
+  }
+  if (field.isList) {
+    refuse2({
+      context,
+      rule: "predicate-list-field",
+      message: `compares scalar list "${name}" \u2014 array operators differ per dialect; use a raw expression for them`,
+      meta: { field: name }
+    });
+  }
+  if (field.isUnsupported === true) {
+    refuse2({
+      context,
+      rule: "predicate-unsupported-type",
+      message: `references "${name}", an Unsupported("${field.nativeType ?? "?"}") column whose operators VibeORM does not model \u2014 use a raw expression`,
+      meta: { field: name }
+    });
+  }
+  if (params.nullTest !== true && (field.type === "Json" || field.type === "Bytes")) {
+    refuse2({
+      context,
+      rule: "predicate-unsupported-type",
+      message: `references ${field.type} column "${name}" \u2014 ${field.type} comparison operators differ per dialect; use a raw expression`,
+      meta: { field: name, type: field.type }
+    });
+  }
+  if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
+    throw unsupportedCapability8({
+      dialect: "mysql",
+      feature: `CHECK constraint referencing auto-increment column "${context.model.name}.${name}"`,
+      hint: "mysql refuses this with error 3818 \u2014 enforce the rule in application code or on a non-generated column"
+    });
+  }
+  return field;
+}
+function quoteColumn(params) {
+  const { field, context } = params;
+  return context.dialect.quoteIdent({ name: field.dbName ?? field.name });
+}
+function compareColumn(params) {
+  const { field, context } = params;
+  const quoted = quoteColumn({ field, context });
+  return context.dialect.name === "sqlite" && field.type === "Decimal" ? `CAST(${quoted} AS REAL)` : quoted;
+}
+function fieldResultType({ field, context }) {
+  if (isLocalDateField({ field }))
+    return { type: field.type, refinement: "localDate" };
+  if (context.dialect.name === "postgres" && field.type === "String" && field.nativeType?.trim().toLowerCase() === "uuid")
+    return { type: "String", refinement: "nativeUuid" };
+  return { type: field.type };
+}
+function resultIdentity({ resultType }) {
+  return resultType.refinement === "localDate" ? "localDate" : fieldTypeIdentity({ type: resultType.type });
+}
+var ARITHMETIC_SQL = {
+  add: "+",
+  sub: "-",
+  mul: "*"
+};
+function renderSqliteArithmetic({ left, right, kind }) {
+  return `(${left} ${ARITHMETIC_SQL[kind]} ${right})`;
+}
+function renderExpression({ expression, context }) {
+  switch (expression.kind) {
+    case "field": {
+      const field = resolveField({ name: expression.name, context });
+      return { text: compareColumn({ field, context }), resultType: fieldResultType({ field, context }), fieldName: field.name };
+    }
+    case "jsonText": {
+      const field = resolveField({ name: expression.field.name, context, nullTest: true });
+      if (field.type !== "Json")
+        refuse2({ context, rule: "predicate-type-mismatch", message: `jsonText requires a scalar Json field, not "${field.name}"` });
+      if (!Array.isArray(expression.path) || Array.from(expression.path).some((segment) => typeof segment !== "string" || segment.includes("\x00"))) {
+        refuse2({ context, rule: "predicate-json-path", message: "jsonText requires a string-only path without NUL bytes" });
+      }
+      const path = expression.path.map((value) => context.dialect.quoteStringLiteral({ value })).join(", ");
+      return { text: `(${quoteColumn({ field, context })} #>> ARRAY[${path}]::text[])`, resultType: { type: "String" }, fieldName: field.name };
+    }
+    case "length":
+    case "lower":
+    case "upper": {
+      const inner = renderExpression({ expression: expression.expression, context });
+      if (inner.resultType.type !== "String" || inner.resultType.refinement === "localDate") {
+        refuse2({ context, rule: "predicate-type-mismatch", message: `${expression.kind} requires a text expression, not a local date or another scalar`, meta: { field: inner.fieldName } });
+      }
+      return { text: `${expression.kind}(${inner.text})`, resultType: { type: expression.kind === "length" ? "Int" : "String" }, fieldName: inner.fieldName };
+    }
+    case "add":
+    case "sub":
+    case "mul": {
+      const left = renderExpression({ expression: expression.left, context });
+      const type = left.resultType.type;
+      if (type !== "Int" && type !== "BigInt" && type !== "Float" && type !== "Decimal") {
+        refuse2({ context, rule: "predicate-type-mismatch", message: `${expression.kind} requires Int, BigInt, Float or Decimal operands`, meta: { field: left.fieldName } });
+      }
+      const right = renderOperand({ operand: expression.right, left, context });
+      const text = context.dialect.name === "sqlite" ? renderSqliteArithmetic({ left: left.text, right, kind: expression.kind, type }) : `(${left.text} ${ARITHMETIC_SQL[expression.kind]} ${right})`;
+      return { text, resultType: { type }, fieldName: left.fieldName };
+    }
+  }
+}
+function renderOperand({ operand, left, context }) {
+  if (operand.kind === "value")
+    return renderLiteral({ value: operand, resultType: left.resultType, fieldName: left.fieldName, context });
+  const other = renderExpression({ expression: operand, context });
+  const leftType = resultIdentity({ resultType: left.resultType });
+  const rightType = resultIdentity({ resultType: other.resultType });
+  if (leftType !== rightType) {
+    refuse2({
+      context,
+      rule: "predicate-type-mismatch",
+      message: `compares "${left.fieldName}" (${leftType}) with "${other.fieldName}" (${rightType}): both operands need the same scalar type`,
+      meta: { field: left.fieldName, other: other.fieldName, fieldType: leftType, otherType: rightType }
+    });
+  }
+  return other.text;
+}
+function renderLiteral(params) {
+  const { resultType, fieldName, context } = params;
+  const { value } = params.value;
+  const type = resultType.type;
+  const wrongCarrier = (expected) => refuse2({
+    context,
+    rule: "predicate-type-mismatch",
+    message: `compares ${fieldTypeIdentity({ type })} field "${fieldName}" with ${describe({ value })}: ${expected}`,
+    meta: { field: fieldName, fieldType: fieldTypeIdentity({ type }), value }
+  });
+  if (isEnumType(type)) {
+    if (typeof value !== "string")
+      return wrongCarrier(`enum ${type.enum} takes one of its member names as a string`);
+    const declared = context.enums.find((entry) => entry.name === type.enum);
+    if (declared !== undefined && !declared.values.includes(value)) {
+      refuse2({
+        context,
+        rule: "predicate-enum-member",
+        message: `compares "${fieldName}" with "${value}", which is not a member of enum ${type.enum} (${declared.values.join(", ")})`,
+        meta: { field: fieldName, enum: type.enum, value, members: [...declared.values] }
+      });
+    }
+    return stringLiteral({ value, context, fieldName });
+  }
+  switch (type) {
+    case "String":
+      if (typeof value !== "string")
+        return wrongCarrier("a String column takes a string literal");
+      if (resultType.refinement === "localDate" && !isCanonicalLocalDate2({ value })) {
+        refuse2({
+          context,
+          rule: "predicate-literal-invalid",
+          message: `compares local-date field "${fieldName}" with a noncanonical or invalid calendar date`,
+          meta: { field: fieldName, value }
+        });
+      }
+      return stringLiteral({ value, context, fieldName });
+    case "Boolean":
+      if (typeof value !== "boolean")
+        return wrongCarrier("a Boolean column takes `true` or `false`");
+      return value ? context.dialect.booleanLiteral.true : context.dialect.booleanLiteral.false;
+    case "Int":
+      return integerLiteral({ value, fieldName, context, min: INT32_MIN, max: INT32_MAX, label: "Int" });
+    case "BigInt":
+      return integerLiteral({ value, fieldName, context, min: INT64_MIN, max: INT64_MAX, label: "BigInt" });
+    case "Float": {
+      if (typeof value !== "number")
+        return wrongCarrier("a Float column takes a number");
+      if (!Number.isFinite(value)) {
+        refuse2({
+          context,
+          rule: "predicate-literal-invalid",
+          message: `compares "${fieldName}" with ${String(value)}: a Float literal must be finite`,
+          meta: { field: fieldName, value: String(value) }
+        });
+      }
+      return String(value);
+    }
+    case "Decimal": {
+      if (typeof value !== "string") {
+        return wrongCarrier('a Decimal column takes exact decimal TEXT ("0", "19.99") \u2014 a JS number cannot carry an exact decimal');
+      }
+      if (!EXACT_DECIMAL.test(value)) {
+        refuse2({
+          context,
+          rule: "predicate-literal-invalid",
+          message: `compares "${fieldName}" with "${value}", which is not an exact decimal literal`,
+          meta: { field: fieldName, value }
+        });
+      }
+      return value;
+    }
+    case "DateTime":
+      refuse2({
+        context,
+        rule: "predicate-unsupported-literal",
+        message: `compares DateTime field "${fieldName}" with a literal. DateTime literals are spelled differently on postgres, mysql and sqlite, so VibeORM does not guess one. Compare two DateTime columns, or write a raw expression for a fixed instant`,
+        meta: { field: fieldName }
+      });
+    case "Json":
+    case "Bytes":
+      return wrongCarrier(`${type} columns take no predicate literal`);
+  }
+}
+function integerLiteral(params) {
+  const { value, fieldName, context, min, max, label } = params;
+  let text;
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      refuse2({
+        context,
+        rule: "predicate-literal-invalid",
+        message: `compares "${fieldName}" with ${String(value)}: an ${label} literal must be an exact integer JavaScript can represent; pass a bigint or a decimal string for larger values`,
+        meta: { field: fieldName, value: String(value) }
+      });
+    }
+    text = String(value);
+  } else if (typeof value === "string") {
+    if (!EXACT_INTEGER.test(value)) {
+      refuse2({
+        context,
+        rule: "predicate-literal-invalid",
+        message: `compares "${fieldName}" with "${value}", which is not an exact integer literal`,
+        meta: { field: fieldName, value }
+      });
+    }
+    text = value;
+  } else {
+    refuse2({
+      context,
+      rule: "predicate-type-mismatch",
+      message: `compares ${label} field "${fieldName}" with ${describe({ value })}: an ${label} column takes an integer`,
+      meta: { field: fieldName, value }
+    });
+  }
+  const parsed = BigInt(text);
+  if (parsed < min || parsed > max) {
+    refuse2({
+      context,
+      rule: "predicate-literal-invalid",
+      message: `compares "${fieldName}" with ${text}, which is outside the range an ${label} column can hold (${min}\u2026${max})`,
+      meta: { field: fieldName, value: text }
+    });
+  }
+  return text;
+}
+function stringLiteral(params) {
+  const { value, context, fieldName } = params;
+  if (value.includes("\x00")) {
+    refuse2({
+      context,
+      rule: "predicate-literal-invalid",
+      message: `compares "${fieldName}" with a string containing a NUL byte, which no dialect here can store`,
+      meta: { field: fieldName }
+    });
+  }
+  return context.dialect.quoteStringLiteral({ value });
+}
+function describe(params) {
+  const { value } = params;
+  return typeof value === "string" ? `the string ${JSON.stringify(value)}` : `the ${typeof value} ${String(value)}`;
+}
+
+// packages/sql/src/dialects/postgres-index-expressions.ts
+import { unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/sqlite-table-definition.ts
+import { VibeError as VibeError8 } from "@vibeorm/schema";
+function tableDefinitionTokens({ sql, backslashEscapes = false }) {
+  const tokens = [];
+  let depth = 0;
+  for (let index = 0;index < sql.length; ) {
+    const char = sql[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    if (char === "-" && sql[index + 1] === "-" || char === "#") {
+      const end = sql.indexOf(`
+`, index + 1);
+      index = end < 0 ? sql.length : end + 1;
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0)
+        throw unavailable();
+      index = end + 2;
+      continue;
+    }
+    const start = index;
+    if (char === "'" || char === '"' || char === "`" || char === "[") {
+      const close = char === "[" ? "]" : char;
+      let value = "";
+      let closed = false;
+      index++;
+      while (index < sql.length) {
+        const current = sql[index++];
+        if (backslashEscapes && current === "\\" && (char === "'" || char === '"')) {
+          if (index >= sql.length)
+            throw unavailable();
+          value += sql[index++];
+        } else if (current === close) {
+          if (close !== "]" && sql[index] === close) {
+            value += close;
+            index++;
+          } else {
+            closed = true;
+            break;
+          }
+        } else
+          value += current;
+      }
+      if (!closed)
+        throw unavailable();
+      tokens.push({ value, kind: char === "'" ? "literal" : "quoted", start, end: index, depth });
+      continue;
+    }
+    if (/[\p{L}\p{N}_$]/u.test(char)) {
+      index++;
+      while (index < sql.length && /[\p{L}\p{N}_$]/u.test(sql[index]))
+        index++;
+      tokens.push({ value: sql.slice(start, index), kind: "word", start, end: index, depth });
+      continue;
+    }
+    if (char === ")") {
+      depth--;
+      if (depth < 0)
+        throw unavailable();
+    }
+    tokens.push({ value: char, kind: "symbol", start, end: ++index, depth });
+    if (char === "(")
+      depth++;
+  }
+  if (depth !== 0)
+    throw unavailable();
+  return tokens;
+}
+function tableDefinitionParts({ sql, backslashEscapes }) {
+  const tokens = tableDefinitionTokens({ sql, backslashEscapes });
+  const words = tokens.filter((token) => token.depth === 0);
+  if (words[0]?.kind !== "word" || words[0].value.toUpperCase() !== "CREATE")
+    throw unavailable();
+  const tablePosition = /^(TEMP|TEMPORARY)$/i.test(words[1]?.value ?? "") ? 2 : 1;
+  if (words[tablePosition]?.kind !== "word" || words[tablePosition].value.toUpperCase() !== "TABLE")
+    throw unavailable();
+  const open = words.find((token) => token.kind === "symbol" && token.value === "(");
+  if (open === undefined)
+    throw unavailable();
+  const close = words.find((token) => token.start > open.start && token.kind === "symbol" && token.value === ")");
+  if (close === undefined)
+    throw unavailable();
+  const delimiters = tokens.filter((token) => token.start > open.start && token.start < close.start && token.depth === 1 && token.kind === "symbol" && token.value === ",");
+  const clauses = [];
+  let start = open.end;
+  for (const delimiter of [...delimiters, close]) {
+    const clause = sql.slice(start, delimiter.start).trim();
+    if (clause.length === 0)
+      throw unavailable();
+    clauses.push(clause);
+    start = delimiter.end;
+  }
+  return { clauses, suffix: sql.slice(close.end) };
+}
+function unavailable() {
+  return new VibeError8({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
+}
+function tableColumnClauses({ sql, backslashEscapes, mysql = false }) {
+  const columns = [];
+  for (const part of tableDefinitionParts({ sql, backslashEscapes }).clauses) {
+    const first = tableDefinitionTokens({ sql: part, backslashEscapes })[0];
+    if (first === undefined || first.kind === "symbol")
+      throw unavailable();
+    if (first.kind === "word" && /^(CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(first.value))
+      continue;
+    if (mysql && first.kind === "word" && /^(KEY|INDEX|FULLTEXT|SPATIAL)$/i.test(first.value))
+      continue;
+    columns.push({ name: first.value, sql: part });
+  }
+  return columns;
+}
+function sqliteColumnClauses({ sql }) {
+  return tableColumnClauses({ sql });
+}
+
+// packages/sql/src/dialects/sqlite-index-expressions.ts
+function extractIndexKeyList({ sql, open, close, tokens, wrapped = false, removeWrapper = wrapped }) {
+  const commas = tokens.filter((token) => token.start > open.start && token.start < close.start && token.depth === open.depth + 1 && token.kind === "symbol" && token.value === ",");
+  const keys = [];
+  let start = open.end;
+  for (const delimiter of [...commas, close]) {
+    const termTokens = tokens.filter((token) => token.start >= start && token.end <= delimiter.start);
+    if (termTokens.length === 0)
+      return;
+    const last = termTokens.at(-1);
+    const sorted = last.depth === open.depth + 1 && last.kind === "word" && /^(ASC|DESC)$/i.test(last.value);
+    const desc = sorted && /^DESC$/i.test(last.value);
+    const bodyTokens = sorted ? termTokens.slice(0, -1) : termTokens;
+    const first = bodyTokens[0];
+    const end = bodyTokens.at(-1);
+    if (first === undefined || end === undefined)
+      return;
+    if (bodyTokens.length === 1 && (first.kind === "word" || first.kind === "quoted")) {
+      keys.push({ kind: "field", name: first.value, desc });
+    } else {
+      const top = bodyTokens.filter((token) => token.depth === open.depth + 1);
+      if (top.some((token) => token.kind === "word" && /^(COLLATE|NULLS)$/i.test(token.value)))
+        return;
+      if (first.kind === "symbol" && first.value === "(" && end.kind === "symbol" && end.value === ")" && end.depth === first.depth) {
+        if (top.length !== 2)
+          return;
+        const text = sql.slice(removeWrapper ? first.end : start, removeWrapper ? end.start : sorted ? last.start : delimiter.start).trim();
+        if (!text)
+          return;
+        keys.push({ kind: "expression", text, desc });
+      } else {
+        if (wrapped)
+          return;
+        const text = sql.slice(start, sorted ? last.start : delimiter.start).trim();
+        if (!text || bodyTokens.some((token) => token.depth === open.depth + 1 && token.kind === "word" && /^(ASC|DESC)$/i.test(token.value)))
+          return;
+        keys.push({ kind: "expression", text, desc });
+      }
+    }
+    start = delimiter.end;
+  }
+  return keys.length === 0 ? undefined : keys;
+}
+function extractStandaloneIndexKeys({ definition, index, postgres = false }) {
+  const tokens = tableDefinitionTokens({ sql: definition });
+  const top = tokens.filter((token) => token.depth === 0);
+  let position = 0;
+  const word = ({ value }) => {
+    const token = top[position];
+    if (token?.kind !== "word" || token.value.toUpperCase() !== value)
+      return false;
+    position++;
+    return true;
+  };
+  if (!word({ value: "CREATE" }))
+    return;
+  word({ value: "UNIQUE" });
+  if (!word({ value: "INDEX" }))
+    return;
+  if (word({ value: "IF" }) && (!word({ value: "NOT" }) || !word({ value: "EXISTS" })))
+    return;
+  let name = top[position++];
+  if (top[position]?.value === ".") {
+    position++;
+    name = top[position++];
+  }
+  if (name === undefined || !["quoted", "word"].includes(name.kind) || name.value !== index || !word({ value: "ON" }))
+    return;
+  const table = top[position++];
+  if (table === undefined || !["quoted", "word"].includes(table.kind))
+    return;
+  if (top[position]?.value === ".") {
+    position++;
+    if (top[position++] === undefined)
+      return;
+  }
+  if (word({ value: "USING" })) {
+    if (!postgres || !word({ value: "BTREE" }))
+      return;
+  }
+  const open = top[position++];
+  const close = top[position++];
+  if (open?.kind !== "symbol" || open.value !== "(" || close?.kind !== "symbol" || close.value !== ")")
+    return;
+  if (postgres && word({ value: "NULLS" }) && (!word({ value: "NOT" }) || !word({ value: "DISTINCT" })))
+    return;
+  const tail = top[position];
+  if (tail !== undefined && !(tail.kind === "word" && tail.value.toUpperCase() === "WHERE") && !(tail.value === ";" && position === top.length - 1))
+    return;
+  const keys = extractIndexKeyList({ sql: definition, open, close, tokens, removeWrapper: postgres });
+  if (postgres && keys !== undefined) {
+    const delimiters = tokens.filter((token) => token.start > open.start && token.start < close.start && token.depth === 1 && token.value === ",");
+    let start = open.end;
+    for (const delimiter of [...delimiters, close]) {
+      const keyTop = tokens.filter((token) => token.start >= start && token.end <= delimiter.start && token.depth === 1);
+      if (keyTop.length > 1 && (keyTop[0]?.kind === "word" || keyTop[0]?.kind === "quoted") && (keyTop[1]?.kind === "quoted" || keyTop[1]?.kind === "word" && !/^(ASC|DESC)$/i.test(keyTop[1].value)))
+        return;
+      start = delimiter.end;
+    }
+    const slices = tokens.filter((token) => token.start >= open.end && token.end <= close.start && token.depth === 1);
+    if (slices.some((token, ordinal) => slices[ordinal - 1]?.value === ")" && (token.kind === "quoted" || token.kind === "word" && !/^(ASC|DESC)$/i.test(token.value))))
+      return;
+  }
+  return keys;
+}
+function extractSqliteIndexKeys({ definition, index }) {
+  return extractStandaloneIndexKeys({ definition, index });
+}
+
+// packages/sql/src/dialects/postgres-index-expressions.ts
+function extractPostgresIndexKeys({ definition, index }) {
+  return extractStandaloneIndexKeys({ definition, index, postgres: true });
+}
+function renderPostgresIndexExpressionProbe({ ...params }) {
+  const { dialect, operation, probe } = params;
+  if (operation === "context")
+    return [{ text: "SELECT current_setting('server_version') AS version, current_setting('server_version_num') AS version_number, current_setting('search_path') AS search_path", values: [], returning: "none" }];
+  const table = dialect.quoteIdent({ name: probe.table });
+  if (operation === "read")
+    return [renderPostgresIndexKeys({ dialect, table: { namespace: "pg_temp", name: probe.table }, expressionMetadata: true })];
+  if (operation === "drop")
+    return [{ text: `DROP TABLE pg_temp.${table}`, values: [], returning: "none" }];
+  if (operation === "clone") {
+    if (params.table === undefined)
+      throw unsupportedCapability9({ dialect: "postgres", feature: "indexExpressionProbeSource" });
+    return [{ text: `CREATE TEMP TABLE ${table} (LIKE ${dialect.quoteIdent({ name: params.table.namespace })}.${dialect.quoteIdent({ name: params.table.name })} INCLUDING DEFAULTS INCLUDING GENERATED INCLUDING IDENTITY INCLUDING STORAGE INCLUDING CONSTRAINTS)`, values: [], returning: "none" }];
+  }
+  if (params.keys === undefined)
+    throw unsupportedCapability9({ dialect: "postgres", feature: "indexExpressionProbeKeys" });
+  if (params.nullsNotDistinct === true && params.unique !== true)
+    throw unsupportedCapability9({ dialect: "postgres", feature: "nonUniqueNullsNotDistinct" });
+  const keys = renderIndexKeys({ dialect, keys: params.keys, unique: params.unique === true });
+  return [{ text: `CREATE ${params.unique ? "UNIQUE " : ""}INDEX ${dialect.quoteIdent({ name: probe.index })} ON pg_temp.${table} (${keys.join(", ")})${params.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}${params.where === undefined ? "" : ` WHERE ${params.where}`}`, values: [], returning: "none" }];
+}
+
+// packages/sql/src/dialects/mysql-index-expressions.ts
+import { MYSQL_FUNCTIONAL_KEY_LIMITS, mysqlIndexKeyWidth, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/mysql-generated-columns.ts
+import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/sqlite-generated-columns.ts
+import { VibeError as VibeError9 } from "@vibeorm/schema";
+function renderSqliteGeneratedColumnClause({ generated }) {
+  return `GENERATED ALWAYS AS (${generated.expression}) STORED`;
+}
+function unavailable2({ column }) {
+  return new VibeError9({ code: "VIBE_MIGRATION", message: `Cannot inspect generated expression for column "${column}"`, meta: { reason: "generated-expression-unavailable", column } });
+}
+function extractGenerationFromDefinition({ definition, column, backslashEscapes = false, mysql = false }) {
+  const matches = tableColumnClauses({ sql: definition, backslashEscapes, mysql }).filter((clause) => clause.name === column);
+  if (matches.length !== 1)
+    throw unavailable2({ column });
+  const columnSql = matches[0].sql;
+  const tokens = tableDefinitionTokens({ sql: columnSql, backslashEscapes }).filter((token) => token.depth === 0);
+  const name = tokens[0];
+  let result;
+  for (let index = 1;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.kind !== "word" || token.value.toUpperCase() !== "AS")
+      continue;
+    const open = tokens[index + 1];
+    const close = tokens[index + 2];
+    if (open?.kind !== "symbol" || open.value !== "(" || close?.kind !== "symbol" || close.value !== ")")
+      throw unavailable2({ column });
+    if (result !== undefined)
+      throw unavailable2({ column });
+    const expression = columnSql.slice(open.end, close.start).trim();
+    if (expression.length === 0 || expression.includes("\x00"))
+      throw unavailable2({ column });
+    const preceding = tokens[index - 1];
+    const generated = preceding?.kind === "word" && preceding.value.toUpperCase() === "ALWAYS" ? tokens[index - 2] : preceding;
+    const explicit = generated?.kind === "word" && generated.value.toUpperCase() === "GENERATED";
+    if (preceding?.kind === "word" && preceding.value.toUpperCase() === "ALWAYS" && !explicit)
+      throw unavailable2({ column });
+    const next = tokens[index + 3];
+    const storage = next?.kind === "word" && next.value.toUpperCase() === "STORED" ? "stored" : "virtual";
+    result = { expression, storage, columnSql, typeSql: columnSql.slice(name.end, explicit ? generated.start : token.start).trim() };
+    index += 2;
+  }
+  if (result === undefined && tokens.some((token, index) => token.kind === "word" && token.value.toUpperCase() === "GENERATED" && tokens[index + 1]?.kind === "word" && tokens[index + 1]?.value.toUpperCase() === "ALWAYS"))
+    throw unavailable2({ column });
+  return result;
+}
+function extractSqliteGeneratedColumn({ definition, column }) {
+  return extractGenerationFromDefinition({ definition, column });
+}
+
+// packages/sql/src/dialects/mysql-generated-columns.ts
+function renderMysqlGeneratedColumnClause({ generated }) {
+  return `GENERATED ALWAYS AS (${generated.expression}) STORED`;
+}
+function renderMysqlGeneratedColumnProbe({ dialect, probe }) {
+  if (dialect.name !== "mysql")
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "temporaryGeneratedColumnProbe" });
+  if (probe.operation === "context")
+    return { text: "SELECT @@SESSION.sql_mode AS sqlMode", values: [], returning: "none" };
+  const q = ({ name }) => dialect.quoteIdent({ name });
+  const name = q({ name: probe.probe });
+  let text;
+  switch (probe.operation) {
+    case "clone":
+      text = `CREATE TEMPORARY TABLE ${name} LIKE ${q({ name: probe.table.namespace })}.${q({ name: probe.table.name })}`;
+      break;
+    case "read":
+      text = `SHOW CREATE TABLE ${probe.table === undefined ? name : `${q({ name: probe.table.namespace })}.${q({ name: probe.table.name })}`}`;
+      break;
+    case "drop":
+      text = `DROP TEMPORARY TABLE ${name}`;
+      break;
+    case "create": {
+      const parts = tableDefinitionParts({ sql: probe.definition, backslashEscapes: probe.backslashEscapes });
+      const columns = tableColumnClauses({ sql: probe.definition, backslashEscapes: probe.backslashEscapes, mysql: true });
+      const targets = columns.filter((column) => column.name === probe.column);
+      if (targets.length > 1)
+        throw unavailable3({ column: probe.column });
+      const targetDefinition = extractMysqlGeneratedColumn({ definition: `CREATE TABLE ${name} (${probe.columnDefinition})`, column: probe.column, backslashEscapes: probe.backslashEscapes });
+      if (targetDefinition?.storage !== "stored")
+        throw unavailable3({ column: probe.column });
+      const clauses = [...parts.clauses];
+      if (targets.length === 1) {
+        clauses[clauses.indexOf(targets[0].sql)] = probe.columnDefinition;
+      } else if (probe.after !== undefined) {
+        const after = columns.filter((column) => column.name === probe.after);
+        if (after.length !== 1)
+          throw unavailable3({ column: probe.after });
+        clauses.splice(clauses.indexOf(after[0].sql) + 1, 0, probe.columnDefinition);
+      } else {
+        const last = columns.at(-1);
+        if (last === undefined)
+          throw unavailable3({ column: probe.column });
+        clauses.splice(clauses.indexOf(last.sql) + 1, 0, probe.columnDefinition);
+      }
+      text = `CREATE TEMPORARY TABLE ${name} (
+${clauses.join(`,
+`)}
+)${parts.suffix}`;
+      break;
+    }
+  }
+  return { text, values: [], returning: "none" };
+}
+function unavailable3({ column }) {
+  return new VibeError10({ code: "VIBE_MIGRATION", message: `Cannot build temporary generated-column definition for "${column}"`, meta: { reason: "generated-expression-unavailable", column } });
+}
+function extractMysqlGeneratedColumn({ definition, column, backslashEscapes }) {
+  return extractGenerationFromDefinition({ definition, column, backslashEscapes, mysql: true });
+}
+
+// packages/sql/src/dialects/mysql-index-expressions.ts
+function assertMysqlIndexKeyStorage({ model, terms }) {
+  const width = mysqlIndexKeyWidth({ terms, model });
+  if (width.kind === "refused")
+    throw unsupportedCapability11({ dialect: "mysql", feature: width.feature, hint: `${model.name}.${width.field}: use bounded VARCHAR/CHAR, an explicit raw cast with intentional width/collation, or a generated column; no automatic cast is inserted` });
+  if (width.kind === "bytes" && width.bytes > MYSQL_FUNCTIONAL_KEY_LIMITS.bytes)
+    throw unsupportedCapability11({ dialect: "mysql", feature: "mysqlFunctionalKeyWidth", hint: `The complete key needs up to ${width.bytes} bytes; modern InnoDB admits at most ${MYSQL_FUNCTIONAL_KEY_LIMITS.bytes}. Use narrower declared storage or an explicit reviewed raw key` });
+}
+function extractMysqlIndexKeys({ definition, index, backslashEscapes }) {
+  const matching = tableDefinitionParts({ sql: definition, backslashEscapes }).clauses.flatMap((sql) => {
+    const tokens = tableDefinitionTokens({ sql, backslashEscapes });
+    const top = tokens.filter((token) => token.depth === 0);
+    let position = top[0]?.kind === "word" && top[0].value.toUpperCase() === "UNIQUE" ? 1 : 0;
+    const key = top[position++];
+    if (key?.kind !== "word" || !/^(KEY|INDEX)$/i.test(key.value))
+      return [];
+    const name = top[position++];
+    if (name === undefined || !["word", "quoted"].includes(name.kind) || name.value !== index)
+      return [];
+    if (top[position]?.kind === "word" && top[position]?.value.toUpperCase() === "USING") {
+      position++;
+      if (top[position++]?.value.toUpperCase() !== "BTREE")
+        return [{ sql, tokens, open: undefined, close: undefined }];
+    }
+    const open = top[position++];
+    const close = top[position++];
+    const tail = top.slice(position);
+    const supported = tail.length === 0 || tail.length === 1 && tail[0]?.value.toUpperCase() === "VISIBLE" || tail.length === 2 && tail[0]?.value.toUpperCase() === "USING" && tail[1]?.value.toUpperCase() === "BTREE";
+    return [{ sql, tokens, open: supported && open?.value === "(" ? open : undefined, close: close?.value === ")" ? close : undefined }];
+  });
+  if (matching.length !== 1)
+    return;
+  const clause = matching[0];
+  if (clause.open === undefined || clause.close === undefined)
+    return;
+  return extractIndexKeyList({ ...clause, open: clause.open, close: clause.close, wrapped: true });
+}
+function renderMysqlIndexExpressionProbe({ ...params }) {
+  const { dialect, probe, operation } = params;
+  if (operation === "context")
+    return [{ text: "SELECT VERSION() AS version, @@SESSION.sql_mode AS sqlMode, @@SESSION.character_set_connection AS characterSet, @@SESSION.collation_connection AS collation", values: [], returning: "none" }];
+  if (operation === "clone") {
+    if (params.table === undefined)
+      throw unsupportedCapability11({ dialect: "mysql", feature: "indexExpressionProbeSource" });
+    return [renderMysqlGeneratedColumnProbe({ dialect, probe: { operation: "clone", probe: probe.table, table: params.table } })];
+  }
+  if (operation === "read" || operation === "drop")
+    return [renderMysqlGeneratedColumnProbe({ dialect, probe: { operation, probe: probe.table } })];
+  if (params.definition === undefined || params.keys === undefined)
+    throw unsupportedCapability11({ dialect: "mysql", feature: "indexExpressionProbeDefinition" });
+  if (params.where !== undefined || params.nullsNotDistinct === true)
+    throw unsupportedCapability11({ dialect: "mysql", feature: "partialOrNullsNotDistinctExpressionIndex" });
+  if (params.backslashEscapes === undefined)
+    throw unsupportedCapability11({ dialect: "mysql", feature: "indexExpressionProbeSqlMode", hint: "Read sqlMode on the pinned session and supply backslashEscapes explicitly" });
+  const parts = tableDefinitionParts({ sql: params.definition, backslashEscapes: params.backslashEscapes });
+  const clauses = parts.clauses.filter((sql) => {
+    const top = tableDefinitionTokens({ sql, backslashEscapes: params.backslashEscapes }).filter((token) => token.depth === 0);
+    const position = top[0]?.kind === "word" && /^UNIQUE$/i.test(top[0].value) ? 1 : 0;
+    return !(top[position]?.kind === "word" && /^(KEY|INDEX)$/i.test(top[position].value) && top[position + 1]?.value === probe.index);
+  });
+  const keys = renderIndexKeys({ dialect, keys: params.keys, unique: params.unique === true });
+  clauses.push(`${params.unique ? "UNIQUE " : ""}KEY ${dialect.quoteIdent({ name: probe.index })} (${keys.join(", ")})`);
+  return [{ text: `CREATE TEMPORARY TABLE ${dialect.quoteIdent({ name: probe.table })} (
+${clauses.join(`,
+`)}
+)${parts.suffix}`, values: [], returning: "none" }];
+}
+
+// packages/sql/src/index-expressions.ts
+function resolveIndexKeys({ index, model, dialect, enums = [], site }) {
+  const computed = isExpressionIndex({ index });
+  if (computed)
+    indexKeyDefinitionKey({ index, model });
+  const terms = indexKeyTerms({ index });
+  if (computed && index.where !== undefined && !dialect.capabilities.partialIndexes)
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "partialIndexes" });
+  if (computed && index.nullsNotDistinct === true && dialect.name !== "postgres")
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "nullsNotDistinct" });
+  if (computed && !dialect.capabilities.expressionIndexes)
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "expressionIndexes" });
+  if (computed && (index.fields.length !== 0 || !terms.some((term) => term.kind !== "field")))
+    throw invalid3({ site, reason: "index-expression-terms" });
+  if (terms.length === 0)
+    throw invalid3({ site, reason: "index-empty-keys" });
+  if (computed && (index.clientName !== undefined || index.constraintName !== undefined))
+    throw invalid3({ site, reason: "index-expression-selector" });
+  if (computed && (index.kind !== "btree" && index.kind !== "unique" || terms.some((term) => term.kind === "field" && term.field.operatorClass !== undefined)))
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "expressionIndexOperatorClasses" });
+  const keys = terms.map((term) => {
+    if (term.kind === "field") {
+      const field = model.fields.find((candidate) => candidate.name === term.field.name);
+      if (field === undefined)
+        throw invalid3({ site, reason: "index-unknown-field" });
+      return { kind: "field", name: field.dbName ?? field.name, desc: term.field.sort === "desc", ...dialect.name === "sqlite" && field.type === "Decimal" ? { decimal: true } : {}, ...term.field.operatorClass === undefined ? {} : { operatorClass: term.field.operatorClass } };
+    }
+    if (term.kind === "raw") {
+      if (index.name === undefined || typeof term.sql !== "string" || !term.sql.trim() || term.sql.includes("\x00"))
+        throw invalid3({ site, reason: "index-raw-expression" });
+      return { kind: "expression", text: term.sql, desc: term.sort === "desc" };
+    }
+    const rendered = renderSchemaExpression({ expression: term.expression, model, dialect, enums, usage: "indexExpression", site });
+    if (!["lower", "upper", "add", "sub", "mul"].includes(term.expression.kind))
+      throw invalid3({ site, reason: "index-expression-root" });
+    if (rendered.resultType.refinement !== undefined || typeof rendered.resultType.type !== "string" || !["String", "Int", "BigInt", "Float", "Decimal"].includes(rendered.resultType.type))
+      throw invalid3({ site, reason: "index-expression-result" });
+    return { kind: "expression", text: rendered.text, desc: term.sort === "desc" };
+  });
+  if (computed && dialect.name === "mysql")
+    assertMysqlIndexKeyStorage({ dialect, model, terms });
+  return keys;
+}
+function renderIndexKeys({ dialect, keys, unique }) {
+  if (keys.length === 0)
+    throw invalid3({ site: "index", reason: "index-empty-keys" });
+  const computed = keys.some((key) => key.kind === "expression");
+  if (computed && !dialect.capabilities.expressionIndexes)
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "expressionIndexes" });
+  if (computed && keys.some((key) => key.kind === "field" && key.operatorClass !== undefined))
+    throw unsupportedCapability12({ dialect: dialect.name, feature: "expressionIndexOperatorClasses" });
+  return keys.map((key) => {
+    if (key.kind === "field") {
+      if (dialect.name === "sqlite" && key.decimal === true)
+        return `CAST(${dialect.quoteIdent({ name: key.name })} AS REAL)${key.desc ? " DESC" : ""}`;
+      return renderIndexColumns({ dialect, columns: [key], unique })[0];
+    }
+    if (!key.text.trim() || key.text.includes("\x00"))
+      throw invalid3({ site: "index", reason: "index-raw-expression" });
+    const expression = dialect.name === "sqlite" ? key.text : `(${key.text})`;
+    return `${expression}${key.desc ? " DESC" : ""}`;
+  });
+}
+function extractIndexKeys({ dialect, definition, index, backslashEscapes = true }) {
+  switch (dialect) {
+    case "postgres":
+      return extractPostgresIndexKeys({ definition, index });
+    case "sqlite":
+      return extractSqliteIndexKeys({ definition, index });
+    case "mysql":
+      return extractMysqlIndexKeys({ definition, index, backslashEscapes });
+  }
+}
+function renderIndexExpressionProbe({ ...params }) {
+  if (params.operation === "context" && params.dialect.name === "sqlite")
+    return [{ text: "SELECT sqlite_version() AS version", values: [], returning: "none" }];
+  if (!params.dialect.capabilities.expressionIndexes)
+    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "expressionIndexes" });
+  switch (params.dialect.name) {
+    case "postgres":
+      return renderPostgresIndexExpressionProbe(params);
+    case "mysql":
+      return renderMysqlIndexExpressionProbe(params);
+    case "sqlite":
+      throw unsupportedCapability12({ dialect: "sqlite", feature: "indexExpressionNormalizationProbe", hint: "SQLite expression indexes use quote-aware source extraction, not a normalization probe" });
+  }
+}
+function assertIndexExpressionVersion({ dialect, version }) {
+  if (dialect === "postgres")
+    return;
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:[-\s].*)?$/);
+  const parts = match?.slice(1, 4).map(Number);
+  const minimum = dialect === "mysql" ? [8, 0, 13] : [3, 9, 0];
+  const admitted = parts !== undefined && !/mariadb/i.test(version) && parts.some((part, ordinal) => part > minimum[ordinal] && parts.slice(0, ordinal).every((prefix, position) => prefix === minimum[position])) || parts !== undefined && parts.every((part, ordinal) => part === minimum[ordinal]);
+  if (!admitted)
+    throw unsupportedCapability12({ dialect, feature: "expressionIndexServerVersion", hint: `Expression indexes require a known ${dialect} version at least ${minimum.join(".")}; received ${JSON.stringify(version)}` });
+}
+function invalid3({ site, reason }) {
+  return new VibeError11({ code: "VIBE_SCHEMA_INVALID", message: `Invalid index keys at ${site}: ${reason}`, meta: { rule: reason, site } });
+}
+// packages/sql/src/dialects/module-dependency.ts
+function renderModuleDependencyQuery(params) {
+  const { dialect, operation } = params;
+  if (operation.kind === "visibility")
+    return dialect.name === "mysql" ? { text: "SHOW GRANTS FOR CURRENT_USER", values: [], returning: "none" } : undefined;
+  if (dialect.name === "sqlite" || operation.tables.length === 0)
+    return;
+  const collector = new ParamCollector(dialect);
+  const owned = operation.tables.map((table, index) => `SELECT ${collector.add(operation.namespace)}${index === 0 ? " AS namespace" : ""}, ${collector.add(table)}${index === 0 ? " AS table_name" : ""}`).join(" UNION ALL ");
+  const pg = dialect.name === "postgres";
+  const nameKey = ({ column }) => pg ? column : `CAST(IF(@@lower_case_table_names = 0, ${column}, LOWER(${column})) AS BINARY)`;
+  const isOwned = ({ namespace, table }) => `EXISTS (SELECT 1 FROM owned_tables o WHERE ${nameKey({ column: namespace })} = ${nameKey({ column: "o.namespace" })} AND ${nameKey({ column: table })} = ${nameKey({ column: "o.table_name" })})`;
+  const sourceNamespace = pg ? "sn.nspname" : "fk.CONSTRAINT_SCHEMA";
+  const sourceTable = pg ? "s.relname" : "fk.TABLE_NAME";
+  const targetNamespace = pg ? "tn.nspname" : "fk.UNIQUE_CONSTRAINT_SCHEMA";
+  const targetTable = pg ? "t.relname" : "fk.REFERENCED_TABLE_NAME";
+  const from = pg ? "pg_catalog.pg_constraint fk JOIN pg_catalog.pg_class s ON s.oid = fk.conrelid JOIN pg_catalog.pg_namespace sn ON sn.oid = s.relnamespace JOIN pg_catalog.pg_class t ON t.oid = fk.confrelid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.relnamespace WHERE fk.contype = 'f'" : "information_schema.REFERENTIAL_CONSTRAINTS fk";
+  return {
+    text: `WITH owned_tables AS (${owned})
+SELECT * FROM (SELECT ${pg ? "fk.conname" : "fk.CONSTRAINT_NAME"} AS constraint_name, ${sourceNamespace} AS source_namespace, ${sourceTable} AS source_table, ${targetNamespace} AS target_namespace, ${targetTable} AS target_table, ${isOwned({ namespace: sourceNamespace, table: sourceTable })} AS source_owned, ${isOwned({ namespace: targetNamespace, table: targetTable })} AS target_owned FROM ${from}) dependencies
+WHERE source_owned OR target_owned
+ORDER BY source_namespace, source_table, constraint_name`,
+    values: collector.values,
+    returning: "none"
+  };
+}
+// packages/sql/src/dialects/migration-replay-coverage.ts
+var extensionMember = (classid, objid) => `EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = '${classid}'::regclass AND d.objid = ${objid} AND d.deptype = 'e')`;
+var extensionOwnedNamespace = `(EXISTS (SELECT 1 FROM pg_catalog.pg_extension e WHERE e.extnamespace = n.oid) OR ${extensionMember("pg_namespace", "n.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.relnamespace = n.oid AND c.relkind IN ('r', 'p', 'v', 'm', 'f', 'S') AND NOT ${extensionMember("pg_class", "c.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_proc p WHERE p.pronamespace = n.oid AND NOT ${extensionMember("pg_proc", "p.oid")}) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_type t WHERE t.typnamespace = n.oid AND (t.typrelid = 0 AND t.typelem = 0 OR t.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c')) AND NOT ${extensionMember("pg_type", "t.oid")})`;
+function renderReplayCoverageGaps(params) {
+  const { dialect } = params;
+  const collector = new ParamCollector(dialect);
+  const namespace = collector.add(params.namespace);
+  if (dialect.name === "postgres")
+    return { text: `SELECT 'type' AS kind, t.typname::text AS name, n.nspname::text AS namespace, NULL::text AS parent FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND (t.typtype IN ('b', 'd', 'r', 'm') AND t.typelem = 0 OR t.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c')) 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')
+UNION ALL SELECT 'routine', p.proname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.prokind <> 'f' AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_proc'::regclass AND d.objid = p.oid AND d.deptype = 'e')
+UNION ALL SELECT 'relation-layout', c.relname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND (c.relkind IN ('p', 'f') OR c.relispartition OR EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid)) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'e')
+UNION ALL SELECT 'rule', r.rulename::text, n.nspname::text, c.relname::text FROM pg_catalog.pg_rewrite r JOIN pg_catalog.pg_class c ON c.oid = r.ev_class JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND r.rulename <> '_RETURN' AND NOT ${extensionMember("pg_class", "c.oid")}
+UNION ALL SELECT 'namespace', n.nspname::text, n.nspname::text, NULL::text FROM pg_catalog.pg_namespace n WHERE n.nspname <> ${namespace} AND n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND NOT (${extensionOwnedNamespace})${params.privateNamespace === undefined ? "" : ` AND n.nspname <> ${collector.add(params.privateNamespace)}`}`, values: collector.values, returning: "none" };
+  if (dialect.name === "mysql")
+    return { text: `SELECT 'procedure' AS kind, ROUTINE_NAME AS name, ROUTINE_SCHEMA AS namespace, NULL AS parent FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_TYPE = 'PROCEDURE'
+UNION ALL SELECT 'event', EVENT_NAME, EVENT_SCHEMA, NULL FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ${collector.add(params.namespace)}
+UNION ALL SELECT DISTINCT 'partition', TABLE_NAME, TABLE_SCHEMA, NULL FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = ${collector.add(params.namespace)} AND PARTITION_NAME IS NOT NULL`, values: collector.values, returning: "none" };
+  return { text: `SELECT 'table-options' AS kind, name, schema AS namespace, NULL AS parent FROM pragma_table_list WHERE schema = ${namespace} AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND (type = 'virtual' OR wr <> 0 OR strict <> 0)`, values: collector.values, returning: "none" };
+}
+// packages/sql/src/dialects/migration-shadow.ts
+import { assertSqlNamespace, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+var SHADOW_DATABASE = Object.freeze({ schema: "_vibeorm_shadow", table: "_vibe_shadow", lock: 1447645267, timeoutSeconds: 60 });
+var SHADOW_CAPABILITIES = Object.freeze({
+  postgres: Object.freeze({ serverProvisioning: true, dedicated: true }),
+  mysql: Object.freeze({ serverProvisioning: true, dedicated: true }),
+  sqlite: Object.freeze({ serverProvisioning: false, dedicated: false })
+});
+function renderShadowOperation(params) {
+  const { dialect, operation } = params;
+  if (!SHADOW_CAPABILITIES[dialect.name].serverProvisioning)
+    throw unsupportedCapability13({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
+  const pg = dialect.name === "postgres";
+  const collector = new ParamCollector(dialect);
+  const marker = pg ? `${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}.${dialect.quoteIdent({ name: SHADOW_DATABASE.table })}` : dialect.quoteIdent({ name: SHADOW_DATABASE.table });
+  const result = (text) => [{ text, values: collector.values, returning: "none" }];
+  switch (operation.kind) {
+    case "createDatabase":
+      return result(`CREATE DATABASE ${dialect.quoteIdent({ name: operation.name })}${pg ? " TEMPLATE template0" : ""}`);
+    case "dropDatabase":
+      return result(`DROP DATABASE ${dialect.quoteIdent({ name: operation.name })}`);
+    case "identity":
+      return result(pg ? `SELECT current_database()::text AS database, (SELECT oid::text FROM pg_catalog.pg_database WHERE datname = current_database()) AS database_id, current_schema()::text AS namespace` : `SELECT DATABASE() AS \`database\`, @@lower_case_table_names AS name_folding, @@server_uuid AS server_id`);
+    case "lock":
+      return result(pg ? `SELECT pg_catalog.pg_advisory_lock(${collector.add(SHADOW_DATABASE.lock)})` : `SELECT GET_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}, ${collector.add(SHADOW_DATABASE.timeoutSeconds)}) AS acquired`);
+    case "unlock":
+      return result(pg ? `SELECT pg_catalog.pg_advisory_unlock(${collector.add(SHADOW_DATABASE.lock)}) AS released` : `SELECT RELEASE_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}) AS released`);
+    case "markerExists":
+      return result(pg ? `SELECT c.relname AS name FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${collector.add(SHADOW_DATABASE.schema)} AND c.relname = ${collector.add(SHADOW_DATABASE.table)}` : `SELECT TABLE_NAME AS name FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)}`);
+    case "markerRead":
+      return result(`SELECT payload FROM ${marker}`);
+    case "markerColumns":
+      return result(`SELECT column_name AS name, data_type AS type, is_nullable AS nullable FROM information_schema.columns AS marker_column WHERE table_schema = ${pg ? collector.add(SHADOW_DATABASE.schema) : "DATABASE()"} AND table_name = ${collector.add(SHADOW_DATABASE.table)} AND ${pg ? `EXISTS (SELECT 1 FROM pg_catalog.pg_class r JOIN pg_catalog.pg_namespace n ON n.oid = r.relnamespace WHERE n.nspname = marker_column.table_schema AND r.relname = marker_column.table_name AND r.relkind = 'r' AND r.relpersistence = 'p' AND NOT r.relrowsecurity AND NOT r.relforcerowsecurity AND NOT r.relhasrules AND NOT r.relhastriggers AND NOT r.relispartition AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attrdef a WHERE a.adrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_constraint c WHERE c.conrelid = r.oid AND c.contype <> 'n') AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_index i WHERE i.indrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = r.oid OR i.inhparent = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attribute a WHERE a.attrelid = r.oid AND (a.attisdropped OR a.attidentity <> '' OR a.attgenerated <> '')))` : `EXISTS (SELECT 1 FROM information_schema.TABLES t WHERE t.TABLE_SCHEMA = marker_column.table_schema AND t.TABLE_NAME = marker_column.table_name AND t.TABLE_TYPE = 'BASE TABLE' AND t.ENGINE = 'InnoDB') AND NOT EXISTS (SELECT 1 FROM information_schema.COLUMNS c WHERE c.TABLE_SCHEMA = marker_column.table_schema AND c.TABLE_NAME = marker_column.table_name AND (c.COLUMN_DEFAULT IS NOT NULL OR c.EXTRA <> '')) AND NOT EXISTS (SELECT 1 FROM information_schema.TRIGGERS t WHERE t.EVENT_OBJECT_SCHEMA = DATABASE() AND t.EVENT_OBJECT_TABLE = ${collector.add(SHADOW_DATABASE.table)}) AND NOT EXISTS (SELECT 1 FROM information_schema.TABLE_CONSTRAINTS c WHERE c.TABLE_SCHEMA = DATABASE() AND c.TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)})`}
+ORDER BY ordinal_position`);
+    case "grants": {
+      if (pg)
+        throw unsupportedCapability13({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
+      return result("SHOW GRANTS FOR CURRENT_USER");
+    }
+    case "markerCreate":
+      return pg ? [{ text: `CREATE SCHEMA ${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}`, values: [], returning: "none" }, { text: `CREATE TABLE ${marker} (payload text NOT NULL)`, values: [], returning: "none" }] : result(`CREATE TABLE ${marker} (payload LONGTEXT NOT NULL) ENGINE=InnoDB`);
+    case "markerWrite":
+      return result(operation.insert ? `INSERT INTO ${marker} (payload) VALUES (${collector.add(operation.value)})` : `UPDATE ${marker} SET payload = ${collector.add(operation.value)}`);
+    case "journal":
+      return result(`SELECT name, checksum, statement_index, error FROM ${dialect.quoteIdent({ name: "_vibe_migrations" })} ORDER BY name`);
+    case "inventory":
+      return result(pg ? `SELECT 'namespace' AS kind, nspname::text AS name, nspname::text AS namespace FROM pg_catalog.pg_namespace WHERE nspname NOT IN ('public', 'information_schema') AND nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'relation', c.relname::text, n.nspname::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'routine', p.proname::text, n.nspname::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'type', t.typname::text, n.nspname::text FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND t.typrelid = 0 AND t.typelem = 0
+UNION ALL SELECT 'extension', e.extname::text, n.nspname::text FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE e.extname <> 'plpgsql'
+UNION ALL SELECT 'marker-dependency', d.objid::text, '${SHADOW_DATABASE.schema}' FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON d.classid = 'pg_class'::regclass AND d.objid = c.oid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}' AND d.deptype NOT IN ('i', 'a') AND d.refclassid <> 'pg_namespace'::regclass
+UNION ALL SELECT 'marker-trigger', t.tgname::text, n.nspname::text FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}'
+UNION ALL SELECT 'namespace-object', o.name::text, n.nspname::text FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_namespace n ON d.refclassid = 'pg_namespace'::regclass AND d.refobjid = n.oid CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.classid, d.objid, d.objsubid) o WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND d.classid NOT IN ('pg_class'::regclass, 'pg_proc'::regclass, 'pg_type'::regclass, 'pg_extension'::regclass)
+UNION ALL SELECT 'database-object', evtname::text, '' FROM pg_catalog.pg_event_trigger
+UNION ALL SELECT 'database-object', pubname::text, '' FROM pg_catalog.pg_publication
+UNION ALL SELECT 'database-object', subname::text, '' FROM pg_catalog.pg_subscription WHERE subdbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = current_database())
+UNION ALL SELECT 'database-object', srvname::text, '' FROM pg_catalog.pg_foreign_server
+UNION ALL SELECT 'database-object', fdwname::text, '' FROM pg_catalog.pg_foreign_data_wrapper
+UNION ALL SELECT 'database-object', c.oid::text, '' FROM pg_catalog.pg_cast c JOIN pg_catalog.pg_type s ON s.oid = c.castsource JOIN pg_catalog.pg_type t ON t.oid = c.casttarget LEFT JOIN pg_catalog.pg_proc p ON p.oid = c.castfunc WHERE s.typnamespace <> 'pg_catalog'::regnamespace OR t.typnamespace <> 'pg_catalog'::regnamespace OR p.pronamespace <> 'pg_catalog'::regnamespace` : `SELECT TABLE_TYPE AS kind, TABLE_NAME AS name, TABLE_SCHEMA AS namespace FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()
+UNION ALL SELECT ROUTINE_TYPE, ROUTINE_NAME, ROUTINE_SCHEMA FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = DATABASE()
+UNION ALL SELECT 'EVENT', EVENT_NAME, EVENT_SCHEMA FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE()
+UNION ALL SELECT 'TRIGGER', TRIGGER_NAME, TRIGGER_SCHEMA FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = DATABASE()
+UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME), CONSTRAINT_SCHEMA FROM information_schema.REFERENTIAL_CONSTRAINTS WHERE UNIQUE_CONSTRAINT_SCHEMA = DATABASE() AND CAST(CONSTRAINT_SCHEMA AS BINARY) <> CAST(DATABASE() AS BINARY)`);
+    case "resetPostgres":
+    case "resetDedicatedPostgres": {
+      if (!pg)
+        throw unsupportedCapability13({ dialect: dialect.name, feature: "postgresShadowReset" });
+      const owned = operation.kind === "resetDedicatedPostgres" ? operation.ownedNamespaces : [];
+      for (const namespace of owned)
+        assertSqlNamespace({ namespace, dialect: "postgres", allowPublic: false });
+      return [
+        ...owned.map((namespace) => ({ text: `DROP SCHEMA IF EXISTS ${dialect.quoteIdent({ name: namespace })} CASCADE`, values: [], returning: "none" })),
+        { text: 'DROP SCHEMA "public" CASCADE', values: [], returning: "none" },
+        { text: 'CREATE SCHEMA "public"', values: [], returning: "none" }
+      ];
+    }
+    case "mysqlForeignKeys": {
+      if (pg)
+        throw unsupportedCapability13({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
+    }
+    case "dropMysqlObject": {
+      if (pg)
+        throw unsupportedCapability13({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
+    }
+  }
+}
+// packages/sql/src/module-journal.ts
+var MODULE_JOURNAL_COLUMN = "module_origin";
+function renderModuleJournal(params) {
+  const { dialect, operation } = params;
+  const q = (name) => dialect.quoteIdent({ name });
+  const table = q(params.table);
+  const column = q(MODULE_JOURNAL_COLUMN);
+  const collector = new ParamCollector(dialect);
+  let text;
+  switch (operation.kind) {
+    case "columns":
+      text = dialect.name === "sqlite" ? `PRAGMA table_info(${table})` : `SELECT column_name AS name FROM information_schema.columns WHERE table_schema = ${dialect.name === "postgres" ? "current_schema()" : "DATABASE()"} AND table_name = ${collector.add(params.table)}`;
+      break;
+    case "addColumn":
+      text = `ALTER TABLE ${table} ADD COLUMN ${column} ${dialect.name === "mysql" ? "LONGTEXT" : "TEXT"}`;
+      break;
+    case "read":
+      text = `SELECT * FROM ${table} ORDER BY ${q("id")}`;
+      break;
     case "insert":
       text = `INSERT INTO ${table} (${["name", "checksum", "statement_index", MODULE_JOURNAL_COLUMN].map(q).join(", ")}) VALUES (${collector.addMany([operation.name, operation.checksum, operation.index, operation.entry]).join(", ")})`;
       break;
@@ -1320,10 +2309,10 @@ import {
 } from "@vibeorm/schema";
 
 // packages/sql/src/identifiers.ts
-import { VibeError as VibeError7 } from "@vibeorm/schema";
+import { VibeError as VibeError12 } from "@vibeorm/schema";
 function assertNoNul(params) {
   if (params.name.includes("\x00")) {
-    throw new VibeError7({
+    throw new VibeError12({
       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") }
@@ -1338,6 +2327,13 @@ var sqliteDialect = {
   capabilities: SQLITE_CAPABILITIES,
   inArrayStrategy: "expand",
   tupleInStrategy: "rowValue",
+  keyListStrategy: "values",
+  keysetSeekStrategy: "rowValue",
+  keyPageStrategy: "inLimit",
+  relationFilterStrategy: "inSelect",
+  deferredJoinPage: null,
+  nativeNullsOrder: "low",
+  nullsUnionPage: false,
   timeOfDayInStrategy: "in",
   upsertForm: "onConflict",
   conflictKeyEquality: {
@@ -1369,6 +2365,7 @@ var sqliteDialect = {
   rowLockSyntax: null,
   advisoryLockFunctions: null,
   rowDefaultKeyword: false,
+  bulkInsertForm: "values",
   emptyInsert: { form: "defaultValues", conflictClause: false },
   statementChain: null,
   paramBudget: 900,
@@ -1392,84 +2389,6 @@ var sqliteDialect = {
   }
 };
 
-// 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/sqlite-fts.ts
 function updateStatements(params) {
   const quote = (name) => sqliteDialect.quoteIdent({ name });
@@ -1531,11 +2450,11 @@ var SQLITE_SESSION_SQL = Object.freeze({
   foreignKeysOn: "PRAGMA foreign_keys = ON"
 });
 // packages/sql/src/composable.ts
-import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 var fragments = new WeakMap;
 registerSqlHandleCheck({ check: (value) => fragments.has(value) });
-function invalid3(message) {
-  throw new VibeError9({ code: "VIBE_VALIDATION", message });
+function invalid4(message) {
+  throw new VibeError13({ code: "VIBE_VALIDATION", message });
 }
 function construct(parts) {
   const snapshot = Object.freeze([...parts]);
@@ -1549,19 +2468,19 @@ function isSqlFragment(value) {
   return typeof value === "object" && value !== null && fragments.has(value);
 }
 function partsOf(value) {
-  return fragments.get(value) ?? invalid3("Expected a constructed SQL fragment");
+  return fragments.get(value) ?? invalid4("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"))) {
-    invalid3("SQL identifiers require non-empty, NUL-free name components");
+    invalid4("SQL identifiers require non-empty, NUL-free name components");
   }
 }
 function template(strings, ...values) {
   if (!Array.isArray(strings) || !Array.isArray(strings.raw) || strings.length !== values.length + 1 || strings.some((text) => typeof text !== "string")) {
-    invalid3("Use sql as a template tag");
+    invalid4("Use sql as a template tag");
   }
   const parts = [];
   for (let index = 0;index < strings.length; index++) {
@@ -1579,7 +2498,7 @@ function template(strings, ...values) {
 var sql = Object.freeze(Object.assign(template, {
   text: ({ text }) => {
     if (typeof text !== "string" || text.includes("\x00"))
-      invalid3("SQL text must be a NUL-free string");
+      invalid4("SQL text must be a NUL-free string");
     return construct([text]);
   },
   ident: ({ parts }) => {
@@ -1589,7 +2508,7 @@ var sql = Object.freeze(Object.assign(template, {
   value: ({ value, decoder }) => construct([Object.freeze({ value: snapshotSqlValue(value), ...decoder === undefined ? {} : { decoder } })]),
   join: ({ items, separator }) => {
     if (!Array.isArray(items))
-      invalid3("sql.join requires an array");
+      invalid4("sql.join requires an array");
     const between = separator === undefined ? [", "] : partsOf(separator);
     const parts = [];
     items.forEach((value, index) => {
@@ -1609,7 +2528,7 @@ var sql = Object.freeze(Object.assign(template, {
   },
   greatest: ({ values }) => {
     if (!Array.isArray(values) || values.length !== 2 || values.some((value) => !isSqlFragment(value)))
-      invalid3("sql.greatest requires two SQL fragments");
+      invalid4("sql.greatest requires two SQL fragments");
     return construct([Object.freeze({ greatest: Object.freeze([...values]) })]);
   }
 }));
@@ -1618,7 +2537,7 @@ function renderSqlFragment(params) {
   const render = (fragment) => renderSqlFragment({ ...params, fragment });
   const encode = (part) => {
     if (part.value === undefined)
-      invalid3("SQL parameters cannot be undefined; use null explicitly");
+      invalid4("SQL parameters cannot be undefined; use null explicitly");
     return snapshotSqlValue(part.decoder === undefined ? part.value : part.decoder.encode({ value: snapshotSqlValue(part.value), dialect: dialect.name }));
   };
   const recording = isSqlBindingCollector({ collector });
@@ -1633,12 +2552,12 @@ function renderSqlFragment(params) {
     const only = parts.length === 1 ? parts[0] : undefined;
     if (recording && only !== undefined && typeof only !== "string" && "value" in only) {
       if (only.decoder !== undefined && resultScalarContract({ decoder: only.decoder }) === undefined)
-        throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL cannot compile an opaque encoder whose output controls a greatest NULL frame" });
+        throw new VibeError13({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL cannot compile an opaque encoder whose output controls a greatest NULL frame" });
       if (only.value === null) {
         if (only.decoder !== undefined)
           recordSqlBindingCheck({ collector, check: () => {
             if (encode({ ...only, value: snapshotSqlValue(only.value) }) !== null)
-              throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL NULL frame encoding changed its declared structure" });
+              throw new VibeError13({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL NULL frame encoding changed its declared structure" });
           } });
         return "NULL";
       }
@@ -1660,10 +2579,10 @@ function renderSqlFragment(params) {
       return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
     if ("row" in part) {
       if (conflict === undefined)
-        invalid3("Existing/incoming row references require a conflict update");
+        invalid4("Existing/incoming row references require a conflict update");
       const name = conflict.columns === undefined ? part.column : conflict.columns[part.column];
       if (name === undefined)
-        invalid3(`Unknown conflict-expression field "${part.column}"`);
+        invalid4(`Unknown conflict-expression field "${part.column}"`);
       const ref = dialect.excludedRowRef;
       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 })}`;
@@ -1685,7 +2604,7 @@ function mapConflictColumns(params) {
     if ("row" in part) {
       const column = Object.hasOwn(params.columns, part.column) ? params.columns[part.column] : undefined;
       if (column === undefined)
-        invalid3(`Unknown conflict-expression field "${part.column}"`);
+        invalid4(`Unknown conflict-expression field "${part.column}"`);
       return Object.freeze({ ...part, column });
     }
     if ("greatest" in part)
@@ -1702,25 +2621,25 @@ 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/query-plan.ts
-import { VibeError as VibeError10 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
 var queries = new WeakMap;
 var commands = new WeakMap;
 var reusableQueries = new WeakMap;
 var reusableCommands = new WeakMap;
 registerSqlHandleCheck({ check: (value) => queries.has(value) || commands.has(value) || reusableQueries.has(value) || reusableCommands.has(value) });
-function invalid4(message) {
-  throw new VibeError10({ code: "VIBE_VALIDATION", message });
+function invalid5(message) {
+  throw new VibeError14({ code: "VIBE_VALIDATION", message });
 }
 function createSqlQuery(params) {
   if (typeof params.render !== "function" || typeof params.decoder?.decode !== "function")
-    invalid4("SQL queries require a renderer and result decoder");
+    invalid5("SQL queries require a renderer and result decoder");
   const query = Object.freeze(Object.create(null));
   queries.set(query, Object.freeze({ render: params.render, decoder: params.decoder }));
   return query;
 }
 function createSqlCommand(params) {
   if (typeof params.render !== "function")
-    invalid4("SQL commands require a renderer");
+    invalid5("SQL commands require a renderer");
   const command = Object.freeze(Object.create(null));
   commands.set(command, params.render);
   return command;
@@ -1738,14 +2657,14 @@ function isReusableSqlCommand(value) {
   return typeof value === "object" && value !== null && reusableCommands.has(value);
 }
 function createReusableSqlQuery(params) {
-  const state = queries.get(params.query) ?? invalid4("Expected an authentic SQL row query");
+  const state = queries.get(params.query) ?? invalid5("Expected an authentic SQL row query");
   sqlInputScopeKeys({ scope: params.scope });
   const query = Object.freeze(Object.create(null));
   reusableQueries.set(query, { ...state, scope: params.scope, cache: new WeakMap });
   return query;
 }
 function createReusableSqlCommand(params) {
-  const render = commands.get(params.query) ?? invalid4("Expected an authentic SQL command");
+  const render = commands.get(params.query) ?? invalid5("Expected an authentic SQL command");
   sqlInputScopeKeys({ scope: params.scope });
   const query = Object.freeze(Object.create(null));
   reusableCommands.set(query, { render, scope: params.scope, cache: new WeakMap });
@@ -1759,7 +2678,7 @@ function compiledTemplate(params) {
   startSqlBindingCollection({ collector, dialect: params.dialect, scope: params.state.scope });
   const text = params.state.render({ dialect: params.dialect, collector });
   if (collector.count() > params.dialect.paramBudget)
-    invalid4("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
+    invalid5("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
   const program = finishSqlBindingCollection({ collector });
   const compiled = Object.freeze({ text, program });
   params.state.cache.set(params.dialect, compiled);
@@ -1769,385 +2688,55 @@ function executionHandle(params) {
   const { value } = params;
   return queries.has(value) || commands.has(value) || reusableQueries.has(value) || reusableCommands.has(value) || isSqlFragment(value) || isSqlInput(value) || sqlInputScopeHandle(params);
 }
-function bindTemplate(params) {
-  const { scope } = params.state;
-  return bindSqlBindingProgram({ program: params.compiled.program, params: params.inputs, isHandle: (value) => executionHandle({ scope, value }) });
-}
-function compileReusableSqlQuery(params) {
-  const state = reusableQueries.get(params.query) ?? invalid4("Expected an authentic reusable SQL row query");
-  const compiled = compiledTemplate({ dialect: params.dialect, state });
-  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }), decoder: state.decoder };
-}
-function compileReusableSqlCommand(params) {
-  const state = reusableCommands.get(params.query) ?? invalid4("Expected an authentic reusable SQL command");
-  const compiled = compiledTemplate({ dialect: params.dialect, state });
-  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }) };
-}
-function compileSqlQuery(params) {
-  const state = queries.get(params.query) ?? invalid4("Expected an authentic SQL row query");
-  const collector = new ParamCollector(params.dialect);
-  const text = state.render({ dialect: params.dialect, collector });
-  if (collector.values.length > params.dialect.paramBudget)
-    invalid4("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
-  return { text, values: collector.values, decoder: state.decoder };
-}
-function compileSqlCommand(params) {
-  const render = commands.get(params.query) ?? invalid4("Expected an authentic SQL command");
-  const collector = new ParamCollector(params.dialect);
-  const text = render({ dialect: params.dialect, collector });
-  if (collector.values.length > params.dialect.paramBudget)
-    invalid4("SQL command exceeds this dialect's parameter budget; statements are never split implicitly");
-  return { text, values: collector.values };
-}
-// packages/sql/src/exclusion.ts
-import { VibeError as VibeError12, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
-
-// packages/sql/src/predicate.ts
-import { VibeError as VibeError11, assertPredicateCapabilities, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
-function renderPredicate(params) {
-  assertPredicateCapabilities({ predicate: params.predicate, dialect: params.dialect.name, usage: params.usage });
-  if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "exclusionConstraints" });
-  if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
-    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "partialIndexes" });
-  }
-  const context = {
-    model: params.model,
-    dialect: params.dialect,
-    enums: params.enums ?? [],
-    usage: params.usage,
-    site: params.site
-  };
-  return renderNode({ node: params.predicate, context });
-}
-var PRECEDENCE = {
-  or: 1,
-  and: 2,
-  not: 3,
-  compare: 4,
-  inList: 4,
-  isNull: 4,
-  isTrue: 4
-};
-var COMPARISON_SQL = {
-  eq: "=",
-  ne: "<>",
-  gt: ">",
-  gte: ">=",
-  lt: "<",
-  lte: "<="
-};
-var EXACT_INTEGER = /^-?(0|[1-9]\d*)$/;
-var EXACT_DECIMAL = /^-?(0|[1-9]\d*)(\.\d+)?$/;
-var INT32_MIN = -2147483648n;
-var INT32_MAX = 2147483647n;
-var INT64_MIN = -(2n ** 63n);
-var INT64_MAX = 2n ** 63n - 1n;
-function refuse2(params) {
-  const { context, rule, message } = params;
-  throw new VibeError11({
-    code: "VIBE_SCHEMA_INVALID",
-    message: `${context.site} on "${context.model.name}": ${message}`,
-    meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
-  });
-}
-function renderChild(params) {
-  const { node, parent, context } = params;
-  if ((node.kind === "and" || node.kind === "or") && node.operands.length === 1) {
-    return renderChild({ node: node.operands[0], parent, context });
-  }
-  const text = renderNode({ node, context });
-  return PRECEDENCE[node.kind] < PRECEDENCE[parent] ? `(${text})` : text;
-}
-function renderNode(params) {
-  const { node, context } = params;
-  switch (node.kind) {
-    case "and":
-    case "or": {
-      if (node.operands.length === 0) {
-        refuse2({
-          context,
-          rule: "predicate-empty",
-          message: `${node.kind === "and" ? "and()" : "or()"} has no operands \u2014 an empty boolean group has no honest SQL spelling`
-        });
-      }
-      if (node.operands.length === 1)
-        return renderNode({ node: node.operands[0], context });
-      const separator = node.kind === "and" ? " AND " : " OR ";
-      return node.operands.map((operand) => renderChild({ node: operand, parent: node.kind, context })).join(separator);
-    }
-    case "not":
-      return `NOT ${renderChild({ node: node.operand, parent: "not", context })}`;
-    case "isTrue":
-      return `COALESCE(${renderNode({ node: node.operand, context })}, FALSE)`;
-    case "isNull": {
-      const field = resolveField({ name: node.field.name, context, nullTest: true });
-      return `${quoteColumn({ field, context })} IS ${node.negate === true ? "NOT NULL" : "NULL"}`;
-    }
-    case "compare": {
-      const left = renderExpression({ expression: node.left, context });
-      const right = renderOperand({ operand: node.right, field: left.field, context });
-      return `${left.text} ${COMPARISON_SQL[node.op]} ${right}`;
-    }
-    case "inList": {
-      if (node.values.length === 0) {
-        refuse2({
-          context,
-          rule: "predicate-empty",
-          message: `inList("${node.field.name}") has no values \u2014 an empty IN list is UNKNOWN on every row and never what an author means`,
-          meta: { field: node.field.name }
-        });
-      }
-      const field = resolveField({ name: node.field.name, context });
-      const values = node.values.map((value) => renderLiteral({ value, field, context })).join(", ");
-      return `${compareColumn({ field, context })} ${node.negate === true ? "NOT IN" : "IN"} (${values})`;
-    }
-  }
-}
-function resolveField(params) {
-  const { name, context } = params;
-  const field = context.model.fields.find((candidate) => candidate.name === name);
-  if (field === undefined) {
-    refuse2({
-      context,
-      rule: "predicate-unknown-field",
-      message: `references field "${name}", which the model does not declare`,
-      meta: { field: name }
-    });
-  }
-  if (field.isList) {
-    refuse2({
-      context,
-      rule: "predicate-list-field",
-      message: `compares scalar list "${name}" \u2014 array operators differ per dialect; use a raw expression for them`,
-      meta: { field: name }
-    });
-  }
-  if (field.isUnsupported === true) {
-    refuse2({
-      context,
-      rule: "predicate-unsupported-type",
-      message: `references "${name}", an Unsupported("${field.nativeType ?? "?"}") column whose operators VibeORM does not model \u2014 use a raw expression`,
-      meta: { field: name }
-    });
-  }
-  if (params.nullTest !== true && (field.type === "Json" || field.type === "Bytes")) {
-    refuse2({
-      context,
-      rule: "predicate-unsupported-type",
-      message: `references ${field.type} column "${name}" \u2014 ${field.type} comparison operators differ per dialect; use a raw expression`,
-      meta: { field: name, type: field.type }
-    });
-  }
-  if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
-    throw unsupportedCapability9({
-      dialect: "mysql",
-      feature: `CHECK constraint referencing auto-increment column "${context.model.name}.${name}"`,
-      hint: "mysql refuses this with error 3818 \u2014 enforce the rule in application code or on a non-generated column"
-    });
-  }
-  return field;
-}
-function quoteColumn(params) {
-  const { field, context } = params;
-  return context.dialect.quoteIdent({ name: field.dbName ?? field.name });
-}
-function compareColumn(params) {
-  const { field, context } = params;
-  const quoted = quoteColumn({ field, context });
-  return context.dialect.name === "sqlite" && field.type === "Decimal" ? `CAST(${quoted} AS REAL)` : quoted;
-}
-function renderExpression(params) {
-  const { expression, context } = params;
-  if (expression.kind === "field") {
-    const field = resolveField({ name: expression.name, context });
-    return { text: compareColumn({ field, context }), field };
-  }
-  if (expression.kind === "jsonText") {
-    const field = resolveField({ name: expression.field.name, context, nullTest: true });
-    if (field.type !== "Json")
-      refuse2({ context, rule: "predicate-type-mismatch", message: `jsonText requires a scalar Json field, not "${field.name}"` });
-    if (!Array.isArray(expression.path) || Array.from(expression.path).some((segment) => typeof segment !== "string" || segment.includes("\x00"))) {
-      refuse2({ context, rule: "predicate-json-path", message: "jsonText requires a string-only path without NUL bytes" });
-    }
-    const path = expression.path.map((value) => context.dialect.quoteStringLiteral({ value })).join(", ");
-    return { text: `(${quoteColumn({ field, context })} #>> ARRAY[${path}]::text[])`, field: { ...field, type: "String" } };
-  }
-  const inner = renderExpression({ expression: expression.expression, context });
-  if (inner.field.type !== "String")
-    refuse2({ context, rule: "predicate-type-mismatch", message: "length requires a text expression" });
-  return { text: `length(${inner.text})`, field: { ...inner.field, type: "Int" } };
-}
-function renderOperand(params) {
-  const { operand, field, context } = params;
-  if (operand.kind === "value")
-    return renderLiteral({ value: operand, field, context });
-  const other = renderExpression({ expression: operand, context });
-  const leftType = fieldTypeIdentity({ type: field.type });
-  const rightType = fieldTypeIdentity({ type: other.field.type });
-  if (leftType !== rightType) {
-    refuse2({
-      context,
-      rule: "predicate-type-mismatch",
-      message: `compares "${field.name}" (${leftType}) with "${other.field.name}" (${rightType}) \u2014 both sides of a comparison need the same scalar type`,
-      meta: { field: field.name, other: other.field.name, fieldType: leftType, otherType: rightType }
-    });
-  }
-  return other.text;
+function bindTemplate(params) {
+  const { scope } = params.state;
+  return bindSqlBindingProgram({ program: params.compiled.program, params: params.inputs, isHandle: (value) => executionHandle({ scope, value }) });
 }
-function renderLiteral(params) {
-  const { field, context } = params;
-  const { value } = params.value;
-  const type = field.type;
-  const wrongCarrier = (expected) => refuse2({
-    context,
-    rule: "predicate-type-mismatch",
-    message: `compares ${fieldTypeIdentity({ type })} field "${field.name}" with ${describe({ value })} \u2014 ${expected}`,
-    meta: { field: field.name, fieldType: fieldTypeIdentity({ type }), value }
-  });
-  if (isEnumType(type)) {
-    if (typeof value !== "string")
-      return wrongCarrier(`enum ${type.enum} takes one of its member names as a string`);
-    const declared = context.enums.find((entry) => entry.name === type.enum);
-    if (declared !== undefined && !declared.values.includes(value)) {
-      refuse2({
-        context,
-        rule: "predicate-enum-member",
-        message: `compares "${field.name}" with "${value}", which is not a member of enum ${type.enum} (${declared.values.join(", ")})`,
-        meta: { field: field.name, enum: type.enum, value, members: [...declared.values] }
-      });
-    }
-    return stringLiteral({ value, context, field });
-  }
-  switch (type) {
-    case "String":
-      if (typeof value !== "string")
-        return wrongCarrier("a String column takes a string literal");
-      return stringLiteral({ value, context, field });
-    case "Boolean":
-      if (typeof value !== "boolean")
-        return wrongCarrier("a Boolean column takes `true` or `false`");
-      return value ? context.dialect.booleanLiteral.true : context.dialect.booleanLiteral.false;
-    case "Int":
-      return integerLiteral({ value, field, context, min: INT32_MIN, max: INT32_MAX, label: "Int" });
-    case "BigInt":
-      return integerLiteral({ value, field, context, min: INT64_MIN, max: INT64_MAX, label: "BigInt" });
-    case "Float": {
-      if (typeof value !== "number")
-        return wrongCarrier("a Float column takes a number");
-      if (!Number.isFinite(value)) {
-        refuse2({
-          context,
-          rule: "predicate-literal-invalid",
-          message: `compares "${field.name}" with ${String(value)} \u2014 a Float literal must be finite`,
-          meta: { field: field.name, value: String(value) }
-        });
-      }
-      return String(value);
-    }
-    case "Decimal": {
-      if (typeof value !== "string") {
-        return wrongCarrier('a Decimal column takes exact decimal TEXT ("0", "19.99") \u2014 a JS number cannot carry an exact decimal');
-      }
-      if (!EXACT_DECIMAL.test(value)) {
-        refuse2({
-          context,
-          rule: "predicate-literal-invalid",
-          message: `compares "${field.name}" with "${value}", which is not an exact decimal literal`,
-          meta: { field: field.name, value }
-        });
-      }
-      return value;
-    }
-    case "DateTime":
-      refuse2({
-        context,
-        rule: "predicate-unsupported-literal",
-        message: `compares DateTime field "${field.name}" with a literal \u2014 DateTime literals are spelled differently on postgres, mysql and sqlite, so VibeORM does not guess one. Compare two DateTime columns, or write a raw expression for a fixed instant`,
-        meta: { field: field.name }
-      });
-    case "Json":
-    case "Bytes":
-      return wrongCarrier(`${type} columns take no predicate literal`);
-  }
+function compileReusableSqlQuery(params) {
+  const state = reusableQueries.get(params.query) ?? invalid5("Expected an authentic reusable SQL row query");
+  const compiled = compiledTemplate({ dialect: params.dialect, state });
+  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }), decoder: state.decoder };
 }
-function integerLiteral(params) {
-  const { value, field, context, min, max, label } = params;
-  let text;
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value)) {
-      refuse2({
-        context,
-        rule: "predicate-literal-invalid",
-        message: `compares "${field.name}" with ${String(value)} \u2014 an ${label} literal must be an exact integer JavaScript can represent; pass a bigint or a decimal string for larger values`,
-        meta: { field: field.name, value: String(value) }
-      });
-    }
-    text = String(value);
-  } else if (typeof value === "string") {
-    if (!EXACT_INTEGER.test(value)) {
-      refuse2({
-        context,
-        rule: "predicate-literal-invalid",
-        message: `compares "${field.name}" with "${value}", which is not an exact integer literal`,
-        meta: { field: field.name, value }
-      });
-    }
-    text = value;
-  } else {
-    refuse2({
-      context,
-      rule: "predicate-type-mismatch",
-      message: `compares ${label} field "${field.name}" with ${describe({ value })} \u2014 an ${label} column takes an integer`,
-      meta: { field: field.name, value }
-    });
-  }
-  const parsed = BigInt(text);
-  if (parsed < min || parsed > max) {
-    refuse2({
-      context,
-      rule: "predicate-literal-invalid",
-      message: `compares "${field.name}" with ${text}, which is outside the range an ${label} column can hold (${min}\u2026${max})`,
-      meta: { field: field.name, value: text }
-    });
-  }
-  return text;
+function compileReusableSqlCommand(params) {
+  const state = reusableCommands.get(params.query) ?? invalid5("Expected an authentic reusable SQL command");
+  const compiled = compiledTemplate({ dialect: params.dialect, state });
+  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }) };
 }
-function stringLiteral(params) {
-  const { value, context, field } = params;
-  if (value.includes("\x00")) {
-    refuse2({
-      context,
-      rule: "predicate-literal-invalid",
-      message: `compares "${field.name}" with a string containing a NUL byte, which no dialect here can store`,
-      meta: { field: field.name }
-    });
-  }
-  return context.dialect.quoteStringLiteral({ value });
+function compileSqlQuery(params) {
+  const state = queries.get(params.query) ?? invalid5("Expected an authentic SQL row query");
+  const collector = new ParamCollector(params.dialect);
+  const text = state.render({ dialect: params.dialect, collector });
+  if (collector.values.length > params.dialect.paramBudget)
+    invalid5("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
+  return { text, values: collector.values, decoder: state.decoder };
 }
-function describe(params) {
-  const { value } = params;
-  return typeof value === "string" ? `the string ${JSON.stringify(value)}` : `the ${typeof value} ${String(value)}`;
+function compileSqlCommand(params) {
+  const render = commands.get(params.query) ?? invalid5("Expected an authentic SQL command");
+  const collector = new ParamCollector(params.dialect);
+  const text = render({ dialect: params.dialect, collector });
+  if (collector.values.length > params.dialect.paramBudget)
+    invalid5("SQL command exceeds this dialect's parameter budget; statements are never split implicitly");
+  return { text, values: collector.values };
 }
-
 // packages/sql/src/exclusion.ts
-function invalid5(rule) {
-  throw new VibeError12({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+import { VibeError as VibeError15, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+function invalid6(rule) {
+  throw new VibeError15({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
 }
 function compileExclusion(params) {
   const { exclusion: spec, model, dialect } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
-    invalid5("name");
+    invalid6("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
-    invalid5("range-type");
+    invalid6("range-type");
   if (!["[)", "[]", "()", "(]"].includes(spec.range.bounds))
-    invalid5("bounds");
+    invalid6("bounds");
   const field = (name) => {
     const value = model.fields.find((entry) => entry.name === name);
     if (value === undefined || value.isList || value.isUnsupported)
-      invalid5("field");
+      invalid6("field");
     return value;
   };
   const endpoint = (value) => {
@@ -2155,17 +2744,17 @@ function compileExclusion(params) {
       return "NULL";
     const infinity = "infinity" in value ? value.infinity : value.nullAs;
     if (infinity !== undefined && (spec.range.type === "int8range" || !["infinity", "-infinity"].includes(infinity)))
-      invalid5("infinity");
+      invalid6("infinity");
     const literal = infinity === undefined ? undefined : `${dialect.quoteStringLiteral({ value: infinity })}::${spec.range.type === "tsrange" ? "timestamp" : "timestamptz"}`;
     if ("infinity" in value)
       return literal;
     const column = field(value.field);
     if (fieldTypeIdentity2({ type: column.type }) !== (spec.range.type === "int8range" ? "BigInt" : "DateTime"))
-      invalid5("range-field-type");
+      invalid6("range-field-type");
     if (column.type === "DateTime") {
       const timezone = /timestamptz|timestamp.*with time zone/i.test(column.nativeType ?? "timestamptz");
       if (timezone !== (spec.range.type === "tstzrange"))
-        invalid5("range-timezone");
+        invalid6("range-timezone");
     }
     const sql = dialect.quoteIdent({ name: column.dbName ?? column.name });
     return literal === undefined ? sql : `COALESCE(${sql}, ${literal})`;
@@ -2173,15 +2762,15 @@ function compileExclusion(params) {
   const keys = spec.keys.map((key) => {
     if ("expression" in key) {
       if (!key.expression.trim() || key.expression.includes("\x00") || key.fields.length === 0)
-        invalid5("expression");
+        invalid6("expression");
       key.fields.forEach(field);
       return `(${key.expression}) WITH =`;
     }
     const column = field(key.field);
     if (column.isOptional)
-      invalid5("nullable-key-requires-expression");
+      invalid6("nullable-key-requires-expression");
     if (!isEnumType2(column.type) && !["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
-      invalid5("key-type");
+      invalid6("key-type");
     return `${dialect.quoteIdent({ name: column.dbName ?? column.name })} WITH =`;
   });
   keys.push(`${spec.range.type}(${endpoint(spec.range.lower)}, ${endpoint(spec.range.upper)}, ${dialect.quoteStringLiteral({ value: spec.range.bounds })}) WITH &&`);
@@ -2190,13 +2779,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   return params.exclusion.requiredExtensions.map((name) => `CREATE EXTENSION IF NOT EXISTS ${params.dialect.quoteIdent({ name })};`);
 }
 function renderExclusionDdl(params) {
   const { dialect, table, exclusion, operation } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
   const target = `ALTER TABLE ${dialect.quoteIdent({ name: table })}`;
   if (operation === "drop")
     return [`${target} DROP CONSTRAINT ${dialect.quoteIdent({ name: exclusion.name })};`];
@@ -2205,14 +2794,14 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
   const scope = probe === undefined ? `n.nspname = ${dialect.quoteStringLiteral({ value: params.namespace ?? "public" })}` : `t.oid = ${dialect.quoteStringLiteral({ value: probe })}::regclass`;
   return `SELECT t.relname AS table_name, c.conname AS constraint_name, pg_catalog.pg_get_constraintdef(c.oid, true) AS definition, c.convalidated AS validated, i.indisvalid AS valid, i.indisready AS ready FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class t ON t.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace JOIN pg_catalog.pg_index i ON i.indexrelid = c.conindid WHERE c.contype = 'x' AND ${scope} ORDER BY t.relname, c.conname`;
 }
 function renderExclusionProbe(params) {
   const { dialect, table, probe, definition } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
   return [`CREATE TEMP TABLE ${dialect.quoteIdent({ name: probe })} (LIKE ${dialect.quoteIdent({ name: params.namespace ?? "public" })}.${dialect.quoteIdent({ name: table })})`, `ALTER TABLE ${dialect.quoteIdent({ name: probe })} ADD CONSTRAINT ${dialect.quoteIdent({ name: `${probe}_x` })} ${definition}`];
 }
 // packages/sql/src/ast.ts
@@ -2244,6 +2833,8 @@ function dbNowMarker(params) {
 function isDbNowMarker(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
+  if (!Object.hasOwn(value, "__dbNow"))
+    return false;
   const keys = Object.keys(value);
   if (keys.length !== 2 || !keys.includes("__dbNow") || !keys.includes("offsetSeconds"))
     return false;
@@ -2291,7 +2882,7 @@ function chainVetoToken(params) {
   return;
 }
 // packages/sql/src/locks.ts
-import { internalError, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { internalError, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -2311,7 +2902,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability11({
+    throw unsupportedCapability15({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -2319,7 +2910,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability11({
+    throw unsupportedCapability15({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -2327,7 +2918,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability11({
+    throw unsupportedCapability15({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -2346,7 +2937,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability11({
+    throw unsupportedCapability15({
       dialect: dialect.name,
       feature: "advisory locks",
       hint: dialect.name === "mysql" ? "mysql's GET_LOCK is SESSION-scoped \u2014 it survives a rollback, so it cannot be released with the transaction" : `${dialect.name} has no advisory-lock functions`
@@ -2385,6 +2976,13 @@ var postgresDialect = {
   capabilities: POSTGRES_CAPABILITIES,
   inArrayStrategy: "any",
   tupleInStrategy: "rowValue",
+  keyListStrategy: "unnest",
+  keysetSeekStrategy: "rowValue",
+  keyPageStrategy: "lateral",
+  relationFilterStrategy: "exists",
+  deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: true },
+  nativeNullsOrder: "high",
+  nullsUnionPage: true,
   timeOfDayInStrategy: "in",
   upsertForm: "onConflict",
   conflictKeyEquality: {
@@ -2434,6 +3032,7 @@ var postgresDialect = {
     keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
   },
   rowDefaultKeyword: true,
+  bulkInsertForm: "unnest",
   emptyInsert: { form: "defaultValues", conflictClause: true },
   statementChain: "dataModifyingCte",
   paramBudget: 30000,
@@ -2462,6 +3061,13 @@ var mysqlDialect = {
   capabilities: MYSQL_CAPABILITIES,
   inArrayStrategy: "expand",
   tupleInStrategy: "rowValue",
+  keyListStrategy: "rowValue",
+  keysetSeekStrategy: "or",
+  keyPageStrategy: "window",
+  relationFilterStrategy: "exists",
+  deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: false },
+  nativeNullsOrder: "low",
+  nullsUnionPage: true,
   timeOfDayInStrategy: "equalities",
   upsertForm: "onDuplicateKey",
   conflictKeyEquality: {
@@ -2497,6 +3103,7 @@ var mysqlDialect = {
   },
   advisoryLockFunctions: null,
   rowDefaultKeyword: true,
+  bulkInsertForm: "values",
   emptyInsert: { form: "emptyRow" },
   statementChain: null,
   paramBudget: 1e4,
@@ -2528,6 +3135,389 @@ var SQL_DIALECTS = {
 function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
+// packages/sql/src/key-list.ts
+import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+var SCALAR_ELEMENT_TYPES = Object.freeze({
+  String: "text",
+  Boolean: "bool",
+  Int: "int4",
+  BigInt: "int8",
+  Float: "float8",
+  Decimal: "numeric",
+  DateTime: "timestamptz",
+  Json: null,
+  Bytes: "bytea"
+});
+var NATIVE_ELEMENT_TYPES = Object.freeze({
+  text: "text",
+  varchar: "varchar",
+  charactervarying: "varchar",
+  char: "bpchar",
+  character: "bpchar",
+  bpchar: "bpchar",
+  uuid: "uuid",
+  citext: "citext",
+  xml: "xml",
+  inet: "inet",
+  money: "money",
+  bit: '"bit"',
+  varbit: "varbit",
+  bitvarying: "varbit",
+  smallint: "int2",
+  int2: "int2",
+  integer: "int4",
+  int: "int4",
+  int4: "int4",
+  bigint: "int8",
+  int8: "int8",
+  oid: "oid",
+  real: "float4",
+  float4: "float4",
+  doubleprecision: "float8",
+  double: "float8",
+  float8: "float8",
+  decimal: "numeric",
+  numeric: "numeric",
+  boolean: "bool",
+  bool: "bool",
+  timestamp: "timestamp",
+  timestampwithouttimezone: "timestamp",
+  timestamptz: "timestamptz",
+  timestampwithtimezone: "timestamptz",
+  date: "date",
+  time: "time",
+  timewithouttimezone: "time",
+  timetz: "timetz",
+  timewithtimezone: "timetz",
+  bytea: "bytea"
+});
+function postgresKeyListElementTypeOf(params) {
+  const { dialect, member } = params;
+  if (member.type === "Enum") {
+    if (member.enumType === undefined)
+      return "text";
+    const name = dialect.quoteIdent({ name: member.enumType.name });
+    return member.enumType.namespace === undefined ? name : `${dialect.quoteIdent({ name: member.enumType.namespace })}.${name}`;
+  }
+  const native = member.nativeType === undefined ? undefined : NATIVE_ELEMENT_TYPES[member.nativeType.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, "")];
+  const type = member.nativeType === undefined ? SCALAR_ELEMENT_TYPES[member.type] : native;
+  return type === null ? undefined : type;
+}
+function postgresKeyListElementType(params) {
+  const { dialect, member } = params;
+  const type = postgresKeyListElementTypeOf({ dialect, member });
+  if (type === undefined) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: `the key-list filter (IN) on a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} member`,
+      hint: "IN binds every member as a typed array; filter this field with equality inside OR instead"
+    });
+  }
+  return type;
+}
+function keyListBindsUntypedRows(params) {
+  return params.members.some((member) => member.type === "DateTime" && member.nativeType === undefined);
+}
+function postgresBulkInsertArrayCastOf(params) {
+  const { dialect, member } = params;
+  if (member.type === "Json")
+    return member.nativeType?.trim().toLowerCase() === "json" ? "text::json" : "text::jsonb";
+  return postgresKeyListElementTypeOf({ dialect, member });
+}
+function postgresBulkInsertArrayCast(params) {
+  const { dialect, member } = params;
+  const cast = postgresBulkInsertArrayCastOf({ dialect, member });
+  if (cast === undefined) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: `a bulk insert binding a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} column as a typed array`,
+      hint: "the query builder keeps VALUES for this column type"
+    });
+  }
+  return cast;
+}
+// packages/sql/src/local-date.ts
+import { localDateCheckName } from "@vibeorm/schema";
+function renderLocalDateCheck({ dialect, table, column }) {
+  if (dialect.name !== "sqlite")
+    return;
+  const quoted = dialect.quoteIdent({ name: column });
+  return {
+    name: localDateCheckName({ table, column }),
+    expression: `${quoted} IS date(${quoted}) AND (${quoted} IS NULL OR ${quoted} >= ${dialect.quoteStringLiteral({ value: "0001-01-01" })})`
+  };
+}
+// packages/sql/src/generated-columns.ts
+import { VibeError as VibeError16, unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/postgres-generated-columns.ts
+import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+function renderPostgresGeneratedColumnClause({ generated }) {
+  return `GENERATED ALWAYS AS (${generated.expression}) STORED`;
+}
+function renderPostgresGeneratedColumnProbe({ dialect, probe }) {
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability17({ dialect: dialect.name, feature: "rollbackGeneratedColumnProbe" });
+  const q = ({ name }) => dialect.quoteIdent({ name });
+  let text;
+  switch (probe.operation) {
+    case "savepoint":
+      text = `SAVEPOINT ${q({ name: probe.savepoint })}`;
+      break;
+    case "rollback":
+      text = `ROLLBACK TO SAVEPOINT ${q({ name: probe.savepoint })}`;
+      break;
+    case "release":
+      text = `RELEASE SAVEPOINT ${q({ name: probe.savepoint })}`;
+      break;
+    case "add":
+      text = `ALTER TABLE ${q({ name: probe.table.namespace })}.${q({ name: probe.table.name })} ADD COLUMN ${q({ name: probe.column })} ${probe.definition}`;
+      break;
+  }
+  return { text, values: [], returning: "none" };
+}
+function renderPostgresDropGeneratedExpression({ dialect, table, column }) {
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability17({ dialect: dialect.name, feature: "dropGeneratedExpression" });
+  return { text: `ALTER TABLE ${dialect.quoteIdent({ name: table.namespace })}.${dialect.quoteIdent({ name: table.name })} ALTER COLUMN ${dialect.quoteIdent({ name: column })} DROP EXPRESSION`, values: [], returning: "none" };
+}
+
+// packages/sql/src/generated-columns.ts
+function renderGeneratedColumnClause({ dialect, generated }) {
+  if (!("generatedColumns" in dialect.capabilities) || dialect.capabilities.generatedColumns !== true) {
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "generatedColumns" });
+  }
+  if (generated.storage !== "stored") {
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "virtualGeneratedColumns" });
+  }
+  if (typeof generated.expression !== "string" || generated.expression.trim().length === 0 || generated.expression.includes("\x00")) {
+    throw new VibeError16({ code: "VIBE_SCHEMA_INVALID", message: "A generated column requires non-empty, NUL-free SQL", meta: { reason: "generated-expression-invalid" } });
+  }
+  switch (dialect.name) {
+    case "postgres":
+      return renderPostgresGeneratedColumnClause({ generated });
+    case "mysql":
+      return renderMysqlGeneratedColumnClause({ generated });
+    case "sqlite":
+      return renderSqliteGeneratedColumnClause({ generated });
+  }
+}
+// packages/sql/src/row-rules.ts
+import { VibeError as VibeError20, internalError as internalError2, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/postgres-row-rules.ts
+import { VibeError as VibeError17, unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+function comparison({ dialect, field }) {
+  const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
+  const cast = field.type === "Json" ? `::pg_catalog.jsonb${field.isList ? "[]" : ""}` : "";
+  return `OLD.${column}${cast} IS DISTINCT FROM NEW.${column}${cast}`;
+}
+function renderPostgresRowRule({ dialect, context }) {
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability19({ dialect: dialect.name, feature: "postgresRowRules" });
+  const { rule, table, functionIdentity, triggerIdentity, protectedFields, gateField } = context;
+  const qualify = ({ name }) => `${dialect.quoteIdent({ name: name.namespace })}.${dialect.quoteIdent({ name: name.name })}`;
+  const functionName = qualify({ name: functionIdentity.name });
+  const tableName = qualify({ name: table });
+  const triggerName = dialect.quoteIdent({ name: triggerIdentity.name });
+  const constraint = dialect.quoteStringLiteral({ value: triggerIdentity.name });
+  const raise = `RAISE EXCEPTION 'VibeORM row rule refused mutation'
+${rule.kind === "appendOnly" ? "    " : "      "}USING ERRCODE = 'check_violation', CONSTRAINT = ${constraint};`;
+  let body;
+  if (rule.kind === "appendOnly") {
+    body = `BEGIN
+  ${raise}
+END;`;
+  } else {
+    const terms = protectedFields.map((field) => comparison({ dialect, field }));
+    if (terms.length === 0) {
+      throw new VibeError17({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+    }
+    const condition = gateField === undefined ? terms.join(`
+    OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
+    ${terms.join(`
+    OR `)}
+  )`;
+    body = `BEGIN
+  IF ${condition} THEN
+    ${raise}
+  END IF;
+  RETURN NEW;
+END;`;
+  }
+  let marker = "$vibe_row_rule$";
+  for (let suffix = 1;body.includes(marker); suffix += 1)
+    marker = `$vibe_row_rule_${suffix}$`;
+  const createFunction = `CREATE FUNCTION ${functionName}() RETURNS pg_catalog.trigger
+LANGUAGE plpgsql VOLATILE CALLED ON NULL INPUT SECURITY INVOKER
+SET search_path = pg_catalog
+AS ${marker}
+${body}
+${marker};`;
+  const createTrigger = `CREATE TRIGGER ${triggerName} BEFORE UPDATE${rule.kind === "appendOnly" ? " OR DELETE" : ""} ON ${tableName}
+FOR EACH ROW EXECUTE FUNCTION ${functionName}();`;
+  return {
+    identities: [functionIdentity, triggerIdentity],
+    create: [{ text: createFunction, values: [] }, { text: createTrigger, values: [] }],
+    drop: [{ text: `DROP TRIGGER ${triggerName} ON ${tableName};`, values: [] }, { text: `DROP FUNCTION ${functionName}();`, values: [] }],
+    protectedFields: protectedFields.map((field) => field.name),
+    ...gateField === undefined ? {} : { gateField: gateField.name }
+  };
+}
+
+// packages/sql/src/dialects/sqlite-row-rules.ts
+import { SQLITE_ROW_RULE_ERROR_PREFIX, VibeError as VibeError18, unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+function renderSqliteRowRule({ dialect, context }) {
+  if (dialect.name !== "sqlite")
+    throw unsupportedCapability20({ dialect: dialect.name, feature: "sqliteRowRules" });
+  const { rule, table, triggers, protectedFields, gateField } = context;
+  if (table.namespace !== "main")
+    throw unsupportedCapability20({ dialect: dialect.name, feature: "fixedNamespaces" });
+  const terms = protectedFields.map((field) => {
+    const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
+    return `OLD.${column} IS NOT NEW.${column}`;
+  });
+  if (rule.kind !== "appendOnly" && terms.length === 0)
+    throw new VibeError18({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+  const condition = rule.kind === "appendOnly" ? "" : gateField === undefined ? `WHEN ${terms.join(`
+  OR `)}
+` : `WHEN OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
+  ${terms.join(`
+  OR `)}
+)
+`;
+  return {
+    identities: triggers.map(({ identity }) => identity),
+    create: triggers.map(({ event, identity }) => ({
+      text: `CREATE TRIGGER ${dialect.quoteIdent({ name: identity.name })} BEFORE ${event.toUpperCase()} ON ${dialect.quoteIdent({ name: table.name })}
+FOR EACH ROW
+${condition}BEGIN
+  SELECT RAISE(ABORT, ${dialect.quoteStringLiteral({ value: `${SQLITE_ROW_RULE_ERROR_PREFIX}${identity.name}` })});
+END;`,
+      values: []
+    })),
+    drop: [...triggers].reverse().map(({ identity }) => ({ text: `DROP TRIGGER ${dialect.quoteIdent({ name: identity.name })};`, values: [] })),
+    protectedFields: protectedFields.map((field) => field.name),
+    ...gateField === undefined ? {} : { gateField: gateField.name }
+  };
+}
+
+// packages/sql/src/dialects/mysql-row-rules.ts
+import { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, VibeError as VibeError19, mysqlRowRuleMessageByteLength, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+function diagnosticLiteral({ name, context, dialect }) {
+  const message = `Check constraint '${name}' is violated.`;
+  if (mysqlRowRuleMessageByteLength({ triggerName: name }) > MYSQL_ROW_RULE_MESSAGE_MAX_BYTES)
+    throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${context.rule.name} exceeds MySQL's ${MYSQL_ROW_RULE_MESSAGE_MAX_BYTES}-byte diagnostic limit; supply a shorter name stem`, meta: { model: context.model, rule: context.rule.name } });
+  if (message.includes("\\")) {
+    const hex = Array.from(new TextEncoder().encode(message), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `_utf8mb4 X'${hex}'`;
+  }
+  return dialect.quoteStringLiteral({ value: message });
+}
+function renderMysqlRowRule({ dialect, context }) {
+  if (dialect.name !== "mysql")
+    throw unsupportedCapability21({ dialect: dialect.name, feature: "mysqlRowRules" });
+  const { rule, table, triggers, protectedFields, gateField, placement } = context;
+  for (const name of Object.keys(placement ?? {}))
+    if (!triggers.some(({ identity }) => identity.name === name))
+      throw new VibeError19({ code: "VIBE_INTERNAL", message: "A MySQL trigger placement names a trigger this rule does not own", meta: { model: context.model, rule: rule.name, trigger: name } });
+  const position = ({ name }) => {
+    const entry = placement?.[name];
+    if (entry === undefined)
+      return "";
+    return "follows" in entry ? ` FOLLOWS ${dialect.quoteIdent({ name: entry.follows })}` : ` PRECEDES ${dialect.quoteIdent({ name: entry.precedes })}`;
+  };
+  const qualify = ({ name }) => table.namespace === "public" ? dialect.quoteIdent({ name }) : `${dialect.quoteIdent({ name: table.namespace })}.${dialect.quoteIdent({ name })}`;
+  const terms = protectedFields.map((field) => {
+    const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
+    return `NOT (OLD.${column} <=> NEW.${column})`;
+  });
+  if (rule.kind !== "appendOnly" && terms.length === 0)
+    throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+  const condition = gateField === undefined ? terms.join(`
+    OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
+    ${terms.join(`
+    OR `)}
+  )`;
+  return {
+    identities: triggers.map(({ identity }) => identity),
+    create: triggers.map(({ event, identity }) => {
+      const signal = `SIGNAL SQLSTATE 'HY000' SET MYSQL_ERRNO = 3819, MESSAGE_TEXT = ${diagnosticLiteral({ name: identity.name, context, dialect })};`;
+      const body = rule.kind === "appendOnly" ? `  ${signal}` : `  IF ${condition} THEN
+    ${signal}
+  END IF;`;
+      return { text: `CREATE TRIGGER ${qualify({ name: identity.name })} BEFORE ${event.toUpperCase()} ON ${qualify({ name: table.name })}
+FOR EACH ROW${position({ name: identity.name })}
+BEGIN
+${body}
+END;`, values: [] };
+    }),
+    drop: [...triggers].reverse().map(({ identity }) => ({ text: `DROP TRIGGER ${qualify({ name: identity.name })};`, values: [] })),
+    protectedFields: protectedFields.map((field) => field.name),
+    ...gateField === undefined ? {} : { gateField: gateField.name }
+  };
+}
+
+// packages/sql/src/row-rules.ts
+function renderRowRule({ schema, model, rule, dialect, placement }) {
+  const issue = rowRuleShapeIssue({ value: rule });
+  if (issue !== undefined) {
+    throw new VibeError20({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { model: model.name } });
+  }
+  if (placement !== undefined && Object.keys(placement).length > 0 && dialect.name !== "mysql")
+    throw unsupportedCapability22({ dialect: dialect.name, feature: "rowRuleTriggerPlacement" });
+  const normalized = normalizeRowRules({ schema, model, rules: [rule], dialect: dialect.name })[0];
+  switch (dialect.name) {
+    case "postgres": {
+      const objects = rowRuleIdentities({ schema, model, rule: normalized, dialect: dialect.name });
+      const functionIdentity = objects.find((object) => object.role === "function")?.identity;
+      const triggerIdentity = objects.find((object) => object.role === "trigger")?.identity;
+      if (functionIdentity?.kind !== "function" || triggerIdentity?.kind !== "trigger")
+        throw internalError2({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
+      const gate = rowRuleGateField({ rule: normalized });
+      const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
+      return renderPostgresRowRule({
+        dialect,
+        context: {
+          model: model.name,
+          table: triggerIdentity.table,
+          rule: normalized,
+          functionIdentity,
+          triggerIdentity: { kind: "trigger", table: triggerIdentity.table, name: triggerIdentity.name },
+          protectedFields: rowRuleProtectedFields({ schema, model, rule: normalized }),
+          ...gateField === undefined ? {} : { gateField }
+        }
+      });
+    }
+    case "sqlite":
+    case "mysql": {
+      const objects = rowRuleIdentities({ schema, model, rule: normalized, dialect: dialect.name });
+      const triggers = objects.map(({ role, identity }) => {
+        if (role !== "trigger" || identity.kind !== "trigger")
+          throw internalError2({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
+        const event = ["update", "delete"].find((event) => identity.name === rowRuleTriggerName({ rule: normalized, event }));
+        if (event === undefined)
+          throw internalError2({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
+        return { event, identity: { kind: "trigger", table: identity.table, name: identity.name } };
+      });
+      const table = triggers[0]?.identity.table;
+      if (table === undefined)
+        throw internalError2({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
+      const gate = rowRuleGateField({ rule: normalized });
+      const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
+      const context = {
+        model: model.name,
+        table,
+        rule: normalized,
+        triggers,
+        protectedFields: rowRuleProtectedFields({ schema, model, rule: normalized }),
+        ...gateField === undefined ? {} : { gateField },
+        ...placement === undefined ? {} : { placement }
+      };
+      return dialect.name === "sqlite" ? renderSqliteRowRule({ dialect, context }) : renderMysqlRowRule({ dialect, context });
+    }
+  }
+}
 // packages/sql/src/dialects/sqlite-json-equality.ts
 function renderSqliteJsonEquality(params) {
   const q = (name) => params.dialect.quoteIdent({ name });
@@ -2543,7 +3533,7 @@ function renderSqliteJsonEquality(params) {
 }
 
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
   sqliteTriggers: { dialect: "sqlite", text: "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'trigger'" }
@@ -2551,7 +3541,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability23({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -2560,7 +3550,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError13, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+import { VibeError as VibeError21, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -2595,7 +3585,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability13({
+    throw unsupportedCapability24({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -2613,7 +3603,7 @@ function renderPostgresWorkload(params) {
   if (query === "statementSnapshot") {
     const bounded = limit ?? 20;
     if (!Number.isInteger(bounded) || bounded < POSTGRES_WORKLOAD_LIMITS.minLimit || bounded > POSTGRES_WORKLOAD_LIMITS.maxLimit) {
-      throw new VibeError13({
+      throw new VibeError21({
         code: "VIBE_CONFIG",
         message: `workload snapshot limit must be an integer between ${POSTGRES_WORKLOAD_LIMITS.minLimit} and ${POSTGRES_WORKLOAD_LIMITS.maxLimit}, got ${String(limit)}`,
         meta: { limit }
@@ -2632,7 +3622,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError13({
+    throw new VibeError21({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -2642,10 +3632,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability26 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError14, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability14, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError22, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability25, validateRlsContextIR } from "@vibeorm/schema";
 var NATIVE_RLS = Object.freeze({ policyName: "vibeorm_managed", tableSchema: "public", settingPrefix: "vibeorm.", parentAlias: "parent" });
 var COLUMN_TYPES = {
   String: { default: "text", native: { text: "text", varchar: "varchar", charactervarying: "varchar", uuid: "uuid" } },
@@ -2658,18 +3648,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function identifier2(params) {
   if (typeof params.name !== "string" || params.name.length === 0 || params.name.includes("\x00") || new TextEncoder().encode(params.name).length > 63) {
-    throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
   }
   return params.dialect.quoteIdent({ name: params.name });
 }
 function tableRef(params) {
   if (params.schema !== undefined && params.schema !== "public" && params.schema !== "pg_temp") {
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
   }
   return `${identifier2({ dialect: params.dialect, name: params.schema ?? NATIVE_RLS.tableSchema })}.${identifier2({ dialect: params.dialect, name: params.table })}`;
 }
@@ -2710,7 +3700,7 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
@@ -2718,7 +3708,7 @@ function protectedModel(params) {
   assertValidSchemaIR({ schema: params.schema });
   const model = params.schema.models.find((entry) => entry.name === params.model);
   if (model === undefined || model.rls === undefined || model.rls === "unprotected") {
-    throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -2751,7 +3741,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -2785,7 +3775,7 @@ function renderRlsContext(params) {
 function renderRlsRole(params) {
   requireRls(params);
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
-    throw new VibeError14({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError22({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
   const collector = new ParamCollector(params.dialect);
   return query({ text: `SELECT set_config('role', ${collector.add(params.role)}, true)`, values: collector.values });
@@ -2937,7 +3927,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -2969,7 +3959,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError3, unsupportedCapability as unsupportedCapability27 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -2995,6 +3985,9 @@ function strictMatchPattern(params) {
   }
   return op === "contains" ? containsPattern({ raw: value }) : op === "startsWith" ? startsWithPattern({ raw: value }) : endsWithPattern({ raw: value });
 }
+function strictMatchCollationPrefilter(params) {
+  return params.strategy === "binary" && params.op === "startsWith" && !params.negate;
+}
 
 // packages/sql/src/render.ts
 function renderStatement(params) {
@@ -3054,13 +4047,13 @@ function quoteCol(dialect, column) {
   const ref = column.table === undefined ? name : `${dialect.quoteIdent({ name: column.table })}.${name}`;
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
-      throw internalError2({ message: "ColRef.castReal is a sqlite Decimal construct" });
+      throw internalError3({ message: "ColRef.castReal is a sqlite Decimal construct" });
     }
     return `CAST(${ref} AS REAL)`;
   }
   if (column.castJsonb !== undefined) {
     if (dialect.name !== "postgres") {
-      throw internalError2({ message: "ColRef.castJsonb is a postgres json construct" });
+      throw internalError3({ message: "ColRef.castJsonb is a postgres json construct" });
     }
     return `${ref}::${column.castJsonb}`;
   }
@@ -3077,7 +4070,7 @@ 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" });
+    throw internalError3({ message: "JsonParamCell storage json is a postgres construct" });
   }
   return "::text::json";
 }
@@ -3098,7 +4091,7 @@ function quoteProjection(dialect, column) {
   if (column.transform === "castText")
     return `${textProjection({ dialect, expression: ref })} AS ${alias}`;
   if (dialect.name !== "postgres") {
-    throw internalError2({ message: "encodeBase64 is a postgres construct" });
+    throw internalError3({ message: "encodeBase64 is a postgres construct" });
   }
   return `encode(${ref}, 'base64') AS ${alias}`;
 }
@@ -3120,7 +4113,7 @@ function renderTable(dialect, table) {
 }
 function assertCount(value, what) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw internalError2({ message: `${what} must be a non-negative integer, got ${value}` });
+    throw internalError3({ message: `${what} must be a non-negative integer, got ${value}` });
   }
 }
 var COMPARISON_SQL2 = {
@@ -3152,7 +4145,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability16({
+  throw unsupportedCapability27({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -3164,7 +4157,7 @@ function renderExpr(params) {
     case "cmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
       }
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
@@ -3175,7 +4168,7 @@ function renderExpr(params) {
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
     }
@@ -3199,11 +4192,11 @@ function renderExpr(params) {
     }
     case "tupleIn": {
       if (expr.columns.length === 0) {
-        throw internalError2({ message: "tupleIn needs at least one column" });
+        throw internalError3({ message: "tupleIn needs at least one column" });
       }
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length) {
-          throw internalError2({
+          throw internalError3({
             message: `tupleIn row has ${row.length} values for ${expr.columns.length} columns`
           });
         }
@@ -3224,6 +4217,32 @@ function renderExpr(params) {
       const base = conjunctions.length === 1 ? conjunctions[0] : `(${conjunctions.join(" OR ")})`;
       return expr.negate === true ? `NOT ${base.startsWith("(") ? base : `(${base})`}` : base;
     }
+    case "keyList":
+      return renderKeyList({ dialect, expr, collector });
+    case "rowCompare": {
+      const op = COMPARISON_SQL2[expr.op];
+      if (op === undefined || expr.columns.length === 0 || expr.values.length !== expr.columns.length) {
+        throw internalError3({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
+      }
+      const columns = expr.columns.map((column) => quoteCol(dialect, column));
+      const placeholders = expr.values.map((value) => collector.add(value));
+      return `(${columns.join(", ")}) ${op} (${placeholders.join(", ")})`;
+    }
+    case "inSelect": {
+      if (expr.columns.length === 0)
+        throw internalError3({ message: "inSelect needs at least one column" });
+      if (dialect.name === "mysql" && (expr.select.limit !== undefined || expr.select.offset !== undefined)) {
+        throw unsupportedCapability27({
+          dialect: dialect.name,
+          feature: "LIMIT inside an IN subquery",
+          hint: "mysql refuses LIMIT directly inside an IN subquery (error 1235); wrap the limited select in a derived table"
+        });
+      }
+      const columns = expr.columns.map((column) => quoteCol(dialect, column));
+      const tested = columns.length === 1 ? columns[0] : `(${columns.join(", ")})`;
+      const sub = renderSelect({ dialect, statement: expr.select, collector });
+      return `${tested} IN (${sub.text})`;
+    }
     case "like": {
       const column = quoteCol(dialect, expr.column);
       const placeholder = collector.add(expr.pattern);
@@ -3252,10 +4271,17 @@ function renderExpr(params) {
         if (dialect.strictMatchStrategy === "glob") {
           base = `${column} GLOB ${collector.add(pattern)}`;
         } else {
+          const prefilter = strictMatchCollationPrefilter({
+            strategy: dialect.strictMatchStrategy,
+            op: expr.op,
+            negate: expr.negate === true
+          }) ? `${column} LIKE ${collector.add(pattern)}${dialect.likeEscapeClause ?? ""}` : null;
           const placeholder = collector.add(pattern);
           base = dialect.strictMatchStrategy === "binary" ? `${column} LIKE CAST(${placeholder} AS BINARY)` : `${column} LIKE ${placeholder}`;
           if (dialect.likeEscapeClause !== null)
             base = `${base}${dialect.likeEscapeClause}`;
+          if (prefilter !== null)
+            base = `(${prefilter} AND ${base})`;
         }
       }
       return expr.negate === true ? `NOT (${base})` : base;
@@ -3277,7 +4303,7 @@ function renderExpr(params) {
     case "aggCmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${renderAggRef(dialect, expr.agg)} ${op} ${collector.add(expr.value)}`;
     }
@@ -3355,10 +4381,146 @@ function listComparison(params) {
   }
   return { column: quoteCol(dialect, column), operand: collector.add(value) };
 }
+function renderKeyList(params) {
+  const { dialect, expr, collector } = params;
+  const arity = expr.columns.length;
+  if (arity === 0)
+    throw internalError3({ message: "keyList needs at least one column" });
+  if (expr.members.length !== arity) {
+    throw internalError3({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
+  }
+  for (const row of expr.rows) {
+    if (row.length !== arity)
+      throw internalError3({ message: `keyList row has ${row.length} values for ${arity} columns` });
+  }
+  if (expr.rows.length === 0)
+    return "1 = 0";
+  const columns = expr.columns.map((column) => quoteCol(dialect, column));
+  const tuple = arity === 1 ? columns[0] : `(${columns.join(", ")})`;
+  if (dialect.keyListStrategy === "unnest") {
+    const types = expr.members.map((member) => postgresKeyListElementType({ dialect, member }));
+    if (!keyListBindsUntypedRows({ members: expr.members })) {
+      const arrays = types.map((type, index) => `${collector.add(expr.rows.map((row) => row[index]))}::${type}[]`);
+      return `${tuple} IN (SELECT * FROM unnest(${arrays.join(", ")}))`;
+    }
+  }
+  if (dialect.timeOfDayInStrategy === "equalities" && expr.members.some((member) => member.timeOfDay === true)) {
+    const conjunctions = expr.rows.map((row) => {
+      const terms = row.map((value, index) => `${columns[index]} = ${collector.add(value)}`);
+      return terms.length === 1 ? terms[0] : `(${terms.join(" AND ")})`;
+    });
+    return conjunctions.length === 1 ? conjunctions[0] : `(${conjunctions.join(" OR ")})`;
+  }
+  const tuples = expr.rows.map((row) => `(${collector.addMany(row).join(", ")})`);
+  return dialect.keyListStrategy === "values" ? `${tuple} IN (VALUES ${tuples.join(", ")})` : `${tuple} IN (${tuples.join(", ")})`;
+}
+var KEY_PAGE_KEYS = "__vibe_keys";
+var KEY_PAGE_IDS = "__vibe_ids";
+var KEY_PAGE_ROWS = "__vibe_page";
+var KEY_PAGE_SELECT_MEMBERS = new Set(["kind", "table", "columns", "where", "orderBy", "limit", "offset"]);
+function renderKeyPage(params) {
+  const { dialect, page, collector } = params;
+  const { select } = page;
+  const arity = page.keyColumns.length;
+  if (arity === 0 || page.members.length !== arity) {
+    throw internalError3({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
+  }
+  if (page.rows.length === 0)
+    throw internalError3({ message: "keyPage needs at least one key" });
+  for (const row of page.rows) {
+    if (row.length !== arity)
+      throw internalError3({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
+  }
+  if (page.identity.length === 0)
+    throw internalError3({ message: "keyPage needs the child's identity columns" });
+  const order = select.orderBy ?? [];
+  if (order.length === 0 || order.some((term) => !("column" in term))) {
+    throw internalError3({ message: "keyPage needs a non-empty order of plain column terms" });
+  }
+  if (select.table.alias !== undefined || Object.keys(select).some((member) => !KEY_PAGE_SELECT_MEMBERS.has(member))) {
+    throw internalError3({ message: "keyPage select carries a member the per-key page cannot render" });
+  }
+  if (dialect.keyPageStrategy === "window") {
+    throw unsupportedCapability27({
+      dialect: dialect.name,
+      feature: "a per-key page (keyPage)",
+      hint: "the runtime keeps the ROW_NUMBER window on this dialect"
+    });
+  }
+  const pageRef = (column) => ({ ...column, table: KEY_PAGE_ROWS });
+  const projection = select.columns.map((column) => quoteProjection(dialect, pageRef(column)));
+  const withKey = (keyRef) => {
+    const equalities = page.keyColumns.map((column, index) => ({ kind: "cmpCol", op: "eq", left: column, right: keyRef(index) }));
+    const operands = select.where === undefined ? equalities : [...equalities, select.where];
+    return operands.length === 1 ? operands[0] : { kind: "and", operands };
+  };
+  const keyPage = (where, rank) => ({
+    kind: "select",
+    table: select.table,
+    columns: page.identity,
+    ...rank ? { rowNumber: { partitionBy: page.keyColumns, orderBy: order, alias: page.rankAlias } } : {},
+    where,
+    orderBy: order,
+    ...select.limit === undefined ? {} : { limit: select.limit },
+    ...select.offset === undefined ? {} : { offset: select.offset }
+  });
+  const rows = renderTable(dialect, { ...select.table, alias: KEY_PAGE_ROWS });
+  const keyAlias = select.table.name === KEY_PAGE_KEYS ? `${KEY_PAGE_KEYS}_1` : KEY_PAGE_KEYS;
+  const keys = dialect.quoteIdent({ name: keyAlias });
+  if (dialect.keyPageStrategy === "lateral") {
+    if (keyListBindsUntypedRows({ members: page.members })) {
+      throw unsupportedCapability27({
+        dialect: dialect.name,
+        feature: "a per-key page over a DateTime key without a declared native type",
+        hint: "the runtime keeps the ROW_NUMBER window for such keys"
+      });
+    }
+    const types = page.members.map((member) => postgresKeyListElementType({ dialect, member }));
+    const arrays = types.map((type, index) => `${collector.add(page.rows.map((row) => row[index]))}::${type}[]`);
+    const names = page.keyColumns.map((_, index) => dialect.quoteIdent({ name: `__vibe_k${index}` }));
+    const ids = renderSelect({ dialect, statement: keyPage(withKey((index) => ({ table: keyAlias, name: `__vibe_k${index}` })), true), collector });
+    const on = page.identity.map((column) => `${quoteCol(dialect, pageRef(column))} = ${quoteCol(dialect, { table: KEY_PAGE_IDS, name: column.name })}`).join(" AND ");
+    const rank = quoteCol(dialect, { table: KEY_PAGE_IDS, name: page.rankAlias });
+    return `SELECT ${[...projection, rank].join(", ")} FROM unnest(${arrays.join(", ")}) AS ${keys} (${names.join(", ")}) CROSS JOIN LATERAL (${ids.text}) AS ${dialect.quoteIdent({ name: KEY_PAGE_IDS })} INNER JOIN ${rows} ON ${on}`;
+  }
+  const partition = page.keyColumns.map((column) => quoteCol(dialect, pageRef(column))).join(", ");
+  const rankOrder = order.map((term) => renderOrderTerm({ dialect, term: { ...term, column: pageRef(term.column) }, collector })).join(", ");
+  const rank = `ROW_NUMBER() OVER (PARTITION BY ${partition} ORDER BY ${rankOrder}) AS ${dialect.quoteIdent({ name: page.rankAlias })}`;
+  const tuples = page.rows.map((row) => `(${collector.addMany(row).join(", ")})`);
+  const membership = renderExpr({
+    dialect,
+    expr: { kind: "inSelect", columns: page.identity.map(pageRef), select: keyPage(withKey((index) => ({ table: keyAlias, name: `column${index + 1}` })), false) },
+    collector
+  });
+  return `SELECT ${[...projection, rank].join(", ")} FROM (VALUES ${tuples.join(", ")}) AS ${keys} INNER JOIN ${rows} ON ${membership}`;
+}
+var UNION_BRANCH_MEMBERS = new Set(["kind", "table", "columns", "where", "orderBy", "limit"]);
+function renderUnionPage(params) {
+  const { dialect, statement, collector } = params;
+  const branches = statement.fromUnion ?? [];
+  if (branches.length < 2)
+    throw internalError3({ message: "fromUnion needs at least two branches" });
+  if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.table.alias !== undefined) {
+    throw internalError3({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
+  }
+  if (statement.rowLock !== undefined)
+    throw internalError3({ message: "a locking read cannot read from a union page" });
+  const outputNames = (branch) => branch.columns.map((column) => column.alias ?? column.name).join("\x00");
+  const names = outputNames(branches[0]);
+  return branches.map((branch, index) => {
+    if (branch.columns.length === 0 || Object.keys(branch).some((member) => !UNION_BRANCH_MEMBERS.has(member))) {
+      throw internalError3({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
+    }
+    if (outputNames(branch) !== names)
+      throw internalError3({ message: "fromUnion branches must project the same output names in the same order" });
+    const inner = renderSelect({ dialect, statement: branch, collector });
+    return `SELECT * FROM (${inner.text}) AS ${dialect.quoteIdent({ name: `__vibe_u${index}` })}`;
+  }).join(" UNION ALL ");
+}
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
-    throw internalError2({ message: `json ${expr.op} expects a string operand` });
+    throw internalError3({ message: `json ${expr.op} expects a string operand` });
   }
   if (expr.op === "string_contains")
     return containsPattern({ raw: expr.value });
@@ -3382,7 +4544,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability16({
+    throw unsupportedCapability27({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -3449,7 +4611,7 @@ function renderJsonFilter(params) {
         const elements = Array.isArray(expr.value) ? expr.value : [expr.value];
         const tests = elements.map((element) => {
           if (element === null || typeof element === "object" && element !== null) {
-            throw unsupportedCapability16({
+            throw unsupportedCapability27({
               dialect: dialect.name,
               feature: "json array_contains with object/array/null elements",
               hint: "sqlite expresses scalar-element containment only \u2014 deep structural containment needs postgres or mysql"
@@ -3463,7 +4625,7 @@ function renderJsonFilter(params) {
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
       default:
-        throw internalError2({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+        throw internalError3({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
     }
   }
   const column = quoteCol(dialect, expr.column);
@@ -3518,11 +4680,11 @@ function renderSelectExpr(params) {
 function renderPositionalRow(params) {
   const { dialect, join, subAlias } = params;
   if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || join.select.rowNumber !== undefined) {
-    throw internalError2({ message: "positional lateral rows require an explicit column-only projection" });
+    throw internalError3({ message: "positional lateral rows require an explicit column-only projection" });
   }
   const names = join.select.columns.map((column) => projectionOutputName({ column }));
   if (new Set(names).size !== names.length) {
-    throw internalError2({ message: "positional lateral projection has duplicate output names" });
+    throw internalError3({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
@@ -3530,7 +4692,7 @@ function renderPositionalRow(params) {
     chunks.push(`json_build_array(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
-    throw internalError2({ message: "positional lateral projection exceeds the transport width limit" });
+    throw internalError3({ message: "positional lateral projection exceeds the transport width limit" });
   }
   return chunks.length === 1 ? chunks[0] : `json_build_array(${chunks.join(", ")})`;
 }
@@ -3538,8 +4700,8 @@ function renderLateralJoin(params) {
   const { dialect, join, collector } = params;
   const inner = renderSelect({ dialect, statement: join.select, collector });
   if (join.agg === "count") {
-    if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr?.kind !== "countAll" || join.select.selectExpr.alias !== join.columnAlias || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined) {
-      throw internalError2({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
+    if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr?.kind !== "countAll" || join.select.selectExpr.alias !== join.columnAlias || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined || join.select.distinct !== undefined) {
+      throw internalError3({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
     }
     return `LEFT JOIN LATERAL (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
   }
@@ -3570,8 +4732,8 @@ function renderLateralJoin(params) {
 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(*)" });
+  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.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
+    throw internalError3({ message: "count subquery must be one ungrouped COUNT(*)" });
   }
   const inner = renderSelect({ dialect, statement: select, collector });
   return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
@@ -3601,27 +4763,27 @@ function renderKeyTableJoin(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 unsupportedCapability16({
+    throw unsupportedCapability27({
       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}` });
+    throw internalError3({ 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" });
+    throw internalError3({ 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)}` });
+      throw internalError3({ 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` });
+      throw internalError3({ message: `key table row has ${row.length} values for ${join.members.length} members` });
     }
     const cells = row.map((value, index) => {
       const placeholder = collector.add(value);
@@ -3648,13 +4810,25 @@ function renderKeyTableJoin(params) {
   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 renderLeftJoin(params) {
+  const { dialect, join, collector } = params;
+  if (join.on.length === 0) {
+    throw internalError3({ message: "left join needs at least one ON pair" });
+  }
+  if (join.select.columns.length === 0 || join.select.columns.some((column) => column.alias === undefined)) {
+    throw internalError3({ message: "a left join's derived select must alias every projected column" });
+  }
+  const inner = renderSelect({ dialect, statement: join.select, collector });
+  const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
+  return `LEFT JOIN (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON ${on}`;
+}
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
-    throw internalError2({ message: "only countAll can combine with a column list" });
+    throw internalError3({ message: "only countAll can combine with a column list" });
   }
   if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
-    throw internalError2({ message: "selectExpr and aggregates cannot combine" });
+    throw internalError3({ message: "selectExpr and aggregates cannot combine" });
   }
   const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
   if (statement.selectExpr !== undefined) {
@@ -3675,16 +4849,19 @@ function renderSelect(params) {
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0) {
-      throw internalError2({ message: "rowNumber needs at least one partition column" });
+      throw internalError3({ message: "rowNumber needs at least one partition column" });
     }
     const partition = rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ");
     const order = rowNumber.orderBy.length === 0 ? "" : ` ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
     columnList.push(`ROW_NUMBER() OVER (PARTITION BY ${partition}${order}) AS ${dialect.quoteIdent({ name: rowNumber.alias })}`);
   }
-  let distinctPrefix = "";
+  let distinctPrefix = statement.distinct === true ? "DISTINCT " : "";
+  if (statement.distinct === true && statement.distinctOn !== undefined) {
+    throw internalError3({ message: "distinct and distinctOn cannot combine" });
+  }
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability16({
+      throw unsupportedCapability27({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -3694,9 +4871,16 @@ function renderSelect(params) {
   }
   const columns = columnList.length === 0 ? "*" : columnList.join(", ");
   let from;
-  if (statement.fromSelect !== undefined) {
+  if (statement.fromUnion !== undefined) {
+    from = `(${renderUnionPage({ dialect, statement, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
+  } else if (statement.keyPage !== undefined) {
+    if (statement.fromSelect !== undefined || statement.table.alias !== undefined) {
+      throw internalError3({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
+    }
+    from = `(${renderKeyPage({ dialect, page: statement.keyPage, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
+  } else if (statement.fromSelect !== undefined) {
     if (statement.table.alias !== undefined) {
-      throw internalError2({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+      throw internalError3({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
     }
     const inner = renderSelect({ dialect, statement: statement.fromSelect, collector });
     from = `(${inner.text}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
@@ -3707,7 +4891,7 @@ function renderSelect(params) {
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
       if (join.on.length === 0) {
-        throw internalError2({ message: "inner join needs at least one ON pair" });
+        throw internalError3({ message: "inner join needs at least one ON pair" });
       }
       const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
@@ -3716,9 +4900,17 @@ function renderSelect(params) {
   if (statement.keyTable !== undefined) {
     text += ` ${renderKeyTableJoin({ dialect, join: statement.keyTable, collector })}`;
   }
+  if (statement.leftJoins !== undefined && statement.leftJoins.length > 0) {
+    if (statement.rowLock !== undefined) {
+      throw internalError3({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
+    }
+    for (const join of statement.leftJoins) {
+      text += ` ${renderLeftJoin({ dialect, join, collector })}`;
+    }
+  }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
-      throw unsupportedCapability16({
+      throw unsupportedCapability27({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -3759,17 +4951,71 @@ function renderSelect(params) {
   }
   return { text, values: collector.values, returning: "none" };
 }
+var UNNEST_ROWS_ALIAS = "__vibe_rows";
+var UNNEST_ORDINALITY = "ord";
+function unnestElement(params) {
+  const { value, column, jsonStorage } = params;
+  if (value === null || value === undefined)
+    return null;
+  if (isJsonParamCell(value)) {
+    if (jsonStorage === undefined || (value.storage ?? "jsonb") !== jsonStorage) {
+      throw internalError3({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
+    }
+    return value.text;
+  }
+  if (jsonStorage === undefined) {
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+        return value;
+      case "object":
+        if (value instanceof Date || value instanceof Uint8Array)
+          return value;
+    }
+  }
+  throw internalError3({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
+}
+function renderUnnestRows(params) {
+  const { dialect, statement, members, collector } = params;
+  if (dialect.bulkInsertForm !== "unnest") {
+    throw unsupportedCapability27({
+      dialect: dialect.name,
+      feature: "a bulk insert bound as typed arrays (INSERT \u2026 SELECT FROM unnest)",
+      hint: "this dialect binds createMany rows as VALUES"
+    });
+  }
+  if (statement.columns.length === 0)
+    throw internalError3({ message: "an unnest insert needs at least one column" });
+  if (members.length !== statement.columns.length) {
+    throw internalError3({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
+  }
+  if (statement.onConflict !== undefined && !("doNothing" in statement.onConflict)) {
+    throw internalError3({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
+  }
+  const aliases = statement.columns.map((_column, index) => dialect.quoteIdent({ name: `c${index + 1}` }));
+  const arrays = members.map((member, index) => {
+    const cast = postgresBulkInsertArrayCast({ dialect, member });
+    const jsonStorage = member.type !== "Json" ? undefined : cast === "text::json" ? "json" : "jsonb";
+    const column = statement.columns[index];
+    const values = statement.rows.map((row) => unnestElement({ value: row[index], column, jsonStorage }));
+    return `${collector.add(values)}::${cast}[]`;
+  });
+  const ord = dialect.quoteIdent({ name: UNNEST_ORDINALITY });
+  return `SELECT ${aliases.join(", ")} FROM unnest(${arrays.join(", ")}) WITH ORDINALITY AS ${dialect.quoteIdent({ name: UNNEST_ROWS_ALIAS })} (${aliases.join(", ")}, ${ord}) ORDER BY ${ord}`;
+}
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
   if (statement.rows.length === 0) {
-    throw internalError2({ message: "insert requires at least one row" });
+    throw internalError3({ message: "insert requires at least one row" });
   }
   const defaultValues = statement.columns.length === 0 && dialect.emptyInsert.form === "defaultValues";
   if (defaultValues && statement.rows.length !== 1) {
-    throw internalError2({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
+    throw internalError3({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
   }
   if (defaultValues && statement.onConflict !== undefined && !(dialect.emptyInsert.form === "defaultValues" && dialect.emptyInsert.conflictClause)) {
-    throw unsupportedCapability16({
+    throw unsupportedCapability27({
       dialect: dialect.name,
       feature: "a conflict clause on an all-default row (DEFAULT VALUES)",
       hint: "supply at least one column value, or drop the conflict clause"
@@ -3777,7 +5023,7 @@ function renderInsert(params) {
   }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
-      throw internalError2({
+      throw internalError3({
         message: `insert row has ${row.length} values but ${statement.columns.length} columns`
       });
     }
@@ -3786,7 +5032,8 @@ function renderInsert(params) {
   const skipConflicts = onConflict !== undefined && "doNothing" in onConflict;
   const insertKeyword = skipConflicts && dialect.doNothingForm === "insertIgnore" ? "INSERT IGNORE INTO" : "INSERT INTO";
   const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
-  const rowsSql = statement.rows.map((row) => `(${row.map((value) => {
+  const unnestSource = statement.unnest === undefined ? undefined : renderUnnestRows({ dialect, statement, members: statement.unnest, collector });
+  const rowsSql = unnestSource !== undefined ? "" : statement.rows.map((row) => `(${row.map((value) => {
     if (isJsonParamCell(value))
       return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     if (isDbNowMarker(value)) {
@@ -3795,13 +5042,13 @@ function renderInsert(params) {
     if (!isSqlDefaultCell(value))
       return collector.add(value);
     if (!dialect.rowDefaultKeyword) {
-      throw internalError2({
+      throw internalError3({
         message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
       });
     }
     return "DEFAULT";
   }).join(", ")})`).join(", ");
-  let text = defaultValues ? `${insertKeyword} ${renderTable(dialect, statement.table)} DEFAULT VALUES` : `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) VALUES ${rowsSql}`;
+  let text = defaultValues ? `${insertKeyword} ${renderTable(dialect, statement.table)} DEFAULT VALUES` : `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) ${unnestSource ?? `VALUES ${rowsSql}`}`;
   if (onConflict !== undefined && !("doNothing" in onConflict) && dialect.excludedRowRef.form === "rowAlias" && Object.values(onConflict.update).some((value) => isExcludedRef(value) || isSqlFragment(value) && sqlUsesIncoming({ fragment: value }))) {
     text += ` AS ${dialect.quoteIdent({ name: dialect.excludedRowRef.alias })}`;
   }
@@ -3811,7 +5058,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability16({
+            throw unsupportedCapability27({
               dialect: dialect.name,
               feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
               hint: "only postgres names constraints in conflict targets \u2014 use a column-list target"
@@ -3826,7 +5073,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability16({
+        throw unsupportedCapability27({
           dialect: dialect.name,
           feature: "a refined conflict target (constraint / partial-index predicate) on INSERT IGNORE",
           hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
@@ -3835,23 +5082,23 @@ function renderInsert(params) {
     } else {
       const updates = Object.entries(onConflict.update);
       if (updates.length === 0) {
-        throw internalError2({ message: "upsert update must set at least one column" });
+        throw internalError3({ message: "upsert update must set at least one column" });
       }
       const selfRef = dialect.quoteIdent({ name: statement.table.name });
       const assignments = renderAssignments({ dialect, entries: updates, collector, selfRef, allowExcluded: true, tableName: statement.table.name });
       if (dialect.upsertForm === "onConflict") {
         if (onConflict.lastInsertIdColumn !== undefined) {
-          throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+          throw internalError3({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability16({
+          throw unsupportedCapability27({
             dialect: dialect.name,
             feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
             hint: "sqlite conflict targets are column lists \u2014 name the indexed columns instead"
           });
         }
         if (onConflict.constraint !== undefined && onConflict.conflictWhere !== undefined) {
-          throw internalError2({
+          throw internalError3({
             message: "a named-constraint conflict target already identifies the index \u2014 it cannot carry a partial predicate too"
           });
         }
@@ -3860,14 +5107,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability16({
+          throw unsupportedCapability27({
             dialect: dialect.name,
             feature: "a named-constraint conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 no target can be named"
           });
         }
         if (onConflict.conflictWhere !== undefined) {
-          throw unsupportedCapability16({
+          throw unsupportedCapability27({
             dialect: dialect.name,
             feature: "a partial-index conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 a partial arbiter cannot be selected; gate the call per dialect"
@@ -3885,7 +5132,7 @@ function renderUpdate(params) {
   const { dialect, statement, collector } = params;
   const assignments = Object.entries(statement.set);
   if (assignments.length === 0) {
-    throw internalError2({ message: "update must set at least one column" });
+    throw internalError3({ message: "update must set at least one column" });
   }
   const setSql = renderAssignments({ dialect, entries: assignments, collector });
   let text = `UPDATE ${renderTable(dialect, statement.table)} SET ${setSql}`;
@@ -3908,12 +5155,12 @@ function renderAssignments(params) {
     const read = selfRef === undefined ? column : `${selfRef}.${column}`;
     if (isSqlFragment(value)) {
       if (params.allowExcluded !== true || selfRef === undefined)
-        throw internalError2({ message: "SQL assignment fragments require a conflict update" });
+        throw internalError3({ message: "SQL assignment fragments require a conflict update" });
       return `${column} = ${renderSqlFragment({ dialect, fragment: value, collector, conflict: { table: params.tableName } })}`;
     }
     if (isExcludedRef(value)) {
       if (params.allowExcluded !== true) {
-        throw internalError2({
+        throw internalError3({
           message: `an incoming-row reference (${value.column}) is only meaningful inside an upsert's update arm`
         });
       }
@@ -3954,19 +5201,19 @@ var CHAIN_ONE_ALIAS = "__vibe_one";
 function renderChain(params) {
   const { dialect, statement, collector } = params;
   if (dialect.statementChain === null) {
-    throw unsupportedCapability16({
+    throw unsupportedCapability27({
       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" });
+    throw internalError3({ 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` });
+      throw internalError3({ 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})`);
@@ -3974,11 +5221,11 @@ function renderChain(params) {
   }
   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" });
+    throw internalError3({ 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}"` });
+      throw internalError3({ 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 ");
@@ -3987,7 +5234,7 @@ function renderChain(params) {
     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` });
+        throw internalError3({ message: `chain result alias "${alias}" collides with a result column` });
       }
     }
     const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
@@ -4024,21 +5271,21 @@ function renderSelectCell(params) {
   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" });
+    throw internalError3({ 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" });
+    throw internalError3({ 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` });
+      throw internalError3({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
     }
     rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
   }
@@ -4050,12 +5297,12 @@ 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" });
+    throw internalError3({ 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" });
+    throw internalError3({ 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}"` });
+      throw internalError3({ message: `chain tally or veto reads undefined step "${name}"` });
     return dialect.quoteIdent({ name });
   };
   const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
@@ -4065,12 +5312,12 @@ function renderTallyColumn(params) {
     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` });
+      throw internalError3({ 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` });
+      throw internalError3({ 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` });
+      throw internalError3({ 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)`;
   });
@@ -4079,25 +5326,25 @@ function renderTallyColumn(params) {
 function renderInsertSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.columns.length === 0)
-    throw internalError2({ message: "insert requires at least one column" });
+    throw internalError3({ message: "insert requires at least one column" });
   if (statement.cells.length !== statement.columns.length) {
-    throw internalError2({
+    throw internalError3({
       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` });
+      throw internalError3({ 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` });
+    throw internalError3({ 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` });
+        throw internalError3({ 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 })}`;
     }
@@ -4116,7 +5363,7 @@ function renderInsertSelect(params) {
   return text + applyReturning({ dialect, requested: statement.returning }).suffix;
 }
 // packages/sql/src/dialects/postgres-type-identity.ts
-import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
 var IDENTIFIER = '(?:"(?:[^"\\x00]|"")+"|[a-zA-Z_][a-zA-Z_0-9$]*)';
 var MODIFIER_VALUE = `(?:[+-]?\\d+|${IDENTIFIER}|'(?:[^'\\x00]|'')*')`;
 var TYPE_NAME = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*(\\(\\s*${MODIFIER_VALUE}(?:\\s*,\\s*${MODIFIER_VALUE})*\\s*\\))?\\s*((?:\\[\\s*\\]\\s*)*)$`);
@@ -4143,13 +5390,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability28({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const { dialect, type } = params;
   return `${type.namespace === undefined ? "" : `${dialect.quoteIdent({ name: type.namespace })}.`}${dialect.quoteIdent({ name: type.name })}${type.modifier}${type.array ? "[]" : ""}`;
 }
 function renderPostgresTypeIdentity(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability28({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -4162,11 +5409,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability29 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability18({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability29({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -4190,36 +5437,36 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability30 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability30({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
   const quote = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${quote(params.table)} DROP CONSTRAINT ${quote(params.constraint)};`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/mysql-check-probe.ts
-import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability20({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability31({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   const probe = q(params.probe);
   switch (params.operation) {
     case "clone":
       if (params.table === undefined)
-        throw unsupportedCapability20({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability31({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
       return { text: `CREATE TEMPORARY TABLE ${probe} LIKE ${q(params.table.namespace)}.${q(params.table.name)}`, values: [], returning: "none" };
     case "add": {
       if (params.expression === undefined || params.definition === undefined)
-        throw unsupportedCapability20({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
-      const parts = tableDefinitionParts({ sql: params.definition });
+        throw unsupportedCapability31({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+      const parts = tableDefinitionParts({ sql: params.definition, backslashEscapes: true });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
 `)}
 )${parts.suffix}`, values: [], returning: "none" };
     }
     case "read":
-      return { text: `SHOW CREATE TABLE ${probe}`, values: [], returning: "none" };
+      return { text: `SHOW CREATE TABLE ${params.table === undefined ? probe : `${q(params.table.namespace)}.${q(params.table.name)}`}`, values: [], returning: "none" };
     case "drop":
       return { text: `DROP TEMPORARY TABLE ${probe}`, values: [], returning: "none" };
   }
@@ -4257,31 +5504,31 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
   const collector = new ParamCollector(params.dialect);
   const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
   return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -4320,7 +5567,7 @@ ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
   return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { internalError as internalError3, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { internalError as internalError4, unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -4328,7 +5575,7 @@ function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
   if (object.kind === "namespace") {
     if (dialect.name !== "postgres")
-      throw unsupportedCapability23({ dialect: dialect.name, feature: "fixedNamespaces" });
+      throw unsupportedCapability34({ dialect: dialect.name, feature: "fixedNamespaces" });
     return { text: `SELECT n.nspname::text AS "name" FROM pg_catalog.pg_namespace n WHERE n.nspname = ${collector.add(object.name)}`, values: collector.values, returning: "none" };
   }
   const physical = "table" in object ? object.table : object.name;
@@ -4392,7 +5639,7 @@ function objectQuery(params) {
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability23({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability34({ dialect: "mysql", feature: "exclusionConstraints" });
         text = `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
         break;
       case "index":
@@ -4402,22 +5649,22 @@ function objectQuery(params) {
         text = `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
         break;
       default:
-        throw unsupportedCapability23({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability34({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability23({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability34({ dialect: "sqlite", feature: "attachedSchemaInspection" });
     const catalog = `${dialect.quoteIdent({ name: physical.namespace })}.sqlite_schema`;
     const kind = object.kind === "table" || object.kind === "view" ? object.kind : object.kind === "trigger" ? "trigger" : object.kind === "index" ? "index" : "table";
     if (["function", "sequence", "postgresExtension", "enum"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability23({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability34({ dialect: "sqlite", feature: `inspect:${object.kind}` });
     const sqliteParams = new ParamCollector(dialect);
     if (object.kind === "column" || object.kind === "columnDefault" || object.kind === "generatedColumn") {
       text = `SELECT x.type AS type, x."notnull" AS "notNull", x.pk AS primaryKeyPosition, x.hidden AS generated, x.dflt_value AS definition, (SELECT sql FROM ${catalog} WHERE name = ${sqliteParams.add(physical.name)} AND type = 'table') AS tableDefinition FROM pragma_table_xinfo(${sqliteParams.add(physical.name)}, ${sqliteParams.add(physical.namespace)}) x WHERE x.name = ${sqliteParams.add(object.column)}`;
       return { text, values: sqliteParams.values, returning: "none" };
     }
     const objectName = object.kind === "trigger" || object.kind === "index" ? object.name : physical.name;
-    text = `SELECT sql AS definition, type AS type FROM ${catalog} WHERE name = ${sqliteParams.add(objectName)} AND type = ${sqliteParams.add(kind)}`;
+    text = `SELECT sql AS definition, type AS type FROM ${catalog} WHERE name = ${sqliteParams.add(objectName)} AND type = ${sqliteParams.add(kind)}${object.kind === "trigger" ? ` AND tbl_name = ${sqliteParams.add(physical.name)}` : ""}`;
     return { text, values: sqliteParams.values, returning: "none" };
   }
   return { text, values: collector.values, returning: "none" };
@@ -4440,7 +5687,7 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability23({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const collector = params.collector;
   if (object.kind === "namespace") {
@@ -4497,7 +5744,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability23({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const groups = new Map;
   for (const [position, identity] of params.identities.entries()) {
     const kind = identity.kind === "constraint" ? `${identity.kind}:${identity.constraintType}` : identity.kind === "generatedColumn" ? "columnDefault" : identity.kind;
@@ -4510,7 +5757,7 @@ function renderMigrationObjectBatch(params) {
     const facts = objectQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
     const dependencies = dependencyQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
     if (JSON.stringify(dependencies.values) !== JSON.stringify(facts.values))
-      throw internalError3({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
+      throw internalError4({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
     const columns = facts.values.map((value, index) => `${dialect.quoteIdent({ name: `p${index + 1}` })} ${Array.isArray(value) ? "text[]" : "text"}`);
     const requests = group.map(({ identity, position }) => ({ position, ...Object.fromEntries(renderMigrationObjectQuery({ dialect, identity }).values.map((value, index) => [`p${index + 1}`, value])) }));
     const collector = new ParamCollector(dialect);
@@ -4530,16 +5777,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability23({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${q(params.table.namespace)}.${q(params.table.name)} ADD CONSTRAINT ${q(params.name)} CHECK (${params.expression}) NOT VALID`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/postgres-migration.ts
-import { VibeError as VibeError15, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
+import { VibeError as VibeError23, unsupportedCapability as unsupportedCapability35 } from "@vibeorm/schema";
 var SETTING_VALUE = /^[0-9]+(?:\.[0-9]+)?\s*(?:us|ms|s|min|h|d)?$/;
 function requirePostgres2(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability24({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability35({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -4554,7 +5801,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError15({
+    throw new VibeError23({
       code: "VIBE_MIGRATION",
       message: `${setting} must be a non-negative integer number of milliseconds (got ${String(milliseconds)})`,
       meta: { reason: "execution-metadata-invalid", setting, value: milliseconds }
@@ -4672,6 +5919,7 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  assertIndexExpressionVersion,
   assertSqlParamBuilding,
   chainVetoToken,
   cloneTimestampDate,
@@ -4699,6 +5947,9 @@ export {
   escapeGlobPattern,
   escapeLikePattern,
   excludedRef,
+  extractIndexKeys,
+  extractMysqlGeneratedColumn,
+  extractSqliteGeneratedColumn,
   float32Codec,
   getSqlDialect,
   isDbNowMarker,
@@ -4720,6 +5971,8 @@ export {
   isStepColumnRef,
   jsonListParameter,
   jsonParamCell,
+  keyListBindsUntypedRows,
+  localDateCodec,
   mapConflictColumns,
   mysqlDialect,
   nativeEnumArrayParameter,
@@ -4729,7 +5982,9 @@ export {
   parsePgArrayLiteralNested,
   parsePostgresTypeName,
   postgresArrayElementFromText,
+  postgresBulkInsertArrayCastOf,
   postgresDialect,
+  postgresKeyListElementTypeOf,
   projectionOutputName,
   recordSqlBinding,
   recordSqlBindingCheck,
@@ -4748,8 +6003,12 @@ export {
   renderExternalDependents,
   renderExternalOwnershipCatalog,
   renderFragment,
+  renderGeneratedColumnClause,
   renderIndexColumns,
+  renderIndexExpressionProbe,
+  renderIndexKeys,
   renderIndexStateQuery,
+  renderLocalDateCheck,
   renderMigrationDependencies,
   renderMigrationHistoryQuery,
   renderMigrationInventory,
@@ -4764,10 +6023,15 @@ export {
   renderModuleDependencyQuery,
   renderModuleJournal,
   renderMysqlCheckProbe,
+  renderMysqlGeneratedColumnProbe,
   renderMysqlObjectMembers,
   renderPostgresDefaultFunctionIdentity,
+  renderPostgresDropGeneratedExpression,
   renderPostgresExplain,
+  renderPostgresGeneratedColumnProbe,
   renderPostgresIndexKeys,
+  renderPostgresJitRestore,
+  renderPostgresJitSuspend,
   renderPostgresPhysicalCatalog,
   renderPostgresTypeIdentity,
   renderPostgresTypeName,
@@ -4790,6 +6054,8 @@ export {
   renderRlsReadinessQuery,
   renderRlsRole,
   renderRowLockClause,
+  renderRowRule,
+  renderSchemaExpression,
   renderShadowOperation,
   renderSqlFragment,
   renderSqliteColumnInventory,
@@ -4797,6 +6063,7 @@ export {
   renderSqliteFtsUpdateTrigger,
   renderSqliteRebuildObjects,
   renderStatement,
+  resolveIndexKeys,
   resultScalarContract,
   returningColumnName,
   sameResultDecoder,
@@ -4813,6 +6080,7 @@ export {
   sqliteTableConstraints,
   startsWithPattern,
   stepColumnRef,
+  strictMatchCollationPrefilter,
   strictMatchPattern,
   tableDefinitionParts,
   timeOfDayCodec,
@@ -4821,4 +6089,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=71705578A45D011664756E2164756E21
+//# debugId=75BF4FE272330AE564756E2164756E21