@vibeorm/sql 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,5 +1,48 @@
 // @bun
+// packages/sql/src/native-enum-parameter.ts
+var NATIVE_ENUM_ARRAY_PARAMETER = Symbol("vibeorm.nativeEnumArrayParameter");
+function nativeEnumArrayParameter(params) {
+  return { [NATIVE_ENUM_ARRAY_PARAMETER]: true, value: params.value, type: params.type };
+}
+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) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability({ dialect: params.dialect.name, feature: "externalObjects" });
+  const scope = "n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND n.nspname NOT IN ('_vibeorm_shadow', '_vibe_shadow')";
+  let text;
+  switch (params.operation) {
+    case "namespaces":
+      text = `SELECT n.nspname::text AS namespace, has_schema_privilege(n.oid, 'USAGE') AS visible FROM pg_catalog.pg_namespace n WHERE ${scope} ORDER BY n.nspname`;
+      break;
+    case "inheritance":
+      text = `SELECT n.nspname::text AS namespace, c.relname::text AS name, pn.nspname::text AS "parentNamespace", p.relname::text AS "parentName" FROM pg_catalog.pg_inherits i JOIN pg_catalog.pg_class c ON c.oid = i.inhrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace JOIN pg_catalog.pg_class p ON p.oid = i.inhparent JOIN pg_catalog.pg_namespace pn ON pn.oid = p.relnamespace WHERE ${scope} ORDER BY n.nspname, c.relname, pn.nspname, p.relname`;
+      break;
+    case "ownedSequences":
+      text = `SELECT n.nspname::text AS namespace, s.relname::text AS name, tn.nspname::text AS "tableNamespace", t.relname::text AS "tableName" FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class s ON s.oid = d.objid AND s.relkind = 'S' JOIN pg_catalog.pg_namespace n ON n.oid = s.relnamespace JOIN pg_catalog.pg_class t ON t.oid = d.refobjid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.relnamespace WHERE d.classid = 'pg_class'::regclass AND d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i') AND d.refobjsubid > 0 AND ${scope} ORDER BY n.nspname, s.relname`;
+      break;
+    case "foreignKeys":
+      text = `SELECT n.nspname::text AS namespace, t.relname::text AS table, rn.nspname::text AS "refNamespace", r.relname::text AS "refTable", c.conname::text AS name 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_class r ON r.oid = c.confrelid JOIN pg_catalog.pg_namespace rn ON rn.oid = r.relnamespace WHERE c.contype = 'f' AND ${scope} ORDER BY n.nspname, t.relname, c.conname`;
+      break;
+  }
+  return { text, values: [], returning: "none" };
+}
+// packages/sql/src/dialects/external-dependents.ts
+import { unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+
 // packages/sql/src/params.ts
+import { unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 class ParamCollector {
   dialect;
   values;
@@ -8,6 +51,19 @@ class ParamCollector {
     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 })}[]`;
+    }
+    if (isJsonListParameter(value)) {
+      if (!this.dialect.capabilities.scalarArrays)
+        throw unsupportedCapability2({ dialect: this.dialect.name, feature: "scalarArrays" });
+      const whole = typeof value.value !== "string";
+      this.values.push(whole ? [...value.value] : value.value);
+      return `${this.dialect.placeholder({ index: this.values.length })}::text::${value.storage}${whole ? "[]" : ""}`;
+    }
     this.values.push(value);
     return this.dialect.placeholder({ index: this.values.length });
   }
@@ -16,6 +72,121 @@ class ParamCollector {
   }
 }
 
+// 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/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} 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 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 = ${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, 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 } });
+    }
+    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;
@@ -50,19 +221,19 @@ function renderReplayCoverageGaps(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 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 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 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 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 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" };
+    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 FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_TYPE = 'PROCEDURE'
-UNION ALL SELECT 'event', EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ${collector.add(params.namespace)}
-UNION ALL SELECT DISTINCT 'partition', TABLE_NAME 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 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" };
+    return { text: `SELECT 'procedure' AS kind, ROUTINE_NAME AS name, ROUTINE_SCHEMA AS namespace, NULL AS parent FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_TYPE = 'PROCEDURE'
+UNION ALL SELECT 'event', EVENT_NAME, EVENT_SCHEMA, NULL FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ${collector.add(params.namespace)}
+UNION ALL SELECT DISTINCT 'partition', TABLE_NAME, TABLE_SCHEMA, NULL FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = ${collector.add(params.namespace)} AND PARTITION_NAME IS NOT NULL`, values: collector.values, returning: "none" };
+  return { text: `SELECT 'table-options' AS kind, name, schema AS namespace, NULL AS parent FROM pragma_table_list WHERE schema = ${namespace} AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND (type = 'virtual' OR wr <> 0 OR strict <> 0)`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-shadow.ts
-import { unsupportedCapability } from "@vibeorm/schema";
+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 }),
@@ -72,7 +243,7 @@ var SHADOW_CAPABILITIES = Object.freeze({
 function renderShadowOperation(params) {
   const { dialect, operation } = params;
   if (!SHADOW_CAPABILITIES[dialect.name].serverProvisioning)
-    throw unsupportedCapability({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
+    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 });
@@ -97,7 +268,7 @@ function renderShadowOperation(params) {
 ORDER BY ordinal_position`);
     case "grants": {
       if (pg)
-        throw unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
+        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
       return result("SHOW GRANTS FOR CURRENT_USER");
     }
     case "markerCreate":
@@ -125,19 +296,27 @@ UNION ALL SELECT ROUTINE_TYPE, ROUTINE_NAME, ROUTINE_SCHEMA FROM information_sch
 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 "resetPostgres":
+    case "resetDedicatedPostgres": {
       if (!pg)
-        throw unsupportedCapability({ dialect: dialect.name, feature: "postgresShadowReset" });
-      return [{ text: 'DROP SCHEMA "public" CASCADE', values: [], returning: "none" }, { text: 'CREATE SCHEMA "public"', values: [], returning: "none" }];
+        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 unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowReset" });
+        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
       return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
     }
     case "dropMysqlObject": {
       if (pg)
-        throw unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowReset" });
+        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
       return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
     }
   }
@@ -170,6 +349,209 @@ function renderModuleJournal(params) {
   }
   return { text, values: collector.values };
 }
