@vibeorm/sql 2.5.0 → 4.0.0

package/dist/index.js

@@ -7,6 +7,14 @@ function nativeEnumArrayParameter(params) {
 function isNativeEnumArrayParameter(value) {
   return typeof value === "object" && value !== null && NATIVE_ENUM_ARRAY_PARAMETER in value;
 }
+// packages/sql/src/json-list-parameter.ts
+var JSON_LIST_PARAMETER = Symbol("vibeorm.jsonListParameter");
+function jsonListParameter(params) {
+  return { [JSON_LIST_PARAMETER]: true, value: params.value, storage: params.storage };
+}
+function isJsonListParameter(value) {
+  return typeof value === "object" && value !== null && JSON_LIST_PARAMETER in value;
+}
 // packages/sql/src/dialects/external-ownership.ts
 import { unsupportedCapability } from "@vibeorm/schema";
 function renderExternalOwnershipCatalog(params) {
@@ -31,799 +39,1649 @@ function renderExternalOwnershipCatalog(params) {
   return { text, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/external-dependents.ts
-import { unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 
 // packages/sql/src/params.ts
-import { unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
-class ParamCollector {
-  dialect;
-  values;
-  constructor(dialect) {
-    this.dialect = dialect;
-    this.values = [];
-  }
-  add(value) {
-    if (isNativeEnumArrayParameter(value)) {
-      if (!this.dialect.capabilities.scalarArrays)
-        throw unsupportedCapability2({ dialect: this.dialect.name, feature: "scalarArrays" });
-      this.values.push(value.value);
-      return `${this.dialect.placeholder({ index: this.values.length })}::${this.dialect.quoteIdent({ name: value.type.namespace })}.${this.dialect.quoteIdent({ name: value.type.name })}[]`;
-    }
-    this.values.push(value);
-    return this.dialect.placeholder({ index: this.values.length });
-  }
-  addMany(values) {
-    return values.map((value) => this.add(value));
-  }
-}
+import { unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 
-// packages/sql/src/dialects/external-dependents.ts
-function renderExternalDependents(params) {
-  if (params.dialect.name !== "postgres")
-    throw unsupportedCapability3({ dialect: params.dialect.name, feature: "externalObjects" });
-  const collector = new ParamCollector(params.dialect);
-  const requests = params.targets.map((target, position) => ({ position, kind: target.kind, namespace: target.namespace, name: target.name, column: target.kind === "column" ? target.column : null }));
-  const request = collector.add(JSON.stringify(requests));
-  const text = `WITH request AS (
-  SELECT * FROM jsonb_to_recordset(${request}::text::jsonb) AS request(position integer, kind text, namespace text, name text, "column" text)
-), target AS (
-  SELECT request.position, 'pg_type'::regclass AS classid, t.oid AS objid, NULL::integer AS objsubid FROM request JOIN pg_catalog.pg_namespace n ON n.nspname = request.namespace JOIN pg_catalog.pg_type t ON t.typnamespace = n.oid AND t.typname = request.name WHERE request.kind = 'type'
-  UNION ALL SELECT request.position, 'pg_class'::regclass, c.oid, a.attnum::integer FROM request JOIN pg_catalog.pg_namespace n ON n.nspname = request.namespace JOIN pg_catalog.pg_class c ON c.relnamespace = n.oid AND c.relname = request.name LEFT JOIN pg_catalog.pg_attribute a ON request.kind = 'column' AND a.attrelid = c.oid AND a.attname = request."column" AND NOT a.attisdropped WHERE request.kind = 'relation' OR request.kind = 'column' AND a.attnum IS NOT NULL
-), owned AS (
-  SELECT position, classid, objid, objsubid FROM target
-  UNION SELECT target.position, 'pg_type'::regclass, c.reltype, NULL FROM target JOIN pg_catalog.pg_class c ON c.oid = target.objid WHERE target.classid = 'pg_class'::regclass AND target.objsubid IS NULL AND c.reltype <> 0
-  UNION SELECT target.position, 'pg_class'::regclass, s.oid, NULL FROM target JOIN pg_catalog.pg_depend sd ON sd.refclassid = target.classid AND sd.refobjid = target.objid AND (target.objsubid IS NULL OR sd.refobjsubid = target.objsubid) AND sd.classid = 'pg_class'::regclass AND sd.deptype IN ('a', 'i') JOIN pg_catalog.pg_class s ON s.oid = sd.objid AND s.relkind = 'S'
-), referenced AS (
-  SELECT position, classid, objid, objsubid FROM owned
-  UNION SELECT owned.position, 'pg_type'::regclass, t.typarray, NULL FROM owned JOIN pg_catalog.pg_type t ON t.oid = owned.objid WHERE owned.classid = 'pg_type'::regclass AND t.typarray <> 0
-)
-SELECT DISTINCT referenced.position, dependent.type AS "dependentType", dependent.identity AS "dependentIdentity", ref.identity AS referenced, d.classid::regclass::text AS "dependentClass",
-  rn.nspname::text AS "relationNamespace", rel.relname::text AS "relationName", rel.relkind::text AS "relationKind", col.attname::text AS "columnName",
-  COALESCE(pn.nspname, tn.nspname, dependent.schema)::text AS "objectNamespace", COALESCE(p.proname, ty.typname)::text AS "objectName"
-FROM referenced
-JOIN pg_catalog.pg_depend d ON d.refclassid = referenced.classid AND d.refobjid = referenced.objid AND (referenced.objsubid IS NULL OR d.refobjsubid = referenced.objsubid) AND d.deptype = 'n'
-CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.classid, d.objid, d.objsubid) dependent
-CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.refclassid, d.refobjid, d.refobjsubid) ref
-LEFT JOIN pg_catalog.pg_class self ON d.classid = 'pg_class'::regclass AND self.oid = d.objid
-LEFT JOIN pg_catalog.pg_index ix ON ix.indexrelid = self.oid
-LEFT JOIN pg_catalog.pg_attrdef ad ON d.classid = 'pg_attrdef'::regclass AND ad.oid = d.objid
-LEFT JOIN pg_catalog.pg_rewrite rw ON d.classid = 'pg_rewrite'::regclass AND rw.oid = d.objid
-LEFT JOIN pg_catalog.pg_trigger tg ON d.classid = 'pg_trigger'::regclass AND tg.oid = d.objid
-LEFT JOIN pg_catalog.pg_constraint con ON d.classid = 'pg_constraint'::regclass AND con.oid = d.objid
-LEFT JOIN pg_catalog.pg_policy pol ON d.classid = 'pg_policy'::regclass AND pol.oid = d.objid
-LEFT JOIN pg_catalog.pg_type ty ON d.classid = 'pg_type'::regclass AND ty.oid = d.objid
-LEFT JOIN pg_catalog.pg_namespace tn ON tn.oid = ty.typnamespace
-LEFT JOIN pg_catalog.pg_proc p ON d.classid = 'pg_proc'::regclass AND p.oid = d.objid
-LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace
-LEFT JOIN pg_catalog.pg_class rel ON rel.oid = COALESCE(ix.indrelid, self.oid, ad.adrelid, rw.ev_class, tg.tgrelid, NULLIF(con.conrelid, 0), pol.polrelid, NULLIF(ty.typrelid, 0))
-LEFT JOIN pg_catalog.pg_namespace rn ON rn.oid = rel.relnamespace
-LEFT JOIN pg_catalog.pg_attribute col ON col.attrelid = rel.oid AND col.attnum = CASE WHEN self.oid IS NOT NULL AND d.objsubid > 0 THEN d.objsubid WHEN ad.oid IS NOT NULL THEN ad.adnum END
-ORDER BY 1, 2, 3, 4`;
-  return { text, values: collector.values, returning: "none" };
+// packages/sql/src/sql-bindings.ts
+import { VibeError as VibeError5, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+
+// packages/sql/src/parameter-snapshot.ts
+import { VibeError as VibeError4 } from "@vibeorm/schema";
+
+// packages/sql/src/sql-input.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+
+// packages/sql/src/result-decoder.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+
+// packages/sql/src/pg-array.ts
+var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
+function toPgArrayLiteral(params) {
+  const { values } = params;
+  const parts = values.map((value) => {
+    if (value === null || value === undefined)
+      return "NULL";
+    const text = String(value);
+    return PG_ARRAY_QUOTE.test(text) ? `"${text.replace(/["\\]/g, (char) => `\\${char}`)}"` : text;
+  });
+  return `{${parts.join(",")}}`;
 }
-// packages/sql/src/dialects/postgres-physical-catalog.ts
-import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
-function renderPostgresPhysicalCatalog(params) {
-  const { dialect } = params;
-  if (dialect.name !== "postgres")
-    throw unsupportedCapability4({ dialect: dialect.name, feature: "postgresPhysicalCatalog" });
-  const collector = new ParamCollector(dialect);
-  const namespace = collector.add(params.namespace);
-  const extensionOwnedFilter = `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON c.oid = d.objid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE d.classid = 'pg_class'::regclass AND d.deptype = 'e' AND n.nspname = ${namespace} AND c.relname = table_name)`;
-  let text;
-  switch (params.query) {
-    case "tables":
-      text = `SELECT table_name FROM information_schema.tables WHERE table_schema = ${namespace} AND table_type = 'BASE TABLE' AND table_name <> '_vibe_migrations' AND ${extensionOwnedFilter} ORDER BY table_name`;
-      break;
-    case "views":
-      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`;
-      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`;
-      break;
-    case "checks":
-      text = `SELECT cl.relname AS table_name, c.conname AS constraint_name, pg_get_constraintdef(c.oid) AS definition 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 WHERE c.contype = 'c' AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname`;
-      break;
-    case "foreignKeys":
-      text = `SELECT c.conname AS constraint_name, cl.relname AS table_name, att.attname AS column_name, fn.nspname AS foreign_namespace, fcl.relname AS foreign_table_name, fatt.attname AS foreign_column_name, c.confdeltype AS on_delete_char, c.confupdtype AS on_update_char, c.convalidated AS validated, c.condeferrable AS deferrable, (SELECT bool_and(t.tgenabled IN ('O', 'A')) FROM pg_catalog.pg_trigger t WHERE t.tgconstraint = c.oid) AS triggers_enabled FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace JOIN pg_catalog.pg_class fcl ON fcl.oid = c.confrelid JOIN pg_catalog.pg_namespace fn ON fn.oid = fcl.relnamespace JOIN unnest(c.conkey) WITH ORDINALITY AS lk(attnum, ord) ON true JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = lk.attnum JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum WHERE c.contype = 'f' AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname, lk.ord`;
-      break;
-    case "enums":
-      text = `SELECT t.typname AS type_name, n.nspname AS type_namespace, e.enumlabel AS enum_value, e.enumsortorder AS sort_order FROM pg_type t JOIN pg_enum e ON t.oid = e.enumtypid JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} ORDER BY t.typname, e.enumsortorder`;
-      break;
-    case "indexes":
-      text = `SELECT tablename AS table_name, indexname AS index_name, indexdef AS index_def, con.conname AS backing_constraint, con.contype AS backing_constraint_type, health.indisvalid AS valid, health.indisready AS ready, health.indimmediate AS immediate, health.indexprs IS NULL AS plain_columns, health.indnkeyatts AS key_count, health.indnatts AS attribute_count FROM pg_indexes ix JOIN pg_catalog.pg_namespace ns ON ns.nspname = ix.schemaname JOIN pg_catalog.pg_class idx ON idx.relnamespace = ns.oid AND idx.relname = ix.indexname JOIN pg_catalog.pg_index health ON health.indexrelid = idx.oid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = idx.oid AND con.contype IN ('p', 'u', 'x') WHERE schemaname = ${namespace} ORDER BY tablename, indexname`;
-      break;
+function parsePgArrayLiteral(params) {
+  const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
+  if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
+    return null;
+  const inner = literal.slice(1, -1);
+  if (inner.length === 0)
+    return [];
+  const out = [];
+  let index = 0;
+  while (index < inner.length) {
+    if (inner[index] === '"') {
+      let text = "";
+      index++;
+      while (index < inner.length) {
+        const char = inner[index];
+        if (char === "\\") {
+          text += inner[index + 1] ?? "";
+          index += 2;
+          continue;
+        }
+        index++;
+        if (char === '"')
+          break;
+        text += char;
+      }
+      out.push(text);
+    } else {
+      let text = "";
+      while (index < inner.length && inner[index] !== ",") {
+        text += inner[index];
+        index++;
+      }
+      out.push(text === "NULL" ? null : text);
+    }
+    if (inner[index] === ",")
+      index++;
   }
-  return { text, values: collector.values, returning: "none" };
+  return out;
 }
-// packages/sql/src/dialects/postgres-index-keys.ts
-import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
-function renderPostgresIndexKeys(params) {
-  const { dialect } = params;
-  if (dialect.name !== "postgres")
-    throw unsupportedCapability5({ dialect: dialect.name, feature: "indexOperatorClasses" });
-  const collector = new ParamCollector(dialect);
-  const scope = params.table === undefined ? "n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'" : `n.nspname = ${collector.add(params.table.namespace)} AND c.relname = ${collector.add(params.table.name)}`;
-  const defaultResolution = `LEFT JOIN LATERAL (WITH RECURSIVE input_types AS (SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t WHERE t.oid = a.atttypid UNION ALL SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t JOIN input_types previous ON t.oid = previous.typbasetype WHERE previous.typtype = 'd'), candidates AS (SELECT candidate.oid, CASE WHEN candidate.opcintype = input.oid THEN 0 WHEN class_input.typispreferred AND class_input.typcategory = input.typcategory THEN 1 ELSE 2 END AS priority FROM pg_catalog.pg_opclass candidate JOIN pg_catalog.pg_type class_input ON class_input.oid = candidate.opcintype CROSS JOIN input_types input WHERE input.typtype <> 'd' AND candidate.opcdefault AND candidate.opcmethod = idx.relam AND (candidate.opcintype = input.oid OR EXISTS (SELECT 1 FROM pg_catalog.pg_cast cast_entry WHERE cast_entry.castsource = input.oid AND cast_entry.casttarget = candidate.opcintype AND cast_entry.castmethod = 'b' AND cast_entry.castcontext = 'i') OR input.typtype = 'e' AND candidate.opcintype = 'pg_catalog.anyenum'::regtype OR input.typelem <> 0 AND candidate.opcintype = 'pg_catalog.anyarray'::regtype)) SELECT (array_agg(candidate.oid))[1] AS oid FROM candidates candidate WHERE candidate.priority = (SELECT min(priority) FROM candidates) HAVING count(*) = 1) resolved_default ON true`;
-  return {
-    text: `SELECT n.nspname AS table_namespace, c.relname AS table_name, idx.relname AS index_name, am.amname AS method, i.indisunique AS unique, pg_catalog.pg_get_expr(i.indpred, i.indrelid, false) AS predicate, i.indnullsnotdistinct AS nulls_not_distinct, k.ordinality AS ordinal, a.attname AS column_name, (i.indoption[k.ordinality - 1] & 1) <> 0 AS descending, opn.nspname AS operator_namespace, op.opcname AS operator_name, COALESCE(op.oid = resolved_default.oid, false) AS exact_default FROM pg_catalog.pg_index i JOIN pg_catalog.pg_class c ON c.oid = i.indrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace JOIN pg_catalog.pg_class idx ON idx.oid = i.indexrelid JOIN pg_catalog.pg_am am ON am.oid = idx.relam CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY k(attnum, ordinality) LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum JOIN pg_catalog.pg_opclass op ON op.oid = i.indclass[k.ordinality - 1] JOIN pg_catalog.pg_namespace opn ON opn.oid = op.opcnamespace ${defaultResolution} WHERE ${scope} AND k.ordinality <= i.indnkeyatts ORDER BY n.nspname, c.relname, idx.relname, k.ordinality`,
-    values: collector.values,
-    returning: "none"
-  };
+function parsePgArrayLiteralNested(params) {
+  const text = params.literal.replace(/^(?:\[-?\d+:-?\d+\])+=/, "");
+  const cursor = { index: 0 };
+  const parsed = parseDimension({ text, cursor });
+  return parsed !== null && cursor.index === text.length ? parsed : null;
 }
-// packages/sql/src/index-columns.ts
-import { VibeError, isSqlObjectIdentity, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
-function renderIndexColumns(params) {
-  const { dialect, columns, unique } = params;
-  const hasOperatorClass = columns.some((column) => column.operatorClass !== undefined);
-  if (hasOperatorClass && !dialect.capabilities.indexOperatorClasses)
-    throw unsupportedCapability6({ dialect: dialect.name, feature: "indexOperatorClasses" });
-  if (hasOperatorClass && unique)
-    throw unsupportedCapability6({ dialect: dialect.name, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
-  return columns.map((column) => {
-    const operatorClass = column.operatorClass;
-    if (operatorClass !== undefined && !isSqlObjectIdentity({ kind: "table", name: operatorClass })) {
-      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", column: column.name } });
+function parseDimension(params) {
+  const { text, cursor } = params;
+  if (text[cursor.index] !== "{")
+    return null;
+  cursor.index++;
+  const out = [];
+  if (text[cursor.index] === "}") {
+    cursor.index++;
+    return out;
+  }
+  while (cursor.index < text.length) {
+    if (text[cursor.index] === "{") {
+      const nested = parseDimension({ text, cursor });
+      if (nested === null)
+        return null;
+      out.push(nested);
+    } else if (text[cursor.index] === '"') {
+      let element = "";
+      cursor.index++;
+      while (cursor.index < text.length && text[cursor.index] !== '"') {
+        if (text[cursor.index] === "\\")
+          cursor.index++;
+        element += text[cursor.index] ?? "";
+        cursor.index++;
+      }
+      if (text[cursor.index] !== '"')
+        return null;
+      cursor.index++;
+      out.push(element);
+    } else {
+      let element = "";
+      while (cursor.index < text.length && text[cursor.index] !== "," && text[cursor.index] !== "}") {
+        element += text[cursor.index];
+        cursor.index++;
+      }
+      out.push(element === "NULL" ? null : element);
     }
-    const ops = operatorClass === undefined ? "" : ` ${dialect.quoteIdent({ name: operatorClass.namespace })}.${dialect.quoteIdent({ name: operatorClass.name })}`;
-    return `${dialect.quoteIdent({ name: column.name })}${ops}${column.desc ? " DESC" : ""}`;
-  });
+    if (text[cursor.index] === ",") {
+      cursor.index++;
+      continue;
+    }
+    if (text[cursor.index] !== "}")
+      return null;
+    cursor.index++;
+    return out;
+  }
+  return null;
 }
-// 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";
+
+// packages/sql/src/codecs.ts
+import { VibeError, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
+function enumMembershipCodec(params) {
+  const { model, field, enum: enumName } = params;
+  const members = new Set(params.members);
   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"
+    encode: (value) => {
+      if (typeof value === "string" && members.has(value))
+        return value;
+      throw new VibeError({
+        code: "VIBE_VALIDATION",
+        message: `Invalid value for enum ${enumName} on ${model}.${field}`,
+        meta: { model, field, enum: enumName }
+      });
+    },
+    decode: (value) => {
+      if (typeof value === "string" && members.has(value))
+        return value;
+      throw invalidStoredData({ model, field, enum: enumName, value });
+    }
   };
 }
-// 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 decodeIsNoop(params) {
+  const { scalarType, wire } = params;
+  if (wire === undefined)
+    return false;
+  if (scalarType === "DateTime")
+    return false;
+  if (scalarType === "Json")
+    return wire.json === "parsed";
+  if (scalarType === "Int" || scalarType === "Float")
+    return wire.numbers === "native";
+  return false;
 }
-// packages/sql/src/dialects/migration-shadow.ts
-import { assertSqlNamespace, unsupportedCapability as unsupportedCapability7 } 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 unsupportedCapability7({ 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 unsupportedCapability7({ 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 unsupportedCapability7({ 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 unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
-      return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
-    }
-    case "dropMysqlObject": {
-      if (pg)
-        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
-      return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
-    }
+var identity = (value) => value;
+var passthroughCodec = { encode: identity, decode: identity };
+var numberCodec = {
+  encode: identity,
+  decode: (value) => typeof value === "string" ? Number(value) : value
+};
+var bigIntCodec = {
+  encode: (value) => typeof value === "bigint" ? value.toString() : value,
+  decode: (value) => {
+    if (typeof value === "bigint")
+      return value;
+    if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim()))
+      return BigInt(value.trim());
+    if (typeof value === "number" && Number.isSafeInteger(value))
+      return BigInt(value);
+    throw new VibeError({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
   }
-}
-// 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;
-    case "complete":
-      text = `UPDATE ${table} SET ${column} = ${collector.add(operation.entry)} WHERE ${q("name")} = ${collector.add(operation.name)}`;
-      break;
+};
+var decimalCodec = {
+  encode: (value) => typeof value === "number" || typeof value === "bigint" ? String(value) : value,
+  decode: identity
+};
+var mysqlDecimalCodec = {
+  encode: decimalCodec.encode,
+  decode: (value) => {
+    if (typeof value !== "string" || !value.includes("."))
+      return value;
+    const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
+    return trimmed === "" || trimmed === "-" ? "0" : trimmed;
   }
-  return { text, values: collector.values };
-}
-// packages/sql/src/dialects/sqlite-session.ts
-var SQLITE_SESSION_SQL = Object.freeze({
-  lockingMode: "PRAGMA main.locking_mode",
-  exclusive: "PRAGMA main.locking_mode = EXCLUSIVE",
-  normal: "PRAGMA main.locking_mode = NORMAL",
-  acquire: "BEGIN EXCLUSIVE",
-  commit: "COMMIT",
-  rollback: "ROLLBACK",
-  touch: "SELECT name FROM main.sqlite_schema LIMIT 1",
-  foreignKeysOn: "PRAGMA foreign_keys = ON"
-});
-// packages/sql/src/composable.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
-var fragments = new WeakMap;
-function invalid(message) {
-  throw new VibeError2({ code: "VIBE_VALIDATION", message });
-}
-function construct(parts) {
-  const snapshot = Object.freeze([...parts]);
-  const fragment = Object.freeze(Object.defineProperty(Object.create(null), "toJSON", {
-    value: () => ({ parts: snapshot })
-  }));
-  fragments.set(fragment, snapshot);
-  return fragment;
+};
+var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
+function parseDateTimeText(params) {
+  const trimmed = params.text.trim();
+  if (ZONE_LESS_DATETIME.test(trimmed)) {
+    const asUtc = new Date(`${trimmed.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z`);
+    if (!Number.isNaN(asUtc.getTime()))
+      return asUtc;
+  }
+  const zoned = PG_ZONED_DATETIME.exec(trimmed);
+  if (zoned !== null) {
+    const [, date, time, fraction, hours, minutes] = zoned;
+    const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
+    if (!Number.isNaN(iso.getTime()))
+      return iso;
+  }
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
-function isSqlFragment(value) {
-  return typeof value === "object" && value !== null && fragments.has(value);
+var dateNativeCodec = {
+  encode: (value) => {
+    if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
+      throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
+    }
+    return value;
+  },
+  decode: (value) => {
+    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+    if (date !== undefined && Number.isFinite(date.getTime()))
+      return date;
+    throw new VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+  }
+};
+var dateTextCodec = {
+  encode: (value) => {
+    dateNativeCodec.encode(value);
+    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+    if (date !== undefined && Number.isFinite(date.getTime()))
+      return date.toISOString();
+    throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+  },
+  decode: dateNativeCodec.decode
+};
+var mysqlDateCodec = {
+  encode: (value) => {
+    dateNativeCodec.encode(value);
+    if (value instanceof Date)
+      return value;
+    if (typeof value === "number") {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime()))
+        return parsed;
+      return value;
+    }
+    if (typeof value === "string")
+      return parseDateTimeText({ text: value }) ?? value;
+    return value;
+  },
+  decode: dateNativeCodec.decode
+};
+var MILLISECONDS_PER_DAY = 86400000;
+var TIME_OF_DAY_TEXT = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
+var pad = (value, width) => String(value).padStart(width, "0");
+var utcMillisecondOfDay = (date) => (date.getTime() % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY;
+var timeOfDayText = (millisecond) => `${pad(Math.floor(millisecond / 3600000), 2)}:${pad(Math.floor(millisecond / 60000) % 60, 2)}:${pad(Math.floor(millisecond / 1000) % 60, 2)}.${pad(millisecond % 1000, 3)}`;
+function makeTimeOfDayCodec(params) {
+  const suffix = params.zoned ? "+00" : "";
+  return Object.freeze({
+    encode: (value) => {
+      dateNativeCodec.encode(value);
+      const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+      if (date === undefined || !Number.isFinite(date.getTime())) {
+        throw new VibeError({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
+      }
+      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
+    },
+    decode: (value) => {
+      if (value instanceof Date && Number.isFinite(value.getTime()))
+        return new Date(utcMillisecondOfDay(value));
+      const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
+      if (match !== null) {
+        const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
+        const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
+        const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
+        if (millisecond <= MILLISECONDS_PER_DAY) {
+          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+        }
+      }
+      throw new VibeError({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
+    }
+  });
 }
-function partsOf(value) {
-  return fragments.get(value) ?? invalid("Expected a constructed SQL fragment");
+var timeCodec = makeTimeOfDayCodec({ zoned: false });
+var timetzCodec = makeTimeOfDayCodec({ zoned: true });
+function timeOfDayCodec(params) {
+  const type = timeOfDayType({ nativeType: params.nativeType });
+  return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
 }
-function identifier(parts) {
-  if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => typeof part !== "string" || part.length === 0 || part.includes("\x00"))) {
-    invalid("SQL identifiers require non-empty, NUL-free name components");
+var booleanIntCodec = {
+  encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
+  decode: (value) => typeof value === "number" ? value !== 0 : value
+};
+var booleanNativeInCodec = {
+  encode: identity,
+  decode: (value) => value === "0" ? false : value === "1" ? true : booleanIntCodec.decode(value)
+};
+function parseJsonText(params) {
+  const { text, context } = params;
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    if (context !== undefined) {
+      throw new VibeError({
+        code: "VIBE_INTERNAL",
+        message: "a bound Json field returned text that is not valid JSON",
+        meta: { ...context }
+      });
+    }
+    throw new VibeError({
+      code: "VIBE_INTERNAL",
+      message: "a Json column returned text that is not valid JSON",
+      meta: { value: text },
+      cause
+    });
   }
 }
-function template(strings, ...values) {
-  if (!Array.isArray(strings) || !Array.isArray(strings.raw) || strings.length !== values.length + 1 || strings.some((text) => typeof text !== "string")) {
-    invalid("Use sql as a template tag");
+var jsonCodec = {
+  encode: (value) => JSON.stringify(value),
+  decode: (value) => {
+    if (typeof value !== "string")
+      return value;
+    return parseJsonText({ text: value });
   }
-  const parts = [];
-  for (let index = 0;index < strings.length; index++) {
-    parts.push(strings[index]);
-    if (index < values.length) {
-      const value = values[index];
-      if (isSqlFragment(value))
-        parts.push(...partsOf(value));
-      else
-        parts.push(Object.freeze({ value }));
-    }
+};
+function shortestFloat32(params) {
+  const { value } = params;
+  if (value === 0 || !Number.isFinite(value))
+    return value;
+  const target = Math.fround(value);
+  for (let precision = 1;precision <= 9; precision++) {
+    const candidate = Number(value.toPrecision(precision));
+    if (Math.fround(candidate) === target)
+      return candidate;
   }
-  return construct(parts);
+  return value;
 }
-var sql = Object.freeze(Object.assign(template, {
-  text: ({ text }) => {
-    if (typeof text !== "string" || text.includes("\x00"))
-      invalid("SQL text must be a NUL-free string");
-    return construct([text]);
-  },
-  ident: ({ parts }) => {
-    identifier(parts);
-    return construct([Object.freeze({ ident: Object.freeze([...parts]) })]);
-  },
-  value: ({ value, decoder }) => construct([Object.freeze({ value, ...decoder === undefined ? {} : { decoder } })]),
-  join: ({ items, separator }) => {
-    if (!Array.isArray(items))
-      invalid("sql.join requires an array");
-    const between = separator === undefined ? [", "] : partsOf(separator);
-    const parts = [];
-    items.forEach((value, index) => {
-      if (index > 0)
-        parts.push(...between);
-      parts.push(...isSqlFragment(value) ? partsOf(value) : [Object.freeze({ value })]);
-    });
-    return construct(parts);
-  },
-  existing: ({ column }) => {
-    identifier([column]);
-    return construct([Object.freeze({ row: "existing", column })]);
-  },
-  incoming: ({ column }) => {
-    identifier([column]);
-    return construct([Object.freeze({ row: "incoming", column })]);
-  },
-  greatest: ({ values }) => {
-    if (!Array.isArray(values) || values.length !== 2 || values.some((value) => !isSqlFragment(value)))
-      invalid("sql.greatest requires two SQL fragments");
-    return construct([Object.freeze({ greatest: Object.freeze([...values]) })]);
+var float32Codec = {
+  encode: identity,
+  decode: (value) => {
+    const number = typeof value === "string" ? Number(value) : value;
+    return typeof number === "number" ? shortestFloat32({ value: number }) : number;
   }
-}));
-function renderSqlFragment(params) {
-  const { dialect, collector, conflict } = params;
-  const render = (fragment) => renderSqlFragment({ ...params, fragment });
-  return partsOf(params.fragment).map((part) => {
-    if (typeof part === "string")
-      return part;
-    if ("value" in part) {
-      if (part.value === undefined)
-        invalid("SQL parameters cannot be undefined; use null explicitly");
-      return collector.add(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
+};
+var booleanFromText = (text) => text === "t" ? true : text === "f" ? false : text;
+var bytesFromText = (text) => /^\\x(?:[0-9a-fA-F]{2})*$/.test(text) ? new Uint8Array(Buffer.from(text.slice(2), "hex")) : text;
+function postgresArrayElementFromText(params) {
+  switch (params.scalarType) {
+    case "Boolean":
+      return booleanFromText;
+    case "Bytes":
+      return bytesFromText;
+    case "Json":
+      return jsonCodec.decode;
+    default:
+      return null;
+  }
+}
+var POSTGRES_CODECS = {
+  String: passthroughCodec,
+  Boolean: passthroughCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateNativeCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var SQLITE_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanIntCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateTextCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var MYSQL_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanNativeInCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: mysqlDecimalCodec,
+  DateTime: mysqlDateCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var DIALECT_CODECS = {
+  postgres: POSTGRES_CODECS,
+  sqlite: SQLITE_CODECS,
+  mysql: MYSQL_CODECS
+};
+
+// packages/sql/src/result-decoder.ts
+var scalarContracts = new WeakMap;
+function resultScalarContract(params) {
+  return scalarContracts.get(params.decoder);
+}
+function registerScalar(params) {
+  if (params.contract !== undefined)
+    scalarContracts.set(params.decoder, Object.freeze(params.contract));
+  return params.decoder;
+}
+function wrappedContract(params) {
+  const contract = scalarContracts.get(params.decoder);
+  if (contract === undefined || params.list === true && contract.list)
+    return;
+  return { ...contract, ...params.list === true ? { list: true, nullable: false } : {}, ...params.nullable === true ? { nullable: true } : {} };
+}
+function refuse(encoding, message) {
+  throw new VibeError2({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
+}
+function scalar(type, valid) {
+  const convert = (params, encoding) => {
+    const { value, dialect } = params;
+    if (value === null || value === undefined)
+      refuse(encoding, `A non-null ${type} projection received null or a missing column`);
+    if (type === "BigInt" && !(typeof value === "bigint" || typeof value === "string" && /^[+-]?\d+$/.test(value) || typeof value === "number" && Number.isSafeInteger(value))) {
+      refuse(encoding, "BigInt requires exact integer text, bigint, or a safe integer");
     }
-    if ("ident" in part)
-      return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
-    if ("row" in part) {
-      if (conflict === undefined)
-        invalid("Existing/incoming row references require a conflict update");
-      const name = conflict.columns === undefined ? part.column : conflict.columns[part.column];
-      if (name === undefined)
-        invalid(`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 })}`;
+    if (type === "Boolean" && value !== true && value !== false && value !== 0 && value !== 1 && !(!encoding && dialect === "mysql" && (value === "0" || value === "1")))
+      refuse(encoding, "Boolean requires true, false, 0, or 1");
+    if (type === "Decimal" && typeof value === "number")
+      refuse(encoding, "Decimal requires exact decimal text, not a floating-point number");
+    if ((type === "Int" || type === "Float") && typeof value === "string" && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) {
+      refuse(encoding, `Invalid ${type} text`);
     }
-    return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
-  }).join("");
+    const codec = DIALECT_CODECS[dialect][type];
+    const result = type === "Json" && params.wire?.json === "parsed" ? value : codec.decode(value);
+    if (!valid(result))
+      refuse(encoding, `Invalid ${type} projection value`);
+    return result;
+  };
+  return registerScalar({ contract: { scalar: type, nullable: false, list: false }, decoder: Object.freeze({
+    decode: (params) => convert(params, false),
+    encode: (params) => {
+      const value = type === "Json" ? params.value : convert(params, true);
+      if (value === undefined || value === null)
+        refuse(true, `A non-null ${type} parameter cannot be null or undefined`);
+      return DIALECT_CODECS[params.dialect][type].encode(value);
+    }
+  }) });
 }
-function mapConflictColumns(params) {
-  return construct(partsOf(params.fragment).map((part) => {
-    if (typeof part === "string")
-      return part;
-    if ("row" in part) {
-      const column = Object.hasOwn(params.columns, part.column) ? params.columns[part.column] : undefined;
-      if (column === undefined)
-        invalid(`Unknown conflict-expression field "${part.column}"`);
-      return Object.freeze({ ...part, column });
+var stringDecoder = scalar("String", (value) => typeof value === "string");
+var dateDecoder = scalar("DateTime", (value) => value instanceof Date && Number.isFinite(value.getTime()));
+var extendedDecoder = registerScalar({ contract: { scalar: "DateTime", nullable: false, list: false }, decoder: Object.freeze({
+  decode: (params) => {
+    if (params.value === "infinity" || params.value === Infinity)
+      return "infinity";
+    if (params.value === "-infinity" || params.value === -Infinity)
+      return "-infinity";
+    return dateDecoder.decode(params);
+  },
+  encode: (params) => {
+    if (params.value === "infinity" || params.value === "-infinity") {
+      if (params.dialect !== "postgres")
+        throw new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
+      return params.value;
     }
-    if ("greatest" in part)
-      return Object.freeze({ greatest: Object.freeze(part.greatest.map((fragment) => mapConflictColumns({ ...params, fragment }))) });
-    return part;
+    return dateDecoder.encode(params);
+  }
+}) });
+function hasEncoder(decoder) {
+  return "encode" in decoder && typeof decoder.encode === "function";
+}
+function nullable({ decoder }) {
+  const read = (params) => params.value === null ? null : decoder.decode(params);
+  if (!hasEncoder(decoder))
+    return Object.freeze({ decode: read });
+  return registerScalar({ contract: wrappedContract({ decoder, nullable: true }), decoder: Object.freeze({
+    decode: read,
+    encode: (params) => params.value === null ? null : decoder.encode(params)
+  }) });
+}
+function array({ decoder }) {
+  const bidirectional = hasEncoder(decoder);
+  const read = (params) => {
+    const raw = params.value;
+    let value;
+    if (params.dialect === "postgres" && typeof raw === "string") {
+      if (bidirectional)
+        value = parsePgArrayLiteral({ literal: raw });
+      else {
+        const elements = parsePgArrayLiteralNested({ literal: raw });
+        if (elements !== null && elements.some((element) => Array.isArray(element)))
+          refuse(false, "Read-only array decoders support one-dimensional SQL arrays only");
+        value = elements;
+      }
+    } else
+      value = ArrayBuffer.isView(raw) && "length" in raw ? Array.from(raw) : raw;
+    if (!Array.isArray(value))
+      refuse(false, "Expected an array projection");
+    return value.map((element) => decoder.decode({ ...params, value: element }));
+  };
+  if (!hasEncoder(decoder))
+    return Object.freeze({ decode: read });
+  return registerScalar({ contract: wrappedContract({ decoder, list: true }), decoder: Object.freeze({
+    decode: read,
+    encode: (params) => {
+      if (!Array.isArray(params.value))
+        refuse(true, "Expected an array parameter");
+      return params.value.map((value) => decoder.encode({ ...params, value }));
+    }
+  }) });
+}
+var encode = Object.freeze({
+  array: ({ encoder }) => Object.freeze({
+    encode: (params) => {
+      if (!Array.isArray(params.value))
+        refuse(true, "Expected an array parameter");
+      return Array.from(params.value, (value) => encoder.encode({ ...params, value }));
+    }
+  })
+});
+var decode = Object.freeze({
+  string: stringDecoder,
+  boolean: scalar("Boolean", (value) => typeof value === "boolean"),
+  int: scalar("Int", (value) => typeof value === "number" && Number.isSafeInteger(value)),
+  float: scalar("Float", (value) => typeof value === "number" && Number.isFinite(value)),
+  bigInt: scalar("BigInt", (value) => typeof value === "bigint"),
+  decimal: scalar("Decimal", (value) => typeof value === "string" && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)),
+  dateTime: dateDecoder,
+  extendedDateTime: extendedDecoder,
+  json: scalar("Json", (value) => value !== undefined),
+  bytes: scalar("Bytes", (value) => value instanceof Uint8Array),
+  nullable,
+  array,
+  enum: ({ values }) => {
+    const members = new Set(values);
+    return registerScalar({ contract: { scalar: "String", nullable: false, list: false }, decoder: Object.freeze({
+      decode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(false, "Unknown enum projection member"),
+      encode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(true, "Unknown enum parameter member")
+    }) });
+  },
+  object: ({ fields }) => {
+    const entries = Object.entries(fields);
+    const convert = (params, encoding) => {
+      if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
+        refuse(encoding, "Expected a result row object");
+      const row = params.value;
+      return Object.fromEntries(entries.map(([name, decoder]) => {
+        if (!Object.hasOwn(row, name))
+          refuse(encoding, `Missing projection column "${name}"`);
+        return [name, encoding ? decoder.encode({ ...params, value: row[name] }) : decoder.decode({ ...params, value: row[name] })];
+      }));
+    };
+    return Object.freeze({ decode: (params) => convert(params, false), encode: (params) => convert(params, true) });
+  }
+});
+
+// packages/sql/src/sql-input.ts
+var inputs = new WeakMap;
+var tokens = new WeakMap;
+var scopes = new WeakMap;
+function invalid(message) {
+  throw new VibeError3({ code: "VIBE_VALIDATION", message });
+}
+function isSqlParam(value) {
+  return typeof value === "object" && value !== null && tokens.has(value);
+}
+function isSqlInput(value) {
+  return typeof value === "object" && value !== null && inputs.has(value);
+}
+function createSqlInput(params) {
+  if (typeof params.contract.encoder?.encode !== "function")
+    invalid("SQL input contracts require a parameter encoder");
+  const input = Object.freeze(Object.create(null));
+  inputs.set(input, Object.freeze({
+    ...params.contract,
+    ...params.contract.enumValues === undefined ? {} : { enumValues: Object.freeze([...params.contract.enumValues]) },
+    ...params.contract.enumType === undefined ? {} : { enumType: Object.freeze({ ...params.contract.enumType }) }
   }));
+  return input;
+}
+function sqlInputContract(params) {
+  const value = params.input;
+  if (typeof value !== "object" || value === null)
+    invalid("SQL input declarations require a decoder or qb.input descriptor");
+  const declared = inputs.get(value);
+  if (declared !== undefined)
+    return declared;
+  if (!("encode" in value) || !("decode" in value) || typeof value.encode !== "function" || typeof value.decode !== "function")
+    invalid("Expected an authentic SQL input descriptor or bidirectional decoder");
+  const decoder = value;
+  const physical = resultScalarContract({ decoder });
+  return Object.freeze({ encoder: decoder, scalar: physical?.scalar ?? "Unknown", nullable: physical?.nullable ?? true, list: physical?.list ?? false });
+}
+function createSqlInputScope(params) {
+  if (typeof params.isHandle !== "function")
+    invalid("SQL input scopes require the builder's handle check");
+  const declarations = params.inputs;
+  if (typeof declarations !== "object" || declarations === null || Array.isArray(declarations))
+    invalid("Reusable SQL requires an input declaration record");
+  const prototype = Object.getPrototypeOf(declarations);
+  if (prototype !== Object.prototype && prototype !== null)
+    invalid("SQL input declarations require a plain record");
+  const keys = Reflect.ownKeys(declarations);
+  const entries = keys.map((key) => {
+    if (typeof key !== "string" || key.length === 0 || key.includes("\x00"))
+      invalid("SQL input names must be nonempty strings without NUL");
+    const descriptor = Object.getOwnPropertyDescriptor(declarations, key);
+    if (!("value" in descriptor))
+      invalid("SQL input declarations cannot contain accessors");
+    return [key, sqlInputContract({ input: descriptor.value })];
+  });
+  const scope = Object.freeze(Object.create(null));
+  scopes.set(scope, { open: true, keys: Object.freeze(entries.map(([key]) => key)), isHandle: params.isHandle });
+  const record = Object.create(null);
+  for (const [key, contract] of entries) {
+    const param = Object.freeze(Object.create(null));
+    tokens.set(param, { scope, key, contract });
+    record[key] = param;
+  }
+  return { scope, params: Object.freeze(record) };
 }
-function compileSql(params) {
-  const collector = new ParamCollector(params.dialect);
-  const text = renderSqlFragment({ dialect: params.dialect, fragment: params.query, collector });
-  return { text, values: collector.values };
+function sealSqlInputScope(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  state.open = false;
 }
-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 }))));
+function assertSqlParamBuilding(params) {
+  const state = tokens.get(params.param) ?? invalid("Expected an authentic SQL input token");
+  if (scopes.get(state.scope)?.open !== true)
+    invalid("SQL input tokens cannot escape their reusable build callback");
+}
+function sqlParamContract(params) {
+  return (tokens.get(params.param) ?? invalid("Expected an authentic SQL input token")).contract;
+}
+function sqlParamKey(params) {
+  const state = tokens.get(params.param) ?? invalid("Expected an authentic SQL input token");
+  if (state.scope !== params.scope)
+    invalid("A reusable query cannot capture another template's input token");
+  return state.key;
+}
+function sqlInputScopeHandle(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  return state.isHandle(params.value);
+}
+function sqlInputScopeKeys(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  if (state.open)
+    invalid("A reusable SQL build must finish before compilation");
+  return state.keys;
 }
-// packages/sql/src/result-decoder.ts
-import { VibeError as VibeError4 } from "@vibeorm/schema";
 
-// packages/sql/src/pg-array.ts
-var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
-function toPgArrayLiteral(params) {
-  const { values } = params;
-  const parts = values.map((value) => {
-    if (value === null || value === undefined)
-      return "NULL";
-    const text = String(value);
-    return PG_ARRAY_QUOTE.test(text) ? `"${text.replace(/["\\]/g, (char) => `\\${char}`)}"` : text;
+// packages/sql/src/parameter-snapshot.ts
+function snapshotSqlValue(value, ancestors = new Set, isHandle) {
+  const invalid = (message) => {
+    throw new VibeError4({ code: "VIBE_VALIDATION", message });
+  };
+  if (isSqlParam(value))
+    return invalid("SQL input tokens are valid only in admitted reusable builder positions");
+  if (isHandle !== undefined && typeof value === "object" && value !== null && isHandle(value))
+    return invalid("SQL builder, plan, template, input and fragment handles are not execution values");
+  if (value === undefined)
+    return invalid("SQL values cannot be undefined; omit a defaulted column or use null");
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "bigint")
+    return value;
+  if (typeof value === "number")
+    return value;
+  if (value instanceof Date)
+    return Number.isFinite(value.getTime()) ? new Date(value.getTime()) : invalid("SQL dates must be finite");
+  if (value instanceof Uint8Array)
+    return new Uint8Array(value);
+  if (typeof value !== "object")
+    return invalid("Unsupported SQL parameter value");
+  if (ancestors.has(value))
+    return invalid("Cyclic SQL parameter values are unsupported");
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+    return invalid("SQL parameters require standard arrays or plain objects");
+  const nested = new Set([...ancestors, value]);
+  const snapshot = array ? [] : Object.create(prototype === null ? null : Object.prototype);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor))
+      return invalid("SQL parameter objects and arrays cannot contain accessors");
+    Object.defineProperty(snapshot, key, { ...descriptor, value: snapshotSqlValue(descriptor.value, nested, isHandle) });
+  }
+  return snapshot;
+}
+
+// packages/sql/src/sql-bindings.ts
+var recordings = new WeakMap;
+var programs = new WeakMap;
+function invalid2(message) {
+  throw new VibeError5({ code: "VIBE_VALIDATION", message });
+}
+function unsupported(message) {
+  throw new VibeError5({ code: "VIBE_UNSUPPORTED_CAPABILITY", message });
+}
+function sqlParameterTransport(params) {
+  if (isNativeEnumArrayParameter(params.value))
+    return { kind: "native-enum-array", type: params.value.type };
+  if (isJsonListParameter(params.value))
+    return { kind: "json-list", storage: params.value.storage, whole: typeof params.value.value !== "string" };
+  return { kind: "plain" };
+}
+function renderSqlParameterTransport(params) {
+  const { dialect, placeholder, transport } = params;
+  if (transport.kind === "plain")
+    return placeholder;
+  if (!dialect.capabilities.scalarArrays)
+    throw unsupportedCapability2({ dialect: dialect.name, feature: "scalarArrays" });
+  if (transport.kind === "native-enum-array")
+    return `${placeholder}::${dialect.quoteIdent({ name: transport.type.namespace })}.${dialect.quoteIdent({ name: transport.type.name })}[]`;
+  return `${placeholder}::text::${transport.storage}${transport.whole ? "[]" : ""}`;
+}
+function sqlParameterWireValue(params) {
+  if (isNativeEnumArrayParameter(params.value))
+    return params.value.value;
+  if (isJsonListParameter(params.value))
+    return typeof params.value.value === "string" ? params.value.value : toPgArrayLiteral({ values: params.value.value });
+  return params.value;
+}
+function isSqlBindingCollector(params) {
+  return recordings.has(params.collector);
+}
+function startSqlBindingCollection(params) {
+  sqlInputScopeKeys({ scope: params.scope });
+  if (recordings.has(params.collector))
+    invalid2("SQL binding collection was already started");
+  recordings.set(params.collector, { dialect: params.dialect, scope: params.scope, steps: [], contracts: new Map, used: new Set });
+}
+function contractShape(contract) {
+  return JSON.stringify({
+    scalar: contract.scalar,
+    nullable: contract.nullable,
+    list: contract.list,
+    nativeType: contract.nativeType,
+    enumValues: contract.enumValues,
+    enumType: contract.enumType === undefined ? undefined : [contract.enumType.namespace, contract.enumType.name],
+    jsonStorage: contract.jsonStorage
   });
-  return `{${parts.join(",")}}`;
 }
-function parsePgArrayLiteral(params) {
-  const { literal } = params;
-  if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
-    return null;
-  const inner = literal.slice(1, -1);
-  if (inner.length === 0)
-    return [];
-  const out = [];
-  let index = 0;
-  while (index < inner.length) {
-    if (inner[index] === '"') {
-      let text = "";
-      index++;
-      while (index < inner.length) {
-        const char = inner[index];
-        if (char === "\\") {
-          text += inner[index + 1] ?? "";
-          index += 2;
-          continue;
-        }
-        index++;
-        if (char === '"')
-          break;
-        text += char;
-      }
-      out.push(text);
-    } else {
-      let text = "";
-      while (index < inner.length && inner[index] !== ",") {
-        text += inner[index];
-        index++;
-      }
-      out.push(text === "NULL" ? null : text);
+function sameContract(left, right) {
+  return left.encoder === right.encoder && left.columnIdentity === right.columnIdentity && contractShape(left) === contractShape(right);
+}
+function recordSqlBinding(params) {
+  const state = recordings.get(params.collector) ?? invalid2("SQL input tokens require execution through their reusable template");
+  let key;
+  if (params.source.kind === "input") {
+    key = sqlParamKey({ param: params.source.param, scope: state.scope });
+    if (params.contract === undefined)
+      invalid2("Named SQL inputs require an effective encoding contract");
+    const previous = state.contracts.get(key);
+    if (previous !== undefined && !sameContract(previous, params.contract))
+      invalid2(`SQL input "${key}" has incompatible encoding contracts`);
+    state.contracts.set(key, params.contract);
+    state.used.add(key);
+  }
+  const transport = params.transport.kind === "native-enum-array" ? Object.freeze({ ...params.transport, type: Object.freeze({ ...params.transport.type }) }) : Object.freeze({ ...params.transport });
+  const source = params.source.kind === "literal" ? Object.freeze({ kind: "literal", value: snapshotSqlValue(params.source.value) }) : Object.freeze({ ...params.source });
+  const placeholder = params.collector.reserve();
+  const text = renderSqlParameterTransport({ dialect: state.dialect, placeholder, transport });
+  state.steps.push(Object.freeze({ kind: "slot", source, key, transport, encode: params.encode, rejectNull: params.rejectNull === true, ...params.validate === undefined ? {} : { validate: params.validate } }));
+  return text;
+}
+function recordSqlBindingCheck(params) {
+  const state = recordings.get(params.collector) ?? invalid2("Expected a structural SQL collector");
+  state.steps.push(Object.freeze({ kind: "check", check: params.check }));
+}
+function finishSqlBindingCollection(params) {
+  const state = recordings.get(params.collector) ?? invalid2("Expected a structural SQL collector");
+  const keys = sqlInputScopeKeys({ scope: state.scope });
+  for (const key of keys)
+    if (!state.used.has(key))
+      invalid2(`Declared SQL input "${key}" is unused by the finished query`);
+  const program = Object.freeze(Object.create(null));
+  programs.set(program, { dialect: state.dialect, keys, steps: Object.freeze([...state.steps]) });
+  return program;
+}
+function inputSnapshot(params) {
+  const value = params.value === undefined && params.keys.length === 0 ? Object.create(null) : params.value;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    invalid2("Reusable SQL parameters require an exact plain record");
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    invalid2("Reusable SQL parameters require a plain record without inherited inputs");
+  const own = Reflect.ownKeys(value);
+  if (own.length !== params.keys.length || own.some((key) => typeof key !== "string" || !params.keys.includes(key)))
+    invalid2("Reusable SQL parameters must contain exactly the declared names");
+  const descriptors = params.keys.map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined || !("value" in descriptor) || descriptor.value === undefined)
+      invalid2(`SQL input "${key}" must be an own defined data property`);
+    return { key, value: descriptor.value };
+  });
+  const snapshot = Object.create(null);
+  for (const entry of descriptors)
+    snapshot[entry.key] = snapshotSqlValue(entry.value, new Set, params.isHandle);
+  return snapshot;
+}
+function sameTransport(left, right) {
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind === "native-enum-array" && right.kind === "native-enum-array")
+    return left.type.namespace === right.type.namespace && left.type.name === right.type.name;
+  if (left.kind === "json-list" && right.kind === "json-list")
+    return left.storage === right.storage && left.whole === right.whole;
+  return true;
+}
+function bindSqlBindingProgram(params) {
+  const state = programs.get(params.program) ?? invalid2("Expected an authentic SQL binding program");
+  const inputs = inputSnapshot({ keys: state.keys, value: params.params, isHandle: params.isHandle });
+  const encodedInputs = new Map;
+  const values = [];
+  for (const step of state.steps) {
+    if (step.kind === "check") {
+      step.check();
+      continue;
     }
-    if (inner[index] === ",")
-      index++;
+    const value = step.source.kind === "literal" ? step.source.value : inputs[step.key];
+    step.validate?.(value);
+    if (step.rejectNull && value === null)
+      invalid2("SQL comparison and membership inputs cannot be SQL NULL; use isNull");
+    let encoded;
+    if (step.key !== undefined && encodedInputs.has(step.key))
+      encoded = encodedInputs.get(step.key);
+    else {
+      encoded = snapshotSqlValue(step.encode({ value: snapshotSqlValue(value), dialect: state.dialect }));
+      if (step.key !== undefined)
+        encodedInputs.set(step.key, encoded);
+    }
+    step.validate?.(encoded);
+    if (step.rejectNull && encoded === null)
+      invalid2("SQL comparison and membership encoders cannot produce SQL NULL; use isNull");
+    if (encoded !== null && !sameTransport(step.transport, sqlParameterTransport({ value: encoded })))
+      unsupported("A reusable SQL encoder produced an undeclared parameter transport shape");
+    values.push(snapshotSqlValue(sqlParameterWireValue({ value: encoded })));
   }
-  return out;
+  return values;
 }
 
-// packages/sql/src/codecs.ts
-import { VibeError as VibeError3, invalidStoredData } from "@vibeorm/schema";
-function enumMembershipCodec(params) {
-  const { model, field, enum: enumName } = params;
-  const members = new Set(params.members);
-  return {
-    encode: (value) => {
-      if (typeof value === "string" && members.has(value))
-        return value;
-      throw new VibeError3({
-        code: "VIBE_VALIDATION",
-        message: `Invalid value for enum ${enumName} on ${model}.${field}`,
-        meta: { model, field, enum: enumName }
+// packages/sql/src/params.ts
+class ParamCollector {
+  dialect;
+  reserved = 0;
+  values;
+  constructor(dialect) {
+    this.dialect = dialect;
+    this.values = [];
+  }
+  reserve() {
+    const index = isSqlBindingCollector({ collector: this }) ? ++this.reserved : this.values.length;
+    return this.dialect.placeholder({ index });
+  }
+  count() {
+    return isSqlBindingCollector({ collector: this }) ? this.reserved : this.values.length;
+  }
+  add(value) {
+    const transport = sqlParameterTransport({ value });
+    if (isSqlBindingCollector({ collector: this }))
+      return recordSqlBinding({
+        collector: this,
+        source: { kind: "literal", value },
+        transport,
+        encode: (params) => params.value
       });
-    },
-    decode: (value) => {
-      if (typeof value === "string" && members.has(value))
-        return value;
-      throw invalidStoredData({ model, field, enum: enumName, value });
+    if (transport.kind !== "plain" && !this.dialect.capabilities.scalarArrays)
+      throw unsupportedCapability3({ dialect: this.dialect.name, feature: "scalarArrays" });
+    this.values.push(sqlParameterWireValue({ value }));
+    return renderSqlParameterTransport({ dialect: this.dialect, placeholder: this.reserve(), transport });
+  }
+  addMany(values) {
+    return values.map((value) => this.add(value));
+  }
+}
+
+// packages/sql/src/dialects/external-dependents.ts
+function renderExternalDependents(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability4({ dialect: params.dialect.name, feature: "externalObjects" });
+  const collector = new ParamCollector(params.dialect);
+  const requests = params.targets.map((target, position) => ({ position, kind: target.kind, namespace: target.namespace, name: target.name, column: target.kind === "column" ? target.column : null }));
+  const request = collector.add(JSON.stringify(requests));
+  const text = `WITH request AS (
+  SELECT * FROM jsonb_to_recordset(${request}::text::jsonb) AS request(position integer, kind text, namespace text, name text, "column" text)
+), target AS (
+  SELECT request.position, 'pg_type'::regclass AS classid, t.oid AS objid, NULL::integer AS objsubid FROM request JOIN pg_catalog.pg_namespace n ON n.nspname = request.namespace JOIN pg_catalog.pg_type t ON t.typnamespace = n.oid AND t.typname = request.name WHERE request.kind = 'type'
+  UNION ALL SELECT request.position, 'pg_class'::regclass, c.oid, a.attnum::integer FROM request JOIN pg_catalog.pg_namespace n ON n.nspname = request.namespace JOIN pg_catalog.pg_class c ON c.relnamespace = n.oid AND c.relname = request.name LEFT JOIN pg_catalog.pg_attribute a ON request.kind = 'column' AND a.attrelid = c.oid AND a.attname = request."column" AND NOT a.attisdropped WHERE request.kind = 'relation' OR request.kind = 'column' AND a.attnum IS NOT NULL
+), owned AS (
+  SELECT position, classid, objid, objsubid FROM target
+  UNION SELECT target.position, 'pg_type'::regclass, c.reltype, NULL FROM target JOIN pg_catalog.pg_class c ON c.oid = target.objid WHERE target.classid = 'pg_class'::regclass AND target.objsubid IS NULL AND c.reltype <> 0
+  UNION SELECT target.position, 'pg_class'::regclass, s.oid, NULL FROM target JOIN pg_catalog.pg_depend sd ON sd.refclassid = target.classid AND sd.refobjid = target.objid AND (target.objsubid IS NULL OR sd.refobjsubid = target.objsubid) AND sd.classid = 'pg_class'::regclass AND sd.deptype IN ('a', 'i') JOIN pg_catalog.pg_class s ON s.oid = sd.objid AND s.relkind = 'S'
+), referenced AS (
+  SELECT position, classid, objid, objsubid FROM owned
+  UNION SELECT owned.position, 'pg_type'::regclass, t.typarray, NULL FROM owned JOIN pg_catalog.pg_type t ON t.oid = owned.objid WHERE owned.classid = 'pg_type'::regclass AND t.typarray <> 0
+)
+SELECT DISTINCT referenced.position, dependent.type AS "dependentType", dependent.identity AS "dependentIdentity", ref.identity AS referenced, d.classid::regclass::text AS "dependentClass",
+  rn.nspname::text AS "relationNamespace", rel.relname::text AS "relationName", rel.relkind::text AS "relationKind", col.attname::text AS "columnName",
+  COALESCE(pn.nspname, tn.nspname, dependent.schema)::text AS "objectNamespace", COALESCE(p.proname, ty.typname)::text AS "objectName"
+FROM referenced
+JOIN pg_catalog.pg_depend d ON d.refclassid = referenced.classid AND d.refobjid = referenced.objid AND (referenced.objsubid IS NULL OR d.refobjsubid = referenced.objsubid) AND d.deptype = 'n'
+CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.classid, d.objid, d.objsubid) dependent
+CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.refclassid, d.refobjid, d.refobjsubid) ref
+LEFT JOIN pg_catalog.pg_class self ON d.classid = 'pg_class'::regclass AND self.oid = d.objid
+LEFT JOIN pg_catalog.pg_index ix ON ix.indexrelid = self.oid
+LEFT JOIN pg_catalog.pg_attrdef ad ON d.classid = 'pg_attrdef'::regclass AND ad.oid = d.objid
+LEFT JOIN pg_catalog.pg_rewrite rw ON d.classid = 'pg_rewrite'::regclass AND rw.oid = d.objid
+LEFT JOIN pg_catalog.pg_trigger tg ON d.classid = 'pg_trigger'::regclass AND tg.oid = d.objid
+LEFT JOIN pg_catalog.pg_constraint con ON d.classid = 'pg_constraint'::regclass AND con.oid = d.objid
+LEFT JOIN pg_catalog.pg_policy pol ON d.classid = 'pg_policy'::regclass AND pol.oid = d.objid
+LEFT JOIN pg_catalog.pg_type ty ON d.classid = 'pg_type'::regclass AND ty.oid = d.objid
+LEFT JOIN pg_catalog.pg_namespace tn ON tn.oid = ty.typnamespace
+LEFT JOIN pg_catalog.pg_proc p ON d.classid = 'pg_proc'::regclass AND p.oid = d.objid
+LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace
+LEFT JOIN pg_catalog.pg_class rel ON rel.oid = COALESCE(ix.indrelid, self.oid, ad.adrelid, rw.ev_class, tg.tgrelid, NULLIF(con.conrelid, 0), pol.polrelid, NULLIF(ty.typrelid, 0))
+LEFT JOIN pg_catalog.pg_namespace rn ON rn.oid = rel.relnamespace
+LEFT JOIN pg_catalog.pg_attribute col ON col.attrelid = rel.oid AND col.attnum = CASE WHEN self.oid IS NOT NULL AND d.objsubid > 0 THEN d.objsubid WHEN ad.oid IS NOT NULL THEN ad.adnum END
+ORDER BY 1, 2, 3, 4`;
+  return { text, values: collector.values, returning: "none" };
+}
+// packages/sql/src/dialects/postgres-physical-catalog.ts
+import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+function renderPostgresPhysicalCatalog(params) {
+  const { dialect } = params;
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability5({ dialect: dialect.name, feature: "postgresPhysicalCatalog" });
+  const collector = new ParamCollector(dialect);
+  const namespace = collector.add(params.namespace);
+  const extensionOwnedFilter = `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON c.oid = d.objid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE d.classid = 'pg_class'::regclass AND d.deptype = 'e' AND n.nspname = ${namespace} AND c.relname = table_name)`;
+  let text;
+  switch (params.query) {
+    case "tables":
+      text = `SELECT table_name FROM information_schema.tables WHERE table_schema = ${namespace} AND table_type = 'BASE TABLE' AND table_name <> '_vibe_migrations' AND ${extensionOwnedFilter} ORDER BY table_name`;
+      break;
+    case "views":
+      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`;
+      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`;
+      break;
+    case "checks":
+      text = `SELECT cl.relname AS table_name, c.conname AS constraint_name, pg_get_constraintdef(c.oid) AS definition 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 WHERE c.contype = 'c' AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname`;
+      break;
+    case "foreignKeys":
+      text = `SELECT c.conname AS constraint_name, cl.relname AS table_name, att.attname AS column_name, fn.nspname AS foreign_namespace, fcl.relname AS foreign_table_name, fatt.attname AS foreign_column_name, c.confdeltype AS on_delete_char, c.confupdtype AS on_update_char, c.convalidated AS validated, c.condeferrable AS deferrable, (SELECT bool_and(t.tgenabled IN ('O', 'A')) FROM pg_catalog.pg_trigger t WHERE t.tgconstraint = c.oid) AS triggers_enabled FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace JOIN pg_catalog.pg_class fcl ON fcl.oid = c.confrelid JOIN pg_catalog.pg_namespace fn ON fn.oid = fcl.relnamespace JOIN unnest(c.conkey) WITH ORDINALITY AS lk(attnum, ord) ON true JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = lk.attnum JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum WHERE c.contype = 'f' AND n.nspname = ${namespace} ORDER BY cl.relname, c.conname, lk.ord`;
+      break;
+    case "enums":
+      text = `SELECT t.typname AS type_name, n.nspname AS type_namespace, e.enumlabel AS enum_value, e.enumsortorder AS sort_order FROM pg_type t JOIN pg_enum e ON t.oid = e.enumtypid JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_type'::regclass AND d.objid = t.oid AND d.deptype = 'e') ORDER BY t.typname, e.enumsortorder`;
+      break;
+    case "indexes":
+      text = `SELECT tablename AS table_name, indexname AS index_name, indexdef AS index_def, con.conname AS backing_constraint, con.contype AS backing_constraint_type, health.indisvalid AS valid, health.indisready AS ready, health.indimmediate AS immediate, health.indexprs IS NULL AS plain_columns, health.indnkeyatts AS key_count, health.indnatts AS attribute_count FROM pg_indexes ix JOIN pg_catalog.pg_namespace ns ON ns.nspname = ix.schemaname JOIN pg_catalog.pg_class idx ON idx.relnamespace = ns.oid AND idx.relname = ix.indexname JOIN pg_catalog.pg_index health ON health.indexrelid = idx.oid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = idx.oid AND con.contype IN ('p', 'u', 'x') WHERE schemaname = ${namespace} ORDER BY tablename, indexname`;
+      break;
+  }
+  return { text, values: collector.values, returning: "none" };
+}
+// packages/sql/src/dialects/postgres-index-keys.ts
+import { unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+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`;
+  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`,
+    values: collector.values,
+    returning: "none"
+  };
+}
+// packages/sql/src/index-columns.ts
+import { VibeError as VibeError6, isSqlObjectIdentity, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+function renderIndexColumns(params) {
+  const { dialect, columns, unique } = params;
+  const hasOperatorClass = columns.some((column) => column.operatorClass !== undefined);
+  if (hasOperatorClass && !dialect.capabilities.indexOperatorClasses)
+    throw unsupportedCapability7({ dialect: dialect.name, feature: "indexOperatorClasses" });
+  if (hasOperatorClass && unique)
+    throw unsupportedCapability7({ dialect: dialect.name, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
+  return columns.map((column) => {
+    const operatorClass = column.operatorClass;
+    if (operatorClass !== undefined && !isSqlObjectIdentity({ kind: "table", name: operatorClass })) {
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", column: column.name } });
     }
+    const ops = operatorClass === undefined ? "" : ` ${dialect.quoteIdent({ name: operatorClass.namespace })}.${dialect.quoteIdent({ name: operatorClass.name })}`;
+    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"
   };
 }
-function decodeIsNoop(params) {
-  const { scalarType, wire } = params;
-  if (wire === undefined)
-    return false;
-  if (scalarType === "DateTime")
-    return false;
-  if (scalarType === "Json")
-    return wire.json === "parsed";
-  if (scalarType === "Int" || scalarType === "Float")
-    return wire.numbers === "native";
-  return false;
+// 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" };
 }
-var identity = (value) => value;
-var passthroughCodec = { encode: identity, decode: identity };
-var numberCodec = {
-  encode: identity,
-  decode: (value) => typeof value === "string" ? Number(value) : value
-};
-var bigIntCodec = {
-  encode: (value) => typeof value === "bigint" ? value.toString() : value,
-  decode: (value) => {
-    if (typeof value === "bigint")
-      return value;
-    if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim()))
-      return BigInt(value.trim());
-    if (typeof value === "number" && Number.isSafeInteger(value))
-      return BigInt(value);
-    throw new VibeError3({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
+// 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");
+    }
+    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 "mysqlForeignKeys": {
+      if (pg)
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
+    }
+    case "dropMysqlObject": {
+      if (pg)
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
+    }
   }
-};
-var decimalCodec = {
-  encode: (value) => typeof value === "number" || typeof value === "bigint" ? String(value) : value,
-  decode: identity
-};
-var mysqlDecimalCodec = {
-  encode: decimalCodec.encode,
-  decode: (value) => {
-    if (typeof value !== "string" || !value.includes("."))
-      return value;
-    const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
-    return trimmed === "" || trimmed === "-" ? "0" : trimmed;
+}
+// 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;
+    case "complete":
+      text = `UPDATE ${table} SET ${column} = ${collector.add(operation.entry)} WHERE ${q("name")} = ${collector.add(operation.name)}`;
+      break;
   }
-};
-var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
-function parseDateTimeText(params) {
-  const trimmed = params.text.trim();
-  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 asUtc;
+  return { text, values: collector.values };
+}
+// packages/sql/src/capabilities.ts
+import {
+  DIALECT_CAPABILITIES,
+  POSTGRES_CAPABILITIES,
+  SQLITE_CAPABILITIES,
+  MYSQL_CAPABILITIES
+} from "@vibeorm/schema";
+
+// packages/sql/src/identifiers.ts
+import { VibeError as VibeError7 } from "@vibeorm/schema";
+function assertNoNul(params) {
+  if (params.name.includes("\x00")) {
+    throw new VibeError7({
+      code: "VIBE_VALIDATION",
+      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
+      meta: { name: params.name.replaceAll("\x00", "\\0") }
+    });
   }
-  const parsed = new Date(trimmed);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+  return params.name;
 }
-var dateNativeCodec = {
-  encode: (value) => {
-    if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
-      throw new VibeError3({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
-    }
-    return value;
+
+// packages/sql/src/dialects/sqlite.ts
+var sqliteDialect = {
+  name: "sqlite",
+  capabilities: SQLITE_CAPABILITIES,
+  inArrayStrategy: "expand",
+  tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
+  upsertForm: "onConflict",
+  conflictKeyEquality: {
+    foldingScalars: [],
+    textIsBinaryByDefault: true,
+    duplicatesInOneStatement: "lastWriteWins"
   },
-  decode: (value) => {
-    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
-    if (date !== undefined && Number.isFinite(date.getTime()))
-      return date;
-    throw new VibeError3({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
-  }
-};
-var dateTextCodec = {
-  encode: (value) => {
-    dateNativeCodec.encode(value);
-    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
-    if (date !== undefined && Number.isFinite(date.getTime()))
-      return date.toISOString();
-    throw new VibeError3({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+  excludedRowRef: { form: "keyword", name: "excluded" },
+  doNothingForm: "onConflictDoNothing",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "glob",
+  greatestForm: "frame",
+  orderByNullsMode: "native",
+  offsetRequiresLimit: { limitText: "-1" },
+  likeEscapeClause: " ESCAPE '\\'",
+  jsonPathMode: "sqliteExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  valueCastTypes: Object.freeze({ String: "TEXT", Boolean: "INTEGER", Int: "INTEGER", BigInt: "INTEGER", Float: "REAL", Decimal: "TEXT", DateTime: "TEXT", Json: "TEXT", Bytes: "BLOB" }),
+  lastInsertIdSql: null,
+  rowLockSyntax: null,
+  advisoryLockFunctions: null,
+  rowDefaultKeyword: false,
+  statementChain: null,
+  paramBudget: 900,
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
   },
-  decode: dateNativeCodec.decode
-};
-var mysqlDateCodec = {
-  encode: (value) => {
-    dateNativeCodec.encode(value);
-    if (value instanceof Date)
-      return value;
-    if (typeof value === "number") {
-      const parsed = new Date(value);
-      if (!Number.isNaN(parsed.getTime()))
-        return parsed;
-      return value;
-    }
-    if (typeof value === "string")
-      return parseDateTimeText({ text: value }) ?? value;
-    return value;
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("'", "''")}'`;
   },
-  decode: dateNativeCodec.decode
-};
-var booleanIntCodec = {
-  encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
-  decode: (value) => typeof value === "number" ? value !== 0 : value
-};
-var booleanNativeInCodec = {
-  encode: identity,
-  decode: booleanIntCodec.decode
-};
-var jsonCodec = {
-  encode: (value) => JSON.stringify(value),
-  decode: (value) => {
-    if (typeof value !== "string")
-      return value;
-    try {
-      return JSON.parse(value);
-    } catch (cause) {
-      throw new VibeError3({
-        code: "VIBE_INTERNAL",
-        message: "a Json column returned text that is not valid JSON",
-        meta: { value },
-        cause
-      });
-    }
+  placeholder() {
+    return "?";
+  },
+  jsonTextProjection({ expression }) {
+    return expression;
+  },
+  renderDbNow({ offsetSeconds, collector }) {
+    if (offsetSeconds === 0)
+      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
   }
 };
-var POSTGRES_CODECS = {
-  String: passthroughCodec,
-  Boolean: passthroughCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: decimalCodec,
-  DateTime: dateNativeCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var SQLITE_CODECS = {
-  String: passthroughCodec,
-  Boolean: booleanIntCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: decimalCodec,
-  DateTime: dateTextCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var MYSQL_CODECS = {
-  String: passthroughCodec,
-  Boolean: booleanNativeInCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: mysqlDecimalCodec,
-  DateTime: mysqlDateCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var DIALECT_CODECS = {
-  postgres: POSTGRES_CODECS,
-  sqlite: SQLITE_CODECS,
-  mysql: MYSQL_CODECS
-};
 
-// packages/sql/src/result-decoder.ts
-function refuse(encoding, message) {
-  throw new VibeError4({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
-}
-function scalar(type, valid) {
-  const convert = (params, encoding) => {
-    const { value, dialect } = params;
-    if (value === null || value === undefined)
-      refuse(encoding, `A non-null ${type} projection received null or a missing column`);
-    if (type === "BigInt" && !(typeof value === "bigint" || typeof value === "string" && /^[+-]?\d+$/.test(value) || typeof value === "number" && Number.isSafeInteger(value))) {
-      refuse(encoding, "BigInt requires exact integer text, bigint, or a safe integer");
+// 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 (type === "Boolean" && value !== true && value !== false && value !== 0 && value !== 1)
-      refuse(encoding, "Boolean requires true, false, 0, or 1");
-    if (type === "Decimal" && typeof value === "number")
-      refuse(encoding, "Decimal requires exact decimal text, not a floating-point number");
-    if ((type === "Int" || type === "Float") && typeof value === "string" && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) {
-      refuse(encoding, `Invalid ${type} text`);
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0)
+        break;
+      index = end + 1;
+      continue;
     }
-    const codec = DIALECT_CODECS[dialect][type];
-    const result = type === "Json" && params.wire?.json === "parsed" ? value : codec.decode(value);
-    if (!valid(result))
-      refuse(encoding, `Invalid ${type} projection value`);
-    return result;
-  };
-  return Object.freeze({
-    decode: (params) => convert(params, false),
-    encode: (params) => {
-      const value = type === "Json" ? params.value : convert(params, true);
-      if (value === undefined || value === null)
-        refuse(true, `A non-null ${type} parameter cannot be null or undefined`);
-      return DIALECT_CODECS[params.dialect][type].encode(value);
+    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();
 }
-var stringDecoder = scalar("String", (value) => typeof value === "string");
-var dateDecoder = scalar("DateTime", (value) => value instanceof Date && Number.isFinite(value.getTime()));
-var extendedDecoder = Object.freeze({
-  decode: (params) => {
-    if (params.value === "infinity" || params.value === Infinity)
-      return "infinity";
-    if (params.value === "-infinity" || params.value === -Infinity)
-      return "-infinity";
-    return dateDecoder.decode(params);
-  },
-  encode: (params) => {
-    if (params.value === "infinity" || params.value === "-infinity") {
-      if (params.dialect !== "postgres")
-        throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
-      return params.value;
-    }
-    return dateDecoder.encode(params);
+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 });
+  const columns = params.columns.map((column) => quote(column)).join(", ");
+  const oldValues = params.columns.map((column) => `old.${quote(column)}`).join(", ");
+  const newValues = params.columns.map((column) => `new.${quote(column)}`).join(", ");
+  const changes = [
+    "old.rowid IS NOT new.rowid",
+    ...params.columns.map((column) => `old.${quote(column)} COLLATE BINARY IS NOT new.${quote(column)} COLLATE BINARY`)
+  ].join(" OR ");
+  const target = `${quote(`${params.ftsTable}_au`)} AFTER UPDATE ON ${quote(params.table)}`;
+  const body = `BEGIN
+  INSERT INTO ${quote(params.ftsTable)}(${quote(params.ftsTable)}, rowid, ${columns}) VALUES ('delete', old.rowid, ${oldValues});
+  INSERT INTO ${quote(params.ftsTable)}(rowid, ${columns}) VALUES (new.rowid, ${newValues});
+END`;
+  const tail = `${target} WHEN (${changes}) ${body}`;
+  return {
+    create: `CREATE TRIGGER IF NOT EXISTS ${tail};`,
+    definition: `CREATE TRIGGER ${tail}`,
+    legacyDefinition: `CREATE TRIGGER ${target} ${body}`
+  };
+}
+function renderSqliteFtsUpdateTrigger(params) {
+  const { create, definition } = updateStatements(params);
+  return { create, definition };
+}
+function sqliteFtsUpdateUpgrade(params) {
+  const quoted = '"(?:[^"]|"")+"';
+  const body = new RegExp(`BEGIN\\n  INSERT INTO (${quoted})\\((${quoted}), rowid, (${quoted}(?:, ${quoted})*)\\) VALUES \\('delete', old\\.rowid, `, "g");
+  for (const match of params.create.matchAll(body)) {
+    const ftsTable = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[1]})` })[0].name;
+    const columns = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[3]})` }).map((column) => column.name);
+    if (params.name !== `${ftsTable}_au`)
+      continue;
+    const statements = updateStatements({ table: params.table, ftsTable, columns });
+    if (params.create !== statements.create)
+      continue;
+    const installed = params.installed === statements.legacyDefinition ? "legacy" : params.installed === statements.definition ? "current" : undefined;
+    if (installed === undefined)
+      continue;
+    if (params.tableDefinition === undefined)
+      return { kind: "tableRequired", ftsTable };
+    const tableTail = `${sqliteDialect.quoteIdent({ name: ftsTable })} USING fts5(${columns.map((name) => sqliteDialect.quoteIdent({ name })).join(", ")}, content=${sqliteDialect.quoteStringLiteral({ value: params.table })})`;
+    if (params.tableDefinition !== `CREATE VIRTUAL TABLE ${tableTail}` && params.tableDefinition !== `CREATE VIRTUAL TABLE IF NOT EXISTS ${tableTail};`)
+      continue;
+    return { kind: "recognized", ftsTable, legacyDefinition: statements.legacyDefinition, currentDefinition: statements.definition, drop: `DROP TRIGGER IF EXISTS ${sqliteDialect.quoteIdent({ name: `${ftsTable}_au` })};`, installed };
   }
+  return;
+}
+// packages/sql/src/dialects/sqlite-session.ts
+var SQLITE_SESSION_SQL = Object.freeze({
+  lockingMode: "PRAGMA main.locking_mode",
+  exclusive: "PRAGMA main.locking_mode = EXCLUSIVE",
+  normal: "PRAGMA main.locking_mode = NORMAL",
+  acquire: "BEGIN EXCLUSIVE",
+  commit: "COMMIT",
+  rollback: "ROLLBACK",
+  touch: "SELECT name FROM main.sqlite_schema LIMIT 1",
+  foreignKeysOn: "PRAGMA foreign_keys = ON"
 });
-var decode = Object.freeze({
-  string: stringDecoder,
-  boolean: scalar("Boolean", (value) => typeof value === "boolean"),
-  int: scalar("Int", (value) => typeof value === "number" && Number.isSafeInteger(value)),
-  float: scalar("Float", (value) => typeof value === "number" && Number.isFinite(value)),
-  bigInt: scalar("BigInt", (value) => typeof value === "bigint"),
-  decimal: scalar("Decimal", (value) => typeof value === "string" && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)),
-  dateTime: dateDecoder,
-  extendedDateTime: extendedDecoder,
-  json: scalar("Json", (value) => value !== undefined),
-  bytes: scalar("Bytes", (value) => value instanceof Uint8Array),
-  nullable: ({ decoder }) => Object.freeze({
-    decode: (params) => params.value === null ? null : decoder.decode(params),
-    encode: (params) => params.value === null ? null : decoder.encode(params)
-  }),
-  array: ({ decoder }) => Object.freeze({
-    decode: (params) => {
-      const raw = params.value;
-      const value = params.dialect === "postgres" && typeof raw === "string" ? parsePgArrayLiteral({ literal: raw }) : ArrayBuffer.isView(raw) && ("length" in raw) ? Array.from(raw) : raw;
-      if (!Array.isArray(value))
-        refuse(false, "Expected an array projection");
-      return value.map((element) => decoder.decode({ ...params, value: element }));
-    },
-    encode: (params) => {
-      if (!Array.isArray(params.value))
-        refuse(true, "Expected an array parameter");
-      return params.value.map((value) => decoder.encode({ ...params, value }));
+// packages/sql/src/composable.ts
+import { VibeError as VibeError9 } from "@vibeorm/schema";
+var fragments = new WeakMap;
+function invalid3(message) {
+  throw new VibeError9({ code: "VIBE_VALIDATION", message });
+}
+function construct(parts) {
+  const snapshot = Object.freeze([...parts]);
+  const fragment = Object.freeze(Object.defineProperty(Object.create(null), "toJSON", {
+    value: () => ({ parts: snapshot })
+  }));
+  fragments.set(fragment, snapshot);
+  return fragment;
+}
+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");
+}
+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");
+  }
+}
+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");
+  }
+  const parts = [];
+  for (let index = 0;index < strings.length; index++) {
+    parts.push(strings[index]);
+    if (index < values.length) {
+      const value = values[index];
+      if (isSqlFragment(value))
+        parts.push(...partsOf(value));
+      else
+        parts.push(Object.freeze({ value: snapshotSqlValue(value) }));
     }
-  }),
-  enum: ({ values }) => {
-    const members = new Set(values);
-    return Object.freeze({
-      decode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(false, "Unknown enum projection member"),
-      encode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(true, "Unknown enum parameter member")
+  }
+  return construct(parts);
+}
+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");
+    return construct([text]);
+  },
+  ident: ({ parts }) => {
+    identifier(parts);
+    return construct([Object.freeze({ ident: Object.freeze([...parts]) })]);
+  },
+  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");
+    const between = separator === undefined ? [", "] : partsOf(separator);
+    const parts = [];
+    items.forEach((value, index) => {
+      if (index > 0)
+        parts.push(...between);
+      parts.push(...isSqlFragment(value) ? partsOf(value) : [Object.freeze({ value: snapshotSqlValue(value) })]);
     });
+    return construct(parts);
   },
-  object: ({ fields }) => {
-    const entries = Object.entries(fields);
-    const convert = (params, encoding) => {
-      if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
-        refuse(encoding, "Expected a result row object");
-      const row = params.value;
-      return Object.fromEntries(entries.map(([name, decoder]) => {
-        if (!Object.hasOwn(row, name))
-          refuse(encoding, `Missing projection column "${name}"`);
-        return [name, encoding ? decoder.encode({ ...params, value: row[name] }) : decoder.decode({ ...params, value: row[name] })];
-      }));
-    };
-    return Object.freeze({ decode: (params) => convert(params, false), encode: (params) => convert(params, true) });
+  existing: ({ column }) => {
+    identifier([column]);
+    return construct([Object.freeze({ row: "existing", column })]);
+  },
+  incoming: ({ column }) => {
+    identifier([column]);
+    return construct([Object.freeze({ row: "incoming", column })]);
+  },
+  greatest: ({ values }) => {
+    if (!Array.isArray(values) || values.length !== 2 || values.some((value) => !isSqlFragment(value)))
+      invalid3("sql.greatest requires two SQL fragments");
+    return construct([Object.freeze({ greatest: Object.freeze([...values]) })]);
   }
-});
+}));
+function renderSqlFragment(params) {
+  const { dialect, collector, conflict } = params;
+  const render = (fragment) => renderSqlFragment({ ...params, fragment });
+  const encode = (part) => {
+    if (part.value === undefined)
+      invalid3("SQL parameters cannot be undefined; use null explicitly");
+    return snapshotSqlValue(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
+  };
+  const recording = isSqlBindingCollector({ collector });
+  const recordValue = (part) => recordSqlBinding({
+    collector,
+    source: { kind: "literal", value: part.value },
+    transport: part.decoder === undefined ? sqlParameterTransport({ value: part.value }) : { kind: "plain" },
+    encode: ({ value, dialect: target }) => part.decoder === undefined ? value : part.decoder.encode({ value, dialect: target.name })
+  });
+  const frameOperand = (fragment) => {
+    const parts = partsOf(fragment).filter((part) => part !== "");
+    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" });
+      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" });
+          } });
+        return "NULL";
+      }
+      const text = recordValue(only);
+      return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+    }
+    const value = only !== undefined && typeof only !== "string" && "value" in only ? { encoded: encode(only) } : undefined;
+    if (value !== undefined && value.encoded === null)
+      return "NULL";
+    const text = value === undefined ? render(fragment) : collector.add(value.encoded);
+    return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+  };
+  return partsOf(params.fragment).map((part) => {
+    if (typeof part === "string")
+      return part;
+    if ("value" in part)
+      return recording ? recordValue(part) : collector.add(encode(part));
+    if ("ident" in part)
+      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");
+      const name = conflict.columns === undefined ? part.column : conflict.columns[part.column];
+      if (name === undefined)
+        invalid3(`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 })}`;
+    }
+    if (dialect.greatestForm === "native")
+      return `GREATEST(${part.greatest.map(render).join(", ")})`;
+    if (!part.greatest.some(containsGreatest)) {
+      return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    }
+    const [left, right] = part.greatest.map(frameOperand);
+    const [a, b, frame] = ["a", "b", "g"].map((name) => dialect.quoteIdent({ name }));
+    return `(SELECT CASE WHEN ${a} IS NULL THEN ${b} WHEN ${b} IS NULL THEN ${a} WHEN ${a} >= ${b} THEN ${a} ELSE ${b} END FROM (SELECT ${left} AS ${a}, ${right} AS ${b}) AS ${frame})`;
+  }).join("");
+}
+function mapConflictColumns(params) {
+  return construct(partsOf(params.fragment).map((part) => {
+    if (typeof part === "string")
+      return part;
+    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}"`);
+      return Object.freeze({ ...part, column });
+    }
+    if ("greatest" in part)
+      return Object.freeze({ greatest: Object.freeze(part.greatest.map((fragment) => mapConflictColumns({ ...params, fragment }))) });
+    return part;
+  }));
+}
+function compileSql(params) {
+  const collector = new ParamCollector(params.dialect);
+  const text = renderSqlFragment({ dialect: params.dialect, fragment: params.query, collector });
+  return { text, values: collector.values };
+}
+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";
+var queries = new WeakMap;
+var commands = new WeakMap;
+var reusableQueries = new WeakMap;
+var reusableCommands = new WeakMap;
+function invalid4(message) {
+  throw new VibeError10({ 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");
+  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");
+  const command = Object.freeze(Object.create(null));
+  commands.set(command, params.render);
+  return command;
+}
+function isSqlQuery(value) {
+  return typeof value === "object" && value !== null && queries.has(value);
+}
+function isSqlCommand(value) {
+  return typeof value === "object" && value !== null && commands.has(value);
+}
+function isReusableSqlQuery(value) {
+  return typeof value === "object" && value !== null && reusableQueries.has(value);
+}
+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");
+  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");
+  sqlInputScopeKeys({ scope: params.scope });
+  const query = Object.freeze(Object.create(null));
+  reusableCommands.set(query, { render, scope: params.scope, cache: new WeakMap });
+  return query;
+}
+function compiledTemplate(params) {
+  const cached = params.state.cache.get(params.dialect);
+  if (cached !== undefined)
+    return cached;
+  const collector = new ParamCollector(params.dialect);
+  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");
+  const program = finishSqlBindingCollection({ collector });
+  const compiled = Object.freeze({ text, program });
+  params.state.cache.set(params.dialect, compiled);
+  return compiled;
+}
+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 VibeError6, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { VibeError as VibeError12, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
 
 // packages/sql/src/predicate.ts
-import { VibeError as VibeError5, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+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 unsupportedCapability8({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
-    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "partialIndexes" });
+    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "partialIndexes" });
   }
   const context = {
     model: params.model,
@@ -840,7 +1698,8 @@ var PRECEDENCE = {
   not: 3,
   compare: 4,
   inList: 4,
-  isNull: 4
+  isNull: 4,
+  isTrue: 4
 };
 var COMPARISON_SQL = {
   eq: "=",
@@ -858,7 +1717,7 @@ var INT64_MIN = -(2n ** 63n);
 var INT64_MAX = 2n ** 63n - 1n;
 function refuse2(params) {
   const { context, rule, message } = params;
-  throw new VibeError5({
+  throw new VibeError11({
     code: "VIBE_SCHEMA_INVALID",
     message: `${context.site} on "${context.model.name}": ${message}`,
     meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
@@ -891,14 +1750,16 @@ function renderNode(params) {
     }
     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 });
+      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 = resolveField({ name: node.left.name, context });
-      const right = renderOperand({ operand: node.right, field: left, context });
-      return `${compareColumn({ field: left, context })} ${COMPARISON_SQL[node.op]} ${right}`;
+      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) {
@@ -942,7 +1803,7 @@ function resolveField(params) {
       meta: { field: name }
     });
   }
-  if (field.type === "Json" || field.type === "Bytes") {
+  if (params.nullTest !== true && (field.type === "Json" || field.type === "Bytes")) {
     refuse2({
       context,
       rule: "predicate-unsupported-type",
@@ -951,7 +1812,7 @@ function resolveField(params) {
     });
   }
   if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
-    throw unsupportedCapability8({
+    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"
@@ -968,22 +1829,43 @@ function compareColumn(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 = resolveField({ name: operand.name, context });
+  const other = renderExpression({ expression: operand, context });
   const leftType = fieldTypeIdentity({ type: field.type });
-  const rightType = fieldTypeIdentity({ type: other.type });
+  const rightType = fieldTypeIdentity({ type: other.field.type });
   if (leftType !== rightType) {
     refuse2({
       context,
       rule: "predicate-type-mismatch",
-      message: `compares "${field.name}" (${leftType}) with "${other.name}" (${rightType}) \u2014 both sides of a comparison need the same scalar type`,
-      meta: { field: field.name, other: other.name, fieldType: leftType, otherType: rightType }
+      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 compareColumn({ field: other, context });
+  return other.text;
 }
 function renderLiteral(params) {
   const { field, context } = params;
@@ -1121,23 +2003,23 @@ function describe(params) {
 }
 
 // packages/sql/src/exclusion.ts
-function invalid2(rule) {
-  throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+function invalid5(rule) {
+  throw new VibeError12({ 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 unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
-    invalid2("name");
+    invalid5("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
-    invalid2("range-type");
+    invalid5("range-type");
   if (!["[)", "[]", "()", "(]"].includes(spec.range.bounds))
-    invalid2("bounds");
+    invalid5("bounds");
   const field = (name) => {
     const value = model.fields.find((entry) => entry.name === name);
     if (value === undefined || value.isList || value.isUnsupported)
-      invalid2("field");
+      invalid5("field");
     return value;
   };
   const endpoint = (value) => {
@@ -1145,17 +2027,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)))
-      invalid2("infinity");
+      invalid5("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"))
-      invalid2("range-field-type");
+      invalid5("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"))
-        invalid2("range-timezone");
+        invalid5("range-timezone");
     }
     const sql = dialect.quoteIdent({ name: column.dbName ?? column.name });
     return literal === undefined ? sql : `COALESCE(${sql}, ${literal})`;
@@ -1163,15 +2045,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)
-        invalid2("expression");
+        invalid5("expression");
       key.fields.forEach(field);
       return `(${key.expression}) WITH =`;
     }
     const column = field(key.field);
     if (column.isOptional)
-      invalid2("nullable-key-requires-expression");
+      invalid5("nullable-key-requires-expression");
     if (!isEnumType2(column.type) && !["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
-      invalid2("key-type");
+      invalid5("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 &&`);
@@ -1180,13 +2062,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ 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 unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ 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 })};`];
@@ -1195,14 +2077,14 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ 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 unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ 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
@@ -1245,7 +2127,7 @@ function isSqlDefaultCell(value) {
   return value === SQL_DEFAULT_CELL;
 }
 function jsonParamCell(params) {
-  return { __jsonParam: true, text: params.text };
+  return params.storage === "json" ? { __jsonParam: true, text: params.text, storage: "json" } : { __jsonParam: true, text: params.text };
 }
 function isJsonParamCell(value) {
   return typeof value === "object" && value !== null && value.__jsonParam === true;
@@ -1256,9 +2138,32 @@ function excludedRef(params) {
 function isExcludedRef(value) {
   return typeof value === "object" && value !== null && value.__excluded === true;
 }
+function returningColumnName(column) {
+  return typeof column === "string" ? column : column.name;
+}
 var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
+function stepColumnRef(params) {
+  return { __stepColumn: true, step: params.step, column: params.column };
+}
+function isStepColumnRef(value) {
+  return typeof value === "object" && value !== null && value.__stepColumn === true;
+}
+var CHAIN_VETO_PREFIX = "__vibe_veto:";
+var CHAIN_VETO_TOKEN_PATTERN = /^[a-z][a-z0-9_]*$/;
+function chainVetoToken(params) {
+  const { message, nonce } = params;
+  if (nonce === "")
+    return;
+  for (let start = message.indexOf(CHAIN_VETO_PREFIX);start >= 0; start = message.indexOf(CHAIN_VETO_PREFIX, start + 1)) {
+    const rest = message.slice(start + CHAIN_VETO_PREFIX.length);
+    const match = /^([a-z][a-z0-9_]*):/.exec(rest);
+    if (match !== null && rest.startsWith(`${nonce}:`, match[0].length))
+      return match[1];
+  }
+  return;
+}
 // packages/sql/src/locks.ts
-import { internalError, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+import { internalError, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -1278,7 +2183,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -1286,7 +2191,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -1294,7 +2199,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -1313,7 +2218,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       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`
@@ -1344,35 +2249,15 @@ function assertInt32(params) {
 var JSON_TRANSPORT = Object.freeze({ chunkSize: 100 });
 function projectionOutputName(params) {
   const { column } = params;
-  return column.transform === undefined ? column.alias ?? column.name : column.name;
-}
-// packages/sql/src/capabilities.ts
-import {
-  DIALECT_CAPABILITIES,
-  POSTGRES_CAPABILITIES,
-  SQLITE_CAPABILITIES,
-  MYSQL_CAPABILITIES
-} from "@vibeorm/schema";
-
-// packages/sql/src/identifiers.ts
-import { VibeError as VibeError7 } from "@vibeorm/schema";
-function assertNoNul(params) {
-  if (params.name.includes("\x00")) {
-    throw new VibeError7({
-      code: "VIBE_VALIDATION",
-      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
-      meta: { name: params.name.replaceAll("\x00", "\\0") }
-    });
-  }
-  return params.name;
+  return column.transform === undefined || column.transform === "jsonText" ? column.alias ?? column.name : column.name;
 }
-
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
   name: "postgres",
   capabilities: POSTGRES_CAPABILITIES,
   inArrayStrategy: "any",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
   upsertForm: "onConflict",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1383,6 +2268,7 @@ var postgresDialect = {
   doNothingForm: "onConflictDoNothing",
   insensitiveLike: "ilike",
   strictMatchStrategy: "native",
+  greatestForm: "native",
   orderByNullsMode: "native",
   offsetRequiresLimit: null,
   likeEscapeClause: null,
@@ -1397,6 +2283,7 @@ var postgresDialect = {
     "array_ends_with"
   ],
   jsonParamCast: "::text::jsonb",
+  valueCastTypes: Object.freeze({ String: "TEXT", Boolean: "BOOLEAN", Int: "INTEGER", BigInt: "BIGINT", Float: "DOUBLE PRECISION", Decimal: "NUMERIC", DateTime: "TIMESTAMPTZ", Json: "JSONB", Bytes: "BYTEA" }),
   lastInsertIdSql: null,
   rowLockSyntax: {
     strengths: Object.freeze({
@@ -1419,6 +2306,7 @@ var postgresDialect = {
     keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
   },
   rowDefaultKeyword: true,
+  statementChain: "dataModifyingCte",
   paramBudget: 30000,
   booleanLiteral: { true: "true", false: "false" },
   quoteIdent({ name }) {
@@ -1430,69 +2318,22 @@ var postgresDialect = {
   placeholder({ index }) {
     return `$${index}`;
   },
+  jsonTextProjection({ expression }) {
+    return `${expression}::text`;
+  },
   renderDbNow({ offsetSeconds, collector }) {
     if (offsetSeconds === 0)
       return "now()";
     return `(now() + make_interval(secs => ${collector.add(offsetSeconds)}))`;
   }
 };
-// packages/sql/src/dialects/sqlite.ts
-var sqliteDialect = {
-  name: "sqlite",
-  capabilities: SQLITE_CAPABILITIES,
-  inArrayStrategy: "expand",
-  tupleInStrategy: "rowValue",
-  upsertForm: "onConflict",
-  conflictKeyEquality: {
-    foldingScalars: [],
-    textIsBinaryByDefault: true,
-    duplicatesInOneStatement: "lastWriteWins"
-  },
-  excludedRowRef: { form: "keyword", name: "excluded" },
-  doNothingForm: "onConflictDoNothing",
-  insensitiveLike: "lower",
-  strictMatchStrategy: "glob",
-  orderByNullsMode: "native",
-  offsetRequiresLimit: { limitText: "-1" },
-  likeEscapeClause: " ESCAPE '\\'",
-  jsonPathMode: "sqliteExtract",
-  supportedJsonOps: [
-    "equals",
-    "string_contains",
-    "string_starts_with",
-    "string_ends_with",
-    "array_contains",
-    "array_starts_with",
-    "array_ends_with"
-  ],
-  jsonParamCast: "",
-  lastInsertIdSql: null,
-  rowLockSyntax: null,
-  advisoryLockFunctions: null,
-  rowDefaultKeyword: false,
-  paramBudget: 900,
-  booleanLiteral: { true: "1", false: "0" },
-  quoteIdent({ name }) {
-    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
-  },
-  quoteStringLiteral({ value }) {
-    return `'${value.replaceAll("'", "''")}'`;
-  },
-  placeholder() {
-    return "?";
-  },
-  renderDbNow({ offsetSeconds, collector }) {
-    if (offsetSeconds === 0)
-      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
-  }
-};
 // packages/sql/src/dialects/mysql.ts
 var mysqlDialect = {
   name: "mysql",
   capabilities: MYSQL_CAPABILITIES,
   inArrayStrategy: "expand",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "equalities",
   upsertForm: "onDuplicateKey",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1504,6 +2345,7 @@ var mysqlDialect = {
   doNothingForm: "insertIgnore",
   insensitiveLike: "lower",
   strictMatchStrategy: "binary",
+  greatestForm: "wrapped-frame",
   orderByNullsMode: "emulate",
   offsetRequiresLimit: { limitText: "18446744073709551615" },
   likeEscapeClause: null,
@@ -1518,6 +2360,7 @@ var mysqlDialect = {
     "array_ends_with"
   ],
   jsonParamCast: "",
+  valueCastTypes: Object.freeze({ String: "CHAR", Boolean: "UNSIGNED", Int: "SIGNED", BigInt: "SIGNED", Float: "DOUBLE", Decimal: "DECIMAL(65, 30)", DateTime: "DATETIME(3)", Json: "JSON", Bytes: "BINARY" }),
   lastInsertIdSql: "SELECT LAST_INSERT_ID() AS `id`",
   rowLockSyntax: {
     strengths: Object.freeze({ update: "FOR UPDATE", share: "FOR SHARE" }),
@@ -1525,6 +2368,7 @@ var mysqlDialect = {
   },
   advisoryLockFunctions: null,
   rowDefaultKeyword: true,
+  statementChain: null,
   paramBudget: 1e4,
   booleanLiteral: { true: "1", false: "0" },
   quoteIdent({ name }) {
@@ -1536,6 +2380,9 @@ var mysqlDialect = {
   placeholder() {
     return "?";
   },
+  jsonTextProjection({ expression }) {
+    return `CAST(${expression} AS CHAR)`;
+  },
   renderDbNow({ offsetSeconds, collector }) {
     if (offsetSeconds === 0)
       return "NOW(6)";
@@ -1551,85 +2398,8 @@ var SQL_DIALECTS = {
 function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
-// packages/sql/src/dialects/sqlite-table-definition.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
-function tableDefinitionParts(params) {
-  const sql = params.sql;
-  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
-    throw unavailable();
-  const parts = [];
-  let start = -1;
-  let depth = 0;
-  let quote;
-  for (let index = 0;index < sql.length; index++) {
-    const char = sql[index];
-    if (quote !== undefined) {
-      if (char === quote) {
-        if (quote !== "]" && sql[index + 1] === quote)
-          index++;
-        else
-          quote = undefined;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"' || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "[") {
-      quote = "]";
-      continue;
-    }
-    if (char === "-" && sql[index + 1] === "-") {
-      const end = sql.indexOf(`
-`, index + 2);
-      if (end < 0)
-        break;
-      index = end;
-      continue;
-    }
-    if (char === "/" && sql[index + 1] === "*") {
-      const end = sql.indexOf("*/", index + 2);
-      if (end < 0)
-        break;
-      index = end + 1;
-      continue;
-    }
-    if (char === "(") {
-      if (depth === 0)
-        start = index + 1;
-      depth++;
-    } else if (char === ")") {
-      depth--;
-      if (depth === 0 && start >= 0) {
-        parts.push(sql.slice(start, index).trim());
-        return { clauses: parts, suffix: sql.slice(index + 1) };
-      }
-    } else if (char === "," && depth === 1) {
-      parts.push(sql.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  throw unavailable();
-}
-function unavailable() {
-  return new VibeError8({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
-}
-function sqliteColumnClauses(params) {
-  const columns = [];
-  for (const part of tableDefinitionParts(params).clauses) {
-    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
-    if (token === null)
-      throw unavailable();
-    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
-      continue;
-    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
-    columns.push({ name, sql: part });
-  }
-  return columns;
-}
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability12 } 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'" }
@@ -1637,7 +2407,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability11({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability12({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -1646,7 +2416,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { VibeError as VibeError13, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -1681,7 +2451,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability12({
+    throw unsupportedCapability13({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -1699,7 +2469,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 VibeError9({
+      throw new VibeError13({
         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 }
@@ -1718,7 +2488,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError9({
+    throw new VibeError13({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -1728,10 +2498,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError10, assertValidSchemaIR, unsupportedCapability as unsupportedCapability13, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError14, assertValidSchemaIR, unsupportedCapability as unsupportedCapability14, 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" } },
@@ -1744,18 +2514,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability14({ 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 VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError14({ 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 unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability14({ 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 })}`;
 }
@@ -1796,14 +2566,14 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(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 VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -1836,7 +2606,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -1870,7 +2640,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 VibeError10({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError14({ 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 });
@@ -2022,7 +2792,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -2054,7 +2824,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -2108,6 +2878,8 @@ function renderStatement(params) {
       return renderUpdate({ dialect, statement, collector });
     case "delete":
       return renderDelete({ dialect, statement, collector });
+    case "chain":
+      return renderChain({ dialect, statement, collector });
     case "rlsReadiness":
       return renderRlsReadinessQuery({ dialect, ...statement });
     case "rlsProbeTable":
@@ -2141,8 +2913,29 @@ function quoteCol(dialect, column) {
     }
     return `CAST(${ref} AS REAL)`;
   }
+  if (column.castJsonb !== undefined) {
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "ColRef.castJsonb is a postgres json construct" });
+    }
+    return `${ref}::${column.castJsonb}`;
+  }
   return ref;
 }
+function typedOrderRef(params) {
+  const { statement, column } = params;
+  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined)
+    return column;
+  const renamed = statement.columns.some((projected) => (projected.alias ?? projected.name) === column.name && (projected.transform !== undefined || projected.alias !== undefined));
+  return renamed ? { ...column, table: statement.table.alias ?? statement.table.name } : column;
+}
+function jsonCellCast(dialect, cell) {
+  if (cell.storage !== "json" || dialect.jsonParamCast === "")
+    return dialect.jsonParamCast;
+  if (dialect.name !== "postgres") {
+    throw internalError2({ message: "JsonParamCell storage json is a postgres construct" });
+  }
+  return "::text::json";
+}
 function quoteProjection(dialect, column) {
   if (column.transform === undefined) {
     const base = quoteCol(dialect, column);
@@ -2150,8 +2943,13 @@ function quoteProjection(dialect, column) {
       return base;
     return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
   }
+  if (column.transform === "jsonText") {
+    const ref = quoteCol(dialect, column);
+    const alias = dialect.quoteIdent({ name: column.alias ?? column.name });
+    return `${dialect.jsonTextProjection({ expression: ref })} AS ${alias}`;
+  }
   if (dialect.name !== "postgres") {
-    throw internalError2({ message: "ColRef.transform is a postgres lateral-join construct" });
+    throw internalError2({ message: "ColRef.transform is a postgres construct" });
   }
   const ref = quoteCol(dialect, column);
   const alias = dialect.quoteIdent({ name: column.name });
@@ -2159,6 +2957,10 @@ function quoteProjection(dialect, column) {
     return `${ref}::text AS ${alias}`;
   return `encode(${ref}, 'base64') AS ${alias}`;
 }
+function renderProjection(params) {
+  const { dialect, columns } = params;
+  return columns.map((column) => quoteProjection(dialect, column)).join(", ");
+}
 function renderTable(dialect, table) {
   if (table.namespace !== undefined)
     assertSqlNamespace2({ namespace: table.namespace, dialect: dialect.name });
@@ -2202,7 +3004,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability15({
+  throw unsupportedCapability16({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -2219,7 +3021,8 @@ function renderExpr(params) {
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
       }
-      return `${quoteCol(dialect, expr.column)} ${op} ${collector.add(expr.value)}`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      return `${compared.column} ${op} ${compared.operand}`;
     }
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
@@ -2235,6 +3038,10 @@ function renderExpr(params) {
         return expr.negate === true ? "1 = 1" : "1 = 0";
       }
       const column = quoteCol(dialect, expr.column);
+      if (expr.timeOfDay === true && dialect.timeOfDayInStrategy === "equalities") {
+        const equalities = collector.addMany(expr.values).map((placeholder) => `${column} = ${placeholder}`);
+        return `${expr.negate === true ? "NOT " : ""}(${equalities.join(" OR ")})`;
+      }
       if (dialect.inArrayStrategy === "any") {
         const base = `${column} = ANY(${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)})`;
         return expr.negate === true ? `NOT (${base})` : base;
@@ -2328,16 +3135,21 @@ function renderExpr(params) {
     }
     case "arrayHas": {
       assertScalarArrays(dialect, 'the scalar-list filter "has"');
-      const base = `${collector.add(expr.value)} = ANY(${quoteCol(dialect, expr.column)})`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      const base = `${compared.operand} = ANY(${compared.column})`;
       return expr.negate === true ? `NOT (${base})` : base;
     }
     case "arrayContainsAll": {
       assertScalarArrays(dialect, 'the scalar-list filter "hasEvery"');
-      return `${quoteCol(dialect, expr.column)} @> ${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)}`;
+      const values = Array.isArray(expr.values) ? [...expr.values] : expr.values;
+      const compared = listComparison({ dialect, column: expr.column, value: values, collector });
+      return `${compared.column} @> ${compared.operand}`;
     }
     case "arrayOverlaps": {
       assertScalarArrays(dialect, 'the scalar-list filter "hasSome"');
-      return `${quoteCol(dialect, expr.column)} && ${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)}`;
+      const values = Array.isArray(expr.values) ? [...expr.values] : expr.values;
+      const compared = listComparison({ dialect, column: expr.column, value: values, collector });
+      return `${compared.column} && ${compared.operand}`;
     }
     case "arrayIsEmpty": {
       assertScalarArrays(dialect, 'the scalar-list filter "isEmpty"');
@@ -2385,6 +3197,16 @@ function jsonPathString(path) {
   }
   return out;
 }
+function listComparison(params) {
+  const { dialect, column, value, collector } = params;
+  if (isJsonListParameter(value) && value.storage === "json") {
+    return {
+      column: `${quoteCol(dialect, column)}::jsonb[]`,
+      operand: collector.add(jsonListParameter({ value: value.value, storage: "jsonb" }))
+    };
+  }
+  return { column: quoteCol(dialect, column), operand: collector.add(value) };
+}
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
@@ -2412,7 +3234,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2422,19 +3244,22 @@ function renderJsonFilter(params) {
   if (dialect.jsonPathMode === "operators") {
     const column = quoteCol(dialect, expr.column);
     const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
+    const extracted = expr.storage === "json" ? `(${column} #> ${pathParam})::jsonb` : `(${column} #> ${pathParam})`;
     switch (expr.op) {
       case "equals":
-        return `(${column} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "string_contains":
       case "string_starts_with":
-      case "string_ends_with":
-        return renderJsonLike({ dialect, target: `(${column} #>> ${pathParam})`, expr, collector });
+      case "string_ends_with": {
+        const target = expr.storage === "json" ? `(${extracted} #>> '{}')` : `(${column} #>> ${pathParam})`;
+        return renderJsonLike({ dialect, target, expr, collector });
+      }
       case "array_contains":
-        return `(${column} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_starts_with":
-        return `(${column} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_ends_with":
-        return `(${column} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
     }
   }
   if (dialect.jsonPathMode === "sqliteExtract") {
@@ -2476,7 +3301,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 unsupportedCapability15({
+            throw unsupportedCapability16({
               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"
@@ -2578,7 +3403,14 @@ function renderLateralJoin(params) {
     const terms = join.select.orderBy;
     const columnTerms = terms.filter((term) => ("column" in term));
     if (columnTerms.length === terms.length && columnTerms.every((term) => projected.has(term.column.name))) {
-      const rendered = columnTerms.map((term) => renderOrderTerm({ dialect, term: { ...term, column: { table: "__sub", name: term.column.name } }, collector }));
+      const rendered = columnTerms.map((term) => renderOrderTerm({
+        dialect,
+        term: {
+          ...term,
+          column: { table: "__sub", name: term.column.name, ...term.column.castJsonb === undefined ? {} : { castJsonb: term.column.castJsonb } }
+        },
+        collector
+      }));
       aggOrder = ` ORDER BY ${rendered.join(", ")}`;
     }
   }
@@ -2587,6 +3419,15 @@ function renderLateralJoin(params) {
   const alias = dialect.quoteIdent({ name: join.alias });
   return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
 }
+function renderCountSubquery(params) {
+  const { dialect, subquery, collector } = params;
+  const select = subquery.select;
+  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
+    throw internalError2({ message: "count subquery must be one ungrouped COUNT(*)" });
+  }
+  const inner = renderSelect({ dialect, statement: select, collector });
+  return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
+}
 function applyReturning(params) {
   const { dialect, requested } = params;
   if (requested === undefined || requested.length === 0) {
@@ -2595,9 +3436,69 @@ function applyReturning(params) {
   if (!dialect.capabilities.returning) {
     return { suffix: "", status: "omitted" };
   }
-  const columns = requested.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const columns = requested.map((column) => {
+    if (typeof column === "string")
+      return dialect.quoteIdent({ name: column });
+    if ("transform" in column) {
+      const name = dialect.quoteIdent({ name: column.name });
+      return `${dialect.jsonTextProjection({ expression: name })} AS ${name}`;
+    }
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "a castText RETURNING column is a postgres construct" });
+    }
+    const name = dialect.quoteIdent({ name: column.name });
+    return `${name}::text AS ${name}`;
+  }).join(", ");
   return { suffix: ` RETURNING ${columns}`, status: "native" };
 }
+function renderKeyTableJoin(params) {
+  const { dialect, join, collector } = params;
+  const postgresMember = (member) => member.kind === "citext" || member.kind === "text" || member.kind === "integer";
+  const admitted = dialect.name === "mysql" ? join.members.every((member) => member.kind !== "citext" && member.kind !== "text") : dialect.name === "postgres" && join.members.every(postgresMember);
+  if (!admitted) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: "relation key table",
+      hint: "the key-table join is mysql's relation association \u2014 this dialect compares relation keys by value"
+    });
+  }
+  if (join.columns.length === 0 || join.columns.length !== join.members.length) {
+    throw internalError2({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+  }
+  if (join.rows.length === 0)
+    throw internalError2({ message: "key table needs at least one key row" });
+  for (const member of join.members) {
+    if (member.kind === "decimal" && !(Number.isInteger(member.scale) && member.scale >= 0 && member.scale <= 30)) {
+      throw internalError2({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+    }
+  }
+  const alias = dialect.quoteIdent({ name: join.alias });
+  const memberNames = join.members.map((_, index) => dialect.quoteIdent({ name: `__vibe_k${index}` }));
+  const rows = join.rows.map((row, ordinal) => {
+    if (row.length !== join.members.length) {
+      throw internalError2({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+    }
+    const cells = row.map((value, index) => {
+      const placeholder = collector.add(value);
+      const member = join.members[index];
+      switch (member.kind) {
+        case "integer":
+          return dialect.name === "mysql" ? `CAST(${placeholder} AS SIGNED)` : `CAST(${placeholder} AS bigint)`;
+        case "decimal":
+          return `CAST(${placeholder} AS DECIMAL(65,${member.scale}))`;
+        case "citext":
+          return `CAST(${placeholder} AS citext)`;
+        case "text":
+          return `CAST(${placeholder} AS text)`;
+        default:
+          return placeholder;
+      }
+    });
+    return dialect.name === "mysql" ? `ROW(${cells.join(", ")}, ${ordinal})` : `(${cells.join(", ")}, ${ordinal})`;
+  });
+  const on = join.columns.map((column, index) => `${quoteCol(dialect, column)} = ${alias}.${memberNames[index]}`).join(" AND ");
+  return `INNER JOIN (VALUES ${rows.join(", ")}) AS ${alias} (${[...memberNames, dialect.quoteIdent({ name: join.ordinalAlias })].join(", ")}) ON ${on}`;
+}
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
@@ -2615,6 +3516,11 @@ function renderSelect(params) {
       columnList.push(`${renderAggRef(dialect, selection.agg)} AS ${dialect.quoteIdent({ name: selection.alias })}`);
     }
   }
+  if (statement.countSubqueries !== undefined) {
+    for (const subquery of statement.countSubqueries) {
+      columnList.push(renderCountSubquery({ dialect, subquery, collector }));
+    }
+  }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0) {
@@ -2627,13 +3533,13 @@ function renderSelect(params) {
   let distinctPrefix = "";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability15({
+      throw unsupportedCapability16({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
       });
     }
-    distinctPrefix = `DISTINCT ON (${statement.distinctOn.map((column) => quoteCol(dialect, column)).join(", ")}) `;
+    distinctPrefix = `DISTINCT ON (${statement.distinctOn.map((column) => quoteCol(dialect, typedOrderRef({ statement, column }))).join(", ")}) `;
   }
   const columns = columnList.length === 0 ? "*" : columnList.join(", ");
   let from;
@@ -2656,9 +3562,12 @@ function renderSelect(params) {
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
     }
   }
+  if (statement.keyTable !== undefined) {
+    text += ` ${renderKeyTableJoin({ dialect, join: statement.keyTable, collector })}`;
+  }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
-      throw unsupportedCapability15({
+      throw unsupportedCapability16({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -2678,7 +3587,7 @@ function renderSelect(params) {
     text += ` HAVING ${renderExpr({ dialect, expr: statement.having, collector })}`;
   }
   if (statement.orderBy !== undefined && statement.orderBy.length > 0) {
-    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term, collector }));
+    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term: "column" in term ? { ...term, column: typedOrderRef({ statement, column: term.column }) } : term, collector }));
     text += ` ORDER BY ${terms.join(", ")}`;
   }
   if (statement.limit !== undefined) {
@@ -2720,7 +3629,7 @@ function renderInsert(params) {
   const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const rowsSql = statement.rows.map((row) => `(${row.map((value) => {
     if (isJsonParamCell(value))
-      return `${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     if (isDbNowMarker(value)) {
       return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
     }
@@ -2743,7 +3652,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability15({
+            throw unsupportedCapability16({
               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"
@@ -2758,7 +3667,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability15({
+        throw unsupportedCapability16({
           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"
@@ -2776,7 +3685,7 @@ function renderInsert(params) {
           throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability15({
+          throw unsupportedCapability16({
             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"
@@ -2792,14 +3701,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability15({
+          throw unsupportedCapability16({
             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 unsupportedCapability15({
+          throw unsupportedCapability16({
             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"
@@ -2852,7 +3761,7 @@ function renderAssignments(params) {
       return `${column} = ${renderIncomingRowColumn({ dialect, column: value.column })}`;
     }
     if (isJsonParamCell(value)) {
-      return `${column} = ${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${column} = ${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     }
     if (isSetOperation(value)) {
       const operand = collector.add(value.value);
@@ -2881,8 +3790,174 @@ function renderDelete(params) {
   const returning = applyReturning({ dialect, requested: statement.returning });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
+var CHAIN_ROWS_ALIAS = "__vibe_rows";
+var CHAIN_ONE_ALIAS = "__vibe_one";
+function renderChain(params) {
+  const { dialect, statement, collector } = params;
+  if (dialect.statementChain === null) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: "a statement chain (data-modifying WITH steps)",
+      hint: "this dialect accepts only SELECT inside WITH \u2014 gate on SqlDialect.statementChain and keep the multi-statement path"
+    });
+  }
+  if (statement.steps.length === 0)
+    throw internalError2({ message: "a statement chain needs at least one step" });
+  const defined = new Set;
+  const steps = [];
+  for (const step of statement.steps) {
+    if (step.name === CHAIN_ROWS_ALIAS || step.name === CHAIN_ONE_ALIAS || defined.has(step.name)) {
+      throw internalError2({ message: `chain step name "${step.name}" is reserved or repeated` });
+    }
+    const body = renderChainStep({ dialect, statement: step.statement, collector, earlier: defined });
+    steps.push(`${dialect.quoteIdent({ name: step.name })} AS (${body})`);
+    defined.add(step.name);
+  }
+  const result = statement.result;
+  if (result.rowsFrom.length === 0 || result.columns.length === 0) {
+    throw internalError2({ message: "a chain result needs at least one source step and one column" });
+  }
+  for (const name of result.rowsFrom) {
+    if (!defined.has(name))
+      throw internalError2({ message: `chain result reads undefined step "${name}"` });
+  }
+  const columnList = result.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const union = result.rowsFrom.map((name) => `SELECT ${columnList} FROM ${dialect.quoteIdent({ name })}`).join(" UNION ALL ");
+  let select = union;
+  if (result.verdict !== undefined || result.tally !== undefined || result.veto !== undefined && result.veto.length > 0) {
+    const extra = [];
+    for (const alias of [result.verdict?.alias, result.tally?.alias]) {
+      if (alias !== undefined && result.columns.includes(alias)) {
+        throw internalError2({ message: `chain result alias "${alias}" collides with a result column` });
+      }
+    }
+    const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
+    const projected = result.columns.map((name) => `${rows}.${dialect.quoteIdent({ name })}`);
+    if (result.verdict !== undefined) {
+      extra.push(`${renderExpr({ dialect, expr: result.verdict.expr, collector })} AS ${dialect.quoteIdent({ name: result.verdict.alias })}`);
+    }
+    if (result.tally !== undefined || result.veto !== undefined && result.veto.length > 0) {
+      extra.push(renderTallyColumn({ dialect, result, defined, collector }));
+    }
+    select = `SELECT ${[...projected, ...extra].join(", ")} FROM (SELECT 1) AS ${dialect.quoteIdent({ name: CHAIN_ONE_ALIAS })}` + ` LEFT JOIN (${union}) AS ${rows} ON TRUE`;
+  }
+  return { text: `WITH ${steps.join(", ")} ${select}`, values: collector.values, returning: "none" };
+}
+function renderChainStep(params) {
+  const { dialect, statement, collector } = params;
+  switch (statement.kind) {
+    case "select":
+      return renderSelect({ dialect, statement, collector }).text;
+    case "insert":
+      return renderInsert({ dialect, statement, collector }).text;
+    case "insertSelect":
+      return renderInsertSelect({ dialect, statement, collector, earlier: params.earlier });
+    case "update":
+      return renderUpdate({ dialect, statement, collector }).text;
+    case "delete":
+      return renderDelete({ dialect, statement, collector }).text;
+  }
+}
+function renderSelectCell(params) {
+  const { dialect, value, collector } = params;
+  if (isJsonParamCell(value))
+    return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
+  if (isDbNowMarker(value))
+    return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
+  if (isSqlDefaultCell(value)) {
+    throw internalError2({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
+  }
+  return collector.add(value);
+}
+function renderRowSource(params) {
+  const { dialect, source, collector } = params;
+  if (source.columns.length === 0 || source.rows.length === 0) {
+    throw internalError2({ message: "a row source needs at least one column and one row" });
+  }
+  const typedBy = renderTable(dialect, source.typedBy);
+  const columns = source.columns.map((name) => dialect.quoteIdent({ name }));
+  const rows = [`(${columns.map((column) => `(SELECT ${column} FROM ${typedBy} WHERE FALSE)`).join(", ")})`];
+  for (const row of source.rows) {
+    if (row.length !== source.columns.length) {
+      throw internalError2({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
+    }
+    rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
+  }
+  const alias = dialect.quoteIdent({ name: source.alias });
+  const columnList = columns.join(", ");
+  return `(SELECT ${columnList} FROM (VALUES ${rows.join(", ")}) AS ${alias} (${columnList}) OFFSET 1) AS ${alias}`;
+}
+function renderTallyColumn(params) {
+  const { dialect, result, defined, collector } = params;
+  const tally = result.tally;
+  if (tally === undefined)
+    throw internalError2({ message: "a chain veto needs a tally column to guard" });
+  if (tally.steps.length === 0)
+    throw internalError2({ message: "a chain tally needs at least one step" });
+  const step = (name) => {
+    if (!defined.has(name))
+      throw internalError2({ message: `chain tally or veto reads undefined step "${name}"` });
+    return dialect.quoteIdent({ name });
+  };
+  const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
+  const sum = tally.steps.map(count).join(" + ");
+  const vetoes = result.veto ?? [];
+  if (vetoes.length === 0)
+    return `${sum} AS ${dialect.quoteIdent({ name: tally.alias })}`;
+  const arms = vetoes.map((veto) => {
+    if (!CHAIN_VETO_TOKEN_PATTERN.test(veto.token))
+      throw internalError2({ message: `chain veto token "${veto.token}" is not a lower-case word` });
+    if (typeof veto.nonce !== "string" || veto.nonce === "")
+      throw internalError2({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
+    const minRows = veto.minRows ?? 1;
+    if (!Number.isSafeInteger(minRows) || minRows < 1)
+      throw internalError2({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
+    const when = minRows === 1 ? `WHEN NOT EXISTS (SELECT 1 FROM ${step(veto.step)})` : `WHEN ${count(veto.step)} < ${minRows}`;
+    return `${when} THEN CAST('${CHAIN_VETO_PREFIX}${veto.token}:' || ${collector.add(veto.nonce)} || ':' || ${count(veto.step)} AS integer)`;
+  });
+  return `CASE ${arms.join(" ")} ELSE ${sum} END AS ${dialect.quoteIdent({ name: tally.alias })}`;
+}
+function renderInsertSelect(params) {
+  const { dialect, statement, collector } = params;
+  if (statement.columns.length === 0)
+    throw internalError2({ message: "insert requires at least one column" });
+  if (statement.cells.length !== statement.columns.length) {
+    throw internalError2({
+      message: `insert row has ${statement.cells.length} values but ${statement.columns.length} columns`
+    });
+  }
+  const from = statement.from ?? [];
+  for (const name of from) {
+    if (!params.earlier.has(name))
+      throw internalError2({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
+  }
+  const source = statement.source;
+  if (source !== undefined && (params.earlier.has(source.alias) || from.includes(source.alias))) {
+    throw internalError2({ message: `row source alias "${source.alias}" collides with a chain step` });
+  }
+  const cells = statement.cells.map((value) => {
+    if (isStepColumnRef(value)) {
+      if (!from.includes(value.step) && value.step !== source?.alias) {
+        throw internalError2({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
+      }
+      return `${dialect.quoteIdent({ name: value.step })}.${dialect.quoteIdent({ name: value.column })}`;
+    }
+    return renderSelectCell({ dialect, value, collector });
+  });
+  const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+  let text = `INSERT INTO ${renderTable(dialect, statement.table)} (${columnList}) SELECT ${cells.join(", ")}`;
+  const relations = from.map((name) => dialect.quoteIdent({ name }));
+  if (source !== undefined)
+    relations.push(renderRowSource({ dialect, source, collector }));
+  if (relations.length > 0)
+    text += ` FROM ${relations.join(" CROSS JOIN ")}`;
+  if (statement.where !== undefined) {
+    text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
+  }
+  return text + applyReturning({ dialect, requested: statement.returning }).suffix;
+}
 // packages/sql/src/dialects/postgres-type-identity.ts
-import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability17 } 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*)*)$`);
@@ -2909,13 +3984,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability17({ 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 unsupportedCapability16({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability17({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -2928,11 +4003,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -2956,28 +4031,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability18({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability19({ 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 unsupportedCapability19 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability20({ 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 unsupportedCapability19({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability20({ 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 unsupportedCapability19({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability20({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
       const parts = tableDefinitionParts({ sql: params.definition });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
@@ -3023,31 +4098,31 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability20({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability21({ 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 unsupportedCapability21 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability22({ 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 unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability22({ 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 unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability22({ 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) {
@@ -3086,7 +4161,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 unsupportedCapability22 } from "@vibeorm/schema";
+import { internalError as internalError3, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -3094,7 +4169,7 @@ function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
   if (object.kind === "namespace") {
     if (dialect.name !== "postgres")
-      throw unsupportedCapability22({ dialect: dialect.name, feature: "fixedNamespaces" });
+      throw unsupportedCapability23({ 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;
@@ -3158,7 +4233,7 @@ function objectQuery(params) {
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability22({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability23({ 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":
@@ -3168,15 +4243,15 @@ 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 unsupportedCapability22({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability23({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability22({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability23({ 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 unsupportedCapability22({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability23({ 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)}`;
@@ -3206,7 +4281,7 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability23({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const collector = params.collector;
   if (object.kind === "namespace") {
@@ -3263,7 +4338,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability23({ 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;
@@ -3296,16 +4371,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability23({ 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 VibeError11, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { VibeError as VibeError15, unsupportedCapability as unsupportedCapability24 } 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 unsupportedCapability23({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability24({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -3320,7 +4395,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError11({
+    throw new VibeError15({
       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 }
@@ -3410,6 +4485,8 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
 export {
   ADVISORY_KEY_BOUNDS,
   ADVISORY_LOCK_RESULT_COLUMN,
+  CHAIN_VETO_PREFIX,
+  CHAIN_VETO_TOKEN_PATTERN,
   DIALECT_CAPABILITIES,
   DIALECT_CODECS,
   JSON_TRANSPORT,
@@ -3431,37 +4508,65 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  assertSqlParamBuilding,
+  chainVetoToken,
   compileExclusion,
+  compileReusableSqlCommand,
+  compileReusableSqlQuery,
   compileSql,
+  compileSqlCommand,
+  compileSqlQuery,
   containsPattern,
+  createReusableSqlCommand,
+  createReusableSqlQuery,
+  createSqlCommand,
+  createSqlInput,
+  createSqlInputScope,
+  createSqlQuery,
   dbNowMarker,
   decode,
   decodeIsNoop,
   describeRowLock,
+  encode,
   endsWithPattern,
   enumMembershipCodec,
   escapeGlobPattern,
   escapeLikePattern,
   excludedRef,
+  float32Codec,
   getSqlDialect,
   isDbNowMarker,
   isExcludedRef,
   isFixedDiagnostic,
+  isJsonListParameter,
   isJsonParamCell,
   isListSetOperation,
   isNativeEnumArrayParameter,
+  isReusableSqlCommand,
+  isReusableSqlQuery,
   isSetOperation,
+  isSqlBindingCollector,
+  isSqlCommand,
   isSqlDefaultCell,
   isSqlFragment,
+  isSqlParam,
+  isSqlQuery,
+  isStepColumnRef,
+  jsonListParameter,
   jsonParamCell,
   mapConflictColumns,
   mysqlDialect,
   nativeEnumArrayParameter,
   parseDateTimeText,
+  parseJsonText,
   parsePgArrayLiteral,
+  parsePgArrayLiteralNested,
   parsePostgresTypeName,
+  postgresArrayElementFromText,
   postgresDialect,
   projectionOutputName,
+  recordSqlBinding,
+  recordSqlBindingCheck,
   renderAdvisoryLock,
   renderCheckProbe,
   renderColumnStateQuery,
@@ -3501,6 +4606,7 @@ export {
   renderPostgresTypeName,
   renderPostgresWorkload,
   renderPredicate,
+  renderProjection,
   renderRelationStateQuery,
   renderReplayCoverageGaps,
   renderRlsColumnType,
@@ -3521,17 +4627,28 @@ export {
   renderSqlFragment,
   renderSqliteColumnInventory,
   renderSqliteForeignKeyInventory,
+  renderSqliteFtsUpdateTrigger,
   renderSqliteRebuildObjects,
   renderStatement,
+  resultScalarContract,
+  returningColumnName,
+  sealSqlInputScope,
+  shortestFloat32,
+  snapshotSqlValue,
   sql,
+  sqlInputContract,
+  sqlParamContract,
   sqlUsesIncoming,
   sqliteColumnClauses,
   sqliteDialect,
+  sqliteFtsUpdateUpgrade,
   sqliteTableConstraints,
   startsWithPattern,
+  stepColumnRef,
   strictMatchPattern,
   tableDefinitionParts,
+  timeOfDayCodec,
   toPgArrayLiteral
 };
 
-//# debugId=55E18657169AA23764756E2164756E21
+//# debugId=B8D70B32D9F5E99064756E2164756E21