@vibeorm/migrate 2.6.0 → 3.0.0

package/dist/fs.js

@@ -15,16 +15,12 @@ function hasMysqlGlobalCatalogVisibility(params) {
 }
 
 // packages/migrate/src/module-ownership.ts
-import { VibeError as VibeError18, sqlObjectKey as sqlObjectKey7, sqlObjectNamespace as sqlObjectNamespace3 } from "@vibeorm/schema";
+import { VibeError as VibeError19, sqlObjectKey as sqlObjectKey7, sqlObjectNamespace as sqlObjectNamespace3 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect4, renderModuleDependencyQuery } from "@vibeorm/sql";
 
 // packages/migrate/src/desired-state.ts
 import { VibeError, assertValidSchemaIR, isSqlObjectDefinition, isSqlObjectIdentity, providerToDialect, sqlObjectKey } from "@vibeorm/schema";
 var UNFINALIZED_DESIRED_STATE = Object.freeze({ version: 1, status: "unfinalized" });
-function isUnfinalizedDesiredState(params) {
-  const value = JSON.parse(params.text);
-  return record(value) && value.version === 1 && value.status === "unfinalized" && Object.keys(value).length === 2;
-}
 var DESIRED_STATE_METADATA = Object.freeze({ filename: "desired-state.json", version: 1 });
 function createDesiredState(params) {
   assertValidSchemaIR({ schema: params.schema });
@@ -107,6 +103,15 @@ function parseDesiredStateSidecar(params) {
     return checked.value;
   }, failure: (cause) => invalid({ migration: params.migration, detail: "malformed metadata", cause }) });
 }
