@vibeorm/sql 5.8.0 → 5.9.0

package/dist/index.js

@@ -99,6 +99,360 @@ function jsonListParameter(params) {
 function isJsonListParameter(value) {
   return typeof value === "object" && value !== null && JSON_LIST_PARAMETER in value;
 }
+// packages/sql/src/json-patch.ts
+import { internalError } from "@vibeorm/schema";
+
+// packages/sql/src/ast.ts
+var COALESCE_REF_NAME = "__vibe_coalesce";
+function coalesceRef(params) {
+  return { name: COALESCE_REF_NAME, coalesce: params.members };
+}
+var SET_OPERATORS = ["increment", "decrement", "multiply", "divide"];
+function isSetOperation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  if (!keys.includes("__op") || !keys.includes("value"))
+    return false;
+  const candidate = value;
+  if (keys.length !== 2 && !(keys.length === 3 && keys.includes("numericType") && candidate.numericType === "Decimal"))
+    return false;
+  return typeof candidate.__op === "string" && SET_OPERATORS.includes(candidate.__op) && (typeof candidate.value === "number" && Number.isFinite(candidate.value) || typeof candidate.value === "string" || typeof candidate.value === "bigint");
+}
+var LIST_SET_OPERATORS = ["append", "concat"];
+function isListSetOperation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes("__listOp") || !keys.includes("value"))
+    return false;
+  const candidate = value;
+  return typeof candidate.__listOp === "string" && LIST_SET_OPERATORS.includes(candidate.__listOp);
+}
+function dbNowMarker(params) {
+  return { __dbNow: true, offsetSeconds: params.offsetSeconds };
+}
+function isDbNowMarker(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  if (!Object.hasOwn(value, "__dbNow"))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes("__dbNow") || !keys.includes("offsetSeconds"))
+    return false;
+  const candidate = value;
+  return candidate.__dbNow === true && typeof candidate.offsetSeconds === "number" && Number.isFinite(candidate.offsetSeconds);
+}
+var SQL_DEFAULT_CELL = Object.freeze({ __sqlDefault: true });
+var SQL_KEEP_CELL = Object.freeze({ __sqlKeep: true });
+function isSqlKeepCell(value) {
+  return value === SQL_KEEP_CELL;
+}
+function isSqlDefaultCell(value) {
+  return value === SQL_DEFAULT_CELL;
+}
+function jsonParamCell(params) {
+  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;
+}
+function excludedRef(params) {
+  return { __excluded: true, column: params.column };
+}
+function isExcludedRef(value) {
+  return typeof value === "object" && value !== null && value.__excluded === true;
+}
+function returningColumnName(column) {
+  return typeof column === "string" ? column : ("capture" in column) || ("from" in column) ? column.alias : column.name;
+}
+function isOtherRowReturningColumn(column) {
+  return typeof column !== "string" && "from" in column;
+}
+function isCaptureReturningColumn(column) {
+  return typeof column !== "string" && "capture" in column;
+}
+var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
+function stepColumnRef(params) {
+  return { __stepColumn: true, step: params.step, column: params.column };
+}
+function sourceColumnRef(params) {
+  return Object.freeze({ __sourceColumn: true, column: params.column });
+}
+function isSourceColumnRef(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return candidate.__sourceColumn === true && typeof candidate.column === "string" && Object.keys(value).length === 2;
+}
+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/json-path.ts
+function jsonPathString(path) {
+  let out = "$";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+    } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)) {
+      out += `.${segment}`;
+    } else {
+      out += `."${segment.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+    }
+  }
+  return out;
+}
+
+// packages/sql/src/json-patch.ts
+var JSON_PATCH_VETO_TOKEN = "json_patch";
+function isJsonPatchOperation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  if (!Object.hasOwn(value, "__jsonPatch"))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.some((key) => key !== "__jsonPatch" && key !== "steps" && key !== "nonce" && key !== "storage"))
+    return false;
+  const candidate = value;
+  return candidate.__jsonPatch === true && Array.isArray(candidate.steps) && candidate.steps.length > 0 && typeof candidate.nonce === "string" && (candidate.storage === undefined || candidate.storage === "json");
+}
+var editNode = () => ({ kind: "edit", create: false, children: new Map });
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function foundType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+  }
+  throw internalError({ message: "a parsed JSON value has no JSON type" });
+}
+function defineMember(params) {
+  Object.defineProperty(params.container, params.key, { value: params.value, enumerable: true, writable: true, configurable: true });
+}
+function applyKnown(params) {
+  const { rest, step, index } = params;
+  let container = params.value;
+  for (let depth = 0;depth < rest.length; depth++) {
+    if (!isJsonObject(container))
+      return { step: index, path: [...params.at, ...rest.slice(0, depth)], found: foundType(container) };
+    const key = rest[depth];
+    if (depth === rest.length - 1) {
+      if ("set" in step)
+        defineMember({ container, key, value: JSON.parse(step.value) });
+      else
+        delete container[key];
+      return;
+    }
+    if (!Object.hasOwn(container, key)) {
+      if (!("set" in step))
+        return;
+      defineMember({ container, key, value: {} });
+    }
+    container = container[key];
+  }
+  return;
+}
+function fold(steps) {
+  const root = editNode();
+  const checks = [];
+  const checked = new Set;
+  for (let index = 0;index < steps.length; index++) {
+    const step = steps[index];
+    const setting = "set" in step;
+    const path = setting ? step.set : step.remove;
+    if (path.length === 0)
+      throw internalError({ message: "a JSON patch step needs a non-empty path" });
+    let node = root;
+    for (let depth = 0;depth < path.length; depth++) {
+      const signature = JSON.stringify(path.slice(0, depth));
+      if (!checked.has(signature)) {
+        checked.add(signature);
+        checks.push({ path: path.slice(0, depth), step: index });
+      }
+      if (setting)
+        node.create = true;
+      const key = path[depth];
+      if (depth === path.length - 1) {
+        node.children.set(key, setting ? { kind: "replace", text: step.value } : { kind: "delete" });
+        break;
+      }
+      let child = node.children.get(key);
+      if (child === undefined) {
+        child = editNode();
+        node.children.set(key, child);
+      }
+      if (child.kind === "edit") {
+        node = child;
+        continue;
+      }
+      if (child.kind === "delete") {
+        if (!setting)
+          break;
+        child = { kind: "replace", text: "{}", parsed: {} };
+        node.children.set(key, child);
+      }
+      child.parsed ??= JSON.parse(child.text);
+      const conflict = applyKnown({ value: child.parsed, rest: path.slice(depth + 1), step, at: path.slice(0, depth + 1), index });
+      if (conflict !== undefined)
+        return { conflict };
+      break;
+    }
+  }
+  return { root, checks };
+}
+function planJsonPatch(params) {
+  const folded = fold(params.steps);
+  return "conflict" in folded ? { conflict: folded.conflict } : { checks: folded.checks };
+}
+var textOf = (node) => node.parsed === undefined ? node.text : JSON.stringify(node.parsed);
+function writtenMembers(node) {
+  const out = [];
+  for (const [key, child] of node.children) {
+    if (child.kind === "replace" || child.kind === "edit" && child.create)
+      out.push([key, child]);
+  }
+  return out;
+}
+function deletedPaths(params) {
+  const out = [];
+  for (const [key, child] of params.node.children) {
+    if (child.kind === "delete")
+      out.push([...params.path, key]);
+    else if (child.kind === "edit")
+      out.push(...deletedPaths({ node: child, path: [...params.path, key] }));
+  }
+  return out;
+}
+var VETO_TEXT = `${CHAIN_VETO_PREFIX}${JSON_PATCH_VETO_TOKEN}:`;
+function renderJsonPatch(params) {
+  const folded = fold(params.patch.steps);
+  if ("conflict" in folded) {
+    throw internalError({ message: "a JSON patch whose steps conflict reached the renderer; the query builder refuses it" });
+  }
+  switch (params.dialect.jsonPathMode) {
+    case "operators":
+      return renderPostgresPatch({ ...params, ...folded });
+    case "sqliteExtract":
+      return renderSqlitePatch({ ...params, ...folded });
+    case "mysqlExtract":
+      return renderMysqlPatch({ ...params, ...folded });
+  }
+}
+function renderPostgresPatch(params) {
+  const { patch, read, collector } = params;
+  const json = patch.storage === "json";
+  const typeOf = json ? "json_typeof" : "jsonb_typeof";
+  const at = (source, path) => path.length === 0 ? source : `${source} #> ${collector.add([...path])}::text[]`;
+  const arms = params.checks.map((check, index) => {
+    const condition = `${typeOf}(${at(read, check.path)}) <> 'object'`;
+    const marker = collector.add(`${patch.nonce}:${index}`);
+    return `WHEN ${condition} THEN to_jsonb(CAST(concat('${VETO_TEXT}', ${marker}::text, ':', ${typeOf}(${at(read, check.path)})) AS integer))`;
+  });
+  const source = json ? `${read}::jsonb` : read;
+  const build = (node, path) => {
+    const base = at(source, path);
+    const start = node.create ? `COALESCE(${base}, '{}'::jsonb)` : base;
+    const members = writtenMembers(node);
+    if (members.length === 0)
+      return start;
+    const pairs = members.map(([key, child]) => {
+      const name = `${collector.add(key)}::text`;
+      return `${name}, ${child.kind === "replace" ? `${collector.add(textOf(child))}::text::jsonb` : build(child, [...path, key])}`;
+    });
+    return `(${start} || jsonb_build_object(${pairs.join(", ")}))`;
+  };
+  let result = build(params.root, []);
+  const deletes = deletedPaths({ node: params.root, path: [] });
+  if (deletes.length > 0)
+    result = `(${result}${deletes.map((path) => ` #- ${collector.add(path)}::text[]`).join("")})`;
+  const value = `CASE ${arms.join(" ")} ELSE ${result} END`;
+  return json ? `(${value})::json` : value;
+}
+function renderSqlitePatch(params) {
+  const { patch, read, collector } = params;
+  const typeOf = (path) => path.length === 0 ? `json_type(${read})` : `json_type(${read}, ${collector.add(jsonPathString(path))})`;
+  const arms = params.checks.map((check, index) => {
+    const condition = `${typeOf(check.path)} <> 'object'`;
+    const marker = collector.add(`${patch.nonce}:${index}`);
+    return `WHEN ${condition} THEN json_extract('{}', '${VETO_TEXT}' || ${marker} || ':' || ${typeOf(check.path)})`;
+  });
+  const build = (node, path) => {
+    const base = path.length === 0 ? read : `json_extract(${read}, ${collector.add(jsonPathString(path))})`;
+    const start = node.create ? `COALESCE(${base}, '{}')` : base;
+    const members = writtenMembers(node);
+    if (members.length === 0)
+      return start;
+    const pairs = members.map(([key, child]) => {
+      const member = collector.add(jsonPathString([key]));
+      return `${member}, json(${child.kind === "replace" ? collector.add(textOf(child)) : build(child, [...path, key])})`;
+    });
+    return `json_set(${start}, ${pairs.join(", ")})`;
+  };
+  let result = build(params.root, []);
+  const deletes = deletedPaths({ node: params.root, path: [] });
+  if (deletes.length > 0)
+    result = `json_remove(${result}, ${deletes.map((path) => collector.add(jsonPathString(path))).join(", ")})`;
+  return `CASE ${arms.join(" ")} ELSE ${result} END`;
+}
+function renderMysqlPatch(params) {
+  const { patch, read, collector } = params;
+  const at = (path) => path.length === 0 ? read : `JSON_EXTRACT(${read}, ${collector.add(jsonPathString(path))})`;
+  const arms = params.checks.map((check, index) => {
+    const condition = `JSON_TYPE(${at(check.path)}) <> 'OBJECT'`;
+    const marker = collector.add(`${patch.nonce}:${index}`);
+    return `WHEN ${condition} THEN JSON_ARRAY(UUID_TO_BIN(CONCAT('${VETO_TEXT}', ${marker}, ':', JSON_TYPE(${at(check.path)}))))`;
+  });
+  const build = (node, path) => {
+    const base = at(path);
+    const start = node.create ? `COALESCE(${base}, JSON_OBJECT())` : base;
+    const members = writtenMembers(node);
+    if (members.length === 0)
+      return start;
+    const pairs = members.map(([key, child]) => {
+      const member = collector.add(jsonPathString([key]));
+      return `${member}, ${child.kind === "replace" ? `CAST(${collector.add(textOf(child))} AS JSON)` : build(child, [...path, key])}`;
+    });
+    return `JSON_SET(${start}, ${pairs.join(", ")})`;
+  };
+  let result = build(params.root, []);
+  const deletes = deletedPaths({ node: params.root, path: [] });
+  if (deletes.length > 0)
+    result = `JSON_REMOVE(${result}, ${deletes.map((path) => collector.add(jsonPathString(path))).join(", ")})`;
+  return `CASE ${arms.join(" ")} ELSE ${result} END`;
+}
+function jsonPatchVetoOf(params) {
+  const start = params.message.indexOf(VETO_TEXT);
+  if (start < 0)
+    return;
+  const match = /^([0-9a-f]+):(\d+):([A-Za-z]+)/.exec(params.message.slice(start + VETO_TEXT.length));
+  if (match === null)
+    return;
+  return { nonce: match[1], check: Number(match[2]), found: match[3] };
+}
 // packages/sql/src/dialects/external-ownership.ts
 import { unsupportedCapability } from "@vibeorm/schema";
 function renderExternalOwnershipCatalog(params) {
@@ -1193,7 +1547,7 @@ function renderPostgresPhysicalCatalog(params) {
   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`;
+      text = `SELECT table_name, pg_catalog.array_to_json(storage_relation.reloptions)::text AS storage_options, pg_catalog.array_to_json(storage_toast.reloptions)::text AS toast_storage_options, storage_relation.reltoastrelid <> 0 AS has_toast_table FROM information_schema.tables JOIN pg_catalog.pg_namespace storage_namespace ON storage_namespace.nspname = table_schema JOIN pg_catalog.pg_class storage_relation ON storage_relation.relnamespace = storage_namespace.oid AND storage_relation.relname = table_name LEFT JOIN pg_catalog.pg_class storage_toast ON storage_toast.oid = storage_relation.reltoastrelid 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`;
@@ -1214,7 +1568,7 @@ function renderPostgresPhysicalCatalog(params) {
       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`;
+      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, pg_catalog.array_to_json(ARRAY(SELECT included.attname FROM pg_catalog.generate_series(health.indnkeyatts + 1, health.indnatts) AS included_key(ordinal) JOIN pg_catalog.pg_attribute included ON included.attrelid = health.indrelid AND included.attnum = health.indkey[included_key.ordinal - 1] ORDER BY included_key.ordinal))::text AS included_columns 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" };
@@ -1810,7 +2164,7 @@ function extractIndexKeyList({ sql, open, close, tokens, wrapped = false, remove
   }
   return keys.length === 0 ? undefined : keys;
 }
-function extractStandaloneIndexKeys({ definition, index, postgres = false }) {
+function extractStandaloneIndexKeys({ definition, index, postgres = false, included }) {
   const tokens = tableDefinitionTokens({ sql: definition });
   const top = tokens.filter((token) => token.depth === 0);
   let position = 0;
@@ -1851,6 +2205,16 @@ function extractStandaloneIndexKeys({ definition, index, postgres = false }) {
   const close = top[position++];
   if (open?.kind !== "symbol" || open.value !== "(" || close?.kind !== "symbol" || close.value !== ")")
     return;
+  let includedCount = 0;
+  if (postgres && word({ value: "INCLUDE" })) {
+    const includeOpen = top[position++];
+    const includeClose = top[position++];
+    if (includeOpen?.kind !== "symbol" || includeOpen.value !== "(" || includeClose?.kind !== "symbol" || includeClose.value !== ")")
+      return;
+    includedCount = 1 + tokens.filter((token) => token.start > includeOpen.start && token.start < includeClose.start && token.depth === 1 && token.value === ",").length;
+  }
+  if (includedCount !== (included ?? 0))
+    return;
   if (postgres && word({ value: "NULLS" }) && (!word({ value: "NOT" }) || !word({ value: "DISTINCT" })))
     return;
   const tail = top[position];
@@ -1877,8 +2241,8 @@ function extractSqliteIndexKeys({ definition, index }) {
 }
 
 // packages/sql/src/dialects/postgres-index-expressions.ts
-function extractPostgresIndexKeys({ definition, index }) {
-  return extractStandaloneIndexKeys({ definition, index, postgres: true });
+function extractPostgresIndexKeys({ definition, index, included }) {
+  return extractStandaloneIndexKeys({ definition, index, postgres: true, ...included === undefined ? {} : { included } });
 }
 function renderPostgresIndexExpressionProbe({ ...params }) {
   const { dialect, operation, probe } = params;
@@ -2147,10 +2511,10 @@ function renderIndexKeys({ dialect, keys, unique }) {
     return `${expression}${key.desc ? " DESC" : ""}`;
   });
 }
-function extractIndexKeys({ dialect, definition, index, backslashEscapes = true }) {
+function extractIndexKeys({ dialect, definition, index, backslashEscapes = true, included }) {
   switch (dialect) {
     case "postgres":
-      return extractPostgresIndexKeys({ definition, index });
+      return extractPostgresIndexKeys({ definition, index, ...included === undefined ? {} : { included } });
     case "sqlite":
       return extractSqliteIndexKeys({ definition, index });
     case "mysql":
@@ -2318,6 +2682,57 @@ UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME
     }
   }
 }
+// packages/sql/src/dialects/migration-shadow-marker.ts
+import { VibeError as VibeError12, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+var SHADOW_MARKER_CAPABILITIES = Object.freeze({
+  postgres: Object.freeze({ databaseMarker: true }),
+  mysql: Object.freeze({ databaseMarker: false }),
+  sqlite: Object.freeze({ databaseMarker: false })
+});
+var AUTOMATIC_SHADOW_NAME_PATTERN = "^(vibeorm_shadow|vibeorm_test_shadow)_[0-9a-f]{32}$";
+var NAME = new RegExp(AUTOMATIC_SHADOW_NAME_PATTERN);
+var MICROS = /^\d{1,20}$/;
+var HOST = /^[A-Za-z0-9._-]{1,253}$/;
+var MARKER = /^\{"vibeorm":"automatic-shadow","version":1,"database":"([a-z0-9_]+)","adminPid":(\d{1,10}),"adminStarted":(?:"(\d{1,20})"|null),"created":"(\d{1,20})","host":"([A-Za-z0-9._-]{1,253})","pid":(\d{1,10})\}$/;
+function micros(expression) {
+  return `(extract(epoch FROM ${expression}) * 1000000)::bigint::text`;
+}
+function positiveInteger(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+function automaticShadowMarkerText(params) {
+  const { marker } = params;
+  if (!NAME.test(marker.database) || !positiveInteger(marker.adminPid) || !positiveInteger(marker.pid) || marker.adminStarted !== null && !MICROS.test(marker.adminStarted) || !MICROS.test(marker.created) || !HOST.test(marker.host)) {
+    throw new VibeError12({ code: "VIBE_INTERNAL", message: "Automatic shadow marker fields are outside their closed format", meta: { reason: "shadow-marker-invalid", database: marker.database } });
+  }
+  return `{"vibeorm":"automatic-shadow","version":1,"database":"${marker.database}","adminPid":${marker.adminPid},"adminStarted":${marker.adminStarted === null ? "null" : `"${marker.adminStarted}"`},"created":"${marker.created}","host":"${marker.host}","pid":${marker.pid}}`;
+}
+function parseAutomaticShadowMarker(params) {
+  if (typeof params.text !== "string")
+    return;
+  const match = MARKER.exec(params.text);
+  if (match === null)
+    return;
+  const marker = { database: match[1], adminPid: Number(match[2]), adminStarted: match[3] ?? null, created: match[4], host: match[5], pid: Number(match[6]) };
+  return NAME.test(marker.database) && positiveInteger(marker.adminPid) && positiveInteger(marker.pid) ? marker : undefined;
+}
+function renderAutomaticShadowOperation(params) {
+  const { dialect, operation } = params;
+  if (!SHADOW_MARKER_CAPABILITIES[dialect.name].databaseMarker)
+    throw unsupportedCapability14({ dialect: dialect.name, feature: "automaticShadowMarker", hint: "only PostgreSQL labels an automatic shadow database with its creator" });
+  const collector = new ParamCollector(dialect);
+  const result = (text) => ({ text, values: collector.values, returning: "none" });
+  switch (operation.kind) {
+    case "session":
+      return result(`SELECT pg_catalog.pg_backend_pid() AS pid, (SELECT ${micros("a.backend_start")} FROM pg_catalog.pg_stat_activity a WHERE a.pid = pg_catalog.pg_backend_pid()) AS started, ${micros("pg_catalog.statement_timestamp()")} AS now`);
+    case "mark":
+      return result(`COMMENT ON DATABASE ${dialect.quoteIdent({ name: operation.marker.database })} IS '${automaticShadowMarkerText({ marker: operation.marker })}'`);
+    case "list":
+      return result(`SELECT d.datname::text AS name, pg_catalog.shobj_description(d.oid, 'pg_database') AS marker, (SELECT count(*)::int FROM pg_catalog.pg_stat_activity a WHERE a.datid = d.oid) AS sessions, ${micros("pg_catalog.statement_timestamp()")} AS now FROM pg_catalog.pg_database d WHERE d.datname ~ ${collector.add(AUTOMATIC_SHADOW_NAME_PATTERN)} ORDER BY d.datname`);
+    case "backends":
+      return result(`SELECT a.pid, ${micros("a.backend_start")} AS started FROM pg_catalog.pg_stat_activity a`);
+  }
+}
 // packages/sql/src/module-journal.ts
 var MODULE_JOURNAL_COLUMN = "module_origin";
 function renderModuleJournal(params) {
@@ -2355,10 +2770,10 @@ import {
 } from "@vibeorm/schema";
 
 // packages/sql/src/identifiers.ts
-import { VibeError as VibeError12 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 function assertNoNul(params) {
   if (params.name.includes("\x00")) {
-    throw new VibeError12({
+    throw new VibeError13({
       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") }
@@ -2400,6 +2815,7 @@ var sqliteDialect = {
   jsonPathMode: "sqliteExtract",
   supportedJsonOps: [
     "equals",
+    "exists",
     "string_contains",
     "string_starts_with",
     "string_ends_with",
@@ -2504,11 +2920,11 @@ var SQLITE_SESSION_SQL = Object.freeze({
   foreignKeysOn: "PRAGMA foreign_keys = ON"
 });
 // packages/sql/src/composable.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
 var fragments = new WeakMap;
 registerSqlHandleCheck({ check: (value) => fragments.has(value) });
 function invalid4(message) {
-  throw new VibeError13({ code: "VIBE_VALIDATION", message });
+  throw new VibeError14({ code: "VIBE_VALIDATION", message });
 }
 function construct(parts) {
   const snapshot = Object.freeze([...parts]);
@@ -2606,12 +3022,12 @@ function renderSqlFragment(params) {
     const only = parts.length === 1 ? parts[0] : undefined;
     if (recording && only !== undefined && typeof only !== "string" && "value" in only) {
       if (only.decoder !== undefined && resultScalarContract({ decoder: only.decoder }) === undefined)
-        throw new VibeError13({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL cannot compile an opaque encoder whose output controls a greatest NULL frame" });
+        throw new VibeError14({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL cannot compile an opaque encoder whose output controls a greatest NULL frame" });
       if (only.value === null) {
         if (only.decoder !== undefined)
           recordSqlBindingCheck({ collector, check: () => {
             if (encode({ ...only, value: snapshotSqlValue(only.value) }) !== null)
-              throw new VibeError13({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL NULL frame encoding changed its declared structure" });
+              throw new VibeError14({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL NULL frame encoding changed its declared structure" });
           } });
         return "NULL";
       }
@@ -2675,14 +3091,14 @@ function sqlUsesIncoming(params) {
   return partsOf(params.fragment).some((part) => typeof part !== "string" && (("row" in part) && part.row === "incoming" || ("greatest" in part) && part.greatest.some((fragment) => sqlUsesIncoming({ fragment }))));
 }
 // packages/sql/src/query-plan.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
 var queries = new WeakMap;
 var commands = new WeakMap;
 var reusableQueries = new WeakMap;
 var reusableCommands = new WeakMap;
 registerSqlHandleCheck({ check: (value) => queries.has(value) || commands.has(value) || reusableQueries.has(value) || reusableCommands.has(value) });
 function invalid5(message) {
-  throw new VibeError14({ code: "VIBE_VALIDATION", message });
+  throw new VibeError15({ code: "VIBE_VALIDATION", message });
 }
 function createSqlQuery(params) {
   if (typeof params.render !== "function" || typeof params.decoder?.decode !== "function")
@@ -2773,14 +3189,14 @@ function compileSqlCommand(params) {
   return { text, values: collector.values };
 }
 // packages/sql/src/exclusion.ts
-import { VibeError as VibeError15, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { VibeError as VibeError16, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 function invalid6(rule) {
-  throw new VibeError15({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+  throw new VibeError16({ 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 unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability15({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
     invalid6("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
@@ -2833,13 +3249,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability15({ 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 unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability15({ 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 })};`];
@@ -2848,111 +3264,18 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability15({ 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 unsupportedCapability14({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability15({ 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"];
-function isSetOperation(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const keys = Object.keys(value);
-  if (!keys.includes("__op") || !keys.includes("value"))
-    return false;
-  const candidate = value;
-  if (keys.length !== 2 && !(keys.length === 3 && keys.includes("numericType") && candidate.numericType === "Decimal"))
-    return false;
-  return typeof candidate.__op === "string" && SET_OPERATORS.includes(candidate.__op) && (typeof candidate.value === "number" && Number.isFinite(candidate.value) || typeof candidate.value === "string" || typeof candidate.value === "bigint");
-}
-var LIST_SET_OPERATORS = ["append", "concat"];
-function isListSetOperation(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const keys = Object.keys(value);
-  if (keys.length !== 2 || !keys.includes("__listOp") || !keys.includes("value"))
-    return false;
-  const candidate = value;
-  return typeof candidate.__listOp === "string" && LIST_SET_OPERATORS.includes(candidate.__listOp);
-}
-function dbNowMarker(params) {
-  return { __dbNow: true, offsetSeconds: params.offsetSeconds };
-}
-function isDbNowMarker(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  if (!Object.hasOwn(value, "__dbNow"))
-    return false;
-  const keys = Object.keys(value);
-  if (keys.length !== 2 || !keys.includes("__dbNow") || !keys.includes("offsetSeconds"))
-    return false;
-  const candidate = value;
-  return candidate.__dbNow === true && typeof candidate.offsetSeconds === "number" && Number.isFinite(candidate.offsetSeconds);
-}
-var SQL_DEFAULT_CELL = Object.freeze({ __sqlDefault: true });
-var SQL_KEEP_CELL = Object.freeze({ __sqlKeep: true });
-function isSqlKeepCell(value) {
-  return value === SQL_KEEP_CELL;
-}
-function isSqlDefaultCell(value) {
-  return value === SQL_DEFAULT_CELL;
-}
-function jsonParamCell(params) {
-  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;
-}
-function excludedRef(params) {
-  return { __excluded: true, column: params.column };
-}
-function isExcludedRef(value) {
-  return typeof value === "object" && value !== null && value.__excluded === true;
-}
-function returningColumnName(column) {
-  return typeof column === "string" ? column : ("capture" in column) ? column.alias : column.name;
-}
-function isCaptureReturningColumn(column) {
-  return typeof column !== "string" && "capture" in column;
-}
-var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
-function stepColumnRef(params) {
-  return { __stepColumn: true, step: params.step, column: params.column };
-}
-function sourceColumnRef(params) {
-  return Object.freeze({ __sourceColumn: true, column: params.column });
-}
-function isSourceColumnRef(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const candidate = value;
-  return candidate.__sourceColumn === true && typeof candidate.column === "string" && Object.keys(value).length === 2;
-}
-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 unsupportedCapability15 } from "@vibeorm/schema";
+import { internalError as internalError2, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -2972,7 +3295,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -2980,7 +3303,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -2988,7 +3311,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -2996,7 +3319,7 @@ function renderRowLockClause(params) {
   }
   if (lock.of !== undefined) {
     if (lock.of.length === 0)
-      throw internalError({ message: "a row lock's `of` list cannot be empty" });
+      throw internalError2({ message: "a row lock's `of` list cannot be empty" });
     const tables = lock.of.map((name) => dialect.quoteIdent({ name })).join(", ");
     return `${strengthText} OF ${tables}${waitText}`;
   }
@@ -3013,7 +3336,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       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`
@@ -3034,11 +3357,11 @@ function renderAdvisoryLocks(params) {
   const { dialect, keys, mode } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null)
-    throw unsupportedCapability15({ dialect: dialect.name, feature: "advisory locks" });
+    throw unsupportedCapability16({ dialect: dialect.name, feature: "advisory locks" });
   if (mode !== "exclusive" && mode !== "shared")
-    throw internalError({ message: "advisory lock mode must be exclusive or shared" });
+    throw internalError2({ message: "advisory lock mode must be exclusive or shared" });
   if (keys.some((key) => typeof key !== "bigint" || key < ADVISORY_KEY_BOUNDS.single.min || key > ADVISORY_KEY_BOUNDS.single.max)) {
-    throw internalError({ message: "advisory lock keys must be signed 64-bit integers" });
+    throw internalError2({ message: "advisory lock keys must be signed 64-bit integers" });
   }
   const collector = new ParamCollector(dialect);
   const binding = collector.add(JSON.stringify(keys.map((key) => key.toString())));
@@ -3055,7 +3378,7 @@ function renderAdvisoryLocks(params) {
 function assertInt32(params) {
   const { value, part } = params;
   if (!Number.isInteger(value) || value < ADVISORY_KEY_BOUNDS.pair.min || value > ADVISORY_KEY_BOUNDS.pair.max) {
-    throw internalError({
+    throw internalError2({
       message: `advisory lock ${part} must be a 32-bit integer, got ${String(value)}`,
       meta: { part, value }
     });
@@ -3101,6 +3424,7 @@ var postgresDialect = {
   jsonPathMode: "operators",
   supportedJsonOps: [
     "equals",
+    "exists",
     "string_contains",
     "string_starts_with",
     "string_ends_with",
@@ -3195,6 +3519,7 @@ var mysqlDialect = {
   jsonPathMode: "mysqlExtract",
   supportedJsonOps: [
     "equals",
+    "exists",
     "string_contains",
     "string_starts_with",
     "string_ends_with",
@@ -3225,11 +3550,12 @@ var mysqlDialect = {
   renderEnumOrdinal({ column }) {
     return `${column} + 0`;
   },
-  renderEnumMinMax({ fn, column, result }) {
+  renderEnumMinMax({ fn, column, result, when }) {
     const aggregate = fn === "min" ? "MIN" : "MAX";
+    const only = (value) => when === undefined ? value : `CASE WHEN ${when} THEN ${value} END`;
     if (result === "ordinal")
-      return `${aggregate}(${column} + 0)`;
-    return `SUBSTRING(${aggregate}(CONCAT(LPAD(${column} + 0, 5, '0'), ${column})), 6)`;
+      return `${aggregate}(${only(`${column} + 0`)})`;
+    return `SUBSTRING(${aggregate}(${only(`CONCAT(LPAD(${column} + 0, 5, '0'), ${column})`)}), 6)`;
   },
   placeholder() {
     return "?";
@@ -3253,7 +3579,7 @@ function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
 // packages/sql/src/key-list.ts
-import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
 var SCALAR_ELEMENT_TYPES = Object.freeze({
   String: "text",
   Boolean: "bool",
@@ -3324,7 +3650,7 @@ function postgresKeyListElementType(params) {
   const { dialect, member } = params;
   const type = postgresKeyListElementTypeOf({ dialect, member });
   if (type === undefined) {
-    throw unsupportedCapability16({
+    throw unsupportedCapability17({
       dialect: dialect.name,
       feature: `the key-list filter (IN) on a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} member`,
       hint: "IN binds every member as a typed array; filter this field with equality inside OR instead"
@@ -3345,7 +3671,7 @@ function postgresBulkInsertArrayCast(params) {
   const { dialect, member } = params;
   const cast = postgresBulkInsertArrayCastOf({ dialect, member });
   if (cast === undefined) {
-    throw unsupportedCapability16({
+    throw unsupportedCapability17({
       dialect: dialect.name,
       feature: `a bulk insert binding a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} column as a typed array`,
       hint: "the query builder keeps VALUES for this column type"
@@ -3365,7 +3691,7 @@ function renderLocalDateCheck({ dialect, table, column }) {
   };
 }
 // packages/sql/src/date-truncation.ts
-import { DATE_TRUNCATION_UNITS, VibeError as VibeError16, internalError as internalError2, unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { DATE_TRUNCATION_UNITS, VibeError as VibeError17, internalError as internalError3, unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 var TIME_ZONE_NAME = /^[A-Za-z][A-Za-z0-9_+\-/]{0,63}$/;
 function isTimeZoneName(params) {
   return typeof params.value === "string" && TIME_ZONE_NAME.test(params.value);
@@ -3373,17 +3699,17 @@ function isTimeZoneName(params) {
 function renderDateTruncation(params) {
   const { dialect, reference, truncation } = params;
   if (!dialect.capabilities.dateTruncation) {
-    throw unsupportedCapability17({
+    throw unsupportedCapability18({
       dialect: dialect.name,
       feature: "a truncated groupBy key ({ field, truncate, timeZone })",
       hint: "only PostgreSQL and PGlite truncate a timestamp in a named time zone \u2014 group by the plain field and bucket the rows in code instead"
     });
   }
   if (!DATE_TRUNCATION_UNITS.includes(truncation.unit)) {
-    throw internalError2({ message: `unknown date truncation unit ${JSON.stringify(truncation.unit)}` });
+    throw internalError3({ message: `unknown date truncation unit ${JSON.stringify(truncation.unit)}` });
   }
   if (!isTimeZoneName({ value: truncation.timeZone })) {
-    throw new VibeError16({
+    throw new VibeError17({
       code: "VIBE_VALIDATION",
       message: `time zone ${JSON.stringify(truncation.timeZone)} is not a time-zone name \u2014 use an IANA name such as "Europe/Oslo" or "UTC"`,
       meta: { timeZone: truncation.timeZone }
@@ -3397,20 +3723,129 @@ function renderDateTruncation(params) {
     case "timestamp":
       return `(date_trunc(${unit}, ${reference} AT TIME ZONE 'UTC', ${zone}) AT TIME ZONE 'UTC')`;
     default:
-      throw internalError2({ message: `unknown date truncation storage ${JSON.stringify(truncation.storage)}` });
+      throw internalError3({ message: `unknown date truncation storage ${JSON.stringify(truncation.storage)}` });
+  }
+}
+// packages/sql/src/native-types.ts
+var POSTGRES_SCALAR_COLUMN_TYPES = Object.freeze({
+  String: "text",
+  Boolean: "boolean",
+  Int: "integer",
+  BigInt: "bigint",
+  Float: "double precision",
+  Decimal: "numeric",
+  DateTime: "timestamptz",
+  Json: "jsonb",
+  Bytes: "bytea"
+});
+var MYSQL_SCALAR_COLUMN_TYPES = Object.freeze({
+  String: `varchar(${mysqlDialect.conflictKeyEquality.defaultStringMaxLength})`,
+  Boolean: "tinyint(1)",
+  Int: "int",
+  BigInt: "bigint",
+  Float: "double",
+  Decimal: "decimal(65,30)",
+  DateTime: "datetime(3)",
+  Json: "json",
+  Bytes: "longblob"
+});
+var SQLITE_SCALAR_STORAGE_CLASSES = Object.freeze({
+  String: "TEXT",
+  Boolean: "INTEGER",
+  Int: "INTEGER",
+  BigInt: "INTEGER",
+  Float: "REAL",
+  Decimal: "TEXT",
+  DateTime: "TEXT",
+  Json: "TEXT",
+  Bytes: "BLOB"
+});
+var POSTGRES_NATIVE_ALIASES = Object.freeze({
+  charactervarying: "varchar",
+  character: "char",
+  bpchar: "char",
+  int: "integer",
+  int4: "integer",
+  int2: "smallint",
+  int8: "bigint",
+  serial: "integer",
+  bigserial: "bigint",
+  bool: "boolean",
+  float4: "real",
+  float8: "doubleprecision",
+  double: "doubleprecision",
+  doubleprecision: "doubleprecision",
+  decimal: "numeric",
+  timestampwithtimezone: "timestamptz",
+  timestampwithouttimezone: "timestamp",
+  timewithtimezone: "timetz",
+  timewithouttimezone: "time",
+  bitvarying: "varbit"
+});
+var POSTGRES_IMPLICIT_MODIFIERS = Object.freeze({
+  bit: "(1)"
+});
+var POSTGRES_DEFAULT_PRECISION_SIX = new Set(["timestamp", "time", "timetz"]);
+function normalizePostgresNativeType(params) {
+  const compact = params.raw.toLowerCase().replace(/\s+/g, "");
+  const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(\[\])?$/);
+  if (match === null)
+    return compact;
+  const base = POSTGRES_NATIVE_ALIASES[match[1]] ?? match[1];
+  const modifier = POSTGRES_DEFAULT_PRECISION_SIX.has(base) && match[2] === "(6)" ? "" : match[2] ?? POSTGRES_IMPLICIT_MODIFIERS[base] ?? "";
+  return `${base}${modifier}${match[3] ?? ""}`;
+}
+var POSTGRES_EXACT_EQUIVALENTS = Object.freeze({
+  DateTime: Object.freeze(["timestamptz(6)"])
+});
+var MYSQL_NATIVE_ALIASES = Object.freeze({
+  integer: "int",
+  dec: "decimal",
+  numeric: "decimal",
+  bool: "tinyint(1)",
+  boolean: "tinyint(1)",
+  character: "char"
+});
+function normalizeMysqlNativeType(params) {
+  const compact = params.raw.toLowerCase().replace(/\s+/g, "");
+  if (compact === "tinyint(1)" || compact === "bool" || compact === "boolean")
+    return "tinyint(1)";
+  const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(.*)$/);
+  if (match === null)
+    return compact;
+  const base = MYSQL_NATIVE_ALIASES[match[1]] ?? match[1];
+  let modifier = match[2] ?? "";
+  if (/^(tinyint|smallint|mediumint|int|bigint)$/.test(base))
+    modifier = "";
+  return `${base}${modifier}${match[3] ?? ""}`;
+}
+function canonicalColumnType(params) {
+  const { dialect, scalar, nativeType } = params;
+  switch (dialect) {
+    case "postgres": {
+      const canonical = normalizePostgresNativeType({ raw: POSTGRES_SCALAR_COLUMN_TYPES[scalar] });
+      if (nativeType === undefined)
+        return canonical;
+      const declared = normalizePostgresNativeType({ raw: nativeType });
+      return declared === canonical || POSTGRES_EXACT_EQUIVALENTS[scalar]?.includes(declared) === true ? canonical : declared;
+    }
+    case "mysql":
+      return normalizeMysqlNativeType({ raw: nativeType ?? MYSQL_SCALAR_COLUMN_TYPES[scalar] });
+    case "sqlite":
+      return SQLITE_SCALAR_STORAGE_CLASSES[scalar];
   }
 }
 // packages/sql/src/generated-columns.ts
-import { VibeError as VibeError17, unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+import { VibeError as VibeError18, unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-generated-columns.ts
-import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
 function renderPostgresGeneratedColumnClause({ generated }) {
   return `GENERATED ALWAYS AS (${generated.expression}) STORED`;
 }
 function renderPostgresGeneratedColumnProbe({ dialect, probe }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability18({ dialect: dialect.name, feature: "rollbackGeneratedColumnProbe" });
+    throw unsupportedCapability19({ dialect: dialect.name, feature: "rollbackGeneratedColumnProbe" });
   const q = ({ name }) => dialect.quoteIdent({ name });
   let text;
   switch (probe.operation) {
@@ -3431,20 +3866,20 @@ function renderPostgresGeneratedColumnProbe({ dialect, probe }) {
 }
 function renderPostgresDropGeneratedExpression({ dialect, table, column }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability18({ dialect: dialect.name, feature: "dropGeneratedExpression" });
+    throw unsupportedCapability19({ dialect: dialect.name, feature: "dropGeneratedExpression" });
   return { text: `ALTER TABLE ${dialect.quoteIdent({ name: table.namespace })}.${dialect.quoteIdent({ name: table.name })} ALTER COLUMN ${dialect.quoteIdent({ name: column })} DROP EXPRESSION`, values: [], returning: "none" };
 }
 
 // packages/sql/src/generated-columns.ts
 function renderGeneratedColumnClause({ dialect, generated }) {
   if (!("generatedColumns" in dialect.capabilities) || dialect.capabilities.generatedColumns !== true) {
-    throw unsupportedCapability19({ dialect: dialect.name, feature: "generatedColumns" });
+    throw unsupportedCapability20({ dialect: dialect.name, feature: "generatedColumns" });
   }
   if (generated.storage !== "stored") {
-    throw unsupportedCapability19({ dialect: dialect.name, feature: "virtualGeneratedColumns" });
+    throw unsupportedCapability20({ dialect: dialect.name, feature: "virtualGeneratedColumns" });
   }
   if (typeof generated.expression !== "string" || generated.expression.trim().length === 0 || generated.expression.includes("\x00")) {
-    throw new VibeError17({ code: "VIBE_SCHEMA_INVALID", message: "A generated column requires non-empty, NUL-free SQL", meta: { reason: "generated-expression-invalid" } });
+    throw new VibeError18({ code: "VIBE_SCHEMA_INVALID", message: "A generated column requires non-empty, NUL-free SQL", meta: { reason: "generated-expression-invalid" } });
   }
   switch (dialect.name) {
     case "postgres":
@@ -3456,10 +3891,10 @@ function renderGeneratedColumnClause({ dialect, generated }) {
   }
 }
 // packages/sql/src/row-rules.ts
-import { VibeError as VibeError21, internalError as internalError3, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { VibeError as VibeError22, internalError as internalError4, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-row-rules.ts
-import { VibeError as VibeError18, unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { VibeError as VibeError19, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 function comparison({ dialect, field }) {
   const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
   const cast = field.type === "Json" ? `::pg_catalog.jsonb${field.isList ? "[]" : ""}` : "";
@@ -3467,7 +3902,7 @@ function comparison({ dialect, field }) {
 }
 function renderPostgresRowRule({ dialect, context }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability20({ dialect: dialect.name, feature: "postgresRowRules" });
+    throw unsupportedCapability21({ dialect: dialect.name, feature: "postgresRowRules" });
   const { rule, table, functionIdentity, triggerIdentity, protectedFields, gateField } = context;
   const qualify = ({ name }) => `${dialect.quoteIdent({ name: name.namespace })}.${dialect.quoteIdent({ name: name.name })}`;
   const functionName = qualify({ name: functionIdentity.name });
@@ -3484,7 +3919,7 @@ END;`;
   } else {
     const terms = protectedFields.map((field) => comparison({ dialect, field }));
     if (terms.length === 0) {
-      throw new VibeError18({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+      throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
     }
     const condition = gateField === undefined ? terms.join(`
     OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
@@ -3519,19 +3954,19 @@ FOR EACH ROW EXECUTE FUNCTION ${functionName}();`;
 }
 
 // packages/sql/src/dialects/sqlite-row-rules.ts
-import { SQLITE_ROW_RULE_ERROR_PREFIX, VibeError as VibeError19, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+import { SQLITE_ROW_RULE_ERROR_PREFIX, VibeError as VibeError20, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 function renderSqliteRowRule({ dialect, context }) {
   if (dialect.name !== "sqlite")
-    throw unsupportedCapability21({ dialect: dialect.name, feature: "sqliteRowRules" });
+    throw unsupportedCapability22({ dialect: dialect.name, feature: "sqliteRowRules" });
   const { rule, table, triggers, protectedFields, gateField } = context;
   if (table.namespace !== "main")
-    throw unsupportedCapability21({ dialect: dialect.name, feature: "fixedNamespaces" });
+    throw unsupportedCapability22({ dialect: dialect.name, feature: "fixedNamespaces" });
   const terms = protectedFields.map((field) => {
     const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
     return `OLD.${column} IS NOT NEW.${column}`;
   });
   if (rule.kind !== "appendOnly" && terms.length === 0)
-    throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+    throw new VibeError20({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
   const condition = rule.kind === "appendOnly" ? "" : gateField === undefined ? `WHEN ${terms.join(`
   OR `)}
 ` : `WHEN OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
@@ -3556,11 +3991,11 @@ END;`,
 }
 
 // packages/sql/src/dialects/mysql-row-rules.ts
-import { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, VibeError as VibeError20, mysqlRowRuleMessageByteLength, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
+import { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, VibeError as VibeError21, mysqlRowRuleMessageByteLength, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 function diagnosticLiteral({ name, context, dialect }) {
   const message = `Check constraint '${name}' is violated.`;
   if (mysqlRowRuleMessageByteLength({ triggerName: name }) > MYSQL_ROW_RULE_MESSAGE_MAX_BYTES)
-    throw new VibeError20({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${context.rule.name} exceeds MySQL's ${MYSQL_ROW_RULE_MESSAGE_MAX_BYTES}-byte diagnostic limit; supply a shorter name stem`, meta: { model: context.model, rule: context.rule.name } });
+    throw new VibeError21({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${context.rule.name} exceeds MySQL's ${MYSQL_ROW_RULE_MESSAGE_MAX_BYTES}-byte diagnostic limit; supply a shorter name stem`, meta: { model: context.model, rule: context.rule.name } });
   if (message.includes("\\")) {
     const hex = Array.from(new TextEncoder().encode(message), (byte) => byte.toString(16).padStart(2, "0")).join("");
     return `_utf8mb4 X'${hex}'`;
@@ -3569,11 +4004,11 @@ function diagnosticLiteral({ name, context, dialect }) {
 }
 function renderMysqlRowRule({ dialect, context }) {
   if (dialect.name !== "mysql")
-    throw unsupportedCapability22({ dialect: dialect.name, feature: "mysqlRowRules" });
+    throw unsupportedCapability23({ dialect: dialect.name, feature: "mysqlRowRules" });
   const { rule, table, triggers, protectedFields, gateField, placement } = context;
   for (const name of Object.keys(placement ?? {}))
     if (!triggers.some(({ identity }) => identity.name === name))
-      throw new VibeError20({ code: "VIBE_INTERNAL", message: "A MySQL trigger placement names a trigger this rule does not own", meta: { model: context.model, rule: rule.name, trigger: name } });
+      throw new VibeError21({ code: "VIBE_INTERNAL", message: "A MySQL trigger placement names a trigger this rule does not own", meta: { model: context.model, rule: rule.name, trigger: name } });
   const position = ({ name }) => {
     const entry = placement?.[name];
     if (entry === undefined)
@@ -3586,7 +4021,7 @@ function renderMysqlRowRule({ dialect, context }) {
     return `NOT (OLD.${column} <=> NEW.${column})`;
   });
   if (rule.kind !== "appendOnly" && terms.length === 0)
-    throw new VibeError20({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+    throw new VibeError21({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
   const condition = gateField === undefined ? terms.join(`
     OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
     ${terms.join(`
@@ -3615,10 +4050,10 @@ END;`, values: [] };
 function renderRowRule({ schema, model, rule, dialect, placement }) {
   const issue = rowRuleShapeIssue({ value: rule });
   if (issue !== undefined) {
-    throw new VibeError21({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { model: model.name } });
+    throw new VibeError22({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { model: model.name } });
   }
   if (placement !== undefined && Object.keys(placement).length > 0 && dialect.name !== "mysql")
-    throw unsupportedCapability23({ dialect: dialect.name, feature: "rowRuleTriggerPlacement" });
+    throw unsupportedCapability24({ dialect: dialect.name, feature: "rowRuleTriggerPlacement" });
   const normalized = normalizeRowRules({ schema, model, rules: [rule], dialect: dialect.name })[0];
   switch (dialect.name) {
     case "postgres": {
@@ -3626,7 +4061,7 @@ function renderRowRule({ schema, model, rule, dialect, placement }) {
       const functionIdentity = objects.find((object) => object.role === "function")?.identity;
       const triggerIdentity = objects.find((object) => object.role === "trigger")?.identity;
       if (functionIdentity?.kind !== "function" || triggerIdentity?.kind !== "trigger")
-        throw internalError3({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError4({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
       const gate = rowRuleGateField({ rule: normalized });
       const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
       return renderPostgresRowRule({
@@ -3647,15 +4082,15 @@ function renderRowRule({ schema, model, rule, dialect, placement }) {
       const objects = rowRuleIdentities({ schema, model, rule: normalized, dialect: dialect.name });
       const triggers = objects.map(({ role, identity }) => {
         if (role !== "trigger" || identity.kind !== "trigger")
-          throw internalError3({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
+          throw internalError4({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
         const event = ["update", "delete"].find((event) => identity.name === rowRuleTriggerName({ rule: normalized, event }));
         if (event === undefined)
-          throw internalError3({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
+          throw internalError4({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
         return { event, identity: { kind: "trigger", table: identity.table, name: identity.name } };
       });
       const table = triggers[0]?.identity.table;
       if (table === undefined)
-        throw internalError3({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError4({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
       const gate = rowRuleGateField({ rule: normalized });
       const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
       const context = {
@@ -3686,15 +4121,16 @@ function renderSqliteJsonEquality(params) {
 }
 
 // packages/sql/src/dialects/diagnostics.ts
-import { assertSqlNamespace as assertSqlNamespace2, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, unsupportedCapability as unsupportedCapability25 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
+  postgresServerVersion: { dialect: "postgres", text: `SELECT pg_catalog.current_setting('server_version_num') AS "serverVersionNum"` },
   sqliteTriggers: { dialect: "sqlite", text: "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'trigger'" }
 });
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability24({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability25({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -3705,7 +4141,7 @@ var CAPTURE_READINESS_SQL = `SELECT pg_catalog.current_setting('server_version_n
 function renderCaptureReadiness(params) {
   const { dialect, tables } = params;
   if (dialect.name !== "postgres") {
-    throw unsupportedCapability24({ dialect: dialect.name, feature: "postgresCaptureReadiness", hint: "row capture reads RETURNING old/new, PostgreSQL 18 or newer" });
+    throw unsupportedCapability25({ dialect: dialect.name, feature: "postgresCaptureReadiness", hint: "row capture reads RETURNING old/new, PostgreSQL 18 or newer" });
   }
   const entries = tables.map((entry, index) => {
     const { name, namespace } = entry.table;
@@ -3719,7 +4155,7 @@ function renderCaptureReadiness(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError22, unsupportedCapability as unsupportedCapability25 } from "@vibeorm/schema";
+import { VibeError as VibeError23, unsupportedCapability as unsupportedCapability26 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -3754,7 +4190,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability25({
+    throw unsupportedCapability26({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -3772,7 +4208,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 VibeError22({
+      throw new VibeError23({
         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 }
@@ -3791,7 +4227,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError22({
+    throw new VibeError23({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -3801,10 +4237,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability27 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError23, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability26, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError24, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability27, 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" } },
@@ -3817,18 +4253,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability27({ 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 VibeError23({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError24({ 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 unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability27({ 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 })}`;
 }
@@ -3869,7 +4305,7 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability27({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
@@ -3877,7 +4313,7 @@ function protectedModel(params) {
   assertValidSchemaIR({ schema: params.schema });
   const model = params.schema.models.find((entry) => entry.name === params.model);
   if (model === undefined || model.rls === undefined || model.rls === "unprotected") {
-    throw new VibeError23({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError24({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -3910,7 +4346,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError23({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError24({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -3951,7 +4387,7 @@ function renderRlsContext(params) {
 }
 function runtimeRoleOf(params) {
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
-    throw new VibeError23({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError24({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
   return params.role;
 }
@@ -4108,7 +4544,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability27({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability28({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -4140,7 +4576,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace3, internalError as internalError4, unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace3, internalError as internalError5, unsupportedCapability as unsupportedCapability29 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -4228,21 +4664,29 @@ function renderStatement(params) {
   }
 }
 function quoteCol(dialect, column) {
+  if (column.coalesce !== undefined) {
+    if (column.coalesce.length < 2 || column.coalesce.some((member) => member.coalesce !== undefined)) {
+      throw internalError5({ message: "ColRef.coalesce needs two or more plain member references" });
+    }
+    return `COALESCE(${column.coalesce.map((member) => quoteCol(dialect, member)).join(", ")})`;
+  }
   const name = dialect.quoteIdent({ name: column.name });
   const ref = column.table === undefined ? name : `${dialect.quoteIdent({ name: column.table })}.${name}`;
   if (column.truncate !== undefined)
     return renderDateTruncation({ dialect, reference: ref, truncation: column.truncate });
+  if (column.groupKey !== undefined)
+    return renderGroupKey({ dialect, reference: ref, key: column.groupKey });
   if (column.enumOrdinal === true)
     return dialect.renderEnumOrdinal({ column: ref });
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
-      throw internalError4({ message: "ColRef.castReal is a sqlite Decimal construct" });
+      throw internalError5({ message: "ColRef.castReal is a sqlite Decimal construct" });
     }
     return `CAST(${ref} AS REAL)`;
   }
   if (column.castJsonb !== undefined) {
     if (dialect.name !== "postgres") {
-      throw internalError4({ message: "ColRef.castJsonb is a postgres json construct" });
+      throw internalError5({ message: "ColRef.castJsonb is a postgres json construct" });
     }
     return `${ref}::${column.castJsonb}`;
   }
@@ -4250,7 +4694,9 @@ function quoteCol(dialect, column) {
 }
 function typedOrderRef(params) {
   const { statement, column } = params;
-  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined || column.truncate !== undefined)
+  if (column.coalesce !== undefined)
+    return { ...column, coalesce: column.coalesce.map((member) => typedOrderRef({ statement, column: member })) };
+  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined || column.truncate !== undefined || column.groupKey !== 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;
@@ -4259,14 +4705,14 @@ function jsonCellCast(dialect, cell) {
   if (cell.storage !== "json" || dialect.jsonParamCast === "")
     return dialect.jsonParamCast;
   if (dialect.name !== "postgres") {
-    throw internalError4({ message: "JsonParamCell storage json is a postgres construct" });
+    throw internalError5({ message: "JsonParamCell storage json is a postgres construct" });
   }
   return "::text::json";
 }
 function quoteProjection(dialect, column) {
   if (column.transform === undefined) {
     const base = quoteCol(dialect, column);
-    const alias = column.alias ?? (column.truncate === undefined ? undefined : column.name);
+    const alias = column.alias ?? (column.truncate === undefined && column.groupKey === undefined ? undefined : column.name);
     if (alias === undefined)
       return base;
     return `${base} AS ${dialect.quoteIdent({ name: alias })}`;
@@ -4283,7 +4729,7 @@ function quoteProjection(dialect, column) {
   if (column.transform === "encodeBase64" && dialect.name === "mysql")
     return `TO_BASE64(${ref}) AS ${alias}`;
   if (dialect.name !== "postgres") {
-    throw internalError4({ message: `${column.transform} is a postgres construct` });
+    throw internalError5({ message: `${column.transform} is a postgres construct` });
   }
   if (column.transform === "encodeArrayBase64")
     return `encode(array_send(${ref}), 'base64') AS ${alias}`;
@@ -4307,7 +4753,7 @@ function renderTable(dialect, table) {
 }
 function assertCount(value, what) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw internalError4({ message: `${what} must be a non-negative integer, got ${value}` });
+    throw internalError5({ message: `${what} must be a non-negative integer, got ${value}` });
   }
 }
 var COMPARISON_SQL2 = {
@@ -4331,7 +4777,9 @@ var AGG_FN_SQL = {
   min: "MIN",
   max: "MAX"
 };
-function renderAggRef(dialect, agg) {
+function renderAggRef(dialect, agg, collector) {
+  if (agg.filter !== undefined)
+    return renderFilteredAggregate({ dialect, agg, filter: agg.filter, collector });
   if (agg.fn === "countAll")
     return "COUNT(*)";
   const column = quoteCol(dialect, agg.column);
@@ -4340,10 +4788,112 @@ function renderAggRef(dialect, agg) {
   }
   return `${AGG_FN_SQL[agg.fn]}(${column})`;
 }
+function renderFilteredAggregate(params) {
+  const { dialect, agg, filter, collector } = params;
+  if (dialect.capabilities.filteredAggregates === "filterClause") {
+    const { filter: _filter, ...plain } = agg;
+    const aggregate = renderAggRef(dialect, plain, collector);
+    return `${aggregate} FILTER (WHERE ${renderExpr({ dialect, expr: filter, collector })})`;
+  }
+  const when = renderExpr({ dialect, expr: filter, collector });
+  if (agg.fn === "countAll")
+    return `COUNT(CASE WHEN ${when} THEN 1 END)`;
+  const column = quoteCol(dialect, agg.column);
+  if ((agg.fn === "min" || agg.fn === "max") && agg.enumOrder !== undefined) {
+    return dialect.renderEnumMinMax({ fn: agg.fn, column, result: agg.enumOrder, when });
+  }
+  return `${AGG_FN_SQL[agg.fn]}(CASE WHEN ${when} THEN ${column} END)`;
+}
+var MAX_GROUP_KEY_PREFIX = 1000;
+function renderGroupKey(params) {
+  const { dialect, reference, key } = params;
+  if (key.kind === "prefix") {
+    if (!Number.isSafeInteger(key.length) || key.length < 1 || key.length > MAX_GROUP_KEY_PREFIX) {
+      throw internalError5({ message: `a groupBy prefix length must be an integer from 1 to ${MAX_GROUP_KEY_PREFIX}, got ${String(key.length)}` });
+    }
+    if (dialect.name === "sqlite")
+      return `substr(${reference}, 1, ${key.length})`;
+    return `${dialect.name === "mysql" ? "LEFT" : "left"}(${reference}, ${key.length})`;
+  }
+  if (key.path.length === 0 || key.path.some((step) => typeof step !== "string" || step.length === 0 || step.includes("\x00"))) {
+    throw internalError5({ message: "a groupBy JSON path needs one or more non-empty object keys without NUL characters" });
+  }
+  switch (dialect.jsonPathMode) {
+    case "operators": {
+      const steps = key.path.map((step) => dialect.quoteStringLiteral({ value: step }));
+      if (key.storage === "json")
+        return `((${reference} -> ${steps.join(" -> ")})::jsonb #>> '{}')`;
+      const last = steps.length - 1;
+      return `(${reference}${steps.map((step, index) => `${index === last ? " ->> " : " -> "}${step}`).join("")})`;
+    }
+    case "sqliteExtract": {
+      const path = dialect.quoteStringLiteral({ value: jsonPathString(key.path) });
+      const extracted = `json_extract(${reference}, ${path})`;
+      return `CASE json_type(${reference}, ${path}) WHEN 'text' THEN ${extracted} WHEN 'true' THEN 'true' WHEN 'false' THEN 'false' WHEN 'null' THEN NULL ELSE CAST(${extracted} AS TEXT) END`;
+    }
+    case "mysqlExtract": {
+      const extracted = `JSON_EXTRACT(${reference}, ${dialect.quoteStringLiteral({ value: jsonPathString(key.path) })})`;
+      return `CASE WHEN JSON_TYPE(${extracted}) = 'NULL' THEN NULL ELSE JSON_UNQUOTE(${extracted}) END`;
+    }
+  }
+}
+function renderGroupingSets(params) {
+  const { dialect, keys, grouping } = params;
+  const sets = groupingSetIndexes({ keys, grouping });
+  const mode = dialect.capabilities.groupingSets;
+  if (mode === "groupingSets") {
+    return `GROUPING SETS (${sets.map((set) => `(${set.map((index) => keys[index]).join(", ")})`).join(", ")})`;
+  }
+  if (mode === "rollup" && isRollupChain({ count: keys.length, sets }))
+    return `${keys.join(", ")} WITH ROLLUP`;
+  throw unsupportedCapability29({
+    dialect: dialect.name,
+    feature: mode === "rollup" ? "groupBy grouping sets other than the rollup of `by` in order" : "groupBy grouping sets",
+    hint: mode === "rollup" ? "MySQL groups by `WITH ROLLUP` only: list the sets [[a, b], [a], []] for by [a, b], or run one groupBy per set" : "run one groupBy per grouping set instead"
+  });
+}
+function groupingSetIndexes(params) {
+  const { keys, grouping } = params;
+  if (grouping.sets.length === 0 || keys.length === 0 || keys.length > 31) {
+    throw internalError5({ message: "grouping sets need one or more sets over 1 to 31 groupBy keys" });
+  }
+  for (const set of grouping.sets) {
+    if (set.some((index) => !Number.isSafeInteger(index) || index < 0 || index >= keys.length)) {
+      throw internalError5({ message: "a grouping set names a groupBy key that does not exist" });
+    }
+  }
+  return grouping.sets;
+}
+function isRollupChain(params) {
+  const { count, sets } = params;
+  if (sets.length !== count + 1)
+    return false;
+  const lengths = new Set;
+  for (const set of sets) {
+    const sorted = [...set].sort((left, right) => left - right);
+    if (!sorted.every((index, position) => index === position))
+      return false;
+    lengths.add(set.length);
+  }
+  return lengths.size === count + 1;
+}
+function renderGroupingSetIndex(params) {
+  const { keys } = params;
+  const sets = groupingSetIndexes(params);
+  const branches = sets.map((set, position) => {
+    let mask = 0;
+    for (let index = 0;index < keys.length; index++) {
+      if (!set.includes(index))
+        mask += 2 ** (keys.length - 1 - index);
+    }
+    return `WHEN ${mask} THEN ${position}`;
+  });
+  return `CASE GROUPING(${keys.join(", ")}) ${branches.join(" ")} END`;
+}
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability28({
+  throw unsupportedCapability29({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -4355,7 +4905,7 @@ function renderExpr(params) {
     case "cmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
@@ -4366,7 +4916,7 @@ function renderExpr(params) {
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
     }
@@ -4390,11 +4940,11 @@ function renderExpr(params) {
     }
     case "tupleIn": {
       if (expr.columns.length === 0) {
-        throw internalError4({ message: "tupleIn needs at least one column" });
+        throw internalError5({ message: "tupleIn needs at least one column" });
       }
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length) {
-          throw internalError4({
+          throw internalError5({
             message: `tupleIn row has ${row.length} values for ${expr.columns.length} columns`
           });
         }
@@ -4420,7 +4970,7 @@ function renderExpr(params) {
     case "rowCompare": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined || expr.columns.length === 0 || expr.values.length !== expr.columns.length) {
-        throw internalError4({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
+        throw internalError5({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
       }
       const columns = expr.columns.map((column) => quoteCol(dialect, column));
       const placeholders = expr.values.map((value) => collector.add(value));
@@ -4428,9 +4978,9 @@ function renderExpr(params) {
     }
     case "inSelect": {
       if (expr.columns.length === 0)
-        throw internalError4({ message: "inSelect needs at least one column" });
+        throw internalError5({ message: "inSelect needs at least one column" });
       if (dialect.name === "mysql" && (expr.select.limit !== undefined || expr.select.offset !== undefined)) {
-        throw unsupportedCapability28({
+        throw unsupportedCapability29({
           dialect: dialect.name,
           feature: "LIMIT inside an IN subquery",
           hint: "mysql refuses LIMIT directly inside an IN subquery (error 1235); wrap the limited select in a derived table"
@@ -4501,9 +5051,9 @@ function renderExpr(params) {
     case "aggCmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
-      return `${renderAggRef(dialect, expr.agg)} ${op} ${collector.add(expr.value)}`;
+      return `${renderAggRef(dialect, expr.agg, collector)} ${op} ${collector.add(expr.value)}`;
     }
     case "arrayHas": {
       assertScalarArrays(dialect, 'the scalar-list filter "has"');
@@ -4556,19 +5106,6 @@ function renderFragment(params) {
   }
   return text;
 }
-function jsonPathString(path) {
-  let out = "$";
-  for (const segment of path) {
-    if (typeof segment === "number") {
-      out += `[${segment}]`;
-    } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)) {
-      out += `.${segment}`;
-    } else {
-      out += `."${segment.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
-    }
-  }
-  return out;
-}
 function listComparison(params) {
   const { dialect, column, value, collector } = params;
   if (isJsonListParameter(value) && value.storage === "json") {
@@ -4583,13 +5120,13 @@ function renderKeyList(params) {
   const { dialect, expr, collector } = params;
   const arity = expr.columns.length;
   if (arity === 0)
-    throw internalError4({ message: "keyList needs at least one column" });
+    throw internalError5({ message: "keyList needs at least one column" });
   if (expr.members.length !== arity) {
-    throw internalError4({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
+    throw internalError5({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
   }
   for (const row of expr.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `keyList row has ${row.length} values for ${arity} columns` });
+      throw internalError5({ message: `keyList row has ${row.length} values for ${arity} columns` });
   }
   if (expr.rows.length === 0)
     return "1 = 0";
@@ -4621,25 +5158,25 @@ function renderKeyPage(params) {
   const { select } = page;
   const arity = page.keyColumns.length;
   if (arity === 0 || page.members.length !== arity) {
-    throw internalError4({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
+    throw internalError5({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
   }
   if (page.rows.length === 0)
-    throw internalError4({ message: "keyPage needs at least one key" });
+    throw internalError5({ message: "keyPage needs at least one key" });
   for (const row of page.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
+      throw internalError5({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
   }
   if (page.identity.length === 0)
-    throw internalError4({ message: "keyPage needs the child's identity columns" });
+    throw internalError5({ message: "keyPage needs the child's identity columns" });
   const order = select.orderBy ?? [];
   if (order.length === 0 || order.some((term) => !("column" in term))) {
-    throw internalError4({ message: "keyPage needs a non-empty order of plain column terms" });
+    throw internalError5({ message: "keyPage needs a non-empty order of plain column terms" });
   }
   if (select.table.alias !== undefined || Object.keys(select).some((member) => !KEY_PAGE_SELECT_MEMBERS.has(member))) {
-    throw internalError4({ message: "keyPage select carries a member the per-key page cannot render" });
+    throw internalError5({ message: "keyPage select carries a member the per-key page cannot render" });
   }
   if (dialect.keyPageStrategy === "window") {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       dialect: dialect.name,
       feature: "a per-key page (keyPage)",
       hint: "the runtime keeps the ROW_NUMBER window on this dialect"
@@ -4667,7 +5204,7 @@ function renderKeyPage(params) {
   const keys = dialect.quoteIdent({ name: keyAlias });
   if (dialect.keyPageStrategy === "lateral") {
     if (keyListBindsUntypedRows({ members: page.members })) {
-      throw unsupportedCapability28({
+      throw unsupportedCapability29({
         dialect: dialect.name,
         feature: "a per-key page over a DateTime key without a declared native type",
         hint: "the runtime keeps the ROW_NUMBER window for such keys"
@@ -4695,22 +5232,22 @@ function renderKeyPage(params) {
 function renderKeyRows(params) {
   const { dialect, statement, keys, collector } = params;
   if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.table.alias !== undefined) {
-    throw internalError4({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
+    throw internalError5({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
   }
   if (statement.rowLock !== undefined)
-    throw internalError4({ message: "a locking read cannot read from key rows" });
+    throw internalError5({ message: "a locking read cannot read from key rows" });
   const arity = keys.columns.length;
   if (arity === 0 || keys.members.length !== arity) {
-    throw internalError4({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
+    throw internalError5({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
   }
   if (keys.rows.length === 0)
-    throw internalError4({ message: "fromKeys needs at least one key row" });
+    throw internalError5({ message: "fromKeys needs at least one key row" });
   for (const row of keys.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
+      throw internalError5({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
   }
   if (dialect.keyListStrategy !== "unnest" || keyListBindsUntypedRows({ members: keys.members })) {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       dialect: dialect.name,
       feature: dialect.keyListStrategy !== "unnest" ? "a key-rows FROM (fromKeys)" : "a key-rows FROM over a DateTime key without a declared native type",
       hint: "the runtime keeps the per-relation loads for this write"
@@ -4726,20 +5263,20 @@ function renderUnionPage(params) {
   const { dialect, statement, collector } = params;
   const branches = statement.fromUnion ?? [];
   if (branches.length < 2)
-    throw internalError4({ message: "fromUnion needs at least two branches" });
+    throw internalError5({ message: "fromUnion needs at least two branches" });
   if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.table.alias !== undefined) {
-    throw internalError4({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
+    throw internalError5({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
   }
   if (statement.rowLock !== undefined)
-    throw internalError4({ message: "a locking read cannot read from a union page" });
+    throw internalError5({ message: "a locking read cannot read from a union page" });
   const outputNames = (branch) => branch.columns.map((column) => column.alias ?? column.name).join("\x00");
   const names = outputNames(branches[0]);
   return branches.map((branch, index) => {
     if (branch.columns.length === 0 || Object.keys(branch).some((member) => !UNION_BRANCH_MEMBERS.has(member))) {
-      throw internalError4({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
+      throw internalError5({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
     }
     if (outputNames(branch) !== names)
-      throw internalError4({ message: "fromUnion branches must project the same output names in the same order" });
+      throw internalError5({ message: "fromUnion branches must project the same output names in the same order" });
     const inner = renderSelect({ dialect, statement: branch, collector });
     return `SELECT * FROM (${inner.text}) AS ${dialect.quoteIdent({ name: `__vibe_u${index}` })}`;
   }).join(" UNION ALL ");
@@ -4747,7 +5284,7 @@ function renderUnionPage(params) {
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
-    throw internalError4({ message: `json ${expr.op} expects a string operand` });
+    throw internalError5({ message: `json ${expr.op} expects a string operand` });
   }
   if (expr.op === "string_contains")
     return containsPattern({ raw: expr.value });
@@ -4768,10 +5305,14 @@ function renderJsonLike(params) {
     base = `${base}${dialect.likeEscapeClause}`;
   return expr.negate === true ? `NOT (${base})` : base;
 }
+function renderJsonExists(params) {
+  const { present, column, exists } = params;
+  return `CASE WHEN ${present} THEN ${exists ? "TRUE" : "FALSE"} WHEN ${column} IS NOT NULL THEN ${exists ? "FALSE" : "TRUE"} END`;
+}
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -4783,6 +5324,16 @@ function renderJsonFilter(params) {
     const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
     const extracted = expr.storage === "json" ? `(${column} #> ${pathParam})::jsonb` : `(${column} #> ${pathParam})`;
     switch (expr.op) {
+      case "exists": {
+        const typeOf = expr.storage === "json" ? "json_typeof" : "jsonb_typeof";
+        const guards = expr.path.flatMap((segment, index) => {
+          if (typeof segment !== "string" || !/^\s*[+-]?\d/.test(segment))
+            return [];
+          const container = index === 0 ? column : `${column} #> ${collector.add(expr.path.slice(0, index).map(String))}::text[]`;
+          return [` AND ${typeOf}(${container}) = 'object'`];
+        });
+        return renderJsonExists({ present: `(${column} #> ${pathParam}) IS NOT NULL${guards.join("")}`, column, exists: expr.value === true });
+      }
       case "equals":
         return `${extracted} ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "string_contains":
@@ -4820,6 +5371,8 @@ function renderJsonFilter(params) {
       return expr.negate === true ? `NOT (${base})` : base;
     };
     switch (expr.op) {
+      case "exists":
+        return renderJsonExists({ present: `json_type(${column}, ${collector.add(jsonPathString(expr.path))}) IS NOT NULL`, column, exists: expr.value === true });
       case "equals":
         return compareExtracted(jsonPathString(expr.path), expr.value);
       case "string_contains":
@@ -4838,7 +5391,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 unsupportedCapability28({
+            throw unsupportedCapability29({
               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"
@@ -4852,12 +5405,16 @@ function renderJsonFilter(params) {
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
       default:
-        throw internalError4({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+        throw internalError5({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
     }
   }
   const column = quoteCol(dialect, expr.column);
   const pathString = jsonPathString(expr.path);
   switch (expr.op) {
+    case "exists": {
+      const present = `JSON_CONTAINS_PATH(${column}, 'one', ${collector.add(pathString)})`;
+      return expr.value === true ? present : `NOT ${present}`;
+    }
     case "equals":
       return `JSON_EXTRACT(${column}, ${collector.add(pathString)}) ${cmp} CAST(${collector.add(JSON.stringify(expr.value))} AS JSON)`;
     case "string_contains":
@@ -4874,10 +5431,18 @@ function renderJsonFilter(params) {
       return `JSON_EXTRACT(${column}, ${collector.add(`${pathString}[last]`)}) ${cmp} CAST(${collector.add(JSON.stringify(expr.value))} AS JSON)`;
   }
 }
+function groupKeyOutputName(params) {
+  const { dialect, statement, column } = params;
+  if (column.groupKey === undefined)
+    return;
+  const text = quoteCol(dialect, column);
+  const projected = statement.columns.find((candidate) => candidate.groupKey !== undefined && candidate.transform === undefined && candidate.alias !== undefined && quoteCol(dialect, candidate) === text);
+  return projected?.alias;
+}
 function renderOrderTerm(params) {
-  const { dialect, term, collector } = params;
+  const { dialect, term, collector, nullsOutputName } = params;
   if ("agg" in term) {
-    return `${renderAggRef(dialect, term.agg)} ${term.direction === "asc" ? "ASC" : "DESC"}`;
+    return `${renderAggRef(dialect, term.agg, collector)} ${term.direction === "asc" ? "ASC" : "DESC"}`;
   }
   const expression = "select" in term ? () => renderScalarSubquery({ dialect, subquery: term, collector }) : () => quoteCol(dialect, term.column);
   const direction = term.direction === "asc" ? "ASC" : "DESC";
@@ -4890,7 +5455,7 @@ function renderOrderTerm(params) {
   if (term.nulls === "first" === (term.direction === "asc")) {
     return `${expression()} ${direction}`;
   }
-  const tested = expression();
+  const tested = nullsOutputName === undefined ? expression() : dialect.quoteIdent({ name: nullsOutputName });
   const nullsTerm = term.nulls === "first" ? `${tested} IS NULL DESC` : `${tested} IS NULL`;
   return `${nullsTerm}, ${expression()} ${direction}`;
 }
@@ -4907,11 +5472,11 @@ function renderPositionalRow(params) {
   const position = join.select.rowNumber;
   const positioned = position !== undefined && json.order === "positionSlot" && join.agg === "jsonArray" && position.partitionBy.length === 0 && position.orderBy.length > 0;
   if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || position !== undefined && !positioned) {
-    throw internalError4({ message: "positional lateral rows require an explicit column-only projection" });
+    throw internalError5({ message: "positional lateral rows require an explicit column-only projection" });
   }
   const names = [...join.select.columns.map((column) => projectionOutputName({ column })), ...positioned ? [position.alias] : []];
   if (new Set(names).size !== names.length) {
-    throw internalError4({ message: "positional lateral projection has duplicate output names" });
+    throw internalError5({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
@@ -4919,14 +5484,14 @@ function renderPositionalRow(params) {
     chunks.push(`${json.rowArray}(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
-    throw internalError4({ message: "positional lateral projection exceeds the transport width limit" });
+    throw internalError5({ message: "positional lateral projection exceeds the transport width limit" });
   }
   return chunks.length === 1 ? chunks[0] : `${json.rowArray}(${chunks.join(", ")})`;
 }
 function lateralJsonOf(params) {
   const json = params.dialect.lateralJson;
   if (json === null)
-    throw internalError4({ message: "lateral JSON rendering on a dialect without LATERAL" });
+    throw internalError5({ message: "lateral JSON rendering on a dialect without LATERAL" });
   return json;
 }
 function renderLateralJoin(params) {
@@ -4934,7 +5499,7 @@ function renderLateralJoin(params) {
   const inner = renderSelect({ dialect, statement: join.select, collector });
   if (join.agg === "count") {
     if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr?.kind !== "countAll" || join.select.selectExpr.alias !== join.columnAlias || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined || join.select.distinct !== undefined) {
-      throw internalError4({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
+      throw internalError5({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
     }
     return `LEFT JOIN LATERAL (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
   }
@@ -4946,12 +5511,14 @@ function renderLateralJoin(params) {
     const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name).concat((join.select.scalarSubqueries ?? []).map((subquery) => subquery.alias)));
     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 subRef = (column) => ({ table: "__sub", name: column.name, ...column.castJsonb === undefined ? {} : { castJsonb: column.castJsonb } });
+    const readable = (column) => column.coalesce === undefined ? projected.has(column.name) : column.coalesce.every((member) => projected.has(member.name));
+    if (columnTerms.length === terms.length && columnTerms.every((term) => readable(term.column))) {
       const rendered = columnTerms.map((term) => renderOrderTerm({
         dialect,
         term: {
           ...term,
-          column: { table: "__sub", name: term.column.name, ...term.column.castJsonb === undefined ? {} : { castJsonb: term.column.castJsonb } }
+          column: term.column.coalesce === undefined ? subRef(term.column) : { ...term.column, coalesce: term.column.coalesce.map(subRef) }
         },
         collector
       }));
@@ -4959,7 +5526,7 @@ function renderLateralJoin(params) {
     }
   }
   if (join.rowFormat !== "positional" && json.order !== "inAggregate") {
-    throw unsupportedCapability28({ dialect: dialect.name, feature: "object-format lateral rows", hint: 'lateral relation rows render positional (rowFormat "positional") on this dialect' });
+    throw unsupportedCapability29({ dialect: dialect.name, feature: "object-format lateral rows", hint: 'lateral relation rows render positional (rowFormat "positional") on this dialect' });
   }
   const rowJson = join.rowFormat === "positional" ? renderPositionalRow({ dialect, join, subAlias }) : `to_json(${subAlias}.*)`;
   const projection = join.agg === "jsonArray" ? `COALESCE(${json.arrayAgg}(${rowJson}${aggOrder}), ${json.emptyArray}) AS ${columnAlias}` : `${rowJson} AS ${columnAlias}`;
@@ -4970,7 +5537,7 @@ 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.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined || select.scalarSubqueries !== undefined) {
-    throw internalError4({ message: "count subquery must be one ungrouped COUNT(*)" });
+    throw internalError5({ message: "count subquery must be one ungrouped COUNT(*)" });
   }
   const inner = renderSelect({ dialect, statement: select, collector });
   return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
@@ -4988,7 +5555,10 @@ function applyReturning(params) {
   if (!dialect.capabilities.returning) {
     const capture = requested.find(isCaptureReturningColumn);
     if (capture !== undefined)
-      renderCaptureReturning({ dialect, column: capture });
+      renderCaptureReturning({ dialect, column: capture, collector: params.collector });
+    const other = requested.find(isOtherRowReturningColumn);
+    if (other !== undefined)
+      renderOtherRowReturning({ dialect, column: other });
     return { suffix: "", status: "omitted" };
   }
   const read = (name) => params.qualify === undefined ? name : `${params.qualify}.${name}`;
@@ -4996,7 +5566,9 @@ function applyReturning(params) {
     if (typeof column === "string")
       return read(dialect.quoteIdent({ name: column }));
     if ("capture" in column)
-      return renderCaptureReturning({ dialect, column });
+      return renderCaptureReturning({ dialect, column, collector: params.collector });
+    if ("from" in column)
+      return renderOtherRowReturning({ dialect, column });
     if ("transform" in column) {
       const name = dialect.quoteIdent({ name: column.name });
       return `${dialect.jsonTextProjection({ expression: read(name) })} AS ${name}`;
@@ -5009,40 +5581,88 @@ function applyReturning(params) {
 function renderCaptureReturning(params) {
   const { dialect, column } = params;
   if (!dialect.capabilities.rowCapture) {
-    throw unsupportedCapability28({ dialect: dialect.name, feature: "row capture (RETURNING old./new.)", hint: "row capture needs PostgreSQL 18 or later; the runtime refuses $transaction({ capture }) on this dialect" });
+    throw unsupportedCapability29({ dialect: dialect.name, feature: "row capture (RETURNING old./new.)", hint: "row capture needs PostgreSQL 18 or later; the runtime refuses $transaction({ capture }) on this dialect" });
   }
-  const name = dialect.quoteIdent({ name: column.name });
   const alias = dialect.quoteIdent({ name: column.alias });
+  if (column.capture === "cascade") {
+    if (params.collector === undefined)
+      throw internalError5({ message: `capture cascade column "${column.alias}" rendered without a parameter collector` });
+    const child = dialect.quoteIdent({ name: CAPTURE_CHILD_ALIAS });
+    const match = column.cascade.on.map((pair) => `${child}.${dialect.quoteIdent({ name: pair.child })} = old.${dialect.quoteIdent({ name: pair.parent })}`).join(" AND ");
+    return `${renderCascadeImages({ dialect, cascade: column.cascade, match, collector: params.collector })} AS ${alias}`;
+  }
+  const name = dialect.quoteIdent({ name: column.name });
   if (column.capture === "inserted")
     return `(old.${name} IS NULL) AS ${alias}`;
-  return `${textProjection({ dialect, expression: `${column.capture}.${name}` })} AS ${alias}`;
+  if (column.capture === "key")
+    return `old.${name} AS ${alias}`;
+  return `${renderCaptureCell({ dialect, row: column.capture, cell: column })} AS ${alias}`;
+}
+var CAPTURE_CHILD_ALIAS = "__vibe_c";
+var CAPTURE_HOP_ALIAS = "__vibe_h";
+function renderCaptureCell(params) {
+  const { dialect, row, cell } = params;
+  const name = dialect.quoteIdent({ name: cell.name });
+  if (cell.hop === undefined)
+    return textProjection({ dialect, expression: `${row}.${name}` });
+  if (cell.hop.on.length === 0)
+    throw internalError5({ message: `capture hop to "${cell.hop.table.name}" needs at least one key column` });
+  const related = dialect.quoteIdent({ name: CAPTURE_HOP_ALIAS });
+  const match = cell.hop.on.map((pair) => `${related}.${dialect.quoteIdent({ name: pair.target })} = ${row}.${dialect.quoteIdent({ name: pair.source })}`).join(" AND ");
+  return `(SELECT ${textProjection({ dialect, expression: `${related}.${name}` })} FROM ${renderTable(dialect, cell.hop.table)} AS ${related} WHERE ${match})`;
+}
+function renderCascadeImages(params) {
+  const { dialect, cascade, match, collector } = params;
+  if (cascade.cells.length === 0 || cascade.on.length === 0)
+    throw internalError5({ message: `capture cascade into "${cascade.table.name}" needs at least one cell and one key column` });
+  if (!Number.isSafeInteger(cascade.limit) || cascade.limit < 1)
+    throw internalError5({ message: `capture cascade into "${cascade.table.name}" needs a positive integer limit` });
+  const child = dialect.quoteIdent({ name: CAPTURE_CHILD_ALIAS });
+  const item = dialect.quoteIdent({ name: "__vibe_i" });
+  const cells = cascade.cells.map((cell) => renderCaptureCell({ dialect, row: child, cell })).join(", ");
+  return `(SELECT array_agg(${item})::text FROM (SELECT DISTINCT ARRAY[${cells}] AS ${item} FROM ${renderTable(dialect, cascade.table)} AS ${child} WHERE ${match} LIMIT ${collector.add(cascade.limit)}) AS ${dialect.quoteIdent({ name: "__vibe_d" })})`;
+}
+function renderOtherRowReturning(params) {
+  const { dialect, column } = params;
+  const fromOld = column.from === "old";
+  if (fromOld ? !dialect.capabilities.rowCapture : !dialect.capabilities.returningReadsJoinedSource) {
+    throw unsupportedCapability29({
+      dialect: dialect.name,
+      feature: fromOld ? "RETURNING old.\u2026 (the row before the write)" : "RETURNING a joined source's columns",
+      hint: fromOld ? "needs PostgreSQL 18 or later" : "read the row inside the write's transaction first, then write it"
+    });
+  }
+  const name = dialect.quoteIdent({ name: column.name });
+  const expression = column.from === "old" ? `old.${name}` : `${dialect.quoteIdent({ name: column.from.source })}.${name}`;
+  const projected = column.projection === "castText" ? textProjection({ dialect, expression }) : column.projection === "jsonText" ? dialect.jsonTextProjection({ expression }) : expression;
+  return `${projected} AS ${dialect.quoteIdent({ name: column.alias })}`;
 }
 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 unsupportedCapability28({
+    throw unsupportedCapability29({
       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 internalError4({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+    throw internalError5({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
   }
   if (join.rows.length === 0)
-    throw internalError4({ message: "key table needs at least one key row" });
+    throw internalError5({ 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 internalError4({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+      throw internalError5({ 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 internalError4({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+      throw internalError5({ message: `key table row has ${row.length} values for ${join.members.length} members` });
     }
     const cells = row.map((value, index) => {
       const placeholder = collector.add(value);
@@ -5072,10 +5692,10 @@ function renderKeyTableJoin(params) {
 function renderLeftJoin(params) {
   const { dialect, join, collector } = params;
   if (join.on.length === 0) {
-    throw internalError4({ message: "left join needs at least one ON pair" });
+    throw internalError5({ message: "left join needs at least one ON pair" });
   }
   if (join.select.columns.length === 0 || join.select.columns.some((column) => column.alias === undefined)) {
-    throw internalError4({ message: "a left join's derived select must alias every projected column" });
+    throw internalError5({ message: "a left join's derived select must alias every projected column" });
   }
   const inner = renderSelect({ dialect, statement: join.select, collector });
   const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
@@ -5084,10 +5704,10 @@ function renderLeftJoin(params) {
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
-    throw internalError4({ message: "only countAll can combine with a column list" });
+    throw internalError5({ message: "only countAll can combine with a column list" });
   }
   if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
-    throw internalError4({ message: "selectExpr and aggregates cannot combine" });
+    throw internalError5({ message: "selectExpr and aggregates cannot combine" });
   }
   const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
   if (statement.selectExpr !== undefined) {
@@ -5095,11 +5715,15 @@ function renderSelect(params) {
   }
   if (statement.aggregates !== undefined) {
     for (const selection of statement.aggregates) {
-      const expression = renderAggRef(dialect, selection.agg);
+      const expression = renderAggRef(dialect, selection.agg, collector);
       const projected = selection.castText === true ? textProjection({ dialect, expression }) : expression;
       columnList.push(`${projected} AS ${dialect.quoteIdent({ name: selection.alias })}`);
     }
   }
+  const groupKeys = statement.groupBy?.map((column) => quoteCol(dialect, column)) ?? [];
+  if (statement.groupingSets !== undefined) {
+    columnList.push(`${renderGroupingSetIndex({ keys: groupKeys, grouping: statement.groupingSets })} AS ${dialect.quoteIdent({ name: statement.groupingSets.indexAlias })}`);
+  }
   if (statement.countSubqueries !== undefined) {
     for (const subquery of statement.countSubqueries) {
       columnList.push(renderCountSubquery({ dialect, subquery, collector }));
@@ -5113,7 +5737,7 @@ function renderSelect(params) {
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0 && rowNumber.orderBy.length === 0) {
-      throw internalError4({ message: "rowNumber needs a partition column or an order" });
+      throw internalError5({ message: "rowNumber needs a partition column or an order" });
     }
     const partition = rowNumber.partitionBy.length === 0 ? "" : `PARTITION BY ${rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ")}`;
     const order = rowNumber.orderBy.length === 0 ? "" : `${partition === "" ? "" : " "}ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
@@ -5121,11 +5745,11 @@ function renderSelect(params) {
   }
   let distinctPrefix = statement.distinct === true ? "DISTINCT " : "";
   if (statement.distinct === true && statement.distinctOn !== undefined) {
-    throw internalError4({ message: "distinct and distinctOn cannot combine" });
+    throw internalError5({ message: "distinct and distinctOn cannot combine" });
   }
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability28({
+      throw unsupportedCapability29({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -5141,12 +5765,12 @@ function renderSelect(params) {
     from = `(${renderUnionPage({ dialect, statement, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
   } else if (statement.keyPage !== undefined) {
     if (statement.fromSelect !== undefined || statement.table.alias !== undefined) {
-      throw internalError4({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
+      throw internalError5({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
     }
     from = `(${renderKeyPage({ dialect, page: statement.keyPage, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
   } else if (statement.fromSelect !== undefined) {
     if (statement.table.alias !== undefined) {
-      throw internalError4({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+      throw internalError5({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
     }
     const inner = renderSelect({ dialect, statement: statement.fromSelect, collector });
     from = `(${inner.text}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
@@ -5157,7 +5781,7 @@ function renderSelect(params) {
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
       if (join.on.length === 0) {
-        throw internalError4({ message: "inner join needs at least one ON pair" });
+        throw internalError5({ message: "inner join needs at least one ON pair" });
       }
       const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
@@ -5168,7 +5792,7 @@ function renderSelect(params) {
   }
   if (statement.leftJoins !== undefined && statement.leftJoins.length > 0) {
     if (statement.rowLock !== undefined) {
-      throw internalError4({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
+      throw internalError5({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
     }
     for (const join of statement.leftJoins) {
       text += ` ${renderLeftJoin({ dialect, join, collector })}`;
@@ -5176,7 +5800,7 @@ function renderSelect(params) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin || dialect.lateralJson === null) {
-      throw unsupportedCapability28({
+      throw unsupportedCapability29({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -5190,13 +5814,25 @@ function renderSelect(params) {
     text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
   }
   if (statement.groupBy !== undefined && statement.groupBy.length > 0) {
-    text += ` GROUP BY ${statement.groupBy.map((column) => quoteCol(dialect, column)).join(", ")}`;
+    text += ` GROUP BY ${statement.groupingSets === undefined ? groupKeys.join(", ") : renderGroupingSets({ dialect, keys: groupKeys, grouping: statement.groupingSets })}`;
+  } else if (statement.groupingSets !== undefined) {
+    throw internalError5({ message: "grouping sets need groupBy columns" });
   }
   if (statement.having !== undefined) {
     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: "column" in term ? { ...term, column: typedOrderRef({ statement, column: term.column }) } : term, collector }));
+    const terms = statement.orderBy.map((term) => {
+      if (!("column" in term))
+        return renderOrderTerm({ dialect, term, collector });
+      const nullsOutputName = term.nulls === undefined || dialect.orderByNullsMode === "native" ? undefined : groupKeyOutputName({ dialect, statement, column: term.column });
+      return renderOrderTerm({
+        dialect,
+        term: { ...term, column: typedOrderRef({ statement, column: term.column }) },
+        collector,
+        ...nullsOutputName === undefined ? {} : { nullsOutputName }
+      });
+    });
     text += ` ORDER BY ${terms.join(", ")}`;
   }
   if (statement.limit !== undefined) {
@@ -5213,10 +5849,10 @@ function renderSelect(params) {
   if (statement.rowLock !== undefined) {
     const target = statement.table.alias ?? statement.table.name;
     if (statement.rowLock.of !== undefined && statement.rowLock.of.some((name) => name !== target)) {
-      throw internalError4({ message: `a row lock's \`of\` list may name only the statement's own table "${target}"` });
+      throw internalError5({ message: `a row lock's \`of\` list may name only the statement's own table "${target}"` });
     }
     if (statement.rowLock.of !== undefined && (statement.fromSelect !== undefined || statement.keyPage !== undefined)) {
-      throw internalError4({ message: "a row lock's `of` list cannot name a derived table" });
+      throw internalError5({ message: "a row lock's `of` list cannot name a derived table" });
     }
     const clause = renderRowLockClause({ dialect, lock: statement.rowLock });
     if (clause !== null)
@@ -5232,7 +5868,7 @@ function unnestElement(params) {
     return null;
   if (isJsonParamCell(value)) {
     if (jsonStorage === undefined || (value.storage ?? "jsonb") !== jsonStorage) {
-      throw internalError4({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
+      throw internalError5({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
     }
     return value.text;
   }
@@ -5248,24 +5884,24 @@ function unnestElement(params) {
           return value;
     }
   }
-  throw internalError4({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
+  throw internalError5({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
 }
 function renderUnnestRows(params) {
   const { dialect, statement, members, collector } = params;
   if (dialect.bulkInsertForm !== "unnest") {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       dialect: dialect.name,
       feature: "a bulk insert bound as typed arrays (INSERT \u2026 SELECT FROM unnest)",
       hint: "this dialect binds createMany rows as VALUES"
     });
   }
   if (statement.columns.length === 0)
-    throw internalError4({ message: "an unnest insert needs at least one column" });
+    throw internalError5({ message: "an unnest insert needs at least one column" });
   if (members.length !== statement.columns.length) {
-    throw internalError4({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
+    throw internalError5({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
   }
   if (statement.onConflict !== undefined && !("doNothing" in statement.onConflict)) {
-    throw internalError4({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
+    throw internalError5({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
   }
   const aliases = statement.columns.map((_column, index) => dialect.quoteIdent({ name: `c${index + 1}` }));
   const arrays = members.map((member, index) => {
@@ -5281,14 +5917,14 @@ function renderUnnestRows(params) {
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
   if (statement.rows.length === 0) {
-    throw internalError4({ message: "insert requires at least one row" });
+    throw internalError5({ message: "insert requires at least one row" });
   }
   const defaultValues = statement.columns.length === 0 && dialect.emptyInsert.form === "defaultValues";
   if (defaultValues && statement.rows.length !== 1) {
-    throw internalError4({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
+    throw internalError5({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
   }
   if (defaultValues && statement.onConflict !== undefined && !(dialect.emptyInsert.form === "defaultValues" && dialect.emptyInsert.conflictClause)) {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       dialect: dialect.name,
       feature: "a conflict clause on an all-default row (DEFAULT VALUES)",
       hint: "supply at least one column value, or drop the conflict clause"
@@ -5296,7 +5932,7 @@ function renderInsert(params) {
   }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
-      throw internalError4({
+      throw internalError5({
         message: `insert row has ${row.length} values but ${statement.columns.length} columns`
       });
     }
@@ -5314,7 +5950,7 @@ function renderInsert(params) {
     if (!isSqlDefaultCell(value))
       return collector.add(value);
     if (!dialect.rowDefaultKeyword) {
-      throw internalError4({
+      throw internalError5({
         message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
       });
     }
@@ -5330,7 +5966,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability28({
+            throw unsupportedCapability29({
               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"
@@ -5346,7 +5982,7 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else {
         if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-          throw unsupportedCapability28({
+          throw unsupportedCapability29({
             dialect: dialect.name,
             feature: "a refined conflict target (constraint / partial-index predicate) on ON DUPLICATE KEY UPDATE",
             hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
@@ -5354,36 +5990,36 @@ function renderInsert(params) {
         }
         const keepName = onConflict.keepColumn ?? statement.columns[0];
         if (keepName === undefined) {
-          throw internalError4({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
+          throw internalError5({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
         }
         const keep = dialect.quoteIdent({ name: keepName });
         const current = `${dialect.quoteIdent({ name: statement.table.name })}.${keep}`;
         const flag = onConflict.duplicateFlag;
         if (flag !== undefined && !/^\d{1,20}$/.test(flag)) {
-          throw internalError4({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
+          throw internalError5({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
         }
         text += flag === undefined ? ` ON DUPLICATE KEY UPDATE ${keep} = ${current}` : ` ON DUPLICATE KEY UPDATE ${keep} = IF(LAST_INSERT_ID(${flag}), ${current}, ${current})`;
       }
     } else {
       const updates = Object.entries(onConflict.update);
       if (updates.length === 0) {
-        throw internalError4({ message: "upsert update must set at least one column" });
+        throw internalError5({ message: "upsert update must set at least one column" });
       }
       const selfRef = dialect.quoteIdent({ name: statement.table.name });
       const assignments = renderAssignments({ dialect, entries: updates, collector, selfRef, allowExcluded: true, tableName: statement.table.name });
       if (dialect.upsertForm === "onConflict") {
         if (onConflict.lastInsertIdColumn !== undefined) {
-          throw internalError4({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+          throw internalError5({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability28({
+          throw unsupportedCapability29({
             dialect: dialect.name,
             feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
             hint: "sqlite conflict targets are column lists \u2014 name the indexed columns instead"
           });
         }
         if (onConflict.constraint !== undefined && onConflict.conflictWhere !== undefined) {
-          throw internalError4({
+          throw internalError5({
             message: "a named-constraint conflict target already identifies the index \u2014 it cannot carry a partial predicate too"
           });
         }
@@ -5392,7 +6028,7 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
         if (onConflict.updateWhere !== undefined) {
           if (!dialect.capabilities.conflictUpdateWhere) {
-            throw unsupportedCapability28({
+            throw unsupportedCapability29({
               dialect: dialect.name,
               feature: "a guarded conflict update (ON CONFLICT \u2026 DO UPDATE \u2026 WHERE)",
               hint: "run the guarded upsert as a find-then-write in a transaction instead"
@@ -5402,21 +6038,21 @@ function renderInsert(params) {
         }
       } else {
         if (onConflict.updateWhere !== undefined) {
-          throw unsupportedCapability28({
+          throw unsupportedCapability29({
             dialect: dialect.name,
             feature: "a guarded conflict update (ON DUPLICATE KEY UPDATE has no WHERE)",
             hint: "run the guarded upsert as a find-then-write in a transaction instead \u2014 the runtime does this when the dialect lacks conflictUpdateWhere"
           });
         }
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability28({
+          throw unsupportedCapability29({
             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 unsupportedCapability28({
+          throw unsupportedCapability29({
             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"
@@ -5427,25 +6063,35 @@ function renderInsert(params) {
       }
     }
   }
-  const returning = applyReturning({ dialect, requested: statement.returning });
+  const returning = applyReturning({ dialect, requested: statement.returning, collector });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
 function renderUpdate(params) {
   const { dialect, statement, collector } = params;
   const assignments = Object.entries(statement.set);
   if (assignments.length === 0) {
-    throw internalError4({ message: "update must set at least one column" });
+    throw internalError5({ message: "update must set at least one column" });
   }
   const source = statement.from;
   if (source !== undefined) {
     if (statement.alias === undefined || statement.alias === source.alias)
-      throw internalError4({ message: "UPDATE \u2026 FROM needs distinct target and source aliases" });
+      throw internalError5({ message: "UPDATE \u2026 FROM needs distinct target and source aliases" });
     const target = dialect.quoteIdent({ name: statement.alias });
     const joined = dialect.quoteIdent({ name: source.alias });
     const assign = () => renderAssignments({ dialect, entries: assignments, collector, selfRef: target, source: joined, ...dialect.name === "mysql" ? { qualifyWrite: target } : {}, ...params.earlier === undefined ? {} : { steps: params.earlier } });
     const where = () => statement.where === undefined ? "" : ` AND ${renderExpr({ dialect, expr: statement.where, collector })}`;
+    if ("select" in source) {
+      if (!dialect.capabilities.returningReadsJoinedSource) {
+        throw unsupportedCapability29({ dialect: dialect.name, feature: "UPDATE \u2026 FROM (SELECT \u2026) with RETURNING of the joined source", hint: "read the row inside the write's transaction first, then write it" });
+      }
+      const set = assign();
+      const joinedSelect = renderSelect({ dialect, statement: source.select, collector }).text;
+      const text = `UPDATE ${renderTable(dialect, statement.table)} AS ${target} SET ${set} FROM (${joinedSelect}) AS ${joined} WHERE ${renderExpr({ dialect, expr: source.on, collector })}${where()}`;
+      const returning = applyReturning({ dialect, requested: statement.returning, qualify: target });
+      return { text: text + returning.suffix, values: collector.values, returning: returning.status };
+    }
     const text = dialect.name === "mysql" ? `UPDATE ${renderTable(dialect, statement.table)} AS ${target} JOIN ${renderTable(dialect, source.table)} AS ${joined} ON ${renderExpr({ dialect, expr: source.on, collector })} SET ${assign()}${statement.where === undefined ? "" : ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`}` : `UPDATE ${renderTable(dialect, statement.table)} AS ${target} SET ${assign()} FROM ${renderTable(dialect, source.table)} AS ${joined} WHERE ${renderExpr({ dialect, expr: source.on, collector })}${where()}`;
-    const returning = applyReturning({ dialect, requested: statement.returning, ...dialect.name === "postgres" ? { qualify: target } : {} });
+    const returning = applyReturning({ dialect, requested: statement.returning, collector, ...dialect.name === "postgres" ? { qualify: target } : {} });
     return { text: text + returning.suffix, values: collector.values, returning: returning.status };
   }
   const setSql = renderAssignments({ dialect, entries: assignments, collector, ...params.earlier === undefined ? {} : { steps: params.earlier } });
@@ -5453,7 +6099,7 @@ function renderUpdate(params) {
   if (statement.where !== undefined) {
     text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
   }
-  const returning = applyReturning({ dialect, requested: statement.returning });
+  const returning = applyReturning({ dialect, requested: statement.returning, collector });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
 function renderIncomingRowColumn(params) {
@@ -5469,23 +6115,23 @@ function renderAssignments(params) {
     const read = selfRef === undefined ? column : `${selfRef}.${column}`;
     if (isSourceColumnRef(value)) {
       if (params.source === undefined)
-        throw internalError4({ message: `an UPDATE set value reads the joined source's column ${value.column}, but the statement joins no source` });
+        throw internalError5({ message: `an UPDATE set value reads the joined source's column ${value.column}, but the statement joins no source` });
       return `${column} = ${params.source}.${dialect.quoteIdent({ name: value.column })}`;
     }
     if (isStepColumnRef(value)) {
       if (params.steps === undefined || !params.steps.has(value.step)) {
-        throw internalError4({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
+        throw internalError5({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
       }
       return `${column} = (SELECT ${dialect.quoteIdent({ name: value.column })} FROM ${dialect.quoteIdent({ name: value.step })})`;
     }
     if (isSqlFragment(value)) {
       if (params.allowExcluded !== true || selfRef === undefined)
-        throw internalError4({ message: "SQL assignment fragments require a conflict update" });
+        throw internalError5({ message: "SQL assignment fragments require a conflict update" });
       return `${column} = ${renderSqlFragment({ dialect, fragment: value, collector, conflict: { table: params.tableName } })}`;
     }
     if (isExcludedRef(value)) {
       if (params.allowExcluded !== true) {
-        throw internalError4({
+        throw internalError5({
           message: `an incoming-row reference (${value.column}) is only meaningful inside an upsert's update arm`
         });
       }
@@ -5493,9 +6139,12 @@ function renderAssignments(params) {
     }
     if (isSqlKeepCell(value)) {
       if (params.allowExcluded !== true || selfRef === undefined)
-        throw internalError4({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
+        throw internalError5({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
       return `${column} = ${read}`;
     }
+    if (isJsonPatchOperation(value)) {
+      return `${column} = ${renderJsonPatch({ dialect, patch: value, read, collector })}`;
+    }
     if (isJsonParamCell(value)) {
       return `${column} = ${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     }
@@ -5523,7 +6172,7 @@ function renderDelete(params) {
   if (statement.where !== undefined) {
     text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
   }
-  const returning = applyReturning({ dialect, requested: statement.returning });
+  const returning = applyReturning({ dialect, requested: statement.returning, collector });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
 var CHAIN_ROWS_ALIAS = "__vibe_rows";
@@ -5531,19 +6180,19 @@ var CHAIN_ONE_ALIAS = "__vibe_one";
 function renderChain(params) {
   const { dialect, statement, collector } = params;
   if (dialect.statementChain === null) {
-    throw unsupportedCapability28({
+    throw unsupportedCapability29({
       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 internalError4({ message: "a statement chain needs at least one step" });
+    throw internalError5({ 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 internalError4({ message: `chain step name "${step.name}" is reserved or repeated` });
+      throw internalError5({ message: `chain step name "${step.name}" is reserved or repeated` });
     }
     const body = renderChainStep({ dialect, statement: step.statement, collector, earlier: defined });
     steps.push(`${dialect.quoteIdent({ name: step.name })} AS (${body})`);
@@ -5552,11 +6201,11 @@ function renderChain(params) {
   const result = statement.result;
   const captures = result.capture ?? [];
   if (captures.length > 0 && !dialect.capabilities.rowCapture) {
-    throw unsupportedCapability28({ dialect: dialect.name, feature: "row capture (RETURNING old./new.)", hint: "row capture needs PostgreSQL 18 or later; the runtime refuses $transaction({ capture }) on this dialect" });
+    throw unsupportedCapability29({ dialect: dialect.name, feature: "row capture (RETURNING old./new.)", hint: "row capture needs PostgreSQL 18 or later; the runtime refuses $transaction({ capture }) on this dialect" });
   }
   for (const alias of captureAliases({ captures })) {
     if (result.columns.includes(alias) || alias === result.verdict?.alias || alias === result.tally?.alias) {
-      throw internalError4({ message: `chain capture alias "${alias}" collides with a result column` });
+      throw internalError5({ message: `chain capture alias "${alias}" collides with a result column` });
     }
   }
   if (result.rowsFrom.length === 0 && result.columns.length === 0 && result.tally !== undefined && result.verdict === undefined) {
@@ -5564,11 +6213,11 @@ function renderChain(params) {
     return { text: `WITH ${steps.join(", ")} SELECT ${[tally, ...renderChainCaptures({ dialect, captures, defined, collector })].join(", ")}`, values: collector.values, returning: "none" };
   }
   if (result.rowsFrom.length === 0 || result.columns.length === 0) {
-    throw internalError4({ message: "a chain result needs at least one source step and one column" });
+    throw internalError5({ message: "a chain result needs at least one source step and one column" });
   }
   for (const name of result.rowsFrom) {
     if (!defined.has(name))
-      throw internalError4({ message: `chain result reads undefined step "${name}"` });
+      throw internalError5({ message: `chain result reads undefined step "${name}"` });
   }
   const columnList = result.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const guarded = result.verdict !== undefined || result.tally !== undefined || result.veto !== undefined && result.veto.length > 0;
@@ -5579,7 +6228,7 @@ function renderChain(params) {
     const extra = [];
     for (const alias of [result.verdict?.alias, result.tally?.alias]) {
       if (alias !== undefined && result.columns.includes(alias)) {
-        throw internalError4({ message: `chain result alias "${alias}" collides with a result column` });
+        throw internalError5({ message: `chain result alias "${alias}" collides with a result column` });
       }
     }
     const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
@@ -5624,6 +6273,8 @@ function captureAliases(params) {
       if (entry.inserted !== undefined)
         out.push(`${entry.alias}_ia`);
     }
+    for (const index of (entry.cascades ?? []).keys())
+      out.push(`${entry.alias}_c${index}`);
   }
   return out;
 }
@@ -5633,7 +6284,7 @@ function renderChainCaptures(params) {
   const out = [];
   for (const entry of captures) {
     if (!defined.has(entry.step))
-      throw internalError4({ message: `chain capture reads undefined step "${entry.step}"` });
+      throw internalError5({ message: `chain capture reads undefined step "${entry.step}"` });
     const step = quote(entry.step);
     const marker = entry.inserted === undefined ? undefined : quote(entry.inserted);
     out.push(`(SELECT count(*) FROM ${step}) AS ${quote(`${entry.alias}_n`)}`);
@@ -5641,23 +6292,36 @@ function renderChainCaptures(params) {
       out.push(`(SELECT count(*) FROM ${step} WHERE ${marker}) AS ${quote(`${entry.alias}_i`)}`);
     const before = entry.before ?? [];
     const after = entry.after ?? [];
-    if (before.length === 0 && after.length === 0)
-      continue;
-    if (!Number.isSafeInteger(entry.limit) || entry.limit < 1)
-      throw internalError4({ message: `chain capture "${entry.alias}" needs a positive integer limit` });
-    const limit = collector.add(entry.limit);
-    const item = quote("__vibe_i");
-    const image = (columns, filter) => `(SELECT array_agg(${item})::text FROM (SELECT DISTINCT ARRAY[${columns.map(quote).join(", ")}] AS ${item} FROM ${step}${filter} LIMIT ${limit}) AS ${quote("__vibe_d")})`;
-    const updatedRows = marker === undefined ? "" : ` WHERE NOT ${marker}`;
-    if (before.length > 0)
-      out.push(`${image(before, updatedRows)} AS ${quote(`${entry.alias}_b`)}`);
-    if (after.length > 0 && (marker === undefined || entry.insertedOnly !== true))
-      out.push(`${image(after, updatedRows)} AS ${quote(`${entry.alias}_a`)}`);
-    if (after.length > 0 && marker !== undefined)
-      out.push(`${image(after, ` WHERE ${marker}`)} AS ${quote(`${entry.alias}_ia`)}`);
+    out.push(...renderImageAggregates({ dialect, entry, step, marker, before, after, collector }));
+    for (const [index, cascade] of (entry.cascades ?? []).entries()) {
+      const keys = quote("__vibe_k");
+      const child = quote(CAPTURE_CHILD_ALIAS);
+      const match = `EXISTS (SELECT 1 FROM ${step} AS ${keys} WHERE ${cascade.on.map((pair) => `${keys}.${quote(pair.parent)} = ${child}.${quote(pair.child)}`).join(" AND ")})`;
+      out.push(`${renderCascadeImages({ dialect, cascade, match, collector })} AS ${quote(`${entry.alias}_c${index}`)}`);
+    }
   }
   return out;
 }
+function renderImageAggregates(params) {
+  const { dialect, entry, step, marker, before, after, collector } = params;
+  const quote = (name) => dialect.quoteIdent({ name });
+  const out = [];
+  if (before.length === 0 && after.length === 0)
+    return out;
+  if (!Number.isSafeInteger(entry.limit) || entry.limit < 1)
+    throw internalError5({ message: `chain capture "${entry.alias}" needs a positive integer limit` });
+  const limit = collector.add(entry.limit);
+  const item = quote("__vibe_i");
+  const image = (columns, filter) => `(SELECT array_agg(${item})::text FROM (SELECT DISTINCT ARRAY[${columns.map(quote).join(", ")}] AS ${item} FROM ${step}${filter} LIMIT ${limit}) AS ${quote("__vibe_d")})`;
+  const updatedRows = marker === undefined ? "" : ` WHERE NOT ${marker}`;
+  if (before.length > 0)
+    out.push(`${image(before, updatedRows)} AS ${quote(`${entry.alias}_b`)}`);
+  if (after.length > 0 && (marker === undefined || entry.insertedOnly !== true))
+    out.push(`${image(after, updatedRows)} AS ${quote(`${entry.alias}_a`)}`);
+  if (after.length > 0 && marker !== undefined)
+    out.push(`${image(after, ` WHERE ${marker}`)} AS ${quote(`${entry.alias}_ia`)}`);
+  return out;
+}
 function renderSelectCell(params) {
   const { dialect, value, collector } = params;
   if (isJsonParamCell(value))
@@ -5665,21 +6329,21 @@ function renderSelectCell(params) {
   if (isDbNowMarker(value))
     return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
   if (isSqlDefaultCell(value)) {
-    throw internalError4({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
+    throw internalError5({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
   }
   return collector.add(value);
 }
 function renderRowSource(params) {
   const { dialect, source, collector } = params;
   if (source.columns.length === 0 || source.rows.length === 0) {
-    throw internalError4({ message: "a row source needs at least one column and one row" });
+    throw internalError5({ 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 internalError4({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
+      throw internalError5({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
     }
     rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
   }
@@ -5691,12 +6355,12 @@ function renderTallyColumn(params) {
   const { dialect, result, defined, collector } = params;
   const tally = result.tally;
   if (tally === undefined)
-    throw internalError4({ message: "a chain veto needs a tally column to guard" });
+    throw internalError5({ message: "a chain veto needs a tally column to guard" });
   if (tally.steps.length === 0)
-    throw internalError4({ message: "a chain tally needs at least one step" });
+    throw internalError5({ message: "a chain tally needs at least one step" });
   const step = (name) => {
     if (!defined.has(name))
-      throw internalError4({ message: `chain tally or veto reads undefined step "${name}"` });
+      throw internalError5({ message: `chain tally or veto reads undefined step "${name}"` });
     return dialect.quoteIdent({ name });
   };
   const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
@@ -5706,14 +6370,14 @@ function renderTallyColumn(params) {
     return `${sum} AS ${dialect.quoteIdent({ name: tally.alias })}`;
   const arms = vetoes.map((veto) => {
     if (!CHAIN_VETO_TOKEN_PATTERN.test(veto.token))
-      throw internalError4({ message: `chain veto token "${veto.token}" is not a lower-case word` });
+      throw internalError5({ message: `chain veto token "${veto.token}" is not a lower-case word` });
     if (typeof veto.nonce !== "string" || veto.nonce === "")
-      throw internalError4({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
     const minRows = veto.minRows ?? 1;
     if (!Number.isSafeInteger(minRows) || minRows < 1)
-      throw internalError4({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
     if (veto.exactRows !== undefined && (!Number.isSafeInteger(veto.exactRows) || veto.exactRows < 0 || veto.minRows !== undefined)) {
-      throw internalError4({ message: `chain veto "${veto.token}" needs a nonnegative safe integer exactRows without minRows` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a nonnegative safe integer exactRows without minRows` });
     }
     const when = veto.exactRows !== undefined ? `WHEN ${count(veto.step)} <> ${veto.exactRows}` : 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)`;
@@ -5723,25 +6387,25 @@ function renderTallyColumn(params) {
 function renderInsertSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.columns.length === 0)
-    throw internalError4({ message: "insert requires at least one column" });
+    throw internalError5({ message: "insert requires at least one column" });
   if (statement.cells.length !== statement.columns.length) {
-    throw internalError4({
+    throw internalError5({
       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 internalError4({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
+      throw internalError5({ 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 internalError4({ message: `row source alias "${source.alias}" collides with a chain step` });
+    throw internalError5({ 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 internalError4({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
+        throw internalError5({ 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 })}`;
     }
@@ -5760,9 +6424,9 @@ function renderInsertSelect(params) {
   const conflict = statement.conflictDoNothing;
   if (conflict !== undefined) {
     if (conflict.columns.length === 0)
-      throw internalError4({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
+      throw internalError5({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
     if (dialect.doNothingForm !== "onConflictDoNothing") {
-      throw unsupportedCapability28({
+      throw unsupportedCapability29({
         dialect: dialect.name,
         feature: "ON CONFLICT DO NOTHING on an INSERT \u2026 SELECT chain step",
         hint: "gate on SqlDialect.statementChain and keep the multi-statement path"
@@ -5770,10 +6434,10 @@ function renderInsertSelect(params) {
     }
     text += ` ON CONFLICT (${conflict.columns.map((name) => dialect.quoteIdent({ name })).join(", ")}) DO NOTHING`;
   }
-  return text + applyReturning({ dialect, requested: statement.returning }).suffix;
+  return text + applyReturning({ dialect, requested: statement.returning, collector }).suffix;
 }
 // packages/sql/src/dialects/postgres-type-identity.ts
-import { unsupportedCapability as unsupportedCapability29 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability30 } 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*)*)$`);
@@ -5800,13 +6464,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability29({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability30({ 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 unsupportedCapability29({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability30({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -5819,11 +6483,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability30 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability30({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability31({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -5847,28 +6511,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability31({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability32({ 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 unsupportedCapability32 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability33({ 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 unsupportedCapability32({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability33({ 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 unsupportedCapability32({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability33({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
       const parts = tableDefinitionParts({ sql: params.definition, backslashEscapes: true });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
@@ -5914,33 +6578,33 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability35 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
 var MYSQL_NO_ROW_LIMIT = " LIMIT 18446744073709551615";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability34({ 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 unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability34({ 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 renderSqliteColumnInventoryBatch(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   const request = params.dialect.quoteIdent({ name: "vibe_request" });
   return { text: `SELECT j.key AS ${request}, x.name AS name, x.hidden AS hidden, x.pk AS pk, x.dflt_value AS definition FROM json_each(${collector.add(JSON.stringify(params.tables))}) j LEFT JOIN pragma_table_xinfo(j.value, ${collector.add(params.namespace)}) x ORDER BY j.key, x.cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventoryBatch(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   const request = params.dialect.quoteIdent({ name: "vibe_request" });
   return { text: `SELECT j.key AS ${request}, f.id AS id, f.seq AS seq, f."from" AS "from", f."to" AS "to", f."table" AS "table", f.on_update AS on_update, f.on_delete AS on_delete, f.match AS match FROM json_each(${collector.add(JSON.stringify(params.tables))}) j LEFT JOIN pragma_foreign_key_list(j.value, ${collector.add(params.namespace)}) f ORDER BY j.key, f.id, f.seq`, values: collector.values, returning: "none" };
@@ -5953,15 +6617,15 @@ var SQLITE_INTROSPECTION_PRAGMA_ORDER = Object.freeze({
 });
 function renderSqliteIntrospectionPragmaBatch(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteIntrospectionPragmaBatch" });
+    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "sqliteIntrospectionPragmaBatch" });
   const order = SQLITE_INTROSPECTION_PRAGMA_ORDER[params.pragma];
   if (order === undefined)
-    throw unsupportedCapability33({ dialect: "sqlite", feature: `introspectionPragma:${String(params.pragma)}` });
+    throw unsupportedCapability34({ dialect: "sqlite", feature: `introspectionPragma:${String(params.pragma)}` });
   return { text: `SELECT j.key AS ${params.dialect.quoteIdent({ name: "vibe_request" })}, p.* FROM json_each(${params.dialect.quoteStringLiteral({ value: JSON.stringify(params.names) })}) j LEFT JOIN pragma_${params.pragma}(j.value) p ORDER BY j.key, ${order}`, values: [], returning: "none" };
 }
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability34({ 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) {
@@ -6003,13 +6667,13 @@ ORDER BY kind, parent, name${MYSQL_NO_ROW_LIMIT}`, values: collector.values, ret
 // packages/sql/src/dialects/migration-visibility.ts
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability35({ 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${MYSQL_NO_ROW_LIMIT}`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { internalError as internalError5, unsupportedCapability as unsupportedCapability35 } from "@vibeorm/schema";
+import { internalError as internalError6, unsupportedCapability as unsupportedCapability36 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -6017,7 +6681,7 @@ function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
   if (object.kind === "namespace") {
     if (dialect.name !== "postgres")
-      throw unsupportedCapability35({ dialect: dialect.name, feature: "fixedNamespaces" });
+      throw unsupportedCapability36({ 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;
@@ -6065,18 +6729,18 @@ function objectQuery(params) {
     }
   } else if (dialect.name === "mysql") {
     if (object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability35({ dialect: "mysql", feature: "exclusionConstraints" });
+      throw unsupportedCapability36({ dialect: "mysql", feature: "exclusionConstraints" });
     const mysql = mysqlFactsText({ dialect, identity: object, namespace, name, collector });
     if (mysql === undefined)
-      throw unsupportedCapability35({ dialect: "mysql", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability36({ dialect: "mysql", feature: `inspect:${object.kind}` });
     text = mysql;
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability35({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability36({ 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 unsupportedCapability35({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability36({ 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)}`;
@@ -6151,7 +6815,7 @@ function mysqlBatches(params) {
 function renderMysqlObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "mysql")
-    throw unsupportedCapability35({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability36({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const position = dialect.quoteIdent({ name: "vibe_position" });
   const groups = new Map;
   for (const [index, identity] of params.identities.entries()) {
@@ -6171,7 +6835,7 @@ function renderMysqlObjectBatch(params) {
 function renderMysqlObjectMembersBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "mysql")
-    throw unsupportedCapability35({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability36({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const position = dialect.quoteIdent({ name: "vibe_position" });
   const ordinal = dialect.quoteIdent({ name: "vibe_ordinal" });
   const groups = new Map;
@@ -6191,7 +6855,7 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability35({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability36({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const collector = params.collector;
   if (object.kind === "namespace") {
@@ -6248,7 +6912,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability35({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability36({ 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;
@@ -6261,7 +6925,7 @@ function renderMigrationObjectBatch(params) {
     const facts = objectQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
     const dependencies = dependencyQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
     if (JSON.stringify(dependencies.values) !== JSON.stringify(facts.values))
-      throw internalError5({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
+      throw internalError6({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
     const columns = facts.values.map((value, index) => `${dialect.quoteIdent({ name: `p${index + 1}` })} ${Array.isArray(value) ? "text[]" : "text"}`);
     const requests = group.map(({ identity, position }) => ({ position, ...Object.fromEntries(renderMigrationObjectQuery({ dialect, identity }).values.map((value, index) => [`p${index + 1}`, value])) }));
     const collector = new ParamCollector(dialect);
@@ -6281,16 +6945,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability35({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability36({ 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 VibeError24, unsupportedCapability as unsupportedCapability36 } from "@vibeorm/schema";
+import { VibeError as VibeError25, unsupportedCapability as unsupportedCapability37 } 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 unsupportedCapability36({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability37({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -6305,7 +6969,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError24({
+    throw new VibeError25({
       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 }
@@ -6400,34 +7064,45 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
 export {
   ADVISORY_KEY_BOUNDS,
   ADVISORY_LOCK_RESULT_COLUMN,
+  AUTOMATIC_SHADOW_NAME_PATTERN,
   CHAIN_VETO_PREFIX,
   CHAIN_VETO_TOKEN_PATTERN,
+  COALESCE_REF_NAME,
   DIALECT_CAPABILITIES,
   DIALECT_CODECS,
   JSON_TRANSPORT,
   MODULE_JOURNAL_COLUMN,
   MYSQL_CAPABILITIES,
   MYSQL_CODECS,
+  MYSQL_SCALAR_COLUMN_TYPES,
   NATIVE_RLS,
   NATIVE_RLS_PROBE_POLICY,
   POSTGRES_CAPABILITIES,
   POSTGRES_CODECS,
   POSTGRES_DIAGNOSTIC_SQL,
+  POSTGRES_EXACT_EQUIVALENTS,
+  POSTGRES_NATIVE_ALIASES,
+  POSTGRES_SCALAR_COLUMN_TYPES,
   POSTGRES_WORKLOAD_LIMITS,
   ParamCollector,
   RLS_READINESS_SQL,
   SHADOW_CAPABILITIES,
   SHADOW_DATABASE,
+  SHADOW_MARKER_CAPABILITIES,
   SQLITE_CAPABILITIES,
   SQLITE_CODECS,
+  SQLITE_SCALAR_STORAGE_CLASSES,
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
   SQL_KEEP_CELL,
   assertIndexExpressionVersion,
   assertSqlParamBuilding,
+  automaticShadowMarkerText,
+  canonicalColumnType,
   chainVetoToken,
   cloneTimestampDate,
+  coalesceRef,
   compareTimestampDates,
   compileExclusion,
   compileReusableSqlCommand,
@@ -6464,10 +7139,13 @@ export {
   isFixedDiagnostic,
   isJsonListParameter,
   isJsonParamCell,
+  isJsonPatchOperation,
   isListSetOperation,
   isNativeEnumArrayParameter,
+  isOtherRowReturningColumn,
   isReusableSqlCommand,
   isReusableSqlQuery,
+  isRollupChain,
   isSetOperation,
   isSourceColumnRef,
   isSqlBindingCollector,
@@ -6481,17 +7159,22 @@ export {
   isTimeZoneName,
   jsonListParameter,
   jsonParamCell,
+  jsonPatchVetoOf,
   keyListBindsUntypedRows,
   localDateCodec,
   mapConflictColumns,
   mysqlDialect,
   nativeEnumArrayParameter,
+  normalizeMysqlNativeType,
+  normalizePostgresNativeType,
+  parseAutomaticShadowMarker,
   parseDateTimeText,
   parseExtendedDateTimeText,
   parseJsonText,
   parsePgArrayLiteral,
   parsePgArrayLiteralNested,
   parsePostgresTypeName,
+  planJsonPatch,
   postgresArrayElementFromText,
   postgresBulkInsertArrayCastOf,
   postgresDialect,
@@ -6502,6 +7185,7 @@ export {
   registerSqlHandleCheck,
   renderAdvisoryLock,
   renderAdvisoryLocks,
+  renderAutomaticShadowOperation,
   renderCaptureReadiness,
   renderCheckProbe,
   renderColumnStateQuery,
@@ -6609,4 +7293,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=D4C3C7B84AC363A964756E2164756E21
+//# debugId=B21A2ED0EE62B5B964756E2164756E21