@vibeorm/sql 5.0.1 → 5.2.0

package/dist/index.js

@@ -2402,6 +2402,12 @@ var sqliteDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return column;
+  },
+  renderEnumMinMax({ fn, column }) {
+    return `${fn === "min" ? "MIN" : "MAX"}(${column})`;
+  },
   placeholder() {
     return "?";
   },
@@ -3075,6 +3081,12 @@ var postgresDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return column;
+  },
+  renderEnumMinMax({ fn, column }) {
+    return `${fn === "min" ? "MIN" : "MAX"}(${column})`;
+  },
   placeholder({ index }) {
     return `$${index}`;
   },
@@ -3148,6 +3160,15 @@ var mysqlDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return `${column} + 0`;
+  },
+  renderEnumMinMax({ fn, column, result }) {
+    const aggregate = fn === "min" ? "MIN" : "MAX";
+    if (result === "ordinal")
+      return `${aggregate}(${column} + 0)`;
+    return `SUBSTRING(${aggregate}(CONCAT(LPAD(${column} + 0, 5, '0'), ${column})), 6)`;
+  },
   placeholder() {
     return "?";
   },
@@ -3281,17 +3302,53 @@ function renderLocalDateCheck({ dialect, table, column }) {
     expression: `${quoted} IS date(${quoted}) AND (${quoted} IS NULL OR ${quoted} >= ${dialect.quoteStringLiteral({ value: "0001-01-01" })})`
   };
 }
+// packages/sql/src/date-truncation.ts
+import { DATE_TRUNCATION_UNITS, VibeError as VibeError16, internalError as internalError2, unsupportedCapability as unsupportedCapability17 } 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);
+}
+function renderDateTruncation(params) {
+  const { dialect, reference, truncation } = params;
+  if (!dialect.capabilities.dateTruncation) {
+    throw unsupportedCapability17({
+      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)}` });
+  }
+  if (!isTimeZoneName({ value: truncation.timeZone })) {
+    throw new VibeError16({
+      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 }
+    });
+  }
+  const unit = dialect.quoteStringLiteral({ value: truncation.unit });
+  const zone = dialect.quoteStringLiteral({ value: truncation.timeZone });
+  switch (truncation.storage) {
+    case "timestamptz":
+      return `date_trunc(${unit}, ${reference}, ${zone})`;
+    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)}` });
+  }
+}
 // packages/sql/src/generated-columns.ts