+function loadDesiredStateSidecar(params) {
+  return parseMigrationMetadata({ text: params.text, parse: (value) => {
+    if (record(value) && value.version === 1 && value.status === "unfinalized" && Object.keys(value).length === 2)
+      return { desiredStatePending: true };
+    const checked = { value, migration: params.migration };
+    assertDesiredState(checked);
+    return { desiredState: checked.value };
+  }, failure: (cause) => invalid({ migration: params.migration, detail: "malformed metadata", cause }) });
+}
 function parseMigrationMetadata(params) {
   try {
     return params.parse(JSON.parse(params.text));
@@ -172,6 +177,9 @@ var SCALAR_TO_PG = {
 var CANONICAL_EQUIVALENTS = {
   DateTime: ["timestamptz(3)", "timestamptz(6)"]
 };
+var EXACT_CANONICAL_EQUIVALENTS = {
+  DateTime: ["timestamptz(6)"]
+};
 var CANONICAL_UDT = {
   text: "String",
   bool: "Boolean",
@@ -240,13 +248,15 @@ var NATIVE_ALIASES = {
 var IMPLICIT_MODIFIERS = {
   bit: "(1)"
 };
+var DEFAULT_PRECISION_SIX = new Set(["timestamp", "time", "timetz"]);
 function normalizeNativeType(params) {
   const compact = params.raw.toLowerCase().replace(/\s+/g, "");
   const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(\[\])?$/);
   if (match === null)
     return compact;
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
-  return `${base}${match[2] ?? IMPLICIT_MODIFIERS[base] ?? ""}${match[3] ?? ""}`;
+  const modifier = DEFAULT_PRECISION_SIX.has(base) && match[2] === "(6)" ? "" : match[2] ?? IMPLICIT_MODIFIERS[base] ?? "";
+  return `${base}${modifier}${match[3] ?? ""}`;
 }
 function parseUnsupportedPostgresType(params) {
   const temporal = /^\s*(time(?:stamp)?)\s*(\(\s*\d+\s*\))?\s+(with|without)\s+time\s+zone\s*((?:\[\s*\]\s*)*)$/i.exec(params.raw);
@@ -259,7 +269,7 @@ function parseUnsupportedPostgresType(params) {
   return NATIVE_ALIASES[base] === undefined ? undefined : parsePostgresTypeName({ raw: normalizeNativeType(params) });
 }
 function columnTypeKey(params) {
-  const { field } = params;
+  const { field, exact } = params;
   const listSuffix = field.isList ? "[]" : "";
   if (field.isUnsupported === true) {
     const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
@@ -270,7 +280,7 @@ function columnTypeKey(params) {
     const scalar = namespace === undefined || namespace === "pg_catalog" ? scalarForBuiltinType({ name: parsed.name }) : undefined;
     if (scalar !== undefined) {
       const { isUnsupported: _unsupported, nativeTypeIdentity: _identity, ...rest } = field;
-      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList } });
+      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList }, ...exact === undefined ? {} : { exact } });
     }
     return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
@@ -281,12 +291,37 @@ function columnTypeKey(params) {
   if (field.nativeType !== undefined) {
     const normalized = normalizeNativeType({ raw: field.nativeType });
     const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
-    const isCanonical = normalized === canonical || (CANONICAL_EQUIVALENTS[field.type]?.includes(normalized) ?? false);
+    const equivalents = exact === true ? EXACT_CANONICAL_EQUIVALENTS : CANONICAL_EQUIVALENTS;
+    const isCanonical = normalized === canonical || (equivalents[field.type]?.includes(normalized) ?? false);
     if (!isCanonical)
       return `n:${normalized}${listSuffix}`;
   }
   return `s:${field.type}${listSuffix}`;
 }
+function declaresExactColumnType(params) {
+  const { field } = params;
+  if (field.isUnsupported === true || field.nativeType === undefined || isEnumType(field.type))
+    return false;
+  return CANONICAL_EQUIVALENTS[field.type]?.includes(normalizeNativeType({ raw: field.nativeType })) ?? false;
+}
+function timestamptzPrecision(params) {
+  const { field } = params;
+  if (field.type !== "DateTime" || field.isUnsupported === true)
+    return;
+  const normalized = field.nativeType === undefined ? "timestamptz" : normalizeNativeType({ raw: field.nativeType });
+  if (normalized === "timestamptz")
+    return 6;
+  const match = /^timestamptz\((\d)\)$/.exec(normalized);
+  return match === null ? undefined : Number(match[1]);
+}
+function isTimestamptzPrecisionWidening(params) {
+  const { from, to } = params;
+  if (from.isList !== to.isList)
+    return false;
+  const before = timestamptzPrecision({ field: from });
+  const after = timestamptzPrecision({ field: to });
+  return before !== undefined && after !== undefined && after >= before;
+}
 function isScalarToArrayChange(params) {
   const { from, to } = params;
   if (from.isList || !to.isList)
@@ -751,6 +786,32 @@ function parseMysqlEnumColumnType(params) {
 }
 
 // packages/migrate/src/normalize.ts
+function firstByName(params) {
+  const result = new Map;
+  for (const entry of params.entries)
+    if (!result.has(entry.name))
+      result.set(entry.name, entry);
+  return result;
+}
+function normalizationLookup(params) {
+  const enums = new Map;
+  const scopedEnums = new Map;
+  for (const entry of params.schema.enums) {
+    const namespace = qualifiedSqlName3({ name: entry.name, namespace: entry.namespace }).namespace;
+    for (const name of new Set([entry.name, entry.dbName ?? entry.name])) {
+      if (!enums.has(name))
+        enums.set(name, entry);
+      const key = JSON.stringify([namespace, name]);
+      if (!scopedEnums.has(key))
+        scopedEnums.set(key, entry);
+    }
+  }
+  return { models: firstByName({ entries: params.schema.models }), fields: new Map(params.schema.models.map((model) => [model, firstByName({ entries: model.fields })])), enums, scopedEnums };
+}
+function lookupFieldName(params) {
+  const field = params.lookup.fields.get(params.model)?.get(params.name);
+  return field?.dbName ?? field?.name ?? params.name;
+}
 function normalizeSchema(params) {
   const { schema } = params;
   const dialect = params.dialect ?? "postgres";
@@ -763,6 +824,7 @@ function normalizeSchema(params) {
       continue;
     enums.set(physicalNameKey({ name: enumDef.dbName ?? enumDef.name, namespace: enumDef.namespace, dialect }), enumDef);
   }
+  const lookup = normalizationLookup({ schema });
   const tables = new Map;
   const views = new Map;
   for (const model of schema.models) {
@@ -772,25 +834,25 @@ function normalizeSchema(params) {
       views.set(physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect }), model);
       continue;
     }
-    const table = normalizeModel({ model, schema, dialect, enums });
+    const table = normalizeModel({ model, lookup, dialect, enums });
     tables.set(physicalNameKey({ name: table.table, namespace: table.namespace, dialect }), table);
   }
   const joinTables = new Map;
   for (const pair of detectImplicitM2MPairs({ schema })) {
-    const join = normalizeJoinTable({ pair, schema, dialect });
+    const join = normalizeJoinTable({ pair, lookup, dialect });
     joinTables.set(physicalNameKey({ name: join.table, namespace: join.namespace, dialect }), join);
   }
   return { tables, joinTables, enums, views };
 }
 function physicalEnumField(params) {
-  const { field, schema, dialect, table } = params;
+  const { field, lookup, dialect, table } = params;
   if (!isEnumType5(field.type))
     return field;
   const type = field.type;
   if (type.namespace !== undefined)
     assertSqlNamespace({ namespace: type.namespace, dialect });
   const name = type.enum;
-  const enumDef = schema.enums.find((candidate) => (candidate.name === name || candidate.dbName === name) && (type.namespace === undefined || qualifiedSqlName3({ name, namespace: candidate.namespace }).namespace === type.namespace));
+  const enumDef = type.namespace === undefined ? lookup.enums.get(name) : lookup.scopedEnums.get(JSON.stringify([type.namespace, name]));
   if (enumDef === undefined)
     return field;
   if (enumStorageOf({ enumDef }) !== "string") {
@@ -829,16 +891,20 @@ function assertStringEnumLabelsFit(params) {
   }
 }
 function columnTypeKeyFor(params) {
-  const { field, dialect, enums } = params;
+  const { field, dialect, enums, exact } = params;
   switch (dialect) {
     case "postgres":
-      return columnTypeKey({ field });
+      return columnTypeKey({ field, ...exact === undefined ? {} : { exact } });
     case "sqlite":
       return sqliteColumnTypeKey({ field, enums });
     case "mysql":
       return mysqlColumnTypeKey({ field, enums });
   }
 }
+function columnTypeChanged(params) {
+  const { declared, actual } = params;
+  return declared.pinsExactType ? declared.exactTypeKey !== actual.exactTypeKey : declared.typeKey !== actual.typeKey;
+}
 function defaultFingerprintFor(params) {
   const { field, dialect } = params;
   switch (dialect) {
@@ -851,46 +917,49 @@ function defaultFingerprintFor(params) {
   }
 }
 function normalizeModel(params) {
-  const { model, schema, dialect, enums } = params;
+  const { model, lookup, dialect, enums } = params;
   const table = model.dbName ?? model.name;
   const columns = new Map;
   for (const logicalField of model.fields) {
-    const field = physicalEnumField({ field: logicalField, schema, dialect, table });
+    const field = physicalEnumField({ field: logicalField, lookup, dialect, table });
     const name = field.dbName ?? field.name;
+    const typeKey = columnTypeKeyFor({ field, dialect, enums });
     columns.set(name, {
       name,
       field,
-      typeKey: columnTypeKeyFor({ field, dialect, enums }),
+      typeKey,
+      exactTypeKey: dialect === "postgres" ? columnTypeKeyFor({ field, dialect, enums, exact: true }) : typeKey,
+      pinsExactType: dialect === "postgres" && declaresExactColumnType({ field }),
       nullable: field.isOptional,
       defaultKey: defaultFingerprintFor({ field, dialect })
     });
   }
-  const pk = normalizePk({ model });
-  const indexes = normalizeIndexes({ model, table, dialect });
-  const fks = normalizeFks({ model, table, schema, dialect });
+  const pk = normalizePk({ model, lookup });
+  const indexes = normalizeIndexes({ model, table, dialect, lookup });
+  const fks = normalizeFks({ model, table, lookup, dialect });
   const checks = new Map;
   for (const check of model.checks ?? [])
     checks.set(check.name, check.expression);
   return { model, table, ...model.namespace === undefined ? {} : { namespace: model.namespace }, columns, pk, indexes, fks, checks };
 }
 function normalizePk(params) {
-  const { model } = params;
+  const { model, lookup } = params;
   if (model.primaryKey !== undefined && model.primaryKey.fields.length > 0) {
-    return model.primaryKey.fields.map((name) => fieldDbName({ model, name }));
+    return model.primaryKey.fields.map((name) => lookupFieldName({ lookup, model, name }));
   }
   return model.fields.filter((field) => field.isId).map((field) => field.dbName ?? field.name);
 }
 function normalizeIndexes(params) {
-  const { model, table, dialect } = params;
+  const { model, table, dialect, lookup } = params;
   const result = new Map;
   const add = (index) => {
     const unique = index.kind === "unique";
     const kind = unique ? "btree" : index.kind;
     const columns = index.fields.map((field) => {
-      const fieldIR = model.fields.find((candidate) => candidate.name === field.name);
+      const fieldIR = lookup.fields.get(model)?.get(field.name);
       const decimal = fieldIR !== undefined && fieldIR.type === "Decimal" && fieldIR.isList !== true;
       return {
-        name: fieldDbName({ model, name: field.name }),
+        name: fieldIR?.dbName ?? fieldIR?.name ?? field.name,
         desc: field.sort === "desc",
         ...decimal ? { decimal: true } : {},
         ...field.operatorClass === undefined ? {} : { operatorClass: field.operatorClass }
@@ -924,8 +993,7 @@ function normalizeIndexes(params) {
 }
 function indexComparisonKey(params) {
   const { unique, kind, columns, where, nullsNotDistinct } = params;
-  const cols = columns.map((column) => `${column.name}${column.desc ? " desc" : ""}${column.operatorClass === undefined ? "" : ` ops:${JSON.stringify([column.operatorClass.namespace, column.operatorClass.name])}`}`).join(",");
-  return `${unique ? "u" : "i"}${nullsNotDistinct === true ? "n" : ""}:${kind}:${cols}:${normalizeWhere({ where })}`;
+  return JSON.stringify([unique, nullsNotDistinct === true, kind, columns.map((column) => [column.name, column.desc === true, column.operatorClass === undefined ? null : [column.operatorClass.namespace, column.operatorClass.name]]), normalizeWhere({ where })]);
 }
 function normalizeWhere(params) {
   const { where } = params;
@@ -1087,22 +1155,22 @@ function parsePrimaryExpression(params) {
   return { text: parts.join(" "), at, kind: "atom" };
 }
 function normalizeFks(params) {
-  const { model, table, schema } = params;
+  const { model, table, lookup } = params;
   const result = new Map;
   for (const relation of model.relations) {
     if (relation.fields === undefined || relation.fields.length === 0)
       continue;
-    const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+    const target = lookup.models.get(relation.targetModel);
     if (target !== undefined && target.isView)
       continue;
     const refTable = target === undefined ? relation.targetModel : target.dbName ?? target.name;
-    const columns = relation.fields.map((name) => fieldDbName({ model, name }));
-    const refColumns = (relation.references ?? []).map((name) => target === undefined ? name : fieldDbName({ model: target, name }));
+    const columns = relation.fields.map((name) => lookupFieldName({ lookup, model, name }));
+    const refColumns = (relation.references ?? []).map((name) => target === undefined ? name : lookupFieldName({ lookup, model: target, name }));
     const required = relation.fields.every((name) => {
-      const field = model.fields.find((candidate) => candidate.name === name);
+      const field = lookup.fields.get(model)?.get(name);
       return field === undefined ? true : !field.isOptional;
     });
-    const key = `${columns.join(",")}\u2192${physicalNameKey({ name: refTable, namespace: target?.namespace, dialect: params.dialect })}.${refColumns.join(",")}`;
+    const key = JSON.stringify([columns, physicalNameKey({ name: refTable, namespace: target?.namespace, dialect: params.dialect }), refColumns]);
     if (result.has(key))
       continue;
     result.set(key, {
@@ -1119,17 +1187,17 @@ function normalizeFks(params) {
   return result;
 }
 function normalizeJoinTable(params) {
-  const { pair, schema, dialect } = params;
+  const { pair, lookup, dialect } = params;
   return {
     table: pair.tableName,
     ...pair.namespace === undefined ? {} : { namespace: pair.namespace },
-    a: joinTableEnd({ modelName: pair.modelA, schema, dialect, joinTable: pair.tableName }),
-    b: joinTableEnd({ modelName: pair.modelB, schema, dialect, joinTable: pair.tableName })
+    a: joinTableEnd({ modelName: pair.modelA, lookup, dialect, joinTable: pair.tableName }),
+    b: joinTableEnd({ modelName: pair.modelB, lookup, dialect, joinTable: pair.tableName })
   };
 }
 function joinTableEnd(params) {
-  const { modelName, schema, joinTable } = params;
-  const model = schema.models.find((candidate) => candidate.name === modelName);
+  const { modelName, lookup, joinTable } = params;
+  const model = lookup.models.get(modelName);
   if (model === undefined) {
     throw new VibeError5({
       code: "VIBE_MIGRATION",
@@ -1137,7 +1205,7 @@ function joinTableEnd(params) {
       meta: { joinTable, model: modelName }
     });
   }
-  const pkFields = model.primaryKey !== undefined && model.primaryKey.fields.length > 0 ? model.primaryKey.fields.map((name) => model.fields.find((field) => field.name === name)) : model.fields.filter((field) => field.isId);
+  const pkFields = model.primaryKey !== undefined && model.primaryKey.fields.length > 0 ? model.primaryKey.fields.map((name) => lookup.fields.get(model)?.get(name)) : model.fields.filter((field) => field.isId);
   const pkField = pkFields[0];
   if (pkFields.length !== 1 || pkField === undefined) {
     throw new VibeError5({
@@ -1150,7 +1218,7 @@ function joinTableEnd(params) {
     table: model.dbName ?? model.name,
     ...model.namespace === undefined ? {} : { namespace: model.namespace },
     column: pkField.dbName ?? pkField.name,
-    field: physicalEnumField({ field: pkField, schema, dialect: params.dialect, table: model.dbName ?? model.name })
+    field: physicalEnumField({ field: pkField, lookup, dialect: params.dialect, table: model.dbName ?? model.name })
   };
 }
 function physicalNameKey(params) {
@@ -1166,11 +1234,6 @@ function schemaNamespaces(params) {
     ...(params.schema.migrationObjects ?? []).flatMap((object) => object.identity.kind === "namespace" ? [object.identity.name] : [])
   ])];
 }
-function fieldDbName(params) {
-  const { model, name } = params;
-  const field = model.fields.find((candidate) => candidate.name === name);
-  return field === undefined ? name : field.dbName ?? field.name;
-}
 
 // packages/migrate/src/object-ownership.ts
 import { VibeError as VibeError6, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, qualifiedSqlName as qualifiedSqlName4, sqlObjectKey as sqlObjectKey2 } from "@vibeorm/schema";
@@ -1275,7 +1338,10 @@ function removalIdentity(params) {
   }
 }
 function schemaObjectIdentities(params) {
-  const normalized = normalizeSchema({ schema: params.schema, dialect: params.dialect });
+  return schemaObjectIdentitiesFromNormalized({ ...params, normalized: normalizeSchema({ schema: params.schema, dialect: params.dialect }) });
+}
+function schemaObjectIdentitiesFromNormalized(params) {
+  const { normalized } = params;
   const result = [];
   if (params.dialect === "postgres") {
     for (const namespace of schemaNamespaces({ schema: params.schema }))
@@ -1390,7 +1456,7 @@ function assertRemovalAuthorization(params) {
 }
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError17, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
+import { VibeError as VibeError18, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect3, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/external-objects.ts
@@ -1760,7 +1826,7 @@ async function verifyExclusions(params) {
 
 // packages/migrate/src/inspect-objects.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { VibeError as VibeError16, sqlObjectKey as sqlObjectKey5, sqlObjectNamespace as sqlObjectNamespace2, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2, qualifiedSqlName as qualifiedSqlName8 } from "@vibeorm/schema";
+import { VibeError as VibeError17, sqlObjectKey as sqlObjectKey5, sqlObjectNamespace as sqlObjectNamespace2, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2, qualifiedSqlName as qualifiedSqlName8 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2, renderMigrationObjectBatch, renderMigrationObjectQuery as renderMigrationObjectQuery2, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2, renderSqliteColumnInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/introspect/postgres.ts
@@ -1958,6 +2024,20 @@ function lowerFirst(value) {
   return value.charAt(0).toLowerCase() + value.slice(1);
 }
 
+// packages/migrate/src/introspect/group.ts
+function groupCatalogRows(params) {
+  const groups = new Map;
+  for (const row of params.rows) {
+    const key = params.key(row);
+    const group = groups.get(key);
+    if (group === undefined)
+      groups.set(key, [row]);
+    else
+      group.push(row);
+  }
+  return groups;
+}
+
 // packages/migrate/src/postgres-type-identity.ts
 import { VibeError as VibeError10, qualifiedSqlName as qualifiedSqlName6 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect3, renderPostgresTypeIdentity } from "@vibeorm/sql";
@@ -2359,10 +2439,15 @@ async function introspectPhysicalPostgres(params) {
     read("checks"),
     Promise.all(namespaces.map(async (namespace) => (await executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6, namespace }) })).map((row) => ({ ...row, table_name: physicalNameKey({ namespace, name: String(row.table_name) }) })))).then((rows) => rows.flat())
   ]);
-  const keysQuery = renderPostgresIndexKeys({ dialect: postgresDialect6 });
+  const keysQuery = renderPostgresIndexKeys({ dialect: postgresDialect6, namespaces });
   const indexKeys = await executor({ text: keysQuery.text, values: [...keysQuery.values] });
   if (indexKeys.some((row) => typeof row.table_namespace !== "string" || typeof row.table_name !== "string" || typeof row.index_name !== "string" || typeof row.method !== "string" || typeof row.unique !== "boolean" || typeof row.descending !== "boolean" || typeof row.exact_default !== "boolean" && row.column_name !== null || typeof row.operator_namespace !== "string" || typeof row.operator_name !== "string" || !Number.isSafeInteger(Number(row.ordinal)) || Number(row.ordinal) < 1))
     throw new VibeError13({ code: "VIBE_MIGRATION", message: "PostgreSQL index-key identity is incomplete", meta: { reason: "index-inspection-unavailable" } });
+  const keysByIndex = groupCatalogRows({ rows: indexKeys, key: (row) => JSON.stringify([physicalNameKey({ namespace: String(row.table_namespace), name: String(row.table_name) }), row.index_name]) });
+  const catalogColumns = new Map(columnRows.map((row) => [JSON.stringify([row.table_name, row.column_name]), row]));
+  const foreignKeysByTable = groupCatalogRows({ rows: fkRows, key: (row) => String(row.table_name) });
+  const catalogIndexesByTable = groupCatalogRows({ rows: indexRows, key: (row) => String(row.table_name) });
+  const exclusionsByTable = groupCatalogRows({ rows: exclusionRows, key: (row) => String(row.table_name) });
   const tables = tableRows.map((row) => row.table_name);
   const views = viewRows.map((row) => row.table_name);
   const columns = columnRows.map((row) => ({
@@ -2380,6 +2465,8 @@ async function introspectPhysicalPostgres(params) {
     numericScale: toNumberOrNull(row.numeric_scale),
     fullType: row.full_type ?? null
   }));
+  const columnsByTable = groupCatalogRows({ rows: columns, key: (column) => column.table });
+  const columnsByIdentity = new Map(columns.map((column) => [JSON.stringify([column.table, column.name]), column]));
   const enums = [];
   {
     const valuesByName = new Map;
@@ -2420,6 +2507,7 @@ async function introspectPhysicalPostgres(params) {
         entry.columns.push(columnName);
     }
   }
+  const uniquesByTable = groupCatalogRows({ rows: uniquesByConstraint.values(), key: (unique) => unique.table });
   const checksByTable = new Map;
   for (const row of checkRows) {
     const table = row.table_name;
@@ -2454,7 +2542,7 @@ async function introspectPhysicalPostgres(params) {
   const fkGroups = [...fkGroupsByName.values()].map((group) => ({
     ...group,
     required: group.columns.every((columnName) => {
-      const column = columns.find((c) => c.table === group.table && c.name === columnName);
+      const column = columnsByIdentity.get(JSON.stringify([group.table, columnName]));
       return column === undefined ? true : !column.nullable;
     })
   }));
@@ -2462,7 +2550,7 @@ async function introspectPhysicalPostgres(params) {
   for (const row of indexRows) {
     if (row.backing_constraint_type === "x")
       continue;
-    const operands = indexKeys.filter((key) => physicalNameKey({ namespace: String(key.table_namespace), name: String(key.table_name) }) === row.table_name && key.index_name === row.index_name);
+    const operands = keysByIndex.get(JSON.stringify([row.table_name, row.index_name])) ?? [];
     if (row.plain_columns === true && operands.length !== Number(row.key_count))
       throw new VibeError13({ code: "VIBE_MIGRATION", message: "Plain index keys could not be read completely; refusing name-only operator-class introspection", meta: { reason: "index-inspection-unavailable", table: row.table_name, index: row.index_name } });
     if (operands.length > 0) {
@@ -2487,22 +2575,24 @@ async function introspectPhysicalPostgres(params) {
         indexes.push(parsed);
     }
   }
+  const indexesByTable = groupCatalogRows({ rows: indexes, key: (index) => index.table });
+  const fkGroupsByTable = groupCatalogRows({ rows: fkGroups, key: (group) => group.table });
   const joinTables = new Map;
   for (const table of tables) {
     const physicalTable = physicalNames.get(table);
     if (!physicalTable.name.startsWith("_"))
       continue;
-    const tableFks = fkRows.filter((row) => row.table_name === table);
-    const tableIndexes = indexRows.filter((row) => row.table_name === table);
-    if (pkByTable.has(table) || (checksByTable.get(table)?.length ?? 0) > 0 || exclusionRows.some((row) => row.table_name === table))
+    const tableFks = foreignKeysByTable.get(table) ?? [];
+    const tableIndexes = catalogIndexesByTable.get(table) ?? [];
+    if (pkByTable.has(table) || (checksByTable.get(table)?.length ?? 0) > 0 || exclusionsByTable.has(table))
       continue;
     if (!tableFks.every((row) => row.validated === true && row.deferrable === false && row.triggers_enabled === true))
       continue;
     if (tableIndexes.length !== 2 || !tableIndexes.every((row) => row.valid === true && row.ready === true && row.immediate === true && row.plain_columns === true && typeof row.key_count === "number" && row.key_count === row.attribute_count))
       continue;
     if (tableFks.some((row) => {
-      const source = columnRows.find((column) => column.table_name === table && column.column_name === row.column_name);
-      const target = columnRows.find((column) => column.table_name === row.foreign_table_name && column.column_name === row.foreign_column_name);
+      const source = catalogColumns.get(JSON.stringify([table, row.column_name]));
+      const target = catalogColumns.get(JSON.stringify([row.foreign_table_name, row.foreign_column_name]));
       return source === undefined || target === undefined || typeof source.full_type !== "string" || source.full_type.length === 0 || source.full_type !== target.full_type || source.column_default !== null || source.is_identity !== "NO" || source.is_generated !== "NEVER" || source.is_nullable !== "NO" || source.collation_name === undefined || source.collation_name !== target.collation_name;
     }))
       continue;
@@ -2510,9 +2600,9 @@ async function introspectPhysicalPostgres(params) {
       continue;
     const detected = detectJoinTable({
       table: physicalTable.name,
-      columnNames: columns.filter((column) => column.table === table).map((column) => column.name),
-      fkGroups: fkGroups.filter((group) => group.table === table).map((group) => ({ ...group, table: physicalTable.name, refTable: physicalNames.get(group.refTable)?.name ?? group.refTable })),
-      indexes: indexes.filter((index) => index.table === table).map((index) => ({ ...index, table: physicalTable.name }))
+      columnNames: (columnsByTable.get(table) ?? []).map((column) => column.name),
+      fkGroups: (fkGroupsByTable.get(table) ?? []).map((group) => ({ ...group, table: physicalTable.name, refTable: physicalNames.get(group.refTable)?.name ?? group.refTable })),
+      indexes: (indexesByTable.get(table) ?? []).map((index) => ({ ...index, table: physicalTable.name }))
     });
     if (detected !== null)
       joinTables.set(table, { ...detected, ...physicalTable.namespace === "public" && namespaces.length === 1 ? {} : { relationName: detected.relationName ?? physicalTable.name.slice(1) }, tableA: physicalNameKey({ namespace: physicalTable.namespace, name: detected.tableA }), tableB: physicalNameKey({ namespace: physicalTable.namespace, name: detected.tableB }) });
@@ -2525,14 +2615,14 @@ async function introspectPhysicalPostgres(params) {
       table,
       physicalTable: physicalNames.get(table).name,
       isView: false,
-      columns,
+      columns: columnsByTable.get(table) ?? [],
       pkByTable,
       pkNames,
-      uniquesByConstraint,
+      uniques: uniquesByTable.get(table) ?? [],
       constraintNames,
-      indexes,
+      indexes: indexesByTable.get(table) ?? [],
       enumNames,
-      exclusions: exclusionRows.filter((row) => row.table_name === table).map((row) => ({ name: String(row.constraint_name), definition: String(row.definition), requiredExtensions: [], catalogDefinition: true })),
+      exclusions: (exclusionsByTable.get(table) ?? []).map((row) => ({ name: String(row.constraint_name), definition: String(row.definition), requiredExtensions: [], catalogDefinition: true })),
       checks: checksByTable.get(table) ?? []
     }));
   }
@@ -2541,10 +2631,10 @@ async function introspectPhysicalPostgres(params) {
       table: view,
       physicalTable: physicalNames.get(view).name,
       isView: true,
-      columns,
+      columns: columnsByTable.get(view) ?? [],
       pkByTable,
       pkNames,
-      uniquesByConstraint,
+      uniques: uniquesByTable.get(view) ?? [],
       constraintNames,
       indexes: [],
       enumNames,
@@ -2564,14 +2654,16 @@ async function introspectPhysicalPostgres(params) {
     logicalNames.add(name);
     return name;
   };
+  const modelBasenames = groupCatalogRows({ rows: physicalNames.values(), key: (entry) => entry.name });
+  const enumBasenames = groupCatalogRows({ rows: enumIdentities.values(), key: (entry) => entry.name });
   const modelNames = new Map(models.map((model) => {
     const identity = physicalNames.get(model.name);
-    const duplicates = [...physicalNames.values()].filter((entry) => entry.name === identity.name).length > 1;
+    const duplicates = (modelBasenames.get(identity.name)?.length ?? 0) > 1;
     return [model.name, logicalName({ key: model.name, name: identity.name, duplicates })];
   }));
   const enumLogicalNames = new Map(enums.map((entry) => {
     const identity = enumIdentities.get(entry.name);
-    const duplicates = [...enumIdentities.values()].filter((candidate) => candidate.name === identity.name).length > 1;
+    const duplicates = (enumBasenames.get(identity.name)?.length ?? 0) > 1;
     return [entry.name, logicalName({ key: entry.name, name: identity.name, duplicates })];
   }));
   const qualifiedModels = models.map((model) => {
@@ -2609,20 +2701,18 @@ async function introspectPhysicalPostgres(params) {
   return resolved.schema;
 }
 function buildModel(params) {
-  const { table, isView, columns, pkByTable, uniquesByConstraint, constraintNames, indexes, enumNames } = params;
-  const tableColumns = columns.filter((column) => column.table === table);
+  const { table, isView, columns, pkByTable, uniques, constraintNames, indexes, enumNames } = params;
+  const tableColumns = columns;
   const pk = pkByTable.get(table) ?? [];
   const uniqueSingles = new Set;
   const multiUniques = [];
-  for (const unique of uniquesByConstraint.values()) {
+  for (const unique of uniques) {
     const name = unique.name;
-    if (unique.table !== table)
-      continue;
     if (unique.columns.length === 1)
       uniqueSingles.add(unique.columns[0]);
     multiUniques.push({ name, columns: unique.columns });
   }
-  const tableIndexes = indexes.filter((index) => index.table === table && !constraintNames.has(JSON.stringify([table, index.name])));
+  const tableIndexes = indexes.filter((index) => !constraintNames.has(JSON.stringify([table, index.name])));
   for (const index of tableIndexes) {
     if (!index.unique)
       continue;
@@ -2720,8 +2810,9 @@ function reverseMapType(params) {
 function nonCanonicalModifier(params) {
   const { column, udt, scalar } = params;
   if (column.dataType === "ARRAY" && column.fullType !== null) {
-    const element = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^(numeric|timestamptz)\([\d,]+\)$/.test(element))
+    const temporal = parseUnsupportedPostgresType({ raw: column.fullType });
+    const element = temporal?.name === "timestamptz" ? `timestamptz${temporal.modifier}` : normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
+    if (element !== "timestamptz(6)" && /^(numeric|timestamptz)\([\d,]+\)$/.test(element))
       return element;
   }
   if (scalar === "DateTime" && udt === "timestamptz") {
@@ -2738,9 +2829,9 @@ function nonCanonicalModifier(params) {
 }
 function withModifier(params) {
   const { column, udt } = params;
-  if (udt === "varchar" && column.dataType === "ARRAY" && column.fullType !== null) {
+  if ((udt === "varchar" || udt === "bpchar" || udt === "bit" || udt === "varbit") && column.dataType === "ARRAY" && column.fullType !== null) {
     const elementType = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^varchar\(\d+\)$/.test(elementType))
+    if (/^(varchar|char|bit|varbit)\(\d+\)$/.test(elementType))
       return elementType;
   }
   if ((udt === "varchar" || udt === "bpchar") && column.charMaxLength !== null) {
@@ -2750,6 +2841,10 @@ function withModifier(params) {
     return "char";
   if ((udt === "bit" || udt === "varbit") && column.charMaxLength !== null)
     return `${udt}(${column.charMaxLength})`;
+  if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.dataType === "ARRAY" && column.fullType !== null) {
+    const element = parseUnsupportedPostgresType({ raw: column.fullType });
+    return element === undefined || element.modifier === "" || element.modifier === "(6)" ? udt : `${udt}${element.modifier}`;
+  }
   if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
     return `${udt}(${column.datetimePrecision})`;
   }
@@ -2902,7 +2997,7 @@ function toNumberOrNull(value) {
 }
 
 // packages/migrate/src/introspect/mysql.ts
-import { exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
+import { VibeError as VibeError14, exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect2 } from "@vibeorm/sql";
 
 // packages/migrate/src/journal-table.ts
@@ -3031,6 +3126,12 @@ async function introspectMysql(params) {
     collation: catalogField({ row, name: "collation_name" }) ?? null,
     extra: (catalogField({ row, name: "extra" }) ?? "").toLowerCase()
   }));
+  const columnsByTable = groupCatalogRows({ rows: columns, key: (column) => column.table });
+  const columnsByIdentity = new Map(columns.map((column) => [JSON.stringify([column.table, column.name]), column]));
+  const catalogColumns = new Map(columnRows.map((row) => [JSON.stringify([catalogField({ row, name: "table_name" }), catalogField({ row, name: "column_name" })]), row]));
+  const statisticsByTable = groupCatalogRows({ rows: statisticRows, key: (row) => String(catalogField({ row, name: "table_name" })) });
+  const foreignKeysByTable = groupCatalogRows({ rows: fkRows, key: (row) => String(catalogField({ row, name: "table_name" })) });
+  const enginesByTable = new Map(tableRows.map((row) => [catalogField({ row, name: "table_name" }), catalogField({ row, name: "engine" })]));
   const rulesByConstraint = new Map;
   for (const row of refRows) {
     rulesByConstraint.set(catalogField({ row, name: "constraint_name" }), {
@@ -3042,6 +3143,15 @@ async function introspectMysql(params) {
   for (const row of fkRows) {
     const constraintName = catalogField({ row, name: "constraint_name" });
     const table = catalogField({ row, name: "table_name" });
+    const tableSchema = catalogField({ row, name: "table_schema" });
+    const referencedSchema = catalogField({ row, name: "referenced_table_schema" });
+    if (typeof tableSchema === "string" && typeof referencedSchema === "string" && tableSchema !== referencedSchema) {
+      throw new VibeError14({
+        code: "VIBE_UNSUPPORTED_CAPABILITY",
+        message: `MySQL cross-database foreign key "${constraintName}" from "${tableSchema}.${table}" to "${referencedSchema}" cannot be introspected without losing its database identity`,
+        meta: { dialect: "mysql", feature: "cross-database foreign keys", constraint: constraintName, table, tableSchema, referencedSchema }
+      });
+    }
     const key = `${table}\x00${constraintName}`;
     const existing = groupsByKey.get(key);
     if (existing === undefined) {
@@ -3064,17 +3174,11 @@ async function introspectMysql(params) {
       onDelete: rules?.onDelete ?? "NoAction",
       onUpdate: rules?.onUpdate ?? "NoAction",
       required: group.columns.every((columnName) => {
-        const column = columns.find((candidate) => candidate.table === group.table && candidate.name === columnName);
+        const column = columnsByIdentity.get(JSON.stringify([group.table, columnName]));
         return column === undefined ? true : !column.nullable;
       })
     };
   });
-  const fkNamesByTable = new Map;
-  for (const group of fkGroups) {
-    const set = fkNamesByTable.get(group.table) ?? new Set;
-    set.add(group.constraintName);
-    fkNamesByTable.set(group.table, set);
-  }
   const pkByTable = new Map;
   const indexes = [];
   {
@@ -3083,6 +3187,12 @@ async function introspectMysql(params) {
       const table = catalogField({ row, name: "table_name" });
       const name = catalogField({ row, name: "index_name" });
       const columnName = catalogField({ row, name: "column_name" });
+      const type = catalogField({ row, name: "index_type" });
+      const unique = Number(catalogField({ row, name: "non_unique" })) === 0;
+      const kind = typeof type === "string" ? type.toLowerCase() : "btree";
+      if (catalogField({ row, name: "sub_part" }) != null || catalogField({ row, name: "expression" }) != null || catalogField({ row, name: "is_visible" }) === "NO" || typeof columnName !== "string" || kind !== "btree" && (kind !== "fulltext" || unique)) {
+        throw new VibeError14({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `MySQL index "${table}.${name}" cannot be introspected without losing its physical shape`, meta: { dialect: "mysql", feature: "index introspection", table, index: name } });
+      }
       if (name === "PRIMARY") {
         const list = pkByTable.get(table);
         if (list === undefined)
@@ -3091,8 +3201,6 @@ async function introspectMysql(params) {
           list.push(columnName);
         continue;
       }
-      if (fkNamesByTable.get(table)?.has(name) === true)
-        continue;
       const key = `${table}\x00${name}`;
       const entry = byKey.get(key);
       const column = {
@@ -3103,7 +3211,8 @@ async function introspectMysql(params) {
         byKey.set(key, {
           table,
           name,
-          unique: Number(catalogField({ row, name: "non_unique" })) === 0,
+          unique,
+          kind,
           columns: [column]
         });
       } else {
@@ -3111,34 +3220,39 @@ async function introspectMysql(params) {
       }
     }
     for (const entry of byKey.values()) {
-      indexes.push({ ...entry, kind: "btree" });
+      const support = groupsByKey.get(`${entry.table}\x00${entry.name}`);
+      if (!entry.unique && entry.kind === "btree" && support !== undefined && entry.columns.length === support.columns.length && entry.columns.every((column, index) => column.name === support.columns[index] && !column.desc))
+        continue;
+      indexes.push(entry);
     }
   }
+  const indexesByTable = groupCatalogRows({ rows: indexes, key: (index) => index.table });
+  const fkGroupsByTable = groupCatalogRows({ rows: fkGroups, key: (group) => group.table });
   const enums = [];
   const joinTables = new Map;
   let foreignKeysEnabled;
   for (const table of tables) {
     if (!table.startsWith("_") || pkByTable.has(table) || (checksByTable.get(table)?.length ?? 0) > 0)
       continue;
-    const tableIndexes = statisticRows.filter((row) => catalogField({ row, name: "table_name" }) === table);
+    const tableIndexes = statisticsByTable.get(table) ?? [];
     if (new Set(tableIndexes.map((row) => catalogField({ row, name: "index_name" }))).size !== 2 || !tableIndexes.every((row) => catalogField({ row, name: "index_type" }) === "BTREE" && catalogField({ row, name: "is_visible" }) === "YES" && catalogField({ row, name: "sub_part" }) === null && catalogField({ row, name: "expression" }) === null && catalogField({ row, name: "collation" }) === "A" && Number.isInteger(Number(catalogField({ row, name: "seq_in_index" }))) && Number(catalogField({ row, name: "seq_in_index" })) > 0))
       continue;
-    const tableFks = fkRows.filter((row) => catalogField({ row, name: "table_name" }) === table);
+    const tableFks = foreignKeysByTable.get(table) ?? [];
     if (tableFks.some((row) => {
       const targetTable = catalogField({ row, name: "referenced_table_name" });
-      const source = columnRows.find((column) => catalogField({ row: column, name: "table_name" }) === table && catalogField({ row: column, name: "column_name" }) === catalogField({ row, name: "column_name" }));
-      const target = columnRows.find((column) => catalogField({ row: column, name: "table_name" }) === targetTable && catalogField({ row: column, name: "column_name" }) === catalogField({ row, name: "referenced_column_name" }));
+      const source = catalogColumns.get(JSON.stringify([table, catalogField({ row, name: "column_name" })]));
+      const target = catalogColumns.get(JSON.stringify([targetTable, catalogField({ row, name: "referenced_column_name" })]));
       if (source === undefined || target === undefined)
         return true;
       const type = catalogField({ row: source, name: "column_type" });
-      return typeof type !== "string" || type.length === 0 || type !== catalogField({ row: target, name: "column_type" }) || catalogField({ row: source, name: "column_default" }) !== null || catalogField({ row: source, name: "extra" }) !== "" || catalogField({ row: source, name: "generation_expression" }) !== "" || catalogField({ row: source, name: "is_nullable" }) !== "NO" || catalogField({ row: source, name: "collation_name" }) === undefined || catalogField({ row: source, name: "collation_name" }) !== catalogField({ row: target, name: "collation_name" }) || catalogField({ row, name: "table_schema" }) === undefined || catalogField({ row, name: "table_schema" }) !== catalogField({ row, name: "referenced_table_schema" }) || ![table, targetTable].every((name) => tableRows.some((entry) => catalogField({ row: entry, name: "table_name" }) === name && catalogField({ row: entry, name: "engine" }) === "InnoDB"));
+      return typeof type !== "string" || type.length === 0 || type !== catalogField({ row: target, name: "column_type" }) || catalogField({ row: source, name: "column_default" }) !== null || catalogField({ row: source, name: "extra" }) !== "" || catalogField({ row: source, name: "generation_expression" }) !== "" || catalogField({ row: source, name: "is_nullable" }) !== "NO" || catalogField({ row: source, name: "collation_name" }) === undefined || catalogField({ row: source, name: "collation_name" }) !== catalogField({ row: target, name: "collation_name" }) || catalogField({ row, name: "table_schema" }) === undefined || catalogField({ row, name: "table_schema" }) !== catalogField({ row, name: "referenced_table_schema" }) || ![table, targetTable].every((name) => enginesByTable.get(name) === "InnoDB");
     }))
       continue;
     const detected = detectJoinTable({
       table,
-      columnNames: columns.filter((column) => column.table === table).map((column) => column.name),
-      fkGroups,
-      indexes
+      columnNames: (columnsByTable.get(table) ?? []).map((column) => column.name),
+      fkGroups: fkGroupsByTable.get(table) ?? [],
+      indexes: indexesByTable.get(table) ?? []
     });
     if (detected === null)
       continue;
@@ -3150,7 +3264,7 @@ async function introspectMysql(params) {
       continue;
     const q = (name) => mysqlDialect2.quoteIdent({ name });
     let valid = true;
-    for (const fk of fkGroups.filter((group) => group.table === table)) {
+    for (const fk of fkGroupsByTable.get(table) ?? []) {
       const rows = await executor({ text: `SELECT 1 AS invalid FROM ${q(table)} child LEFT JOIN ${q(fk.refTable)} parent ON child.${q(fk.columns[0])} = parent.${q(fk.refColumns[0])} WHERE parent.${q(fk.refColumns[0])} IS NULL LIMIT 1`, values: [] });
       if (rows.length > 0) {
         valid = false;
@@ -3167,9 +3281,9 @@ async function introspectMysql(params) {
     models.push(buildModel2({
       table,
       isView: false,
-      columns,
+      columns: columnsByTable.get(table) ?? [],
       pkByTable,
-      indexes,
+      indexes: indexesByTable.get(table) ?? [],
       enums,
       checks: checksByTable.get(table) ?? []
     }));
@@ -3178,7 +3292,7 @@ async function introspectMysql(params) {
     models.push(buildModel2({
       table: view,
       isView: true,
-      columns,
+      columns: columnsByTable.get(view) ?? [],
       pkByTable: new Map,
       indexes: [],
       enums,
@@ -3196,9 +3310,9 @@ async function introspectMysql(params) {
 }
 function buildModel2(params) {
   const { table, isView, columns, pkByTable, indexes, enums } = params;
-  const tableColumns = columns.filter((column) => column.table === table);
+  const tableColumns = columns;
   const pk = pkByTable.get(table) ?? [];
-  const tableIndexes = indexes.filter((index) => index.table === table);
+  const tableIndexes = indexes;
   const uniqueSingles = new Set;
   for (const index of tableIndexes) {
     if (index.unique && index.columns.length === 1) {
@@ -3229,7 +3343,7 @@ function buildModel2(params) {
       continue;
     modelIndexes.push({
       name: index.name,
-      kind: index.unique ? "unique" : "btree",
+      kind: index.unique ? "unique" : index.kind,
       fields: index.columns.map((column) => ({
         name: column.name,
         ...column.desc ? { sort: "desc" } : {}
@@ -3761,7 +3875,7 @@ function q(name) {
 }
 
 // packages/migrate/src/execute.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
@@ -3802,7 +3916,7 @@ function assertSelfManagedResumeSafe(params) {
   const completedIndex = params.direction === "up" ? params.start + 1 : -(params.start + 2);
   const rewind = selfManagedResumeStart({ sql: params.sql, start: params.start });
   const retryIndex = params.direction === "up" ? rewind : -(rewind + 1);
-  throw new VibeError14({
+  throw new VibeError15({
     code: "VIBE_MIGRATION",
     message: `migration "${params.migration}" has a legacy sqlite checkpoint at ${params.direction} COMMIT (statement ${params.start + 1}). The block may already have committed; replay is refused. Inspect the block's effects. If it committed, set its journal statement_index to ${completedIndex} and error to NULL to resume the remaining statements. Only if the entire block did not commit, set statement_index to ${retryIndex} and error to NULL to retry the block. Do not mark the whole migration applied unless all remaining statements also ran.`,
     meta: { reason: "uncertain-statement", migration: params.migration, statementIndex: params.start, direction: params.direction, dialect: "sqlite" }
@@ -3831,7 +3945,7 @@ function unsupportedScript(params) {
   const { migration, direction, index, problem, found } = params;
   const subject = direction === "down" ? `the down script of migration "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${params.statements}`;
-  return new VibeError14({
+  return new VibeError15({
     code: "VIBE_MIGRATION",
     message: `${subject} manages its own sqlite transactions, and ${position} breaks the shape recovery depends on: ${found}. ` + `A table-rebuild block must be written exactly as \`${SUPPORTED_BLOCK_SHAPE}\`. ` + "Inside that block a crash rolls everything back, so a resume can replay it safely. " + "A statement that sits in a foreign-keys-off region with no transaction around it commits on its own, " + "and the resume would run it a second time with no error raised either time. " + "Nothing has been executed. Move the statement after `PRAGMA foreign_keys=ON`, where it commits together " + "with its own journal checkpoint, or give it its own `BEGIN;` and `COMMIT;`. " + 'See "Self-managed sqlite scripts" in docs/migrations.md.',
     meta: { reason: "unsupported-self-managed-script", problem, migration, statementIndex: index, direction }
@@ -3887,7 +4001,7 @@ async function executeStatement(params) {
     const rows = await executor({ text: statement, values: [] });
     if (rows.length > 0) {
       const sample = rows.slice(0, 5).map((row) => `${String(row.table)} rowid ${String(row.rowid)} \u2192 ${String(row.parent)}`).join("; ");
-      throw new VibeError14({
+      throw new VibeError15({
         code: "VIBE_MIGRATION",
         message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
         meta: { violations: rows }
@@ -3942,7 +4056,7 @@ async function prepareOperatorClassDiff(params) {
 }
 
 // packages/migrate/src/postgres-default-equivalence.ts
-import { VibeError as VibeError15 } from "@vibeorm/schema";
+import { VibeError as VibeError16 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect8, renderPostgresDefaultFunctionIdentity } from "@vibeorm/sql";
 var IDENTIFIER = '(?:"(?:[^"\\u0000]|"")+"|[A-Za-z_][A-Za-z_0-9$]*)';
 var CALL = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*\\(\\s*\\)\\s*$`);
@@ -3961,7 +4075,7 @@ async function equivalentPostgresDefaultFunction(params) {
     return false;
   const query = renderPostgresDefaultFunctionIdentity({ dialect: postgresDialect8, table: params.table, column: params.column });
   const rows = await params.executor({ text: query.text, values: [...query.values] }).catch((cause) => {
-    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
+    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
   });
   if (rows.length !== 1)
     return false;
@@ -4056,7 +4170,7 @@ async function inspectSqlObject(params) {
       }
     }
     return { state: "present", definition: { identity: params.identity, facts, dependencies: [], format: "catalog-v2" } };
-  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError16 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError17 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
 }
 function postgresInspection(params) {
   if (!params.addresses.every((address) => typeof address === "string"))
@@ -4071,7 +4185,7 @@ function postgresInspection(params) {
   return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v2" } };
 }
 function unavailableReason(params) {
-  return params.error instanceof VibeError16 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
+  return params.error instanceof VibeError17 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
 }
 async function readBatch(params) {
   const positions = new Set(params.batch.positions);
@@ -4079,7 +4193,7 @@ async function readBatch(params) {
     const rows = new Map;
     for (const row of await params.executor({ text: params.batch.text, values: [...params.batch.values] })) {
       if (typeof row.position !== "number" || !Number.isInteger(row.position) || !positions.has(row.position))
-        throw new VibeError16({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
+        throw new VibeError17({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
       const matches = rows.get(row.position) ?? [];
       matches.push(row);
       rows.set(row.position, matches);
@@ -4124,7 +4238,7 @@ async function assertCatalogVisibility(params) {
   const grants = new Set(rows.map((row) => row.privilege));
   const missing = ["SELECT", "TRIGGER", "SHOW VIEW", "EXECUTE"].filter((privilege) => !grants.has(privilege));
   if (missing.length > 0)
-    throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
+    throw new VibeError17({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
 }
 var CATALOG_V1_OMITTED_FACTS = Object.freeze({
   function: ["definerOwner"],
@@ -4148,9 +4262,20 @@ function compare(params) {
     differences.push({ attribute: "dependencies", expected, actual });
   return differences;
 }
+function compareInspectedSqlObject(params) {
+  const { identity, ownership, expected, live } = params;
+  if (live.state !== "present")
+    return { identity, ownership, state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} };
+  if (expected === undefined)
+    return identity.kind === "namespace" ? { identity, ownership, state: "matching", differences: [] } : { identity, ownership, state: "unavailable", reason: "independent-definition-required", differences: [] };
+  if (params.dialect === "postgres" && identity.kind === "table" && (expected.facts.persistence === undefined || expected.facts.options === undefined))
+    return { identity, ownership, state: "unavailable", reason: "table-physical-reference-required", differences: compare({ expected, live: live.definition }) };
+  const differences = compare({ expected, live: live.definition });
+  return { identity, ownership, state: differences.length === 0 ? "matching" : "changed", differences };
+}
 function assertProbeMode(params) {
   if (params.probe !== undefined && params.probe !== "none" && DIALECT_CAPABILITIES2[params.dialect].checkNormalization !== params.probe)
-    throw new VibeError16({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
+    throw new VibeError17({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
 }
 async function verifyMigrationState(params) {
   return verifyState(params);
@@ -4173,18 +4298,7 @@ async function verifyState(params) {
     const expected = definitions.get(key);
     const live = inspections === undefined ? await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity }) : inspections[position];
     position++;
-    if (live.state !== "present") {
-      objects.push({ identity, ownership, state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
-    } else if (expected === undefined && identity.kind === "namespace") {
-      objects.push({ identity, ownership, state: "matching", differences: [] });
-    } else if (expected === undefined) {
-      objects.push({ identity, ownership, state: "unavailable", reason: "independent-definition-required", differences: [] });
-    } else if (params.dialect === "postgres" && identity.kind === "table" && (expected.facts.persistence === undefined || expected.facts.options === undefined)) {
-      objects.push({ identity, ownership, state: "unavailable", reason: "table-physical-reference-required", differences: compare({ expected, live: live.definition }) });
-    } else {
-      const differences = compare({ expected, live: live.definition });
-      objects.push({ identity, ownership, state: differences.length === 0 ? "matching" : "changed", differences });
-    }
+    objects.push(compareInspectedSqlObject({ identity, ownership, expected, live, dialect: params.dialect }));
   }
   if (params.dialect === "postgres" && schemaNamespaces({ schema: params.expected.schema }).length > 0 || params.expected.schema.models.length > 0 || params.expected.schema.enums.length > 0)
     objects.push(...await verifySchemaObjects(params));
@@ -4248,7 +4362,8 @@ async function verifySchemaObjects(params) {
     pin("primaryKey", desired.pk, live.pk);
     for (const [column, field] of desired.columns) {
       const stored = live.columns.get(column);
-      pin(`columns.${column}.type`, field.typeKey, stored?.typeKey);
+      const exactType = field.pinsExactType;
+      pin(`columns.${column}.type`, exactType ? field.exactTypeKey : field.typeKey, exactType ? stored?.exactTypeKey : stored?.typeKey);
       pin(`columns.${column}.nullable`, field.nullable, stored?.nullable);
       if (params.dialect === "mysql" && field.field.collation !== undefined) {
         pin(`columns.${column}.collation`, field.field.collation.toLowerCase(), stored?.field.collation?.toLowerCase());
@@ -4352,7 +4467,7 @@ async function verifyMigrationTransition(params) {
 }
 async function verifySqliteTransitionBeforeRestore(params) {
   if (params.dialect !== "sqlite")
-    throw new VibeError16({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
+    throw new VibeError17({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
   await executeStatement({ executor: params.executor, dialect: "sqlite", statement: "PRAGMA foreign_key_check;" });
   return verifyTransition({ ...params, sqliteRestorePending: true });
 }
@@ -4362,7 +4477,7 @@ async function verifyTransition(params) {
     for (const identity of params.removals ?? []) {
       const owner = externalObjectOwner({ identity, external });
       if (owner !== undefined)
-        throw new VibeError16({ code: "VIBE_MIGRATION", message: "Transition removals cannot target externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
+        throw new VibeError17({ code: "VIBE_MIGRATION", message: "Transition removals cannot target externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
     }
     params = { ...params, from: projectExternalState({ state: params.from, external }), to: projectExternalState({ state: params.to, external }) };
   }
@@ -4387,12 +4502,12 @@ async function migrationNamespace(params) {
   const rows = await params.executor({ text: query.text, values: [] });
   const namespace = rows[0]?.namespace;
   if (typeof namespace !== "string" || namespace.length === 0)
-    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
+    throw new VibeError17({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
   return namespace;
 }
 function assertMigrationState(params) {
   if (!params.report.inSync)
-    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", shadowReusable: true, objects: params.report.objects.filter((object) => object.state !== "matching") } });
+    throw new VibeError17({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", shadowReusable: true, objects: params.report.objects.filter((object) => object.state !== "matching") } });
 }
 async function deparsePostgresCheck(params) {
   const definition = await deparsePostgresCheckDefinition({ ...params, constraint: "vibeorm_check_probe" });
@@ -4406,7 +4521,7 @@ async function deparsePostgresCheckDefinition(params) {
     await params.executor({ text: query.text });
     const result = await inspectSqlObject({ executor: params.executor, dialect: "postgres", identity: { kind: "constraint", constraintType: "check", table: params.table, name } });
     if (result.state !== "present" || typeof result.definition.facts.definition !== "string")
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
     return { ...result.definition, identity: { kind: "constraint", constraintType: "check", table: params.table, name: params.constraint }, facts: { ...result.definition.facts, definition: result.definition.facts.definition.replace(/ NOT VALID$/, ""), validated: true } };
   } finally {
     await params.executor({ text: "ROLLBACK TO SAVEPOINT vibeorm_check_probe" });
@@ -4424,7 +4539,7 @@ async function deparseMysqlCheck(params) {
     const source = await params.executor({ text: read.text, values: [] });
     const definition = source[0]?.["Create Table"];
     if (typeof definition !== "string")
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
     const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
     await params.executor({ text: drop.text });
     created = false;
@@ -4435,7 +4550,7 @@ async function deparseMysqlCheck(params) {
     const normalizedDefinition = rows[0]?.["Create Table"];
     const check = typeof normalizedDefinition === "string" ? parseSqliteNamedChecks({ tableSql: normalizedDefinition }).find((entry) => entry.name === probe) : undefined;
     if (check === undefined)
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
     return check.expression;
   } finally {
     if (created) {
@@ -4462,7 +4577,7 @@ async function prepareCheckDiff(params) {
         const desired = await deparsePostgresCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "rollback" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         if (live.definition.facts.definition === desired) {
           checks.push(next);
           continue;
@@ -4474,7 +4589,7 @@ async function prepareCheckDiff(params) {
         const desired = await deparseMysqlCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "temporary" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         checks.push(desired === live.definition.facts.definition ? next : { name: check.name, expression: check.expression });
         continue;
       }
@@ -4487,7 +4602,7 @@ async function prepareCheckDiff(params) {
         checks.push({ name: check.name, expression: check.expression });
         continue;
       }
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
     }
     models.push({ ...model, checks });
   }
@@ -4514,7 +4629,7 @@ async function inspectMigrationInventory(params) {
   for (const row of rows) {
     const name = row.name;
     if (typeof name !== "string" || typeof row.kind !== "string")
-      throw new VibeError17({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
+      throw new VibeError18({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
     const qualified = { namespace: params.namespace, name };
     const table = { namespace: params.namespace, name: String(row.parent ?? "") };
     let identity;
@@ -4540,7 +4655,7 @@ async function inspectMigrationInventory(params) {
       case "constraint": {
         const constraintType = kinds[String(row.subtype)];
         if (constraintType === undefined)
-          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError18({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
         identity = { kind: "constraint", table, name, constraintType };
         break;
       }
@@ -4550,17 +4665,17 @@ async function inspectMigrationInventory(params) {
           const query = renderMysqlObjectMembers2({ dialect: getSqlDialect3({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
           const members = await params.executor({ text: query.text, values: [...query.values] });
           if (members.length === 0)
-            throw new VibeError17({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
+            throw new VibeError18({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
           argumentTypes = members.filter((member) => member.mode !== null).map((member) => ({ namespace: "mysql", name: String(member.type) }));
         }
         const candidate = { kind: "function", name: qualified, argumentTypes };
         if (!isSqlObjectIdentity2(candidate))
-          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError18({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
         identity = candidate;
         break;
       }
       default:
-        throw new VibeError17({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
+        throw new VibeError18({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
     }
     objects.push({ identity, ...typeof row.backing === "string" ? { backingConstraint: row.backing } : {} });
     if (params.dialect === "sqlite" && row.kind === "table" && typeof row.definition === "string" && !/^\s*CREATE\s+VIRTUAL\s+TABLE\b/i.test(row.definition)) {
@@ -4604,7 +4719,7 @@ async function inspectMigrationInventory(params) {
 
 // packages/migrate/src/module-ownership.ts
 function refusal(params) {
-  return new VibeError18({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
+  return new VibeError19({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
 }
 function identities(params) {
   return [...schemaObjectIdentities({ schema: params.state.schema, dialect: params.dialect, namespace: params.namespace }), ...(params.state.schema.migrationObjects ?? []).map((object) => object.identity), ...params.state.definitions.map((definition) => definition.identity)];
@@ -4665,7 +4780,7 @@ function assertModuleOwnership(params) {
     throw refusal({ reason: "module-mutates-application-state", moduleId: origin.moduleId });
 }
 function dependencyUnavailable(params) {
-  return new VibeError18({ code: "VIBE_MIGRATION", message: "Cannot establish module foreign-key dependencies across namespaces. MySQL requires direct global SHOW VIEW (or SELECT) without partial revokes; SHOW VIEW exposes metadata without granting external row reads. Restore catalog visibility before retrying", meta: { reason: "module-dependency-unavailable", moduleId: params.origin.moduleId }, ...params.cause === undefined ? {} : { cause: params.cause } });
+  return new VibeError19({ code: "VIBE_MIGRATION", message: "Cannot establish module foreign-key dependencies across namespaces. MySQL requires direct global SHOW VIEW (or SELECT) without partial revokes; SHOW VIEW exposes metadata without granting external row reads. Restore catalog visibility before retrying", meta: { reason: "module-dependency-unavailable", moduleId: params.origin.moduleId }, ...params.cause === undefined ? {} : { cause: params.cause } });
 }
 async function assertCrossNamespaceModuleDependencies(params) {
   const { executor, origin } = params;
@@ -4727,15 +4842,15 @@ async function assertApplicationModuleState(params) {
     const options = { executor: params.executor, dialect: origin.dialect, from: state.from, to: state.to, removals: state.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } };
     const report = params.sqliteRestorePending === true ? await verifySqliteTransitionBeforeRestore(options) : await verifyMigrationTransition(options);
     if (!report.inSync)
-      throw new VibeError18({ code: "VIBE_MIGRATION", message: `Application SQL cannot change objects owned by module ${origin.moduleId}; use its reviewed module upgrade`, meta: { reason: "module-application-mutation", moduleId: origin.moduleId, report } });
+      throw new VibeError19({ code: "VIBE_MIGRATION", message: `Application SQL cannot change objects owned by module ${origin.moduleId}; use its reviewed module upgrade`, meta: { reason: "module-application-mutation", moduleId: origin.moduleId, report } });
   }
 }
 
 // packages/migrate/src/module-adoption.ts
-import { VibeError as VibeError19 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } from "@vibeorm/schema";
 var MODULE_ADOPTION_METADATA = Object.freeze({ filename: "module-adoption.json", version: 1 });
 function invalid3() {
-  return new VibeError19({ code: "VIBE_MIGRATION", message: "Local module adoption proof is malformed or lacks immutable source provenance; restore the reviewed local history", meta: { reason: "module-adoption-invalid" } });
+  return new VibeError20({ code: "VIBE_MIGRATION", message: "Local module adoption proof is malformed or lacks immutable source provenance; restore the reviewed local history", meta: { reason: "module-adoption-invalid" } });
 }
 function assertMarker(params) {
   const value = params.value;
@@ -4771,7 +4886,7 @@ function serializeModuleAdoption(params) {
 }
 
 // packages/migrate/src/sql-statements.ts
-import { VibeError as VibeError20 } from "@vibeorm/schema";
+import { VibeError as VibeError21 } from "@vibeorm/schema";
 var COMPOUND_BODY_HEADER = /^(?:\s|--[^\n]*\n|\/\*[\s\S]*?\*\/)*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY)\s+)?(?:DEFINER\s*=\s*\S+\s+)?(?:TRIGGER|PROCEDURE|FUNCTION|EVENT)\b/i;
 var BLOCK_OPENERS = new Set(["BEGIN", "CASE", "IF", "LOOP", "WHILE", "REPEAT"]);
 function splitSqlStatements(params) {
@@ -4847,7 +4962,7 @@ function splitSqlStatements(params) {
             continue;
           }
           if (dialect === "mysql" || dialect === undefined) {
-            throw new VibeError20({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
+            throw new VibeError21({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
           }
         }
         if (value === endQuote) {
@@ -4921,10 +5036,10 @@ function joinSqlStatements(params) {
 
 // packages/migrate/src/module-origin.ts
 import { createHash } from "crypto";
-import { VibeError as VibeError21, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
+import { VibeError as VibeError22, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
 var MODULE_ORIGIN_METADATA = Object.freeze({ filename: "module-origin.json", version: 1 });
 function invalid4() {
-  return new VibeError21({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
+  return new VibeError22({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
 }
 function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -4988,7 +5103,7 @@ function assertMaterializedModuleMigration(params) {
     return;
   const restored = restoreModuleMigration({ migration, origin: migration.moduleOrigin });
   if (migration.desiredState === undefined || canonicalMigrationJson({ value: restored }) !== canonicalMigrationJson({ value: migration }))
-    throw new VibeError21({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
+    throw new VibeError22({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
 }
 function restoreModuleMigration(params) {
   const { migration, origin } = params;
@@ -5013,13 +5128,13 @@ function restoreModuleMigration(params) {
 // packages/migrate/src/fs.ts
 import { readFile, readdir } from "fs/promises";
 import { join } from "path";
-import { VibeError as VibeError36, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
+import { VibeError as VibeError37, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
 
 // packages/migrate/src/migration-checksum.ts
 import { createHash as createHash2 } from "crypto";
 
 // packages/migrate/src/execution.ts
-import { VibeError as VibeError22 } from "@vibeorm/schema";
+import { VibeError as VibeError23 } from "@vibeorm/schema";
 var EXECUTION_SIDECAR_FILENAME = "execution.json";
 var EXECUTION_SIDECAR_VERSION = 1;
 function isDefaultExecution(params) {
@@ -5058,7 +5173,7 @@ ${lines.join(`
 `)}`;
 }
 function invalid5(params) {
-  return new VibeError22({
+  return new VibeError23({
     code: "VIBE_MIGRATION",
     message: `invalid execution metadata for migration "${params.migration}": ${params.detail}`,
     meta: { reason: "execution-metadata-invalid", migration: params.migration }
@@ -5109,7 +5224,7 @@ function parseExecutionSidecar(params) {
   try {
     parsed = JSON.parse(params.text);
   } catch (error) {
-    throw new VibeError22({
+    throw new VibeError23({
       code: "VIBE_MIGRATION",
       message: `invalid execution metadata for migration "${migration}": not valid JSON`,
       meta: { reason: "execution-metadata-invalid", migration },
@@ -5208,7 +5323,7 @@ function migrationChecksum(params) {
 }
 
 // packages/migrate/src/shadow-guard.ts
-import { VibeError as VibeError23 } from "@vibeorm/schema";
+import { VibeError as VibeError24 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect5, renderShadowOperation } from "@vibeorm/sql";
 var replayExecutors = new WeakSet;
 function isShadowReplayExecutor(params) {
@@ -5220,7 +5335,7 @@ async function assertDatabaseNotShadow(params) {
   const [query] = renderShadowOperation({ dialect: getSqlDialect5({ dialect: params.dialect }), operation: { kind: "markerExists" } });
   const rows = await params.executor({ text: query.text, values: [...query.values] });
   if (rows.length !== 0)
-    throw new VibeError23({ code: "VIBE_MIGRATION", message: "This database is claimed as a disposable migration shadow. Application migrations must use the deployment target.", meta: { reason: "shadow-database-is-not-target" } });
+    throw new VibeError24({ code: "VIBE_MIGRATION", message: "This database is claimed as a disposable migration shadow. Application migrations must use the deployment target.", meta: { reason: "shadow-database-is-not-target" } });
 }
 function runShadowReplay(params) {
   replayExecutors.add(params.executor);
@@ -5230,7 +5345,7 @@ function runShadowReplay(params) {
 }
 
 // packages/migrate/src/external-dependencies.ts
-import { VibeError as VibeError24, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError25, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect6, renderExternalDependents } from "@vibeorm/sql";
 function externalDependencyTargets(params) {
   return params.steps.flatMap((step) => {
@@ -5253,7 +5368,7 @@ function externalDependencyTargets(params) {
   });
 }
 function unavailable() {
-  return new VibeError24({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency row", meta: { reason: "external-inventory-unavailable" } });
+  return new VibeError25({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency row", meta: { reason: "external-inventory-unavailable" } });
 }
 function text(params) {
   const value = params.row[params.key];
@@ -5294,7 +5409,7 @@ function assertNoExternalDependents(params) {
     const dependent = dependentOwner({ row, external: params.external });
     if (dependent.owner === undefined)
       continue;
-    throw new VibeError24({
+    throw new VibeError25({
       code: "VIBE_MIGRATION",
       message: "An externally owned object depends on an application object this change drops or retypes; automatic DDL is refused",
       meta: { reason: "external-owned-dependency", owner: dependent.owner, ...dependent.identity === undefined ? {} : { identity: dependent.identity }, dependent: { type, identity }, dependency: target.dependency, referenced }
@@ -5315,9 +5430,9 @@ async function refuseExternalDependents(params) {
 }
 
 // packages/migrate/src/module-history.ts
-import { VibeError as VibeError25, sqlObjectKey as sqlObjectKey9, providerToDialect as providerToDialect3 } from "@vibeorm/schema";
+import { VibeError as VibeError26, sqlObjectKey as sqlObjectKey9, providerToDialect as providerToDialect3 } from "@vibeorm/schema";
 function refusal2(params) {
-  return new VibeError25({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
+  return new VibeError26({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
 }
 function moduleHistoryHeads(params) {
   const heads = new Map;
@@ -5424,11 +5539,11 @@ function assertModuleUpgradeHistory(params) {
 }
 
 // packages/migrate/src/module-journal.ts
-import { VibeError as VibeError27 } from "@vibeorm/schema";
+import { VibeError as VibeError28 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect7, MODULE_JOURNAL_COLUMN, renderModuleJournal } from "@vibeorm/sql";
 
 // packages/migrate/src/journal-read.ts
-import { VibeError as VibeError26 } from "@vibeorm/schema";
+import { VibeError as VibeError27 } from "@vibeorm/schema";
 var MISSING_TABLE_IDENTIFIERS = new Set(["42P01", "42S02", "ER_NO_SUCH_TABLE"]);
 function isMissingTable(params) {
   let current = params.cause;
@@ -5452,7 +5567,7 @@ async function readJournalRows(params) {
       if (presence.state === "missing")
         return;
     }
-    throw new VibeError26({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
+    throw new VibeError27({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
   });
   if (rows === undefined)
     return;
@@ -5460,7 +5575,7 @@ async function readJournalRows(params) {
   for (const row of rows) {
     const index = row.statement_index;
     if (typeof row.name !== "string" || typeof row.checksum !== "string" || typeof index !== "number" && typeof index !== "string" || typeof index === "string" && !/^-?\d+$/.test(index) || !Number.isSafeInteger(Number(index)) || row.module_origin !== null && row.module_origin !== undefined && typeof row.module_origin !== "string" || row.error !== null && row.error !== undefined && typeof row.error !== "string" || result.has(row.name)) {
-      throw new VibeError26({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
+      throw new VibeError27({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
     }
     result.set(row.name, { checksum: row.checksum, statementIndex: Number(index), ...typeof row.error === "string" ? { error: row.error } : {}, ...typeof row.module_origin === "string" ? { moduleEntry: row.module_origin } : {} });
   }
@@ -5469,7 +5584,7 @@ async function readJournalRows(params) {
 
 // packages/migrate/src/module-journal.ts
 function invalid6() {
-  return new VibeError27({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
+  return new VibeError28({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
 }
 function parseModuleJournalEntry(params) {
   return parseMigrationMetadata({ text: params.text, failure: invalid6, parse: (value) => {
@@ -5528,7 +5643,7 @@ function moduleRecordComplete(params) {
 }
 
 // packages/migrate/src/runner.ts
-import { VibeError as VibeError35 } from "@vibeorm/schema";
+import { VibeError as VibeError36 } from "@vibeorm/schema";
 import {
   DIALECT_CAPABILITIES as DIALECT_CAPABILITIES3,
   getSqlDialect as getSqlDialect9,
@@ -5538,7 +5653,7 @@ import {
 } from "@vibeorm/sql";
 
 // packages/migrate/src/recovery.ts
-import { VibeError as VibeError28 } from "@vibeorm/schema";
+import { VibeError as VibeError29 } from "@vibeorm/schema";
 import {
   getSqlDialect as getSqlDialect8,
   renderColumnStateQuery,
@@ -5554,7 +5669,7 @@ function constraintUnverifiable(params) {
   });
 }
 function conflict2(params) {
-  return new VibeError28({
+  return new VibeError29({
     code: "VIBE_MIGRATION",
     message: params.message,
     meta: { reason: params.reason, ...params.meta }
@@ -5659,10 +5774,10 @@ async function establishOperationState(params) {
 
 // packages/migrate/src/differ.ts
 import { assertIndexOperatorClasses as assertIndexOperatorClasses2, isEnumType as isEnumType6, qualifiedSqlName as qualifiedSqlName9, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
-import { VibeError as VibeError30 } from "@vibeorm/schema";
+import { VibeError as VibeError31 } from "@vibeorm/schema";
 
 // packages/migrate/src/renames.ts
-import { VibeError as VibeError29, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { VibeError as VibeError30, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 function tableOf(model) {
   return model.dbName ?? model.name;
 }
@@ -5673,7 +5788,7 @@ function hasColumn(params) {
   return params.model.fields.some((field) => (field.dbName ?? field.name) === params.column);
 }
 function ambiguous(params) {
-  return new VibeError29({
+  return new VibeError30({
     code: "VIBE_MIGRATION",
     message: `rename refused: ${params.detail}`,
     meta: { reason: "rename-ambiguous", ...params.meta }
@@ -5775,17 +5890,34 @@ function planRenames(params) {
 
 // packages/migrate/src/differ.ts
 function diffSchemas(params) {
+  return diffSchemasWithNormalization(params).steps;
+}
+function diffSchemasWithNormalization(params) {
   const dialect = params.dialect ?? "postgres";
   assertIndexOperatorClasses2({ schema: params.to, dialect });
-  for (const kind of ["models", "enums"])
+  for (const kind of ["models", "enums"]) {
+    const sourceByName = new Map;
+    const sourcePhysical = new Set;
+    const targetPhysical = new Set(params.to[kind].map((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect })));
+    const removedByBasename = new Map;
+    for (const entry of params.from[kind]) {
+      if (!sourceByName.has(entry.name))
+        sourceByName.set(entry.name, entry);
+      const basename = entry.dbName ?? entry.name;
+      const key = physicalNameKey({ name: basename, namespace: entry.namespace, dialect });
+      sourcePhysical.add(key);
+      if (!targetPhysical.has(key) && !removedByBasename.has(basename))
+        removedByBasename.set(basename, entry);
+    }
     for (const entry of params.to[kind]) {
       const key = physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect });
-      const before = params.from[kind].find((candidate) => candidate.name === entry.name) ?? params.from[kind].find((candidate) => (candidate.dbName ?? candidate.name) === (entry.dbName ?? entry.name) && !params.to[kind].some((target) => physicalNameKey({ name: target.dbName ?? target.name, namespace: target.namespace, dialect }) === physicalNameKey({ name: candidate.dbName ?? candidate.name, namespace: candidate.namespace, dialect })));
-      if (before !== undefined && qualifiedSqlName9({ name: entry.name, namespace: before.namespace }).namespace !== qualifiedSqlName9({ name: entry.name, namespace: entry.namespace }).namespace && !params.from[kind].some((candidate) => physicalNameKey({ name: candidate.dbName ?? candidate.name, namespace: candidate.namespace, dialect }) === key))
+      const before = sourceByName.get(entry.name) ?? removedByBasename.get(entry.dbName ?? entry.name);
+      if (before !== undefined && qualifiedSqlName9({ name: entry.name, namespace: before.namespace }).namespace !== qualifiedSqlName9({ name: entry.name, namespace: entry.namespace }).namespace && !sourcePhysical.has(key))
         throw unsupportedCapability10({ dialect, feature: "automaticNamespaceMove", hint: "Moving populated objects to a fixed namespace requires an explicit reviewed migration" });
     }
-  for (const schema of [params.from, params.to])
-    normalizeSchema({ schema, dialect });
+  }
+  let from = normalizeSchema({ schema: params.from, dialect });
+  const to = normalizeSchema({ schema: params.to, dialect });
   for (const schema of [params.from, params.to])
     if (dialect !== "postgres" && schema.models.some((model) => (model.exclusions?.length ?? 0) > 0))
       throw unsupportedCapability10({ dialect, feature: "exclusionConstraints" });
@@ -5794,11 +5926,12 @@ function diffSchemas(params) {
   if (dialect !== "postgres")
     refuseScalarListColumns({ schema: params.to, dialect });
   const renamed = planRenames({ from: params.from, to: params.to, renames: params.renames ?? [], dialect });
+  if (renamed.from !== params.from)
+    from = normalizeSchema({ schema: renamed.from, dialect });
   params = { ...params, from: renamed.from };
-  const from = normalizeSchema({ schema: params.from, dialect });
-  const to = normalizeSchema({ schema: params.to, dialect });
+  const sourceNamespaces = new Set(dialect === "postgres" ? schemaNamespaces({ schema: params.from }) : []);
   const buckets = {
-    createNamespace: dialect === "postgres" ? schemaNamespaces({ schema: params.to }).filter((namespace) => !schemaNamespaces({ schema: params.from }).includes(namespace)).map((namespace) => ({ kind: "createNamespace", namespace, destructive: false })) : [],
+    createNamespace: dialect === "postgres" ? schemaNamespaces({ schema: params.to }).filter((namespace) => !sourceNamespaces.has(namespace)).map((namespace) => ({ kind: "createNamespace", namespace, destructive: false })) : [],
     dropExclusion: [],
     addExclusion: [],
     dropView: [],
@@ -5826,16 +5959,22 @@ function diffSchemas(params) {
   diffViews({ from, to, buckets });
   diffJoinTables({ from, to, buckets });
   diffTables({ from, to, buckets, dialect });
+  const sourceModels = new Map;
+  for (const model of params.from.models) {
+    const key = physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect });
+    if (!sourceModels.has(key))
+      sourceModels.set(key, model);
+  }
   for (const model of params.to.models) {
     const table = model.dbName ?? model.name;
     const placement = model.namespace === undefined ? {} : { namespace: model.namespace };
-    const previous = params.from.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect }) === physicalNameKey({ name: table, namespace: model.namespace, dialect }));
+    const previous = sourceModels.get(physicalNameKey({ name: table, namespace: model.namespace, dialect }));
     for (const exclusion of model.exclusions ?? []) {
       const before = previous?.exclusions?.find((entry) => entry.name === exclusion.name);
       if (before?.definition === exclusion.definition)
         continue;
       if (before?.catalogDefinition)
-        throw new VibeError30({ code: "VIBE_MIGRATION", message: "Exclusion comparison requires normalized evidence", meta: { reason: "exclusion-inspection-unavailable", table, name: exclusion.name } });
+        throw new VibeError31({ code: "VIBE_MIGRATION", message: "Exclusion comparison requires normalized evidence", meta: { reason: "exclusion-inspection-unavailable", table, name: exclusion.name } });
       if (before !== undefined)
         buckets.dropExclusion.push({ kind: "dropExclusion", table, ...placement, exclusion: before, destructive: false });
       buckets.addExclusion.push({ kind: "addExclusion", table, ...placement, exclusion, destructive: false });
@@ -5845,7 +5984,8 @@ function diffSchemas(params) {
         buckets.dropExclusion.push({ kind: "dropExclusion", table, exclusion, destructive: false });
   }
   refuseDependentEnumStorageChanges({ from, to, buckets, dialect });
-  return withRlsSteps({ from: params.from, to: params.to, steps: [
+  refuseMysqlForeignKeyColumnRewrites({ from, to, buckets, dialect });
+  return { from, to, steps: withRlsSteps({ from: params.from, to: params.to, steps: [
     ...buckets.createNamespace,
     ...renamed.steps,
     ...buckets.dropView,
@@ -5869,7 +6009,7 @@ function diffSchemas(params) {
     ...buckets.addForeignKey,
     ...buckets.createJoinTable,
     ...buckets.dropEnum
-  ] });
+  ] }) };
 }
 function refuseScalarListColumns(params) {
   const { schema, dialect } = params;
@@ -5936,6 +6076,40 @@ function refuseDependentEnumStorageChanges(params) {
     }
   }
 }
+function refuseMysqlForeignKeyColumnRewrites(params) {
+  const { from, to, buckets, dialect } = params;
+  if (dialect !== "mysql")
+    return;
+  const droppedFks = new Set(buckets.dropForeignKey.map((step) => step.kind === "dropForeignKey" ? `${step.table}\x00${step.constraintName}` : ""));
+  for (const step of buckets.alterColumn) {
+    if (step.kind !== "alterColumn")
+      continue;
+    const collation = step.changes.includes("collation");
+    const type = step.changes.includes("type") && !isMysqlVarcharWidening({ from: step.from, to: step.to });
+    if (!collation && !type)
+      continue;
+    const joined = [...from.joinTables].some(([key, join]) => to.joinTables.has(key) && [join.a, join.b].some((end) => end.table === step.table && end.column === step.column));
+    const foreign = [...from.tables].some(([tableKey, table]) => [...table.fks].some(([fkKey, fk]) => to.tables.get(tableKey)?.fks.has(fkKey) === true && !droppedFks.has(`${table.table}\x00${fk.constraintName}`) && (table.table === step.table && fk.columns.includes(step.column) || fk.refTable === step.table && fk.refColumns.includes(step.column))));
+    if (!joined && !foreign)
+      continue;
+    throw unsupportedCapability10({
+      dialect,
+      feature: `${collation ? "collation" : "type"} change of "${step.table}"."${step.column}" ${joined ? "referenced by an implicit many-to-many join table" : "in a foreign key"}`,
+      hint: `drop the foreign key, change both columns' ${collation ? "collation" : "type"} and re-add it in a reviewed manual migration`
+    });
+  }
+}
+function isMysqlVarcharWidening(params) {
+  const length = (field) => {
+    if (isEnumType6(field.type) || field.isList || field.isUnsupported === true)
+      return null;
+    const match = /^varchar\((\d+)\)$/.exec(normalizeMysqlType({ raw: mysqlColumnTypeSql({ field, enums: new Map }) }));
+    return match === null ? null : Number(match[1]);
+  };
+  const before = length(params.from);
+  const after = length(params.to);
+  return before !== null && after !== null && after >= before;
+}
 function diffViews(params) {
   const { from, to, buckets } = params;
   for (const [name, view] of from.views) {
@@ -6044,7 +6218,7 @@ function diffOneTable(params) {
       continue;
     }
     const changes = [];
-    if (before.typeKey !== column.typeKey)
+    if (columnTypeChanged({ declared: column, actual: before }))
       changes.push("type");
     if (before.nullable !== column.nullable)
       changes.push("nullability");
@@ -6067,7 +6241,7 @@ function diffOneTable(params) {
           assertStringEnumLabelsFit({ field: column.field, values, dialect, table });
       }
     }
-    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(storageChange && column.field.type === "String");
+    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(dialect === "postgres" && isTimestamptzPrecisionWidening({ from: before.field, to: column.field })) && !(storageChange && column.field.type === "String");
     if (dialect !== "postgres" && changes.includes("type") && isEnumType6(before.field.type) && isEnumType6(column.field.type)) {
       const fromValues = resolveEnumValues({ name: before.field.type.enum, enums: fromEnums });
       const toValues = resolveEnumValues({ name: column.field.type.enum, enums: toEnums });
@@ -6091,7 +6265,7 @@ function diffOneTable(params) {
       from: before.field,
       to: column.field,
       changes,
-      destructive: narrowingType || collationChanged
+      destructive: narrowingType || collationChanged || dialect === "mysql" && before.nullable && !column.nullable
     });
   }
   for (const [name] of previous.columns) {
@@ -6099,9 +6273,7 @@ function diffOneTable(params) {
       buckets.dropColumn.push({ kind: "dropColumn", table, ...placement, column: name, destructive: true });
     }
   }
-  const pkBefore = previous.pk.join(",");
-  const pkAfter = current.pk.join(",");
-  if (pkBefore !== pkAfter) {
+  if (previous.pk.length !== current.pk.length || previous.pk.some((column, index) => column !== current.pk[index])) {
     if (previous.pk.length > 0) {
       buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, ...placement, destructive: false, ...previous.model.primaryKeyConstraintName === undefined ? {} : { constraintName: previous.model.primaryKeyConstraintName } });
     }
@@ -6121,7 +6293,7 @@ function diffOneTable(params) {
     if (before === expression)
       continue;
     if (before !== undefined && previous.model.checks?.some((check) => check.name === name && check.catalogExpression === true))
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: "Unequal catalog CHECK text requires normalized evidence or explicit replacement through the live planner", meta: { reason: "check-inspection-unavailable", table, name } });
+      throw new VibeError31({ code: "VIBE_MIGRATION", message: "Unequal catalog CHECK text requires normalized evidence or explicit replacement through the live planner", meta: { reason: "check-inspection-unavailable", table, name } });
     if (before !== undefined)
       buckets.dropCheck.push({ kind: "dropCheck", table, ...placement, name, destructive: false });
     buckets.addCheck.push({ kind: "addCheck", table, ...placement, name, expression, destructive: false });
@@ -6207,11 +6379,11 @@ function diffOneTable(params) {
 }
 
 // packages/migrate/src/ddl/render.ts
-import { VibeError as VibeError34, sqlObjectKey as sqlObjectKey10 } from "@vibeorm/schema";
+import { VibeError as VibeError35, sqlObjectKey as sqlObjectKey10 } from "@vibeorm/schema";
 
 // packages/migrate/src/ddl/postgres.ts
 import { renderExclusionSetup } from "@vibeorm/sql";
-import { VibeError as VibeError31, assertSqlNamespace as assertSqlNamespace3, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { VibeError as VibeError32, assertSqlNamespace as assertSqlNamespace3, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect9, renderRlsPolicyPath, renderIndexColumns } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
@@ -6248,7 +6420,7 @@ function refuseSameTransactionEnumUse(params) {
       const found = use(field);
       if (found === undefined)
         continue;
-      throw new VibeError31({
+      throw new VibeError32({
         code: "VIBE_MIGRATION",
         message: `enum value "${found.value}" is added to "${found.enumName}" and used as a default on "${step.table}"."${field.dbName ?? field.name}" in the same migration \u2014 PostgreSQL cannot use an enum member before the transaction that added it commits. Split this into two migrations: the first containing only the ALTER TYPE ... ADD VALUE, the second the column change`,
         meta: { enum: found.enumName, value: found.value, table: step.table, column: field.dbName ?? field.name, rule: "enum-value-used-in-adding-transaction" }
@@ -6322,7 +6494,7 @@ ${lines.join(`,
     case "dropIndex":
       if (step.constraintName !== undefined) {
         if (step.table === undefined)
-          throw new VibeError31({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
+          throw new VibeError32({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
         return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.constraintName)};`];
       }
       return [`DROP INDEX ${qualifiedName(step.name, step.namespace)};`];
@@ -6387,7 +6559,7 @@ function columnDefSql(params) {
   const { field } = params;
   const name = q2(field.dbName ?? field.name);
   if (field.default?.kind === "autoincrement" && !isIdentityColumn({ field })) {
-    throw new VibeError31({
+    throw new VibeError32({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -6423,7 +6595,7 @@ function renderAlterColumn(params) {
   }
   if (step.changes.includes("default") || droppedDefault) {
     if (step.to.default?.kind === "autoincrement") {
-      throw new VibeError31({
+      throw new VibeError32({
         code: "VIBE_MIGRATION",
         message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
         meta: { table: step.table, column: step.column }
@@ -6443,7 +6615,7 @@ function q2(name) {
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError32, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { VibeError as VibeError33, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 import { sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -6591,7 +6763,7 @@ function renderSqliteSteps(params) {
         continue;
       const awaitsNewParent = [...toNorm?.tables.get(table)?.fks.values() ?? []].some((fk) => createdTables.has(fk.refTable));
       if (awaitsNewParent) {
-        throw new VibeError32({
+        throw new VibeError33({
           code: "VIBE_MIGRATION",
           message: `cannot order this sqlite migration safely: rebuilding "${table}" must happen BEFORE the dropped table(s) it references (${[
             ...droppedTables
@@ -6620,7 +6792,7 @@ function renderSqliteSteps(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError33({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "createEnum":
       case "dropEnum":
       case "addEnumValue":
@@ -6706,7 +6878,7 @@ function renderSqliteSteps(params) {
       case "renameColumn": {
         const renamed = step.kind === "renameTable" ? step.from : step.table;
         if (rebuildSet.has(renamed) || step.kind === "renameTable" && rebuildSet.has(step.to)) {
-          throw new VibeError32({
+          throw new VibeError33({
             code: "VIBE_MIGRATION",
             message: `sqlite cannot rename "${renamed}" in the same migration that rebuilds it \u2014 the table-rebuild recipe is written against a single table name. Split the rename and the column/constraint change into two migrations`,
             meta: { reason: "rename-ambiguous", table: renamed, dialect: "sqlite" }
@@ -6760,7 +6932,7 @@ function classifyRebuilds(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError33({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "alterColumn":
       case "dropForeignKey":
       case "addPrimaryKey":
@@ -6821,7 +6993,7 @@ function renderTableRebuild(params) {
   const source = from.tables.get(table);
   const target = to.tables.get(table);
   if (source === undefined || target === undefined) {
-    throw new VibeError32({
+    throw new VibeError33({
       code: "VIBE_MIGRATION",
       message: `cannot rebuild "${table}" \u2014 the table is missing from the ${source === undefined ? "from" : "to"} schema`,
       meta: { table }
@@ -6956,7 +7128,7 @@ function columnDefSql2(params) {
   const { field, constraintTable, enums, inlinePkAutoincrement } = params;
   const name = field.dbName ?? field.name;
   if (field.default?.kind === "autoincrement" && !inlinePkAutoincrement) {
-    throw new VibeError32({
+    throw new VibeError33({
       code: "VIBE_MIGRATION",
       message: `autoincrement on sqlite requires "${field.name}" to be the single-column Int or BigInt primary key`,
       meta: { field: field.name }
@@ -6975,7 +7147,7 @@ function columnDefSql2(params) {
     const enumName = field.type.enum;
     const values = resolveEnumValues({ name: enumName, enums });
     if (values === undefined) {
-      throw new VibeError32({
+      throw new VibeError33({
         code: "VIBE_MIGRATION",
         message: `enum "${enumName}" on column "${field.name}" is not declared in the schema \u2014 sqlite rendering needs the target schema's enums for the CHECK constraint`,
         meta: { field: field.name, enum: enumName }
@@ -7010,7 +7182,7 @@ function requireSchemas(params) {
   const { step, fromNorm, toNorm } = params;
   if (fromNorm !== undefined && toNorm !== undefined)
     return;
-  throw new VibeError32({
+  throw new VibeError33({
     code: "VIBE_MIGRATION",
     message: `sqlite step "${describeStep({ step })}" requires a table rebuild \u2014 renderSteps needs the { from, to } schemas to construct it`,
     meta: { step: step.kind }
@@ -7021,7 +7193,7 @@ function q3(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError33, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { VibeError as VibeError34, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect3 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps) {
@@ -7169,12 +7341,12 @@ ${lines.join(`,
       ];
     case "addExclusion":
     case "dropExclusion":
-      throw new VibeError33({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
+      throw new VibeError34({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
     case "dropCheck":
       return [`ALTER TABLE ${q4(step.table)} DROP CHECK ${q4(step.name)};`];
     case "dropIndex": {
       if (step.table === undefined) {
-        throw new VibeError33({
+        throw new VibeError34({
           code: "VIBE_MIGRATION",
           message: `dropIndex "${step.name}" carries no table \u2014 mysql's DROP INDEX requires one`,
           meta: { index: step.name }
@@ -7204,8 +7376,8 @@ ${lines.join(`,
     case "dropForeignKey":
       return [`ALTER TABLE ${q4(step.table)} DROP FOREIGN KEY ${q4(step.constraintName)};`];
     case "createJoinTable": {
-      const aType = mysqlColumnTypeSql({ field: { ...step.a.field, isList: false }, enums });
-      const bType = mysqlColumnTypeSql({ field: { ...step.b.field, isList: false }, enums });
+      const aType = joinColumnTypeSql({ field: step.a.field, enums });
+      const bType = joinColumnTypeSql({ field: step.b.field, enums });
       const names = implicitJoinTableObjectNames4({ table: step.table });
       return [
         `CREATE TABLE ${q4(step.table)} (
@@ -7226,12 +7398,17 @@ ${lines.join(`,
       return [`ALTER TABLE ${q4(step.table)} DROP PRIMARY KEY;`];
   }
 }
+function joinColumnTypeSql(params) {
+  const { field, enums } = params;
+  const type = mysqlColumnTypeSql({ field: { ...field, isList: false }, enums });
+  return field.collation === undefined ? type : `${type} COLLATE ${q4(field.collation)}`;
+}
 function columnDefSql3(params) {
   const { field, enums } = params;
   const name = q4(field.dbName ?? field.name);
   const autoincrement = field.default?.kind === "autoincrement";
   if (autoincrement && field.type !== "Int" && field.type !== "BigInt") {
-    throw new VibeError33({
+    throw new VibeError34({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -7253,7 +7430,7 @@ function renderAlterColumn2(params) {
   const { step, enums } = params;
   assertEnumStringTransition({ from: step.from, to: step.to, dialect: "mysql", table: step.table, column: step.column });
   if (step.to.default?.kind === "autoincrement" && step.from.default?.kind !== "autoincrement") {
-    throw new VibeError33({
+    throw new VibeError34({
       code: "VIBE_MIGRATION",
       message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
       meta: { table: step.table, column: step.column }
@@ -7293,24 +7470,24 @@ function declaredSqlitePreservation(params) {
       continue;
     const facts = object.expected?.facts;
     if (facts === undefined)
-      throw new VibeError34({ code: "VIBE_MIGRATION", message: "SQLite rebuild requires independently declared preservation definitions", meta: { reason: "sqlite-preservation-unavailable", identity } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: "SQLite rebuild requires independently declared preservation definitions", meta: { reason: "sqlite-preservation-unavailable", identity } });
     if (identity.kind === "trigger" || identity.kind === "index") {
       if (identity.kind === "index" && to.models.some((model) => (model.dbName ?? model.name) === identity.table.name && model.indexes.some((index) => index.name === identity.name)))
         continue;
       if (typeof facts.definition !== "string")
-        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite restoration SQL", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: "Missing SQLite restoration SQL", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const statements = restore.get(identity.table.name) ?? [];
       statements.push(facts.definition);
       restore.set(identity.table.name, statements);
     } else if (identity.kind === "column" || identity.kind === "generatedColumn") {
       if (typeof facts.columnDefinition !== "string")
-        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite column clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: "Missing SQLite column clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const fields = columns.get(identity.table.name) ?? new Map;
       fields.set(identity.column, { sql: facts.columnDefinition, generated: Number(facts.generated) > 1 });
       columns.set(identity.table.name, fields);
     } else if (identity.kind === "columnDefault") {
       if (facts.definition !== null && typeof facts.definition !== "string")
-        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite default clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: "Missing SQLite default clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const expression = facts.definition;
       to = { ...to, models: to.models.map((model) => (model.dbName ?? model.name) !== identity.table.name ? model : { ...model, fields: model.fields.map((field) => {
         if ((field.dbName ?? field.name) !== identity.column)
@@ -7347,7 +7524,7 @@ function renderSteps(params) {
 }
 
 // packages/migrate/src/extensions.ts
-import { extensionDeclarations } from "@vibeorm/schema";
+import { extensionDeclarations, providerToDialect as providerToDialect4, qualifiedSqlName as qualifiedSqlName10, SQL_NAMESPACES } from "@vibeorm/schema";
 function collectExtensionArtifacts(params) {
   const { schema, dialect, extensions } = params;
   const setup = [];
@@ -7414,6 +7591,10 @@ function stripExtensionArtifacts(params) {
   const models = [];
   for (const model of schema.models) {
     const tableName = model.dbName ?? model.name;
+    if (providerToDialect4({ provider: schema.datasource.provider }) === "postgres" && qualifiedSqlName10({ name: tableName, namespace: model.namespace }).namespace !== SQL_NAMESPACES.postgres) {
+      models.push(model);
+      continue;
+    }
     if (tables.exact.has(tableName) || tables.prefixes.some((prefix) => tableName.startsWith(prefix))) {
       continue;
     }
@@ -7437,6 +7618,8 @@ function planMissingArtifacts(params) {
     return [];
   const modelByTable = new Map;
   for (const model of introspected.models) {
+    if (providerToDialect4({ provider: introspected.datasource.provider }) === "postgres" && qualifiedSqlName10({ name: model.dbName ?? model.name, namespace: model.namespace }).namespace !== SQL_NAMESPACES.postgres)
+      continue;
     modelByTable.set(model.dbName ?? model.name, model);
   }
   return artifacts.filter((artifact) => {
@@ -7595,10 +7778,10 @@ function assertNativeMigrationMetadata(params) {
   if (!native)
     return;
   if (!DIALECT_CAPABILITIES3[params.dialect].nativeRowLevelSecurity) {
-    throw new VibeError35({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
+    throw new VibeError36({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
   }
   if (params.migration.rls === undefined) {
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Native RLS migration files require trusted rls.from/rls.to schema metadata. SQL alone cannot prove policy ownership or drift; regenerate with preserved security metadata.", meta: { reason: "rls-migration-metadata-required", migration: params.migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Native RLS migration files require trusted rls.from/rls.to schema metadata. SQL alone cannot prove policy ownership or drift; regenerate with preserved security metadata.", meta: { reason: "rls-migration-metadata-required", migration: params.migration.name } });
   }
 }
 var PG_ADVISORY_LOCK_KEY = 1447645253;
@@ -7679,12 +7862,12 @@ function generateMigration(params) {
     }),
     ...orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).flatMap((object) => {
       if (object.dialect !== dialect)
-        throw new VibeError35({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}` });
+        throw new VibeError36({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}` });
       const previous = (params.desiredState?.from.schema.migrationObjects ?? from.migrationObjects)?.find((entry) => entry.id === object.id);
       if (previous === undefined)
         return [...object.create];
       if (JSON.stringify(previous) !== JSON.stringify(object))
-        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", shadowReusable: true, id: object.id } });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", shadowReusable: true, id: object.id } });
       return [];
     })
   ];
@@ -7710,8 +7893,8 @@ async function withMigrationLock(params) {
     }, (cause) => releaseLock({ executor, dialect: params.dialect }).then(() => {
       throw cause;
     }, (cleanupCause) => {
-      if (cause instanceof VibeError35)
-        throw new VibeError35({ code: cause.code, message: cause.message, meta: { ...cause.meta, cleanupCause }, cause });
+      if (cause instanceof VibeError36)
+        throw new VibeError36({ code: cause.code, message: cause.message, meta: { ...cause.meta, cleanupCause }, cause });
       throw cause;
     }));
   };
@@ -7741,11 +7924,11 @@ function assertMigrationMetadata(params) {
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   if (migration.desiredStatePending === true)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration ${migration.name} has unfinalized desired state; finalize its reviewed before/after declarations before applying`, meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration ${migration.name} has unfinalized desired state; finalize its reviewed before/after declarations before applying`, meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   if (migration.desiredState !== undefined) {
     assertDesiredState({ value: migration.desiredState, migration: migration.name });
     if (migration.desiredState.dialect !== dialect)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch", migration: migration.name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch", migration: migration.name } });
   }
   assertNativeMigrationMetadata({ migration, sql: migration.sql, dialect });
   assertExecutable({ migration, execution: migration.execution, sql: migration.sql, dialect });
@@ -7755,7 +7938,7 @@ async function applyMigrations(params) {
   const dialect = params.dialect ?? "postgres";
   const trustedReplay = isShadowReplayExecutor({ executor });
   if (params.history !== undefined && params.history !== "complete" && params.history !== "subset")
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
   if (params.history === "complete")
     assertDistinctMigrationNames({ migrations });
   for (const migration of migrations)
@@ -7771,7 +7954,7 @@ async function applyMigrations(params) {
       assertModuleUpgradeHistory({ migrations, records: moduleRecords });
       const namespace = await migrationNamespace({ executor, dialect });
       if (dialect !== "postgres" && migrations.some((migration) => migration.moduleOrigin !== undefined && moduleNamespace({ origin: migration.moduleOrigin }) !== namespace))
-        throw new VibeError35({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
     }
     if (params.history === "complete")
       assertCompleteHistory({ migrations, recorded, dialect });
@@ -7782,7 +7965,7 @@ async function applyMigrations(params) {
     });
     const adopted = pending.find((migration) => migration.moduleAdoption !== undefined);
     if (adopted !== undefined && !trustedReplay)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: "An adopted source must be recorded by the verified adoption workflow, never executed by ordinary apply", meta: { reason: "module-adoption-recording-required", migration: adopted.name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: "An adopted source must be recorded by the verified adoption workflow, never executed by ordinary apply", meta: { reason: "module-adoption-recording-required", migration: adopted.name } });
     if (external !== undefined && !trustedReplay)
       for (const migration of pending)
         await assertExternalMigrationMutation({ executor, migration, dialect, namespace: await migrationNamespace({ executor, dialect }), external });
@@ -7798,7 +7981,7 @@ async function applyMigrations(params) {
         await assertLiveModuleOwnership({ executor, origin: migration.moduleOrigin, resume: stored !== undefined });
       if (stored !== undefined) {
         if (stored.statementIndex < 0) {
-          throw new VibeError35({
+          throw new VibeError36({
             code: "VIBE_MIGRATION",
             message: `migration "${migration.name}" is mid-rollback (${-stored.statementIndex - 1} down statement(s) done) \u2014 finish it with \`migrate down\` or repair with resolveMigration before applying`,
             meta: { migration: migration.name, statementIndex: stored.statementIndex }
@@ -7956,7 +8139,7 @@ async function repairMigration(params) {
   const { executor, name, dialect } = params;
   const moduleRecord = (await readModuleJournal({ executor, dialect })).get(name);
   if (moduleRecord?.entry !== undefined)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
   await ensureMigrationsTable({ executor, dialect });
   if (params.as === "applied") {
     const insert = `INSERT INTO ${q5(dialect, MIGRATIONS_TABLE_NAME)} (${q5(dialect, "name")}, ${q5(dialect, "checksum")}, ${q5(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, ${RESOLVED_STATEMENT_INDEX})`;
@@ -7978,7 +8161,7 @@ async function rollbackMigration(params) {
     const stored = assertRollbackRecord({ migration, stored: recorded.get(migration.name), dialect });
     const newest = [...recorded.keys()].at(-1);
     if (newest !== migration.name)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
     await validateRollbackRecovery({ executor, migration, downSql, stored, dialect });
     await executeRollback({ ...params, executor, dialect, downSql, stored });
   } });
@@ -7996,7 +8179,7 @@ async function rollbackMigrations(params) {
       const target = journal.findIndex((row) => row.name === params.to);
       const row = journal[target];
       if (row?.state !== "applied")
-        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
       assertMigrationMetadata({ migration: byName.get(row.name), dialect });
       start = target + 1;
     }
@@ -8004,7 +8187,7 @@ async function rollbackMigrations(params) {
     for (const row of journal.slice(start).reverse()) {
       const migration = byName.get(row.name);
       if (migration === undefined)
-        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
       const stored = assertRollbackRecord({ migration, stored: recorded.get(row.name), dialect });
       const downSql = validateRollbackFile({ ...params, migration, dialect });
       plan.push({ migration, downSql, stored });
@@ -8023,21 +8206,21 @@ function validateRollbackFile(params) {
   const { migration, dialect } = params;
   assertModuleAdoption({ migration });
   if (migration.moduleAdoption !== undefined)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Reversal across verified module adoption is refused; it would execute destructive source down SQL against pre-existing data", meta: { reason: "module-adoption-reverse-refused", migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Reversal across verified module adoption is refused; it would execute destructive source down SQL against pre-existing data", meta: { reason: "module-adoption-reverse-refused", migration: migration.name } });
   if (migration.desiredStatePending === true)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   if (migration.moduleOrigin !== undefined) {
     assertMaterializedModuleMigration({ migration });
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   const downSql = migration.downSql;
   if (downSql === undefined)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
   assertProbeMode({ dialect, probe: params.probe });
   if (migration.desiredState !== undefined) {
     assertDesiredState({ value: migration.desiredState, migration: migration.name });
     if (migration.desiredState.dialect !== dialect)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch" } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch" } });
     assertRemovalAuthorization({ steps: diffSchemas({ from: migration.desiredState.to.schema, to: (migration.desiredState.down ?? migration.desiredState.from).schema, dialect }), previous: migration.desiredState.to, dialect, namespace: dialect === "sqlite" ? "main" : "public", ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss } });
   }
   assertNativeMigrationMetadata({ migration, sql: downSql, dialect });
@@ -8050,10 +8233,10 @@ function validateRollbackFile(params) {
 function assertRollbackRecord(params) {
   const { migration, stored, dialect } = params;
   if (stored === undefined)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
   assertChecksumMatches({ migration, stored: stored.checksum });
   if (stored.statementIndex >= 0 && (!isCompleteRecord({ dialect, migration, stored }) || stored.error !== undefined))
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
   return stored;
 }
 async function validateRollbackRecovery(params) {
@@ -8062,7 +8245,7 @@ async function validateRollbackRecovery(params) {
     return;
   const start = -stored.statementIndex - 1;
   if (start > downSql.length)
-    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
   if (dialect === "sqlite" && usesSelfManagedTransactions({ sql: downSql }))
     assertSelfManagedResumeSafe({ sql: downSql, start, migration: migration.name, direction: "down" });
   if (!marksInflight({ dialect, execution: migration.downExecution }) || start >= downSql.length)
@@ -8128,7 +8311,7 @@ async function runTransactionalDown(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError35({
+    throw new VibeError36({
       code: "VIBE_MIGRATION",
       message: `rollback of "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name, ...timeoutDiagnostic({ error }) },
@@ -8211,7 +8394,7 @@ async function runNonTransactionalDown(params) {
           values: [marks ? `${INFLIGHT_PREFIX}${index}` : error instanceof Error ? error.message : String(error), migration.name]
         });
       } catch {}
-      throw new VibeError35({
+      throw new VibeError36({
         code: "VIBE_MIGRATION",
         message: `rollback of "${migration.name}" failed at down statement ${index + 1} of ${downSql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running the rollback resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeoutDiagnostic({ error }) },
@@ -8273,7 +8456,7 @@ async function runTransactional(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError35({
+    throw new VibeError36({
       code: "VIBE_MIGRATION",
       message: `migration "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name },
@@ -8369,7 +8552,7 @@ async function runNonTransactional(params) {
       } catch {}
       const sqlState = sqlStateOf(error);
       const timeout = sqlState === "55P03" ? "lock-timeout" : sqlState === "57014" ? "statement-timeout" : undefined;
-      throw new VibeError35({
+      throw new VibeError36({
         code: "VIBE_MIGRATION",
         message: timeout === "lock-timeout" ? `migration "${migration.name}" gave up waiting for a lock at statement ${index + 1} of ${migration.sql.length} (lock_timeout ${String(execution?.lockTimeoutMs ?? 0)}ms, SQLSTATE 55P03). Another session holds a conflicting lock; inspect the declared operation before retrying.` : timeout === "statement-timeout" ? `migration "${migration.name}" exceeded its statement_timeout at statement ${index + 1} of ${migration.sql.length} (${String(execution?.statementTimeoutMs ?? 0)}ms, SQLSTATE 57014). Inspect the declared operation before retrying.` : `migration "${migration.name}" failed at statement ${index + 1} of ${migration.sql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running applyMigrations resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeout === undefined ? {} : { reason: timeout, sqlState } },
@@ -8397,7 +8580,7 @@ async function acquireLock(params) {
     });
     const acquired = Number(rows[0]?.vibe_lock) === 1;
     if (!acquired) {
-      throw new VibeError35({
+      throw new VibeError36({
         code: "VIBE_MIGRATION",
         message: `could not acquire the migration lock ('${MYSQL_LOCK_NAME}') within ${MYSQL_LOCK_TIMEOUT_SECONDS}s \u2014 another migration run is in progress`,
         meta: { lock: MYSQL_LOCK_NAME }
@@ -8432,7 +8615,7 @@ function uncertainStatement(params) {
   const subject = direction === "down" ? `rollback of "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${statements.length}`;
   const why = dialect === "mysql" ? "MySQL commits every statement on its own, so nothing outside the statement records whether it finished." : "That statement declares no operation whose effect recovery can read back from the catalog.";
-  return new VibeError35({
+  return new VibeError36({
     code: "VIBE_MIGRATION",
     message: `${subject} was interrupted while ${position} was running. ${why} ` + "It may or may not have committed, and replaying it could apply it twice, so VibeORM stops here instead of guessing. " + 'Inspect what that statement did to the database, then follow "Recovering from a stopped migration" in docs/migrations.md: ' + `clear the \`error\` column of this migration's journal row if the statement did NOT land, set \`statement_index\` to ${direction === "down" ? -(index + 2) : index + 1} if it DID, ` + "or finish the whole migration by hand and record that with `vibeorm migrate resolve --applied`. " + `The statement was: ${statements[index].slice(0, 200)}`,
     meta: {
@@ -8450,7 +8633,7 @@ function assertExecutable(params) {
   if (execution === undefined || isDefaultExecution({ execution }))
     return;
   if (dialect !== "postgres") {
-    throw new VibeError35({
+    throw new VibeError36({
       code: "VIBE_UNSUPPORTED_CAPABILITY",
       message: `migration "${migration.name}" declares explicit execution semantics (transaction: "${execution.transaction}"), which only the postgres runner implements \u2014 ${dialect} has no separate nontransactional regime to opt into`,
       meta: { reason: "nontransactional-unsupported", dialect, migration: migration.name, feature: "nontransactionalMigrations" }
@@ -8526,7 +8709,7 @@ function assertChecksumMatches(params) {
   const actual = checksumOf({ migration });
   if (stored === actual)
     return;
-  throw new VibeError35({
+  throw new VibeError36({
     code: "VIBE_MIGRATION",
     message: `checksum mismatch for migration "${migration.name}" \u2014 its SQL changed after it was applied (recorded ${stored.slice(0, 12)}\u2026, current ${actual.slice(0, 12)}\u2026)`,
     meta: { migration: migration.name, recorded: stored, current: actual }
@@ -8537,7 +8720,7 @@ function assertResumable(params) {
   const actual = checksumOf({ migration });
   if (stored.checksum === actual)
     return;
-  throw new VibeError35({
+  throw new VibeError36({
     code: "VIBE_MIGRATION",
     message: `migration "${migration.name}" is partially applied (${stored.statementIndex} statement(s) done) and its SQL has CHANGED since \u2014 refusing to resume; restore the original SQL or repair with resolveMigration`,
     meta: {
@@ -8557,7 +8740,7 @@ function assertDistinctMigrationNames(params) {
   const names = new Set;
   for (const migration of params.migrations) {
     if (names.has(migration.name))
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
     names.add(migration.name);
   }
 }
@@ -8565,15 +8748,15 @@ function assertCompleteHistory(params) {
   const byName = new Map(params.migrations.map((migration) => [migration.name, migration]));
   for (const name of params.recorded.keys()) {
     if (!byName.has(name))
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
   }
   let index = 0;
   for (const [name, stored] of params.recorded) {
     const migration = params.migrations[index];
     if (migration?.name !== name)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
     if (stored.statementIndex >= 0 && !isCompleteRecord({ dialect: params.dialect, migration, stored }) && index !== params.recorded.size - 1)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
     index++;
   }
 }
@@ -8582,16 +8765,16 @@ async function assertApplyHistory(params) {
   const byName = new Map(migrations.map((migration) => [migration.name, migration]));
   for (const [name, stored] of recorded) {
     if (stored.statementIndex < 0) {
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
     }
     const migration = byName.get(name);
     if (migration === undefined) {
       if (stored.error !== undefined)
-        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
       continue;
     }
     if (isCompleteRecord({ dialect, migration, stored }) && stored.error !== undefined)
-      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
     if (isCompleteRecord({ dialect, migration, stored }))
       assertChecksumMatches({ migration, stored: stored.checksum });
     else
@@ -8627,7 +8810,7 @@ function absent(error) {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
 }
 function failure(params) {
-  return new VibeError36({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
+  return new VibeError37({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
 }
 async function optionalFile(params) {
   return readFile(params.path, "utf-8").catch((cause) => {
@@ -8641,13 +8824,13 @@ function rlsMetadata(params) {
     const metadata = JSON.parse(params.text);
     const strings = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
     if (metadata?.version !== 1 || typeof metadata.destructive !== "boolean" || metadata.rls === undefined || !strings(metadata.securityChanges) || !strings(metadata.downSecurityChanges) || metadata.sqlChecksum !== migrationChecksum({ sql: params.migration.sql }) || metadata.downChecksum !== migrationChecksum({ sql: params.migration.downSql ?? [] })) {
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
     }
     assertValidSchemaIR4({ schema: metadata.rls.from });
     assertValidSchemaIR4({ schema: metadata.rls.to });
     return { ...params.migration, rls: metadata.rls, destructive: metadata.destructive, securityChanges: metadata.securityChanges, downSecurityChanges: metadata.downSecurityChanges };
   }).catch((cause) => {
-    throw new VibeError36({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
+    throw new VibeError37({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
   });
 }
 async function loadMigrationFiles(params) {
@@ -8679,10 +8862,7 @@ async function loadMigrationFiles(params) {
       migration = { ...migration, ...parseExecutionSidecar({ text: execution, migration: name, statements: migration.sql.length, downStatements: migration.downSql?.length ?? 0 }) };
     const desired = await optionalFile({ path: join(directory, DESIRED_STATE_METADATA.filename) });
     if (desired !== undefined) {
-      const pending = await Promise.resolve().then(() => isUnfinalizedDesiredState({ text: desired })).catch((cause) => {
-        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Malformed desired state for ${name}`, meta: { reason: "desired-state-invalid", migration: name }, cause });
-      });
-      migration = pending ? { ...migration, desiredStatePending: true } : { ...migration, desiredState: parseDesiredStateSidecar({ text: desired, migration: name }) };
+      migration = { ...migration, ...loadDesiredStateSidecar({ text: desired, migration: name }) };
     }
     const origin = await optionalFile({ path: join(directory, MODULE_ORIGIN_METADATA.filename) });
     if (origin !== undefined)
@@ -8701,4 +8881,4 @@ export {
   splitSqlStatements
 };
 
-//# debugId=91A1E2329350564C64756E2164756E21
+//# debugId=73DFB0227E02518164756E2164756E21