+// packages/sql/src/capabilities.ts
+import {
+  DIALECT_CAPABILITIES,
+  POSTGRES_CAPABILITIES,
+  SQLITE_CAPABILITIES,
+  MYSQL_CAPABILITIES
+} from "@vibeorm/schema";
+
+// packages/sql/src/identifiers.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+function assertNoNul(params) {
+  if (params.name.includes("\x00")) {
+    throw new VibeError2({
+      code: "VIBE_VALIDATION",
+      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
+      meta: { name: params.name.replaceAll("\x00", "\\0") }
+    });
+  }
+  return params.name;
+}
+
+// packages/sql/src/dialects/sqlite.ts
+var sqliteDialect = {
+  name: "sqlite",
+  capabilities: SQLITE_CAPABILITIES,
+  inArrayStrategy: "expand",
+  tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
+  upsertForm: "onConflict",
+  conflictKeyEquality: {
+    foldingScalars: [],
+    textIsBinaryByDefault: true,
+    duplicatesInOneStatement: "lastWriteWins"
+  },
+  excludedRowRef: { form: "keyword", name: "excluded" },
+  doNothingForm: "onConflictDoNothing",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "glob",
+  greatestForm: "frame",
+  orderByNullsMode: "native",
+  offsetRequiresLimit: { limitText: "-1" },
+  likeEscapeClause: " ESCAPE '\\'",
+  jsonPathMode: "sqliteExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  lastInsertIdSql: null,
+  rowLockSyntax: null,
+  advisoryLockFunctions: null,
+  rowDefaultKeyword: false,
+  statementChain: null,
+  paramBudget: 900,
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
+  },
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("'", "''")}'`;
+  },
+  placeholder() {
+    return "?";
+  },
+  renderDbNow({ offsetSeconds, collector }) {
+    if (offsetSeconds === 0)
+      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
+  }
+};
+
+// packages/sql/src/dialects/sqlite-table-definition.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+function tableDefinitionParts(params) {
+  const sql = params.sql;
+  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
+    throw unavailable();
+  const parts = [];
+  let start = -1;
+  let depth = 0;
+  let quote;
+  for (let index = 0;index < sql.length; index++) {
+    const char = sql[index];
+    if (quote !== undefined) {
+      if (char === quote) {
+        if (quote !== "]" && sql[index + 1] === quote)
+          index++;
+        else
+          quote = undefined;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "[") {
+      quote = "]";
+      continue;
+    }
+    if (char === "-" && sql[index + 1] === "-") {
+      const end = sql.indexOf(`
+`, index + 2);
+      if (end < 0)
+        break;
+      index = end;
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0)
+        break;
+      index = end + 1;
+      continue;
+    }
+    if (char === "(") {
+      if (depth === 0)
+        start = index + 1;
+      depth++;
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        parts.push(sql.slice(start, index).trim());
+        return { clauses: parts, suffix: sql.slice(index + 1) };
+      }
+    } else if (char === "," && depth === 1) {
+      parts.push(sql.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  throw unavailable();
+}
+function unavailable() {
+  return new VibeError3({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
+}
+function sqliteColumnClauses(params) {
+  const columns = [];
+  for (const part of tableDefinitionParts(params).clauses) {
+    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
+    if (token === null)
+      throw unavailable();
+    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
+      continue;
+    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
+    columns.push({ name, sql: part });
+  }
+  return columns;
+}
+
+// packages/sql/src/dialects/sqlite-fts.ts
+function updateStatements(params) {
+  const quote = (name) => sqliteDialect.quoteIdent({ name });
+  const columns = params.columns.map((column) => quote(column)).join(", ");
+  const oldValues = params.columns.map((column) => `old.${quote(column)}`).join(", ");
+  const newValues = params.columns.map((column) => `new.${quote(column)}`).join(", ");
+  const changes = [
+    "old.rowid IS NOT new.rowid",
+    ...params.columns.map((column) => `old.${quote(column)} COLLATE BINARY IS NOT new.${quote(column)} COLLATE BINARY`)
+  ].join(" OR ");
+  const target = `${quote(`${params.ftsTable}_au`)} AFTER UPDATE ON ${quote(params.table)}`;
+  const body = `BEGIN
+  INSERT INTO ${quote(params.ftsTable)}(${quote(params.ftsTable)}, rowid, ${columns}) VALUES ('delete', old.rowid, ${oldValues});
+  INSERT INTO ${quote(params.ftsTable)}(rowid, ${columns}) VALUES (new.rowid, ${newValues});
+END`;
+  const tail = `${target} WHEN (${changes}) ${body}`;
+  return {
+    create: `CREATE TRIGGER IF NOT EXISTS ${tail};`,
+    definition: `CREATE TRIGGER ${tail}`,
+    legacyDefinition: `CREATE TRIGGER ${target} ${body}`
+  };
+}
+function renderSqliteFtsUpdateTrigger(params) {
+  const { create, definition } = updateStatements(params);
+  return { create, definition };
+}
+function sqliteFtsUpdateUpgrade(params) {
+  const quoted = '"(?:[^"]|"")+"';
+  const body = new RegExp(`BEGIN\\n  INSERT INTO (${quoted})\\((${quoted}), rowid, (${quoted}(?:, ${quoted})*)\\) VALUES \\('delete', old\\.rowid, `, "g");
+  for (const match of params.create.matchAll(body)) {
+    const ftsTable = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[1]})` })[0].name;
+    const columns = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[3]})` }).map((column) => column.name);
+    if (params.name !== `${ftsTable}_au`)
+      continue;
+    const statements = updateStatements({ table: params.table, ftsTable, columns });
+    if (params.create !== statements.create)
+      continue;
+    const installed = params.installed === statements.legacyDefinition ? "legacy" : params.installed === statements.definition ? "current" : undefined;
+    if (installed === undefined)
+      continue;
+    if (params.tableDefinition === undefined)
+      return { kind: "tableRequired", ftsTable };
+    const tableTail = `${sqliteDialect.quoteIdent({ name: ftsTable })} USING fts5(${columns.map((name) => sqliteDialect.quoteIdent({ name })).join(", ")}, content=${sqliteDialect.quoteStringLiteral({ value: params.table })})`;
+    if (params.tableDefinition !== `CREATE VIRTUAL TABLE ${tableTail}` && params.tableDefinition !== `CREATE VIRTUAL TABLE IF NOT EXISTS ${tableTail};`)
+      continue;
+    return { kind: "recognized", ftsTable, legacyDefinition: statements.legacyDefinition, currentDefinition: statements.definition, drop: `DROP TRIGGER IF EXISTS ${sqliteDialect.quoteIdent({ name: `${ftsTable}_au` })};`, installed };
+  }
+  return;
+}
 // packages/sql/src/dialects/sqlite-session.ts
 var SQLITE_SESSION_SQL = Object.freeze({
   lockingMode: "PRAGMA main.locking_mode",
@@ -182,10 +564,10 @@ var SQLITE_SESSION_SQL = Object.freeze({
   foreignKeysOn: "PRAGMA foreign_keys = ON"
 });
 // packages/sql/src/composable.ts
-import { VibeError } from "@vibeorm/schema";
+import { VibeError as VibeError4 } from "@vibeorm/schema";
 var fragments = new WeakMap;
 function invalid(message) {
-  throw new VibeError({ code: "VIBE_VALIDATION", message });
+  throw new VibeError4({ code: "VIBE_VALIDATION", message });
 }
 function construct(parts) {
   const snapshot = Object.freeze([...parts]);
@@ -201,6 +583,9 @@ function isSqlFragment(value) {
 function partsOf(value) {
   return fragments.get(value) ?? invalid("Expected a constructed SQL fragment");
 }
+function containsGreatest(fragment) {
+  return partsOf(fragment).some((part) => typeof part !== "string" && ("greatest" in part));
+}
 function identifier(parts) {
   if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => typeof part !== "string" || part.length === 0 || part.includes("\x00"))) {
     invalid("SQL identifiers require non-empty, NUL-free name components");
@@ -263,14 +648,25 @@ var sql = Object.freeze(Object.assign(template, {
 function renderSqlFragment(params) {
   const { dialect, collector, conflict } = params;
   const render = (fragment) => renderSqlFragment({ ...params, fragment });
+  const encode = (part) => {
+    if (part.value === undefined)
+      invalid("SQL parameters cannot be undefined; use null explicitly");
+    return part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name });
+  };
+  const frameOperand = (fragment) => {
+    const parts = partsOf(fragment).filter((part) => part !== "");
+    const only = parts.length === 1 ? parts[0] : undefined;
+    const value = only !== undefined && typeof only !== "string" && "value" in only ? { encoded: encode(only) } : undefined;
+    if (value !== undefined && value.encoded === null)
+      return "NULL";
+    const text = value === undefined ? render(fragment) : collector.add(value.encoded);
+    return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+  };
   return partsOf(params.fragment).map((part) => {
     if (typeof part === "string")
       return part;
-    if ("value" in part) {
-      if (part.value === undefined)
-        invalid("SQL parameters cannot be undefined; use null explicitly");
-      return collector.add(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
-    }
+    if ("value" in part)
+      return collector.add(encode(part));
     if ("ident" in part)
       return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
     if ("row" in part) {
@@ -283,7 +679,14 @@ function renderSqlFragment(params) {
       const qualifier = part.row === "existing" ? dialect.quoteIdent({ name: conflict.table }) : ref.form === "keyword" ? ref.name : dialect.quoteIdent({ name: ref.alias });
       return `${qualifier}.${dialect.quoteIdent({ name })}`;
     }
-    return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    if (dialect.greatestForm === "native")
+      return `GREATEST(${part.greatest.map(render).join(", ")})`;
+    if (!part.greatest.some(containsGreatest)) {
+      return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    }
+    const [left, right] = part.greatest.map(frameOperand);
+    const [a, b, frame] = ["a", "b", "g"].map((name) => dialect.quoteIdent({ name }));
+    return `(SELECT CASE WHEN ${a} IS NULL THEN ${b} WHEN ${b} IS NULL THEN ${a} WHEN ${a} >= ${b} THEN ${a} ELSE ${b} END FROM (SELECT ${left} AS ${a}, ${right} AS ${b}) AS ${frame})`;
   }).join("");
 }
 function mapConflictColumns(params) {
@@ -310,7 +713,7 @@ function sqlUsesIncoming(params) {
   return partsOf(params.fragment).some((part) => typeof part !== "string" && (("row" in part) && part.row === "incoming" || ("greatest" in part) && part.greatest.some((fragment) => sqlUsesIncoming({ fragment }))));
 }
 // packages/sql/src/result-decoder.ts
-import { VibeError as VibeError3 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 
 // packages/sql/src/pg-array.ts
 var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
@@ -325,7 +728,7 @@ function toPgArrayLiteral(params) {
   return `{${parts.join(",")}}`;
 }
 function parsePgArrayLiteral(params) {
-  const { literal } = params;
+  const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
   if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
     return null;
   const inner = literal.slice(1, -1);
@@ -363,9 +766,63 @@ function parsePgArrayLiteral(params) {
   }
   return out;
 }
+function parsePgArrayLiteralNested(params) {
+  const text = params.literal.replace(/^(?:\[-?\d+:-?\d+\])+=/, "");
+  const cursor = { index: 0 };
+  const parsed = parseDimension({ text, cursor });
+  return parsed !== null && cursor.index === text.length ? parsed : null;
+}
+function parseDimension(params) {
+  const { text, cursor } = params;
+  if (text[cursor.index] !== "{")
+    return null;
+  cursor.index++;
+  const out = [];
+  if (text[cursor.index] === "}") {
+    cursor.index++;
+    return out;
+  }
+  while (cursor.index < text.length) {
+    if (text[cursor.index] === "{") {
+      const nested = parseDimension({ text, cursor });
+      if (nested === null)
+        return null;
+      out.push(nested);
+    } else if (text[cursor.index] === '"') {
+      let element = "";
+      cursor.index++;
+      while (cursor.index < text.length && text[cursor.index] !== '"') {
+        if (text[cursor.index] === "\\")
+          cursor.index++;
+        element += text[cursor.index] ?? "";
+        cursor.index++;
+      }
+      if (text[cursor.index] !== '"')
+        return null;
+      cursor.index++;
+      out.push(element);
+    } else {
+      let element = "";
+      while (cursor.index < text.length && text[cursor.index] !== "," && text[cursor.index] !== "}") {
+        element += text[cursor.index];
+        cursor.index++;
+      }
+      out.push(element === "NULL" ? null : element);
+    }
+    if (text[cursor.index] === ",") {
+      cursor.index++;
+      continue;
+    }
+    if (text[cursor.index] !== "}")
+      return null;
+    cursor.index++;
+    return out;
+  }
+  return null;
+}
 
 // packages/sql/src/codecs.ts
-import { VibeError as VibeError2, invalidStoredData } from "@vibeorm/schema";
+import { VibeError as VibeError5, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
 function enumMembershipCodec(params) {
   const { model, field, enum: enumName } = params;
   const members = new Set(params.members);
@@ -373,7 +830,7 @@ function enumMembershipCodec(params) {
     encode: (value) => {
       if (typeof value === "string" && members.has(value))
         return value;
-      throw new VibeError2({
+      throw new VibeError5({
         code: "VIBE_VALIDATION",
         message: `Invalid value for enum ${enumName} on ${model}.${field}`,
         meta: { model, field, enum: enumName }
@@ -413,7 +870,7 @@ var bigIntCodec = {
       return BigInt(value.trim());
     if (typeof value === "number" && Number.isSafeInteger(value))
       return BigInt(value);
-    throw new VibeError2({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
+    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
   }
 };
 var decimalCodec = {
@@ -430,6 +887,7 @@ var mysqlDecimalCodec = {
   }
 };
 var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
 function parseDateTimeText(params) {
   const trimmed = params.text.trim();
   if (ZONE_LESS_DATETIME.test(trimmed)) {
@@ -437,13 +895,20 @@ function parseDateTimeText(params) {
     if (!Number.isNaN(asUtc.getTime()))
       return asUtc;
   }
+  const zoned = PG_ZONED_DATETIME.exec(trimmed);
+  if (zoned !== null) {
+    const [, date, time, fraction, hours, minutes] = zoned;
+    const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
+    if (!Number.isNaN(iso.getTime()))
+      return iso;
+  }
   const parsed = new Date(trimmed);
   return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
 var dateNativeCodec = {
   encode: (value) => {
     if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
-      throw new VibeError2({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
+      throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
     }
     return value;
   },
@@ -451,7 +916,7 @@ var dateNativeCodec = {
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
     if (date !== undefined && Number.isFinite(date.getTime()))
       return date;
-    throw new VibeError2({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
   }
 };
 var dateTextCodec = {
@@ -460,7 +925,7 @@ var dateTextCodec = {
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
     if (date !== undefined && Number.isFinite(date.getTime()))
       return date.toISOString();
-    throw new VibeError2({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+    throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
   },
   decode: dateNativeCodec.decode
 };
@@ -481,6 +946,44 @@ var mysqlDateCodec = {
   },
   decode: dateNativeCodec.decode
 };
+var MILLISECONDS_PER_DAY = 86400000;
+var TIME_OF_DAY_TEXT = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
+var pad = (value, width) => String(value).padStart(width, "0");
+var utcMillisecondOfDay = (date) => (date.getTime() % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY;
+var timeOfDayText = (millisecond) => `${pad(Math.floor(millisecond / 3600000), 2)}:${pad(Math.floor(millisecond / 60000) % 60, 2)}:${pad(Math.floor(millisecond / 1000) % 60, 2)}.${pad(millisecond % 1000, 3)}`;
+function makeTimeOfDayCodec(params) {
+  const suffix = params.zoned ? "+00" : "";
+  return Object.freeze({
+    encode: (value) => {
+      dateNativeCodec.encode(value);
+      const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+      if (date === undefined || !Number.isFinite(date.getTime())) {
+        throw new VibeError5({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
+      }
+      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
+    },
+    decode: (value) => {
+      if (value instanceof Date && Number.isFinite(value.getTime()))
+        return new Date(utcMillisecondOfDay(value));
+      const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
+      if (match !== null) {
+        const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
+        const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
+        const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
+        if (millisecond <= MILLISECONDS_PER_DAY) {
+          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+        }
+      }
+      throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
+    }
+  });
+}
+var timeCodec = makeTimeOfDayCodec({ zoned: false });
+var timetzCodec = makeTimeOfDayCodec({ zoned: true });
+function timeOfDayCodec(params) {
+  const type = timeOfDayType({ nativeType: params.nativeType });
+  return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
+}
 var booleanIntCodec = {
   encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
   decode: (value) => typeof value === "number" ? value !== 0 : value
@@ -497,7 +1000,7 @@ var jsonCodec = {
     try {
       return JSON.parse(value);
     } catch (cause) {
-      throw new VibeError2({
+      throw new VibeError5({
         code: "VIBE_INTERNAL",
         message: "a Json column returned text that is not valid JSON",
         meta: { value },
@@ -506,6 +1009,39 @@ var jsonCodec = {
     }
   }
 };
+function shortestFloat32(params) {
+  const { value } = params;
+  if (value === 0 || !Number.isFinite(value))
+    return value;
+  const target = Math.fround(value);
+  for (let precision = 1;precision <= 9; precision++) {
+    const candidate = Number(value.toPrecision(precision));
+    if (Math.fround(candidate) === target)
+      return candidate;
+  }
+  return value;
+}
+var float32Codec = {
+  encode: identity,
+  decode: (value) => {
+    const number = typeof value === "string" ? Number(value) : value;
+    return typeof number === "number" ? shortestFloat32({ value: number }) : number;
+  }
+};
+var booleanFromText = (text) => text === "t" ? true : text === "f" ? false : text;
+var bytesFromText = (text) => /^\\x(?:[0-9a-fA-F]{2})*$/.test(text) ? new Uint8Array(Buffer.from(text.slice(2), "hex")) : text;
+function postgresArrayElementFromText(params) {
+  switch (params.scalarType) {
+    case "Boolean":
+      return booleanFromText;
+    case "Bytes":
+      return bytesFromText;
+    case "Json":
+      return jsonCodec.decode;
+    default:
+      return null;
+  }
+}
 var POSTGRES_CODECS = {
   String: passthroughCodec,
   Boolean: passthroughCodec,
@@ -547,7 +1083,7 @@ var DIALECT_CODECS = {
 
 // packages/sql/src/result-decoder.ts
 function refuse(encoding, message) {
-  throw new VibeError3({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
+  throw new VibeError6({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
 }
 function scalar(type, valid) {
   const convert = (params, encoding) => {
@@ -593,7 +1129,7 @@ var extendedDecoder = Object.freeze({
   encode: (params) => {
     if (params.value === "infinity" || params.value === "-infinity") {
       if (params.dialect !== "postgres")
-        throw new VibeError3({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
+        throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
       return params.value;
     }
     return dateDecoder.encode(params);
@@ -651,15 +1187,15 @@ var decode = Object.freeze({
   }
 });
 // packages/sql/src/exclusion.ts
-import { VibeError as VibeError5, fieldTypeIdentity as fieldTypeIdentity2, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { VibeError as VibeError8, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 
 // packages/sql/src/predicate.ts
-import { VibeError as VibeError4, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError7, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 function renderPredicate(params) {
   if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
-    throw unsupportedCapability2({ dialect: params.dialect.name, feature: "partialIndexes" });
+    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "partialIndexes" });
   }
   const context = {
     model: params.model,
@@ -694,7 +1230,7 @@ var INT64_MIN = -(2n ** 63n);
 var INT64_MAX = 2n ** 63n - 1n;
 function refuse2(params) {
   const { context, rule, message } = params;
-  throw new VibeError4({
+  throw new VibeError7({
     code: "VIBE_SCHEMA_INVALID",
     message: `${context.site} on "${context.model.name}": ${message}`,
     meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
@@ -787,7 +1323,7 @@ function resolveField(params) {
     });
   }
   if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
-    throw unsupportedCapability2({
+    throw unsupportedCapability8({
       dialect: "mysql",
       feature: `CHECK constraint referencing auto-increment column "${context.model.name}.${name}"`,
       hint: "mysql refuses this with error 3818 \u2014 enforce the rule in application code or on a non-generated column"
@@ -958,12 +1494,12 @@ function describe(params) {
 
 // packages/sql/src/exclusion.ts
 function invalid2(rule) {
-  throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+  throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
 }
 function compileExclusion(params) {
   const { exclusion: spec, model, dialect } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
     invalid2("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
@@ -1006,7 +1542,7 @@ function compileExclusion(params) {
     const column = field(key.field);
     if (column.isOptional)
       invalid2("nullable-key-requires-expression");
-    if (!["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
+    if (!isEnumType2(column.type) && !["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
       invalid2("key-type");
     return `${dialect.quoteIdent({ name: column.dbName ?? column.name })} WITH =`;
   });
@@ -1016,13 +1552,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability3({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability9({ 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 unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability9({ 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 })};`];
@@ -1031,15 +1567,15 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
-  const scope = probe === undefined ? "n.nspname = 'public'" : `t.oid = ${dialect.quoteStringLiteral({ value: probe })}::regclass`;
+    throw unsupportedCapability9({ 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 unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
-  return [`CREATE TEMP TABLE ${dialect.quoteIdent({ name: probe })} (LIKE ${dialect.quoteIdent({ name: "public" })}.${dialect.quoteIdent({ name: table })})`, `ALTER TABLE ${dialect.quoteIdent({ name: probe })} ADD CONSTRAINT ${dialect.quoteIdent({ name: `${probe}_x` })} ${definition}`];
+    throw unsupportedCapability9({ 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
 var SET_OPERATORS = ["increment", "decrement", "multiply", "divide"];
@@ -1081,7 +1617,7 @@ function isSqlDefaultCell(value) {
   return value === SQL_DEFAULT_CELL;
 }
 function jsonParamCell(params) {
-  return { __jsonParam: true, text: params.text };
+  return params.storage === "json" ? { __jsonParam: true, text: params.text, storage: "json" } : { __jsonParam: true, text: params.text };
 }
 function isJsonParamCell(value) {
   return typeof value === "object" && value !== null && value.__jsonParam === true;
@@ -1092,9 +1628,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 unsupportedCapability4 } from "@vibeorm/schema";
+import { internalError, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -1114,7 +1673,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability4({
+    throw unsupportedCapability10({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -1122,7 +1681,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability10({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -1130,7 +1689,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability10({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -1149,7 +1708,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability10({
       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`
@@ -1182,33 +1741,13 @@ function projectionOutputName(params) {
   const { column } = params;
   return column.transform === undefined ? column.alias ?? column.name : column.name;
 }
-// packages/sql/src/capabilities.ts
-import {
-  DIALECT_CAPABILITIES,
-  POSTGRES_CAPABILITIES,
-  SQLITE_CAPABILITIES,
-  MYSQL_CAPABILITIES
-} from "@vibeorm/schema";
-
-// packages/sql/src/identifiers.ts
-import { VibeError as VibeError6 } from "@vibeorm/schema";
-function assertNoNul(params) {
-  if (params.name.includes("\x00")) {
-    throw new VibeError6({
-      code: "VIBE_VALIDATION",
-      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
-      meta: { name: params.name.replaceAll("\x00", "\\0") }
-    });
-  }
-  return params.name;
-}
-
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
   name: "postgres",
   capabilities: POSTGRES_CAPABILITIES,
   inArrayStrategy: "any",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "in",
   upsertForm: "onConflict",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1219,6 +1758,7 @@ var postgresDialect = {
   doNothingForm: "onConflictDoNothing",
   insensitiveLike: "ilike",
   strictMatchStrategy: "native",
+  greatestForm: "native",
   orderByNullsMode: "native",
   offsetRequiresLimit: null,
   likeEscapeClause: null,
@@ -1255,6 +1795,7 @@ var postgresDialect = {
     keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
   },
   rowDefaultKeyword: true,
+  statementChain: "dataModifyingCte",
   paramBudget: 30000,
   booleanLiteral: { true: "true", false: "false" },
   quoteIdent({ name }) {
@@ -1272,63 +1813,13 @@ var postgresDialect = {
     return `(now() + make_interval(secs => ${collector.add(offsetSeconds)}))`;
   }
 };
-// packages/sql/src/dialects/sqlite.ts
-var sqliteDialect = {
-  name: "sqlite",
-  capabilities: SQLITE_CAPABILITIES,
-  inArrayStrategy: "expand",
-  tupleInStrategy: "rowValue",
-  upsertForm: "onConflict",
-  conflictKeyEquality: {
-    foldingScalars: [],
-    textIsBinaryByDefault: true,
-    duplicatesInOneStatement: "lastWriteWins"
-  },
-  excludedRowRef: { form: "keyword", name: "excluded" },
-  doNothingForm: "onConflictDoNothing",
-  insensitiveLike: "lower",
-  strictMatchStrategy: "glob",
-  orderByNullsMode: "native",
-  offsetRequiresLimit: { limitText: "-1" },
-  likeEscapeClause: " ESCAPE '\\'",
-  jsonPathMode: "sqliteExtract",
-  supportedJsonOps: [
-    "equals",
-    "string_contains",
-    "string_starts_with",
-    "string_ends_with",
-    "array_contains",
-    "array_starts_with",
-    "array_ends_with"
-  ],
-  jsonParamCast: "",
-  lastInsertIdSql: null,
-  rowLockSyntax: null,
-  advisoryLockFunctions: null,
-  rowDefaultKeyword: false,
-  paramBudget: 900,
-  booleanLiteral: { true: "1", false: "0" },
-  quoteIdent({ name }) {
-    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
-  },
-  quoteStringLiteral({ value }) {
-    return `'${value.replaceAll("'", "''")}'`;
-  },
-  placeholder() {
-    return "?";
-  },
-  renderDbNow({ offsetSeconds, collector }) {
-    if (offsetSeconds === 0)
-      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
-  }
-};
 // packages/sql/src/dialects/mysql.ts
 var mysqlDialect = {
   name: "mysql",
   capabilities: MYSQL_CAPABILITIES,
   inArrayStrategy: "expand",
   tupleInStrategy: "rowValue",
+  timeOfDayInStrategy: "equalities",
   upsertForm: "onDuplicateKey",
   conflictKeyEquality: {
     foldingScalars: ["Decimal"],
@@ -1340,6 +1831,7 @@ var mysqlDialect = {
   doNothingForm: "insertIgnore",
   insensitiveLike: "lower",
   strictMatchStrategy: "binary",
+  greatestForm: "wrapped-frame",
   orderByNullsMode: "emulate",
   offsetRequiresLimit: { limitText: "18446744073709551615" },
   likeEscapeClause: null,
@@ -1361,6 +1853,7 @@ var mysqlDialect = {
   },
   advisoryLockFunctions: null,
   rowDefaultKeyword: true,
+  statementChain: null,
   paramBudget: 1e4,
   booleanLiteral: { true: "1", false: "0" },
   quoteIdent({ name }) {
@@ -1388,7 +1881,7 @@ function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability11 } 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'" }
@@ -1396,7 +1889,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability5({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability11({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -1405,7 +1898,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError7, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -1440,7 +1933,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability6({
+    throw unsupportedCapability12({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -1458,7 +1951,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 VibeError7({
+      throw new VibeError9({
         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 }
@@ -1477,7 +1970,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError7({
+    throw new VibeError9({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -1487,10 +1980,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError8, assertValidSchemaIR, unsupportedCapability as unsupportedCapability7, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError10, assertValidSchemaIR, unsupportedCapability as unsupportedCapability13, 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" } },
@@ -1503,18 +1996,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability13({ 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 VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError10({ 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 unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability13({ 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 })}`;
 }
@@ -1555,14 +2048,14 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability13({ 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 VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -1595,7 +2088,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -1629,7 +2122,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 VibeError8({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError10({ 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 });
@@ -1781,7 +2274,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -1813,7 +2306,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { internalError as internalError2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -1867,6 +2360,8 @@ function renderStatement(params) {
       return renderUpdate({ dialect, statement, collector });
     case "delete":
       return renderDelete({ dialect, statement, collector });
+    case "chain":
+      return renderChain({ dialect, statement, collector });
     case "rlsReadiness":
       return renderRlsReadinessQuery({ dialect, ...statement });
     case "rlsProbeTable":
@@ -1900,8 +2395,29 @@ function quoteCol(dialect, column) {
     }
     return `CAST(${ref} AS REAL)`;
   }
+  if (column.castJsonb !== undefined) {
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "ColRef.castJsonb is a postgres json construct" });
+    }
+    return `${ref}::${column.castJsonb}`;
+  }
   return ref;
 }
+function typedOrderRef(params) {
+  const { statement, column } = params;
+  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined)
+    return column;
+  const renamed = statement.columns.some((projected) => (projected.alias ?? projected.name) === column.name && (projected.transform !== undefined || projected.alias !== undefined));
+  return renamed ? { ...column, table: statement.table.alias ?? statement.table.name } : column;
+}
+function jsonCellCast(dialect, cell) {
+  if (cell.storage !== "json" || dialect.jsonParamCast === "")
+    return dialect.jsonParamCast;
+  if (dialect.name !== "postgres") {
+    throw internalError2({ message: "JsonParamCell storage json is a postgres construct" });
+  }
+  return "::text::json";
+}
 function quoteProjection(dialect, column) {
   if (column.transform === undefined) {
     const base = quoteCol(dialect, column);
@@ -1910,7 +2426,7 @@ function quoteProjection(dialect, column) {
     return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
   }
   if (dialect.name !== "postgres") {
-    throw internalError2({ message: "ColRef.transform is a postgres lateral-join construct" });
+    throw internalError2({ message: "ColRef.transform is a postgres construct" });
   }
   const ref = quoteCol(dialect, column);
   const alias = dialect.quoteIdent({ name: column.name });
@@ -1918,8 +2434,15 @@ 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) {
-  const name = dialect.quoteIdent({ name: table.name });
+  if (table.namespace !== undefined)
+    assertSqlNamespace2({ namespace: table.namespace, dialect: dialect.name });
+  const relation = dialect.quoteIdent({ name: table.name });
+  const name = table.namespace === undefined ? relation : `${dialect.quoteIdent({ name: table.namespace })}.${relation}`;
   if (table.alias === undefined)
     return name;
   return `${name} AS ${dialect.quoteIdent({ name: table.alias })}`;
@@ -1958,7 +2481,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability9({
+  throw unsupportedCapability15({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -1975,7 +2498,8 @@ function renderExpr(params) {
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
       }
-      return `${quoteCol(dialect, expr.column)} ${op} ${collector.add(expr.value)}`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      return `${compared.column} ${op} ${compared.operand}`;
     }
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
@@ -1991,8 +2515,12 @@ 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([...expr.values])})`;
+        const base = `${column} = ANY(${collector.add(Array.isArray(expr.values) ? [...expr.values] : expr.values)})`;
         return expr.negate === true ? `NOT (${base})` : base;
       }
       const placeholders = collector.addMany(expr.values);
@@ -2084,16 +2612,21 @@ function renderExpr(params) {
     }
     case "arrayHas": {
       assertScalarArrays(dialect, 'the scalar-list filter "has"');
-      const base = `${collector.add(expr.value)} = ANY(${quoteCol(dialect, expr.column)})`;
+      const compared = listComparison({ dialect, column: expr.column, value: expr.value, collector });
+      const base = `${compared.operand} = ANY(${compared.column})`;
       return expr.negate === true ? `NOT (${base})` : base;
     }
     case "arrayContainsAll": {
       assertScalarArrays(dialect, 'the scalar-list filter "hasEvery"');
-      return `${quoteCol(dialect, expr.column)} @> ${collector.add([...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([...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"');
@@ -2141,6 +2674,16 @@ function jsonPathString(path) {
   }
   return out;
 }
+function listComparison(params) {
+  const { dialect, column, value, collector } = params;
+  if (isJsonListParameter(value) && value.storage === "json") {
+    return {
+      column: `${quoteCol(dialect, column)}::jsonb[]`,
+      operand: collector.add(jsonListParameter({ value: value.value, storage: "jsonb" }))
+    };
+  }
+  return { column: quoteCol(dialect, column), operand: collector.add(value) };
+}
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
@@ -2168,7 +2711,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability9({
+    throw unsupportedCapability15({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2178,19 +2721,22 @@ function renderJsonFilter(params) {
   if (dialect.jsonPathMode === "operators") {
     const column = quoteCol(dialect, expr.column);
     const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
+    const extracted = expr.storage === "json" ? `(${column} #> ${pathParam})::jsonb` : `(${column} #> ${pathParam})`;
     switch (expr.op) {
       case "equals":
-        return `(${column} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "string_contains":
       case "string_starts_with":
-      case "string_ends_with":
-        return renderJsonLike({ dialect, target: `(${column} #>> ${pathParam})`, expr, collector });
+      case "string_ends_with": {
+        const target = expr.storage === "json" ? `(${extracted} #>> '{}')` : `(${column} #>> ${pathParam})`;
+        return renderJsonLike({ dialect, target, expr, collector });
+      }
       case "array_contains":
-        return `(${column} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_starts_with":
-        return `(${column} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_ends_with":
-        return `(${column} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `${extracted} -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
     }
   }
   if (dialect.jsonPathMode === "sqliteExtract") {
@@ -2232,7 +2778,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 unsupportedCapability9({
+            throw unsupportedCapability15({
               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"
@@ -2334,7 +2880,14 @@ function renderLateralJoin(params) {
     const terms = join.select.orderBy;
     const columnTerms = terms.filter((term) => ("column" in term));
     if (columnTerms.length === terms.length && columnTerms.every((term) => projected.has(term.column.name))) {
-      const rendered = columnTerms.map((term) => renderOrderTerm({ dialect, term: { ...term, column: { table: "__sub", name: term.column.name } }, collector }));
+      const rendered = columnTerms.map((term) => renderOrderTerm({
+        dialect,
+        term: {
+          ...term,
+          column: { table: "__sub", name: term.column.name, ...term.column.castJsonb === undefined ? {} : { castJsonb: term.column.castJsonb } }
+        },
+        collector
+      }));
       aggOrder = ` ORDER BY ${rendered.join(", ")}`;
     }
   }
@@ -2343,6 +2896,15 @@ function renderLateralJoin(params) {
   const alias = dialect.quoteIdent({ name: join.alias });
   return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
 }
+function renderCountSubquery(params) {
+  const { dialect, subquery, collector } = params;
+  const select = subquery.select;
+  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
+    throw internalError2({ message: "count subquery must be one ungrouped COUNT(*)" });
+  }
+  const inner = renderSelect({ dialect, statement: select, collector });
+  return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
+}
 function applyReturning(params) {
   const { dialect, requested } = params;
   if (requested === undefined || requested.length === 0) {
@@ -2351,9 +2913,65 @@ function applyReturning(params) {
   if (!dialect.capabilities.returning) {
     return { suffix: "", status: "omitted" };
   }
-  const columns = requested.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const columns = requested.map((column) => {
+    if (typeof column === "string")
+      return dialect.quoteIdent({ name: column });
+    if (dialect.name !== "postgres") {
+      throw internalError2({ message: "a castText RETURNING column is a postgres construct" });
+    }
+    const name = dialect.quoteIdent({ name: column.name });
+    return `${name}::text AS ${name}`;
+  }).join(", ");
   return { suffix: ` RETURNING ${columns}`, status: "native" };
 }
+function renderKeyTableJoin(params) {
+  const { dialect, join, collector } = params;
+  const postgresMember = (member) => member.kind === "citext" || member.kind === "text" || member.kind === "integer";
+  const admitted = dialect.name === "mysql" ? join.members.every((member) => member.kind !== "citext" && member.kind !== "text") : dialect.name === "postgres" && join.members.every(postgresMember);
+  if (!admitted) {
+    throw unsupportedCapability15({
+      dialect: dialect.name,
+      feature: "relation key table",
+      hint: "the key-table join is mysql's relation association \u2014 this dialect compares relation keys by value"
+    });
+  }
+  if (join.columns.length === 0 || join.columns.length !== join.members.length) {
+    throw internalError2({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+  }
+  if (join.rows.length === 0)
+    throw internalError2({ message: "key table needs at least one key row" });
+  for (const member of join.members) {
+    if (member.kind === "decimal" && !(Number.isInteger(member.scale) && member.scale >= 0 && member.scale <= 30)) {
+      throw internalError2({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+    }
+  }
+  const alias = dialect.quoteIdent({ name: join.alias });
+  const memberNames = join.members.map((_, index) => dialect.quoteIdent({ name: `__vibe_k${index}` }));
+  const rows = join.rows.map((row, ordinal) => {
+    if (row.length !== join.members.length) {
+      throw internalError2({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+    }
+    const cells = row.map((value, index) => {
+      const placeholder = collector.add(value);
+      const member = join.members[index];
+      switch (member.kind) {
+        case "integer":
+          return dialect.name === "mysql" ? `CAST(${placeholder} AS SIGNED)` : `CAST(${placeholder} AS bigint)`;
+        case "decimal":
+          return `CAST(${placeholder} AS DECIMAL(65,${member.scale}))`;
+        case "citext":
+          return `CAST(${placeholder} AS citext)`;
+        case "text":
+          return `CAST(${placeholder} AS text)`;
+        default:
+          return placeholder;
+      }
+    });
+    return dialect.name === "mysql" ? `ROW(${cells.join(", ")}, ${ordinal})` : `(${cells.join(", ")}, ${ordinal})`;
+  });
+  const on = join.columns.map((column, index) => `${quoteCol(dialect, column)} = ${alias}.${memberNames[index]}`).join(" AND ");
+  return `INNER JOIN (VALUES ${rows.join(", ")}) AS ${alias} (${[...memberNames, dialect.quoteIdent({ name: join.ordinalAlias })].join(", ")}) ON ${on}`;
+}
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
@@ -2371,6 +2989,11 @@ function renderSelect(params) {
       columnList.push(`${renderAggRef(dialect, selection.agg)} AS ${dialect.quoteIdent({ name: selection.alias })}`);
     }
   }
+  if (statement.countSubqueries !== undefined) {
+    for (const subquery of statement.countSubqueries) {
+      columnList.push(renderCountSubquery({ dialect, subquery, collector }));
+    }
+  }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0) {
@@ -2383,13 +3006,13 @@ function renderSelect(params) {
   let distinctPrefix = "";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability9({
+      throw unsupportedCapability15({
         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;
@@ -2412,9 +3035,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 unsupportedCapability9({
+      throw unsupportedCapability15({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -2434,7 +3060,7 @@ function renderSelect(params) {
     text += ` HAVING ${renderExpr({ dialect, expr: statement.having, collector })}`;
   }
   if (statement.orderBy !== undefined && statement.orderBy.length > 0) {
-    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term, collector }));
+    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term: "column" in term ? { ...term, column: typedOrderRef({ statement, column: term.column }) } : term, collector }));
     text += ` ORDER BY ${terms.join(", ")}`;
   }
   if (statement.limit !== undefined) {
@@ -2476,7 +3102,7 @@ function renderInsert(params) {
   const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const rowsSql = statement.rows.map((row) => `(${row.map((value) => {
     if (isJsonParamCell(value))
-      return `${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     if (isDbNowMarker(value)) {
       return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
     }
@@ -2499,7 +3125,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability9({
+            throw unsupportedCapability15({
               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"
@@ -2514,7 +3140,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability9({
+        throw unsupportedCapability15({
           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"
@@ -2532,7 +3158,7 @@ function renderInsert(params) {
           throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability9({
+          throw unsupportedCapability15({
             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"
@@ -2548,14 +3174,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability9({
+          throw unsupportedCapability15({
             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 unsupportedCapability9({
+          throw unsupportedCapability15({
             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"
@@ -2608,7 +3234,7 @@ function renderAssignments(params) {
       return `${column} = ${renderIncomingRowColumn({ dialect, column: value.column })}`;
     }
     if (isJsonParamCell(value)) {
-      return `${column} = ${collector.add(value.text)}${dialect.jsonParamCast}`;
+      return `${column} = ${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     }
     if (isSetOperation(value)) {
       const operand = collector.add(value.value);
@@ -2637,85 +3263,174 @@ function renderDelete(params) {
   const returning = applyReturning({ dialect, requested: statement.returning });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
-// packages/sql/src/dialects/sqlite-table-definition.ts
-import { VibeError as VibeError9 } 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;
+var CHAIN_ROWS_ALIAS = "__vibe_rows";
+var CHAIN_ONE_ALIAS = "__vibe_one";
+function renderChain(params) {
+  const { dialect, statement, collector } = params;
+  if (dialect.statementChain === null) {
+    throw unsupportedCapability15({
+      dialect: dialect.name,
+      feature: "a statement chain (data-modifying WITH steps)",
+      hint: "this dialect accepts only SELECT inside WITH \u2014 gate on SqlDialect.statementChain and keep the multi-statement path"
+    });
+  }
+  if (statement.steps.length === 0)
+    throw internalError2({ message: "a statement chain needs at least one step" });
+  const defined = new Set;
+  const steps = [];
+  for (const step of statement.steps) {
+    if (step.name === CHAIN_ROWS_ALIAS || step.name === CHAIN_ONE_ALIAS || defined.has(step.name)) {
+      throw internalError2({ message: `chain step name "${step.name}" is reserved or repeated` });
     }
-    if (char === "-" && sql[index + 1] === "-") {
-      const end = sql.indexOf(`
-`, index + 2);
-      if (end < 0)
-        break;
-      index = end;
-      continue;
+    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` });
+      }
     }
-    if (char === "/" && sql[index + 1] === "*") {
-      const end = sql.indexOf("*/", index + 2);
-      if (end < 0)
-        break;
-      index = end + 1;
-      continue;
+    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 (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;
+    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`;
   }
-  throw unavailable();
+  return { text: `WITH ${steps.join(", ")} ${select}`, values: collector.values, returning: "none" };
 }
-function unavailable() {
-  return new VibeError9({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
+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 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 });
+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 columns;
+  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 unsupportedCapability10 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability16 } 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*)*)$`);
@@ -2742,13 +3457,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability16({ 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 unsupportedCapability10({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -2761,11 +3476,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability11({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability17({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -2789,28 +3504,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability18({ 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 unsupportedCapability13 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability19({ 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 unsupportedCapability13({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability19({ 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 unsupportedCapability13({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability19({ 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(`,
@@ -2856,31 +3571,31 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability20({ 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 unsupportedCapability15 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability21({ 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 unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability21({ 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 unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability21({ 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) {
@@ -2900,6 +3615,8 @@ UNION ALL SELECT 'trigger', t.tgname::text, r.relname::text, NULL, NULL, NULL FR
 UNION ALL SELECT 'column', a.attname::text, r.relname::text, NULL, NULL, NULL FROM relations r JOIN pg_catalog.pg_attribute a ON a.attrelid = r.oid WHERE a.attnum > 0 AND NOT a.attisdropped AND r.relkind IN ('r','p')
 UNION ALL SELECT CASE WHEN a.attgenerated <> '' THEN 'generatedColumn' ELSE 'columnDefault' END, a.attname::text, r.relname::text, NULL, NULL, NULL FROM relations r JOIN pg_catalog.pg_attribute a ON a.attrelid = r.oid JOIN pg_catalog.pg_attrdef d ON d.adrelid = r.oid AND d.adnum = a.attnum WHERE a.attnum > 0 AND NOT a.attisdropped
 UNION ALL SELECT 'function', p.proname::text, NULL, NULL, COALESCE((SELECT json_agg(json_build_object('namespace', tn.nspname, 'name', t.typname) ORDER BY a.ord)::text FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace), '[]'), NULL 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 'enum', t.typname::text, NULL, NULL, NULL, NULL FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND t.typtype = 'e' 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')
+${params.namespace === "public" ? "" : `UNION ALL SELECT 'namespace', n.nspname::text, NULL, NULL, NULL, NULL FROM pg_catalog.pg_namespace n WHERE n.nspname = ${namespace}`}
 ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
   }
   if (params.dialect.name === "mysql") {
@@ -2917,12 +3634,17 @@ 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 unsupportedCapability16 } from "@vibeorm/schema";
+import { internalError as internalError3, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
 function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
+  if (object.kind === "namespace") {
+    if (dialect.name !== "postgres")
+      throw unsupportedCapability22({ 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;
   const namespace = collector.add(physical.namespace);
   const name = collector.add(physical.name);
@@ -2984,7 +3706,7 @@ function objectQuery(params) {
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability16({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability22({ 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":
@@ -2994,15 +3716,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 unsupportedCapability16({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability22({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability16({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability22({ 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 unsupportedCapability16({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability22({ 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)}`;
@@ -3032,10 +3754,14 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
-  const physical = "table" in object ? object.table : object.name;
   const collector = params.collector;
+  if (object.kind === "namespace") {
+    const namespace = collector.add(object.name);
+    return { text: `SELECT DISTINCT json_build_array(d.deptype, a.type, a.object_names, a.object_args)::text AS address FROM pg_catalog.pg_namespace n JOIN pg_catalog.pg_depend d ON d.classid = 'pg_namespace'::regclass AND d.objid = n.oid AND d.objsubid = 0 CROSS JOIN LATERAL pg_catalog.pg_identify_object_as_address(d.refclassid, d.refobjid, d.refobjsubid) a WHERE n.nspname = ${namespace} ORDER BY address`, values: collector.values, returning: "none" };
+  }
+  const physical = "table" in object ? object.table : object.name;
   const namespace = collector.add(physical.namespace);
   const name = collector.add(physical.name);
   const relation = `SELECT c.oid FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND c.relname = ${name}`;
@@ -3085,7 +3811,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability22({ 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;
@@ -3118,16 +3844,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability22({ 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 VibeError10, unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { VibeError as VibeError11, unsupportedCapability as unsupportedCapability23 } 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 unsupportedCapability17({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability23({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -3142,7 +3868,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError10({
+    throw new VibeError11({
       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 }
@@ -3232,6 +3958,8 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
 export {
   ADVISORY_KEY_BOUNDS,
   ADVISORY_LOCK_RESULT_COLUMN,
+  CHAIN_VETO_PREFIX,
+  CHAIN_VETO_TOKEN_PATTERN,
   DIALECT_CAPABILITIES,
   DIALECT_CODECS,
   JSON_TRANSPORT,
@@ -3253,6 +3981,7 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  chainVetoToken,
   compileExclusion,
   compileSql,
   containsPattern,
@@ -3265,21 +3994,29 @@ export {
   escapeGlobPattern,
   escapeLikePattern,
   excludedRef,
+  float32Codec,
   getSqlDialect,
   isDbNowMarker,
   isExcludedRef,
   isFixedDiagnostic,
+  isJsonListParameter,
   isJsonParamCell,
   isListSetOperation,
+  isNativeEnumArrayParameter,
   isSetOperation,
   isSqlDefaultCell,
   isSqlFragment,
+  isStepColumnRef,
+  jsonListParameter,
   jsonParamCell,
   mapConflictColumns,
   mysqlDialect,
+  nativeEnumArrayParameter,
   parseDateTimeText,
   parsePgArrayLiteral,
+  parsePgArrayLiteralNested,
   parsePostgresTypeName,
+  postgresArrayElementFromText,
   postgresDialect,
   projectionOutputName,
   renderAdvisoryLock,
@@ -3293,7 +4030,10 @@ export {
   renderExclusionProbe,
   renderExclusionSetup,
   renderExpr,
+  renderExternalDependents,
+  renderExternalOwnershipCatalog,
   renderFragment,
+  renderIndexColumns,
   renderIndexStateQuery,
   renderMigrationDependencies,
   renderMigrationHistoryQuery,
@@ -3312,10 +4052,13 @@ export {
   renderMysqlObjectMembers,
   renderPostgresDefaultFunctionIdentity,
   renderPostgresExplain,
+  renderPostgresIndexKeys,
+  renderPostgresPhysicalCatalog,
   renderPostgresTypeIdentity,
   renderPostgresTypeName,
   renderPostgresWorkload,
   renderPredicate,
+  renderProjection,
   renderRelationStateQuery,
   renderReplayCoverageGaps,
   renderRlsColumnType,
@@ -3336,16 +4079,23 @@ export {
   renderSqlFragment,
   renderSqliteColumnInventory,
   renderSqliteForeignKeyInventory,
+  renderSqliteFtsUpdateTrigger,
   renderSqliteRebuildObjects,
   renderStatement,
+  returningColumnName,
+  shortestFloat32,
   sql,
   sqlUsesIncoming,
   sqliteColumnClauses,
   sqliteDialect,
+  sqliteFtsUpdateUpgrade,
   sqliteTableConstraints,
   startsWithPattern,
+  stepColumnRef,
   strictMatchPattern,
+  tableDefinitionParts,
+  timeOfDayCodec,
   toPgArrayLiteral
 };
 
-//# debugId=B1F6683E5EF3B96D64756E2164756E21
+//# debugId=67799F9417158D9264756E2164756E21