-import { VibeError as VibeError16, unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+import { VibeError as VibeError17, unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-generated-columns.ts
-import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 function renderPostgresGeneratedColumnClause({ generated }) {
   return `GENERATED ALWAYS AS (${generated.expression}) STORED`;
 }
 function renderPostgresGeneratedColumnProbe({ dialect, probe }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: dialect.name, feature: "rollbackGeneratedColumnProbe" });
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "rollbackGeneratedColumnProbe" });
   const q = ({ name }) => dialect.quoteIdent({ name });
   let text;
   switch (probe.operation) {
@@ -3312,20 +3369,20 @@ function renderPostgresGeneratedColumnProbe({ dialect, probe }) {
 }
 function renderPostgresDropGeneratedExpression({ dialect, table, column }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: dialect.name, feature: "dropGeneratedExpression" });
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "dropGeneratedExpression" });
   return { text: `ALTER TABLE ${dialect.quoteIdent({ name: table.namespace })}.${dialect.quoteIdent({ name: table.name })} ALTER COLUMN ${dialect.quoteIdent({ name: column })} DROP EXPRESSION`, values: [], returning: "none" };
 }
 
 // packages/sql/src/generated-columns.ts
 function renderGeneratedColumnClause({ dialect, generated }) {
   if (!("generatedColumns" in dialect.capabilities) || dialect.capabilities.generatedColumns !== true) {
-    throw unsupportedCapability18({ dialect: dialect.name, feature: "generatedColumns" });
+    throw unsupportedCapability19({ dialect: dialect.name, feature: "generatedColumns" });
   }
   if (generated.storage !== "stored") {
-    throw unsupportedCapability18({ dialect: dialect.name, feature: "virtualGeneratedColumns" });
+    throw unsupportedCapability19({ dialect: dialect.name, feature: "virtualGeneratedColumns" });
   }
   if (typeof generated.expression !== "string" || generated.expression.trim().length === 0 || generated.expression.includes("\x00")) {
-    throw new VibeError16({ code: "VIBE_SCHEMA_INVALID", message: "A generated column requires non-empty, NUL-free SQL", meta: { reason: "generated-expression-invalid" } });
+    throw new VibeError17({ code: "VIBE_SCHEMA_INVALID", message: "A generated column requires non-empty, NUL-free SQL", meta: { reason: "generated-expression-invalid" } });
   }
   switch (dialect.name) {
     case "postgres":
@@ -3337,10 +3394,10 @@ function renderGeneratedColumnClause({ dialect, generated }) {
   }
 }
 // packages/sql/src/row-rules.ts
-import { VibeError as VibeError20, internalError as internalError2, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
+import { VibeError as VibeError21, internalError as internalError3, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-row-rules.ts
-import { VibeError as VibeError17, unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+import { VibeError as VibeError18, unsupportedCapability as unsupportedCapability20 } 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 ? "[]" : ""}` : "";
@@ -3348,7 +3405,7 @@ function comparison({ dialect, field }) {
 }
 function renderPostgresRowRule({ dialect, context }) {
   if (dialect.name !== "postgres")
-    throw unsupportedCapability19({ dialect: dialect.name, feature: "postgresRowRules" });
+    throw unsupportedCapability20({ 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 });
@@ -3365,7 +3422,7 @@ END;`;
   } else {
     const terms = protectedFields.map((field) => comparison({ dialect, field }));
     if (terms.length === 0) {
-      throw new VibeError17({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+      throw new VibeError18({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
     }
     const condition = gateField === undefined ? terms.join(`
     OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
@@ -3400,19 +3457,19 @@ FOR EACH ROW EXECUTE FUNCTION ${functionName}();`;
 }
 
 // packages/sql/src/dialects/sqlite-row-rules.ts
-import { SQLITE_ROW_RULE_ERROR_PREFIX, VibeError as VibeError18, unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { SQLITE_ROW_RULE_ERROR_PREFIX, VibeError as VibeError19, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 function renderSqliteRowRule({ dialect, context }) {
   if (dialect.name !== "sqlite")
-    throw unsupportedCapability20({ dialect: dialect.name, feature: "sqliteRowRules" });
+    throw unsupportedCapability21({ dialect: dialect.name, feature: "sqliteRowRules" });
   const { rule, table, triggers, protectedFields, gateField } = context;
   if (table.namespace !== "main")
-    throw unsupportedCapability20({ dialect: dialect.name, feature: "fixedNamespaces" });
+    throw unsupportedCapability21({ dialect: dialect.name, feature: "fixedNamespaces" });
   const terms = protectedFields.map((field) => {
     const column = dialect.quoteIdent({ name: field.dbName ?? field.name });
     return `OLD.${column} IS NOT NEW.${column}`;
   });
   if (rule.kind !== "appendOnly" && terms.length === 0)
-    throw new VibeError18({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+    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 = rule.kind === "appendOnly" ? "" : gateField === undefined ? `WHEN ${terms.join(`
   OR `)}
 ` : `WHEN OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
@@ -3437,11 +3494,11 @@ END;`,
 }
 
 // packages/sql/src/dialects/mysql-row-rules.ts
-import { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, VibeError as VibeError19, mysqlRowRuleMessageByteLength, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+import { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, VibeError as VibeError20, mysqlRowRuleMessageByteLength, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 function diagnosticLiteral({ name, context, dialect }) {
   const message = `Check constraint '${name}' is violated.`;
   if (mysqlRowRuleMessageByteLength({ triggerName: name }) > MYSQL_ROW_RULE_MESSAGE_MAX_BYTES)
-    throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${context.rule.name} exceeds MySQL's ${MYSQL_ROW_RULE_MESSAGE_MAX_BYTES}-byte diagnostic limit; supply a shorter name stem`, meta: { model: context.model, rule: context.rule.name } });
+    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 } });
   if (message.includes("\\")) {
     const hex = Array.from(new TextEncoder().encode(message), (byte) => byte.toString(16).padStart(2, "0")).join("");
     return `_utf8mb4 X'${hex}'`;
@@ -3450,11 +3507,11 @@ function diagnosticLiteral({ name, context, dialect }) {
 }
 function renderMysqlRowRule({ dialect, context }) {
   if (dialect.name !== "mysql")
-    throw unsupportedCapability21({ dialect: dialect.name, feature: "mysqlRowRules" });
+    throw unsupportedCapability22({ dialect: dialect.name, feature: "mysqlRowRules" });
   const { rule, table, triggers, protectedFields, gateField, placement } = context;
   for (const name of Object.keys(placement ?? {}))
     if (!triggers.some(({ identity }) => identity.name === name))
-      throw new VibeError19({ code: "VIBE_INTERNAL", message: "A MySQL trigger placement names a trigger this rule does not own", meta: { model: context.model, rule: rule.name, trigger: name } });
+      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 } });
   const position = ({ name }) => {
     const entry = placement?.[name];
     if (entry === undefined)
@@ -3467,7 +3524,7 @@ function renderMysqlRowRule({ dialect, context }) {
     return `NOT (OLD.${column} <=> NEW.${column})`;
   });
   if (rule.kind !== "appendOnly" && terms.length === 0)
-    throw new VibeError19({ code: "VIBE_SCHEMA_INVALID", message: `Row rule ${rule.name} has no protected fields`, meta: { model: context.model, rule: rule.name } });
+    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 = gateField === undefined ? terms.join(`
     OR `) : `OLD.${dialect.quoteIdent({ name: gateField.dbName ?? gateField.name })} IS NOT NULL AND (
     ${terms.join(`
@@ -3496,10 +3553,10 @@ END;`, values: [] };
 function renderRowRule({ schema, model, rule, dialect, placement }) {
   const issue = rowRuleShapeIssue({ value: rule });
   if (issue !== undefined) {
-    throw new VibeError20({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { model: model.name } });
+    throw new VibeError21({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { model: model.name } });
   }
   if (placement !== undefined && Object.keys(placement).length > 0 && dialect.name !== "mysql")
-    throw unsupportedCapability22({ dialect: dialect.name, feature: "rowRuleTriggerPlacement" });
+    throw unsupportedCapability23({ dialect: dialect.name, feature: "rowRuleTriggerPlacement" });
   const normalized = normalizeRowRules({ schema, model, rules: [rule], dialect: dialect.name })[0];
   switch (dialect.name) {
     case "postgres": {
@@ -3507,7 +3564,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 internalError2({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError3({ 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({
@@ -3528,15 +3585,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 internalError2({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
+          throw internalError3({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
         const event = ["update", "delete"].find((event) => identity.name === rowRuleTriggerName({ rule: normalized, event }));
         if (event === undefined)
-          throw internalError2({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
+          throw internalError3({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
         return { event, identity: { kind: "trigger", table: identity.table, name: identity.name } };
       });
       const table = triggers[0]?.identity.table;
       if (table === undefined)
-        throw internalError2({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError3({ 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 = {
@@ -3567,7 +3624,7 @@ function renderSqliteJsonEquality(params) {
 }
 
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
   sqliteTriggers: { dialect: "sqlite", text: "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'trigger'" }
@@ -3575,7 +3632,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability23({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability24({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -3584,7 +3641,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError21, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
+import { VibeError as VibeError22, unsupportedCapability as unsupportedCapability25 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -3619,7 +3676,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability24({
+    throw unsupportedCapability25({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -3637,7 +3694,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 VibeError21({
+      throw new VibeError22({
         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 }
@@ -3656,7 +3713,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError21({
+    throw new VibeError22({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -3666,10 +3723,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability26 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability27 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError22, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability25, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError23, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability26, 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" } },
@@ -3682,18 +3739,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability26({ 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 VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError23({ 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 unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability26({ 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 })}`;
 }
@@ -3734,7 +3791,7 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability25({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
@@ -3742,7 +3799,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 VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError23({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -3775,7 +3832,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError22({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError23({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -3816,7 +3873,7 @@ function renderRlsContext(params) {
 }
 function runtimeRoleOf(params) {
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
-    throw new VibeError22({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError23({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
   return params.role;
 }
@@ -3973,7 +4030,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability26({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability27({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -4005,7 +4062,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError3, unsupportedCapability as unsupportedCapability27 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError4, unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -4091,15 +4148,19 @@ function renderStatement(params) {
 function quoteCol(dialect, column) {
   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.enumOrdinal === true)
+    return dialect.renderEnumOrdinal({ column: ref });
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
-      throw internalError3({ message: "ColRef.castReal is a sqlite Decimal construct" });
+      throw internalError4({ message: "ColRef.castReal is a sqlite Decimal construct" });
     }
     return `CAST(${ref} AS REAL)`;
   }
   if (column.castJsonb !== undefined) {
     if (dialect.name !== "postgres") {
-      throw internalError3({ message: "ColRef.castJsonb is a postgres json construct" });
+      throw internalError4({ message: "ColRef.castJsonb is a postgres json construct" });
     }
     return `${ref}::${column.castJsonb}`;
   }
@@ -4107,7 +4168,7 @@ function quoteCol(dialect, column) {
 }
 function typedOrderRef(params) {
   const { statement, column } = params;
-  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined)
+  if (column.table !== undefined || column.castReal === true || column.castJsonb !== undefined || column.truncate !== 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;
@@ -4116,16 +4177,17 @@ function jsonCellCast(dialect, cell) {
   if (cell.storage !== "json" || dialect.jsonParamCast === "")
     return dialect.jsonParamCast;
   if (dialect.name !== "postgres") {
-    throw internalError3({ message: "JsonParamCell storage json is a postgres construct" });
+    throw internalError4({ message: "JsonParamCell storage json is a postgres construct" });
   }
   return "::text::json";
 }
 function quoteProjection(dialect, column) {
   if (column.transform === undefined) {
     const base = quoteCol(dialect, column);
-    if (column.alias === undefined)
+    const alias = column.alias ?? (column.truncate === undefined ? undefined : column.name);
+    if (alias === undefined)
       return base;
-    return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
+    return `${base} AS ${dialect.quoteIdent({ name: alias })}`;
   }
   if (column.transform === "jsonText") {
     const ref = quoteCol(dialect, column);
@@ -4139,7 +4201,7 @@ function quoteProjection(dialect, column) {
   if (column.transform === "encodeBase64" && dialect.name === "mysql")
     return `TO_BASE64(${ref}) AS ${alias}`;
   if (dialect.name !== "postgres") {
-    throw internalError3({ message: `${column.transform} is a postgres construct` });
+    throw internalError4({ message: `${column.transform} is a postgres construct` });
   }
   if (column.transform === "encodeArrayBase64")
     return `encode(array_send(${ref}), 'base64') AS ${alias}`;
@@ -4163,7 +4225,7 @@ function renderTable(dialect, table) {
 }
 function assertCount(value, what) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw internalError3({ message: `${what} must be a non-negative integer, got ${value}` });
+    throw internalError4({ message: `${what} must be a non-negative integer, got ${value}` });
   }
 }
 var COMPARISON_SQL2 = {
@@ -4190,12 +4252,16 @@ var AGG_FN_SQL = {
 function renderAggRef(dialect, agg) {
   if (agg.fn === "countAll")
     return "COUNT(*)";
-  return `${AGG_FN_SQL[agg.fn]}(${quoteCol(dialect, agg.column)})`;
+  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 });
+  }
+  return `${AGG_FN_SQL[agg.fn]}(${column})`;
 }
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability27({
+  throw unsupportedCapability28({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -4207,7 +4273,7 @@ function renderExpr(params) {
     case "cmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
       }
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
@@ -4218,7 +4284,7 @@ function renderExpr(params) {
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
     }
@@ -4242,11 +4308,11 @@ function renderExpr(params) {
     }
     case "tupleIn": {
       if (expr.columns.length === 0) {
-        throw internalError3({ message: "tupleIn needs at least one column" });
+        throw internalError4({ message: "tupleIn needs at least one column" });
       }
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length) {
-          throw internalError3({
+          throw internalError4({
             message: `tupleIn row has ${row.length} values for ${expr.columns.length} columns`
           });
         }
@@ -4272,7 +4338,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 internalError3({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
+        throw internalError4({ 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));
@@ -4280,9 +4346,9 @@ function renderExpr(params) {
     }
     case "inSelect": {
       if (expr.columns.length === 0)
-        throw internalError3({ message: "inSelect needs at least one column" });
+        throw internalError4({ message: "inSelect needs at least one column" });
       if (dialect.name === "mysql" && (expr.select.limit !== undefined || expr.select.offset !== undefined)) {
-        throw unsupportedCapability27({
+        throw unsupportedCapability28({
           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"
@@ -4353,7 +4419,7 @@ function renderExpr(params) {
     case "aggCmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError3({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${renderAggRef(dialect, expr.agg)} ${op} ${collector.add(expr.value)}`;
     }
@@ -4435,13 +4501,13 @@ function renderKeyList(params) {
   const { dialect, expr, collector } = params;
   const arity = expr.columns.length;
   if (arity === 0)
-    throw internalError3({ message: "keyList needs at least one column" });
+    throw internalError4({ message: "keyList needs at least one column" });
   if (expr.members.length !== arity) {
-    throw internalError3({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
+    throw internalError4({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
   }
   for (const row of expr.rows) {
     if (row.length !== arity)
-      throw internalError3({ message: `keyList row has ${row.length} values for ${arity} columns` });
+      throw internalError4({ message: `keyList row has ${row.length} values for ${arity} columns` });
   }
   if (expr.rows.length === 0)
     return "1 = 0";
@@ -4473,25 +4539,25 @@ function renderKeyPage(params) {
   const { select } = page;
   const arity = page.keyColumns.length;
   if (arity === 0 || page.members.length !== arity) {
-    throw internalError3({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
+    throw internalError4({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
   }
   if (page.rows.length === 0)
-    throw internalError3({ message: "keyPage needs at least one key" });
+    throw internalError4({ message: "keyPage needs at least one key" });
   for (const row of page.rows) {
     if (row.length !== arity)
-      throw internalError3({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
+      throw internalError4({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
   }
   if (page.identity.length === 0)
-    throw internalError3({ message: "keyPage needs the child's identity columns" });
+    throw internalError4({ message: "keyPage needs the child's identity columns" });
   const order = select.orderBy ?? [];
   if (order.length === 0 || order.some((term) => !("column" in term))) {
-    throw internalError3({ message: "keyPage needs a non-empty order of plain column terms" });
+    throw internalError4({ message: "keyPage needs a non-empty order of plain column terms" });
   }
   if (select.table.alias !== undefined || Object.keys(select).some((member) => !KEY_PAGE_SELECT_MEMBERS.has(member))) {
-    throw internalError3({ message: "keyPage select carries a member the per-key page cannot render" });
+    throw internalError4({ message: "keyPage select carries a member the per-key page cannot render" });
   }
   if (dialect.keyPageStrategy === "window") {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       dialect: dialect.name,
       feature: "a per-key page (keyPage)",
       hint: "the runtime keeps the ROW_NUMBER window on this dialect"
@@ -4519,7 +4585,7 @@ function renderKeyPage(params) {
   const keys = dialect.quoteIdent({ name: keyAlias });
   if (dialect.keyPageStrategy === "lateral") {
     if (keyListBindsUntypedRows({ members: page.members })) {
-      throw unsupportedCapability27({
+      throw unsupportedCapability28({
         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"
@@ -4547,22 +4613,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 internalError3({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
+    throw internalError4({ 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 internalError3({ message: "a locking read cannot read from key rows" });
+    throw internalError4({ message: "a locking read cannot read from key rows" });
   const arity = keys.columns.length;
   if (arity === 0 || keys.members.length !== arity) {
-    throw internalError3({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
+    throw internalError4({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
   }
   if (keys.rows.length === 0)
-    throw internalError3({ message: "fromKeys needs at least one key row" });
+    throw internalError4({ message: "fromKeys needs at least one key row" });
   for (const row of keys.rows) {
     if (row.length !== arity)
-      throw internalError3({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
+      throw internalError4({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
   }
   if (dialect.keyListStrategy !== "unnest" || keyListBindsUntypedRows({ members: keys.members })) {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       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"
@@ -4578,20 +4644,20 @@ function renderUnionPage(params) {
   const { dialect, statement, collector } = params;
   const branches = statement.fromUnion ?? [];
   if (branches.length < 2)
-    throw internalError3({ message: "fromUnion needs at least two branches" });
+    throw internalError4({ message: "fromUnion needs at least two branches" });
   if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.table.alias !== undefined) {
-    throw internalError3({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
+    throw internalError4({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
   }
   if (statement.rowLock !== undefined)
-    throw internalError3({ message: "a locking read cannot read from a union page" });
+    throw internalError4({ message: "a locking read cannot read from a union page" });
   const outputNames = (branch) => branch.columns.map((column) => column.alias ?? column.name).join("\x00");
   const names = outputNames(branches[0]);
   return branches.map((branch, index) => {
     if (branch.columns.length === 0 || Object.keys(branch).some((member) => !UNION_BRANCH_MEMBERS.has(member))) {
-      throw internalError3({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
+      throw internalError4({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
     }
     if (outputNames(branch) !== names)
-      throw internalError3({ message: "fromUnion branches must project the same output names in the same order" });
+      throw internalError4({ 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 ");
@@ -4599,7 +4665,7 @@ function renderUnionPage(params) {
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
-    throw internalError3({ message: `json ${expr.op} expects a string operand` });
+    throw internalError4({ message: `json ${expr.op} expects a string operand` });
   }
   if (expr.op === "string_contains")
     return containsPattern({ raw: expr.value });
@@ -4623,7 +4689,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -4690,7 +4756,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 unsupportedCapability27({
+            throw unsupportedCapability28({
               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"
@@ -4704,7 +4770,7 @@ function renderJsonFilter(params) {
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
       default:
-        throw internalError3({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+        throw internalError4({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
     }
   }
   const column = quoteCol(dialect, expr.column);
@@ -4731,23 +4797,20 @@ function renderOrderTerm(params) {
   if ("agg" in term) {
     return `${renderAggRef(dialect, term.agg)} ${term.direction === "asc" ? "ASC" : "DESC"}`;
   }
-  if ("select" in term) {
-    const sub = renderSelect({ dialect, statement: term.select, collector });
-    return `(${sub.text}) ${term.direction === "asc" ? "ASC" : "DESC"}`;
-  }
-  const column = quoteCol(dialect, term.column);
+  const expression = "select" in term ? () => renderScalarSubquery({ dialect, subquery: term, collector }) : () => quoteCol(dialect, term.column);
   const direction = term.direction === "asc" ? "ASC" : "DESC";
   if (term.nulls === undefined) {
-    return `${column} ${direction}`;
+    return `${expression()} ${direction}`;
   }
   if (dialect.orderByNullsMode === "native") {
-    return `${column} ${direction} NULLS ${term.nulls === "first" ? "FIRST" : "LAST"}`;
+    return `${expression()} ${direction} NULLS ${term.nulls === "first" ? "FIRST" : "LAST"}`;
   }
   if (term.nulls === "first" === (term.direction === "asc")) {
-    return `${column} ${direction}`;
+    return `${expression()} ${direction}`;
   }
-  const nullsTerm = term.nulls === "first" ? `${column} IS NULL DESC` : `${column} IS NULL`;
-  return `${nullsTerm}, ${column} ${direction}`;
+  const tested = expression();
+  const nullsTerm = term.nulls === "first" ? `${tested} IS NULL DESC` : `${tested} IS NULL`;
+  return `${nullsTerm}, ${expression()} ${direction}`;
 }
 function renderSelectExpr(params) {
   const { dialect, expr } = params;
@@ -4762,11 +4825,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 internalError3({ message: "positional lateral rows require an explicit column-only projection" });
+    throw internalError4({ 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 internalError3({ message: "positional lateral projection has duplicate output names" });
+    throw internalError4({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
@@ -4774,14 +4837,14 @@ function renderPositionalRow(params) {
     chunks.push(`${json.rowArray}(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
-    throw internalError3({ message: "positional lateral projection exceeds the transport width limit" });
+    throw internalError4({ 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 internalError3({ message: "lateral JSON rendering on a dialect without LATERAL" });
+    throw internalError4({ message: "lateral JSON rendering on a dialect without LATERAL" });
   return json;
 }
 function renderLateralJoin(params) {
@@ -4789,7 +4852,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 internalError3({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
+      throw internalError4({ 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`;
   }
@@ -4798,7 +4861,7 @@ function renderLateralJoin(params) {
   const json = lateralJsonOf({ dialect });
   let aggOrder = "";
   if (json.order === "inAggregate" && join.agg === "jsonArray" && join.select.orderBy !== undefined && join.select.orderBy.length > 0) {
-    const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name));
+    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))) {
@@ -4814,7 +4877,7 @@ function renderLateralJoin(params) {
     }
   }
   if (join.rowFormat !== "positional" && json.order !== "inAggregate") {
-    throw unsupportedCapability27({ dialect: dialect.name, feature: "object-format lateral rows", hint: 'lateral relation rows render positional (rowFormat "positional") on this dialect' });
+    throw unsupportedCapability28({ 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}`;
@@ -4824,12 +4887,17 @@ function renderLateralJoin(params) {
 function renderCountSubquery(params) {
   const { dialect, subquery, collector } = params;
   const select = subquery.select;
-  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
-    throw internalError3({ message: "count subquery must be one ungrouped COUNT(*)" });
+  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined || select.scalarSubqueries !== undefined) {
+    throw internalError4({ message: "count subquery must be one ungrouped COUNT(*)" });
   }
   const inner = renderSelect({ dialect, statement: select, collector });
   return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
 }
+function renderScalarSubquery(params) {
+  const { dialect, subquery, collector } = params;
+  const value = `(${renderSelect({ dialect, statement: subquery.select, collector }).text})`;
+  return subquery.coalesce === 0 ? `COALESCE(${value}, 0)` : value;
+}
 function applyReturning(params) {
   const { dialect, requested } = params;
   if (requested === undefined || requested.length === 0) {
@@ -4855,27 +4923,27 @@ function renderKeyTableJoin(params) {
   const postgresMember = (member) => member.kind === "citext" || member.kind === "text" || member.kind === "integer";
   const admitted = dialect.name === "mysql" ? join.members.every((member) => member.kind !== "citext" && member.kind !== "text") : dialect.name === "postgres" && join.members.every(postgresMember);
   if (!admitted) {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       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 internalError3({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+    throw internalError4({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
   }
   if (join.rows.length === 0)
-    throw internalError3({ message: "key table needs at least one key row" });
+    throw internalError4({ 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 internalError3({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+      throw internalError4({ 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 internalError3({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+      throw internalError4({ message: `key table row has ${row.length} values for ${join.members.length} members` });
     }
     const cells = row.map((value, index) => {
       const placeholder = collector.add(value);
@@ -4905,10 +4973,10 @@ function renderKeyTableJoin(params) {
 function renderLeftJoin(params) {
   const { dialect, join, collector } = params;
   if (join.on.length === 0) {
-    throw internalError3({ message: "left join needs at least one ON pair" });
+    throw internalError4({ message: "left join needs at least one ON pair" });
   }
   if (join.select.columns.length === 0 || join.select.columns.some((column) => column.alias === undefined)) {
-    throw internalError3({ message: "a left join's derived select must alias every projected column" });
+    throw internalError4({ 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 ");
@@ -4917,10 +4985,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 internalError3({ message: "only countAll can combine with a column list" });
+    throw internalError4({ message: "only countAll can combine with a column list" });
   }
   if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
-    throw internalError3({ message: "selectExpr and aggregates cannot combine" });
+    throw internalError4({ message: "selectExpr and aggregates cannot combine" });
   }
   const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
   if (statement.selectExpr !== undefined) {
@@ -4938,10 +5006,15 @@ function renderSelect(params) {
       columnList.push(renderCountSubquery({ dialect, subquery, collector }));
     }
   }
+  if (statement.scalarSubqueries !== undefined) {
+    for (const subquery of statement.scalarSubqueries) {
+      columnList.push(`${renderScalarSubquery({ dialect, subquery, collector })} AS ${dialect.quoteIdent({ name: subquery.alias })}`);
+    }
+  }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0 && rowNumber.orderBy.length === 0) {
-      throw internalError3({ message: "rowNumber needs a partition column or an order" });
+      throw internalError4({ 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(", ")}`;
@@ -4949,11 +5022,11 @@ function renderSelect(params) {
   }
   let distinctPrefix = statement.distinct === true ? "DISTINCT " : "";
   if (statement.distinct === true && statement.distinctOn !== undefined) {
-    throw internalError3({ message: "distinct and distinctOn cannot combine" });
+    throw internalError4({ message: "distinct and distinctOn cannot combine" });
   }
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability27({
+      throw unsupportedCapability28({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -4969,12 +5042,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 internalError3({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
+      throw internalError4({ 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 internalError3({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+      throw internalError4({ 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 })}`;
@@ -4985,7 +5058,7 @@ function renderSelect(params) {
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
       if (join.on.length === 0) {
-        throw internalError3({ message: "inner join needs at least one ON pair" });
+        throw internalError4({ 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}`;
@@ -4996,7 +5069,7 @@ function renderSelect(params) {
   }
   if (statement.leftJoins !== undefined && statement.leftJoins.length > 0) {
     if (statement.rowLock !== undefined) {
-      throw internalError3({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
+      throw internalError4({ 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 })}`;
@@ -5004,7 +5077,7 @@ function renderSelect(params) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin || dialect.lateralJson === null) {
-      throw unsupportedCapability27({
+      throw unsupportedCapability28({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -5053,7 +5126,7 @@ function unnestElement(params) {
     return null;
   if (isJsonParamCell(value)) {
     if (jsonStorage === undefined || (value.storage ?? "jsonb") !== jsonStorage) {
-      throw internalError3({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
+      throw internalError4({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
     }
     return value.text;
   }
@@ -5069,24 +5142,24 @@ function unnestElement(params) {
           return value;
     }
   }
-  throw internalError3({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
+  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` });
 }
 function renderUnnestRows(params) {
   const { dialect, statement, members, collector } = params;
   if (dialect.bulkInsertForm !== "unnest") {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       dialect: dialect.name,
       feature: "a bulk insert bound as typed arrays (INSERT \u2026 SELECT FROM unnest)",
       hint: "this dialect binds createMany rows as VALUES"
     });
   }
   if (statement.columns.length === 0)
-    throw internalError3({ message: "an unnest insert needs at least one column" });
+    throw internalError4({ message: "an unnest insert needs at least one column" });
   if (members.length !== statement.columns.length) {
-    throw internalError3({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
+    throw internalError4({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
   }
   if (statement.onConflict !== undefined && !("doNothing" in statement.onConflict)) {
-    throw internalError3({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
+    throw internalError4({ 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) => {
@@ -5102,14 +5175,14 @@ function renderUnnestRows(params) {
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
   if (statement.rows.length === 0) {
-    throw internalError3({ message: "insert requires at least one row" });
+    throw internalError4({ message: "insert requires at least one row" });
   }
   const defaultValues = statement.columns.length === 0 && dialect.emptyInsert.form === "defaultValues";
   if (defaultValues && statement.rows.length !== 1) {
-    throw internalError3({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
+    throw internalError4({ 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 unsupportedCapability27({
+    throw unsupportedCapability28({
       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"
@@ -5117,7 +5190,7 @@ function renderInsert(params) {
   }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
-      throw internalError3({
+      throw internalError4({
         message: `insert row has ${row.length} values but ${statement.columns.length} columns`
       });
     }
@@ -5135,7 +5208,7 @@ function renderInsert(params) {
     if (!isSqlDefaultCell(value))
       return collector.add(value);
     if (!dialect.rowDefaultKeyword) {
-      throw internalError3({
+      throw internalError4({
         message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
       });
     }
@@ -5151,7 +5224,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability27({
+            throw unsupportedCapability28({
               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"
@@ -5167,7 +5240,7 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else {
         if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-          throw unsupportedCapability27({
+          throw unsupportedCapability28({
             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"
@@ -5175,52 +5248,69 @@ function renderInsert(params) {
         }
         const keepName = onConflict.keepColumn ?? statement.columns[0];
         if (keepName === undefined) {
-          throw internalError3({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
+          throw internalError4({ 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 internalError3({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
+          throw internalError4({ 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 internalError3({ message: "upsert update must set at least one column" });
+        throw internalError4({ 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 internalError3({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+          throw internalError4({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability27({
+          throw unsupportedCapability28({
             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 internalError3({
+          throw internalError4({
             message: "a named-constraint conflict target already identifies the index \u2014 it cannot carry a partial predicate too"
           });
         }
         const partial = onConflict.conflictWhere === undefined ? "" : ` WHERE ${onConflict.conflictWhere}`;
         const target = onConflict.constraint !== undefined ? ` ON CONSTRAINT ${dialect.quoteIdent({ name: onConflict.constraint })}` : ` (${onConflict.columns.map((name) => dialect.quoteIdent({ name })).join(", ")})${partial}`;
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
+        if (onConflict.updateWhere !== undefined) {
+          if (!dialect.capabilities.conflictUpdateWhere) {
+            throw unsupportedCapability28({
+              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"
+            });
+          }
+          text += ` WHERE ${renderExpr({ dialect, expr: onConflict.updateWhere, collector })}`;
+        }
       } else {
+        if (onConflict.updateWhere !== undefined) {
+          throw unsupportedCapability28({
+            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 unsupportedCapability27({
+          throw unsupportedCapability28({
             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 unsupportedCapability27({
+          throw unsupportedCapability28({
             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"
@@ -5238,7 +5328,7 @@ function renderUpdate(params) {
   const { dialect, statement, collector } = params;
   const assignments = Object.entries(statement.set);
   if (assignments.length === 0) {
-    throw internalError3({ message: "update must set at least one column" });
+    throw internalError4({ message: "update must set at least one column" });
   }
   const setSql = renderAssignments({ dialect, entries: assignments, collector, ...params.earlier === undefined ? {} : { steps: params.earlier } });
   let text = `UPDATE ${renderTable(dialect, statement.table)} SET ${setSql}`;
@@ -5261,18 +5351,18 @@ function renderAssignments(params) {
     const read = selfRef === undefined ? column : `${selfRef}.${column}`;
     if (isStepColumnRef(value)) {
       if (params.steps === undefined || !params.steps.has(value.step)) {
-        throw internalError3({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
+        throw internalError4({ 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 internalError3({ message: "SQL assignment fragments require a conflict update" });
+        throw internalError4({ 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 internalError3({
+        throw internalError4({
           message: `an incoming-row reference (${value.column}) is only meaningful inside an upsert's update arm`
         });
       }
@@ -5280,7 +5370,7 @@ function renderAssignments(params) {
     }
     if (isSqlKeepCell(value)) {
       if (params.allowExcluded !== true || selfRef === undefined)
-        throw internalError3({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
+        throw internalError4({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
       return `${column} = ${read}`;
     }
     if (isJsonParamCell(value)) {
@@ -5318,19 +5408,19 @@ var CHAIN_ONE_ALIAS = "__vibe_one";
 function renderChain(params) {
   const { dialect, statement, collector } = params;
   if (dialect.statementChain === null) {
-    throw unsupportedCapability27({
+    throw unsupportedCapability28({
       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 internalError3({ message: "a statement chain needs at least one step" });
+    throw internalError4({ 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 internalError3({ message: `chain step name "${step.name}" is reserved or repeated` });
+      throw internalError4({ 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})`);
@@ -5338,11 +5428,11 @@ function renderChain(params) {
   }
   const result = statement.result;
   if (result.rowsFrom.length === 0 || result.columns.length === 0) {
-    throw internalError3({ message: "a chain result needs at least one source step and one column" });
+    throw internalError4({ message: "a chain result needs at least one source step and one column" });
   }
   for (const name of result.rowsFrom) {
     if (!defined.has(name))
-      throw internalError3({ message: `chain result reads undefined step "${name}"` });
+      throw internalError4({ message: `chain result reads undefined step "${name}"` });
   }
   const columnList = result.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const union = result.rowsFrom.map((name) => `SELECT ${columnList} FROM ${dialect.quoteIdent({ name })}`).join(" UNION ALL ");
@@ -5351,7 +5441,7 @@ function renderChain(params) {
     const extra = [];
     for (const alias of [result.verdict?.alias, result.tally?.alias]) {
       if (alias !== undefined && result.columns.includes(alias)) {
-        throw internalError3({ message: `chain result alias "${alias}" collides with a result column` });
+        throw internalError4({ message: `chain result alias "${alias}" collides with a result column` });
       }
     }
     const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
@@ -5388,21 +5478,21 @@ function renderSelectCell(params) {
   if (isDbNowMarker(value))
     return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
   if (isSqlDefaultCell(value)) {
-    throw internalError3({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
+    throw internalError4({ 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 internalError3({ message: "a row source needs at least one column and one row" });
+    throw internalError4({ 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 internalError3({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
+      throw internalError4({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
     }
     rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
   }
@@ -5414,12 +5504,12 @@ function renderTallyColumn(params) {
   const { dialect, result, defined, collector } = params;
   const tally = result.tally;
   if (tally === undefined)
-    throw internalError3({ message: "a chain veto needs a tally column to guard" });
+    throw internalError4({ message: "a chain veto needs a tally column to guard" });
   if (tally.steps.length === 0)
-    throw internalError3({ message: "a chain tally needs at least one step" });
+    throw internalError4({ message: "a chain tally needs at least one step" });
   const step = (name) => {
     if (!defined.has(name))
-      throw internalError3({ message: `chain tally or veto reads undefined step "${name}"` });
+      throw internalError4({ message: `chain tally or veto reads undefined step "${name}"` });
     return dialect.quoteIdent({ name });
   };
   const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
@@ -5429,12 +5519,12 @@ function renderTallyColumn(params) {
     return `${sum} AS ${dialect.quoteIdent({ name: tally.alias })}`;
   const arms = vetoes.map((veto) => {
     if (!CHAIN_VETO_TOKEN_PATTERN.test(veto.token))
-      throw internalError3({ message: `chain veto token "${veto.token}" is not a lower-case word` });
+      throw internalError4({ message: `chain veto token "${veto.token}" is not a lower-case word` });
     if (typeof veto.nonce !== "string" || veto.nonce === "")
-      throw internalError3({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
+      throw internalError4({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
     const minRows = veto.minRows ?? 1;
     if (!Number.isSafeInteger(minRows) || minRows < 1)
-      throw internalError3({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
+      throw internalError4({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
     const when = minRows === 1 ? `WHEN NOT EXISTS (SELECT 1 FROM ${step(veto.step)})` : `WHEN ${count(veto.step)} < ${minRows}`;
     return `${when} THEN CAST('${CHAIN_VETO_PREFIX}${veto.token}:' || ${collector.add(veto.nonce)} || ':' || ${count(veto.step)} AS integer)`;
   });
@@ -5443,25 +5533,25 @@ function renderTallyColumn(params) {
 function renderInsertSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.columns.length === 0)
-    throw internalError3({ message: "insert requires at least one column" });
+    throw internalError4({ message: "insert requires at least one column" });
   if (statement.cells.length !== statement.columns.length) {
-    throw internalError3({
+    throw internalError4({
       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 internalError3({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
+      throw internalError4({ 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 internalError3({ message: `row source alias "${source.alias}" collides with a chain step` });
+    throw internalError4({ 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 internalError3({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
+        throw internalError4({ 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 })}`;
     }
@@ -5480,9 +5570,9 @@ function renderInsertSelect(params) {
   const conflict = statement.conflictDoNothing;
   if (conflict !== undefined) {
     if (conflict.columns.length === 0)
-      throw internalError3({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
+      throw internalError4({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
     if (dialect.doNothingForm !== "onConflictDoNothing") {
-      throw unsupportedCapability27({
+      throw unsupportedCapability28({
         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"
@@ -5493,7 +5583,7 @@ function renderInsertSelect(params) {
   return text + applyReturning({ dialect, requested: statement.returning }).suffix;
 }
 // packages/sql/src/dialects/postgres-type-identity.ts
-import { unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability29 } 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*)*)$`);
@@ -5520,13 +5610,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability28({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability29({ 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 unsupportedCapability28({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability29({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -5539,11 +5629,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability29 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability30 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability29({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability30({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -5567,28 +5657,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability30 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability30({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability31({ 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 unsupportedCapability31 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability31({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability32({ 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 unsupportedCapability31({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability32({ 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 unsupportedCapability31({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability32({ 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(`,
@@ -5634,33 +5724,33 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
 var MYSQL_NO_ROW_LIMIT = " LIMIT 18446744073709551615";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
 function renderSqliteColumnInventoryBatch(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability33({ 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 unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability33({ 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" };
@@ -5673,15 +5763,15 @@ var SQLITE_INTROSPECTION_PRAGMA_ORDER = Object.freeze({
 });
 function renderSqliteIntrospectionPragmaBatch(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteIntrospectionPragmaBatch" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteIntrospectionPragmaBatch" });
   const order = SQLITE_INTROSPECTION_PRAGMA_ORDER[params.pragma];
   if (order === undefined)
-    throw unsupportedCapability32({ dialect: "sqlite", feature: `introspectionPragma:${String(params.pragma)}` });
+    throw unsupportedCapability33({ 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 unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -5723,13 +5813,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 unsupportedCapability33({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability34({ 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 internalError4, unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
+import { internalError as internalError5, unsupportedCapability as unsupportedCapability35 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -5737,7 +5827,7 @@ function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
   if (object.kind === "namespace") {
     if (dialect.name !== "postgres")
-      throw unsupportedCapability34({ dialect: dialect.name, feature: "fixedNamespaces" });
+      throw unsupportedCapability35({ 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;
@@ -5785,18 +5875,18 @@ function objectQuery(params) {
     }
   } else if (dialect.name === "mysql") {
     if (object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability34({ dialect: "mysql", feature: "exclusionConstraints" });
+      throw unsupportedCapability35({ dialect: "mysql", feature: "exclusionConstraints" });
     const mysql = mysqlFactsText({ dialect, identity: object, namespace, name, collector });
     if (mysql === undefined)
-      throw unsupportedCapability34({ dialect: "mysql", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability35({ dialect: "mysql", feature: `inspect:${object.kind}` });
     text = mysql;
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability34({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability35({ 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 unsupportedCapability34({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability35({ 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)}`;
@@ -5871,7 +5961,7 @@ function mysqlBatches(params) {
 function renderMysqlObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "mysql")
-    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability35({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const position = dialect.quoteIdent({ name: "vibe_position" });
   const groups = new Map;
   for (const [index, identity] of params.identities.entries()) {
@@ -5891,7 +5981,7 @@ function renderMysqlObjectBatch(params) {
 function renderMysqlObjectMembersBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "mysql")
-    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability35({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const position = dialect.quoteIdent({ name: "vibe_position" });
   const ordinal = dialect.quoteIdent({ name: "vibe_ordinal" });
   const groups = new Map;
@@ -5911,7 +6001,7 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability35({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const collector = params.collector;
   if (object.kind === "namespace") {
@@ -5968,7 +6058,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability35({ 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;
@@ -5981,7 +6071,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 internalError4({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
+      throw internalError5({ 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);
@@ -6001,16 +6091,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability34({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability35({ 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 VibeError23, unsupportedCapability as unsupportedCapability35 } from "@vibeorm/schema";
+import { VibeError as VibeError24, unsupportedCapability as unsupportedCapability36 } 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 unsupportedCapability35({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability36({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -6025,7 +6115,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError23({
+    throw new VibeError24({
       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 }
@@ -6196,6 +6286,7 @@ export {
   isSqlParam,
   isSqlQuery,
   isStepColumnRef,
+  isTimeZoneName,
   jsonListParameter,
   jsonParamCell,
   keyListBindsUntypedRows,
@@ -6222,6 +6313,7 @@ export {
   renderColumnStateQuery,
   renderConstraintOwnedIndexDrop,
   renderConstraintStateQuery,
+  renderDateTruncation,
   renderDiagnostic,
   renderExclusionCatalog,
   renderExclusionDdl,
@@ -6322,4 +6414,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=F22851A5DD4820AE64756E2164756E21
+//# debugId=7A09C0BE2E07A46664756E2164756E21