@vibeorm/migrate 2.7.0 → 3.0.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // @bun
 // packages/migrate/src/external-objects.ts
-import { IDENTIFIER_LIMITS, VibeError as VibeError17, identifierLength, sqlNamespaceIssue, sqlObjectKey as sqlObjectKey6, sqlObjectNamespace as sqlObjectNamespace2, qualifiedSqlName as qualifiedSqlName8, enumStorageOf as enumStorageOf3, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { IDENTIFIER_LIMITS, VibeError as VibeError18, identifierLength, sqlNamespaceIssue, sqlObjectKey as sqlObjectKey6, sqlObjectNamespace as sqlObjectNamespace2, qualifiedSqlName as qualifiedSqlName8, enumStorageOf as enumStorageOf3, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect3, renderExternalOwnershipCatalog, renderReplayCoverageGaps } from "@vibeorm/sql";
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError16, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
+import { VibeError as VibeError17, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/exclusions.ts
@@ -85,16 +85,12 @@ async function verifyExclusions(params) {
 
 // packages/migrate/src/inspect-objects.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { VibeError as VibeError15, sqlObjectKey as sqlObjectKey4, sqlObjectNamespace, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2, qualifiedSqlName as qualifiedSqlName7 } from "@vibeorm/schema";
+import { VibeError as VibeError16, sqlObjectKey as sqlObjectKey4, sqlObjectNamespace, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2, qualifiedSqlName as qualifiedSqlName7 } from "@vibeorm/schema";
 import { getSqlDialect, renderMigrationObjectBatch, renderMigrationObjectQuery as renderMigrationObjectQuery2, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2, renderSqliteColumnInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/desired-state.ts
 import { VibeError as VibeError2, assertValidSchemaIR, isSqlObjectDefinition, isSqlObjectIdentity, providerToDialect, sqlObjectKey as sqlObjectKey2 } 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 });
@@ -177,6 +173,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));
@@ -1046,6 +1051,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";
@@ -1058,6 +1089,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) {
@@ -1067,25 +1099,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") {
@@ -1150,48 +1182,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 }),
-      exactTypeKey: columnTypeKeyFor({ field, dialect, enums, exact: true }),
+      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 }
@@ -1225,8 +1258,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;
@@ -1388,22 +1420,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, {
@@ -1420,17 +1452,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 VibeError7({
       code: "VIBE_MIGRATION",
@@ -1438,7 +1470,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 VibeError7({
@@ -1451,7 +1483,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) {
@@ -1467,10 +1499,19 @@ 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/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
@@ -1874,10 +1915,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 VibeError11({ 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) => ({
@@ -1895,6 +1941,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;
@@ -1935,6 +1983,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;
@@ -1969,7 +2018,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;
     })
   }));
@@ -1977,7 +2026,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 VibeError11({ 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) {
@@ -2002,22 +2051,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;
@@ -2025,9 +2076,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 }) });
@@ -2040,14 +2091,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) ?? []
     }));
   }
@@ -2056,10 +2107,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,
@@ -2079,14 +2130,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) => {
@@ -2124,20 +2177,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;
@@ -2422,7 +2473,7 @@ function toNumberOrNull(value) {
 }
 
 // packages/migrate/src/introspect/mysql.ts
-import { exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
+import { VibeError as VibeError12, exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect2 } from "@vibeorm/sql";
 
 // packages/migrate/src/journal-table.ts
@@ -2551,6 +2602,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" }), {
@@ -2562,6 +2619,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 VibeError12({
+        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) {
@@ -2584,17 +2650,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 = [];
   {
@@ -2603,6 +2663,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 VibeError12({ 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)
@@ -2611,8 +2677,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 = {
@@ -2623,7 +2687,8 @@ async function introspectMysql(params) {
         byKey.set(key, {
           table,
           name,
-          unique: Number(catalogField({ row, name: "non_unique" })) === 0,
+          unique,
+          kind,
           columns: [column]
         });
       } else {
@@ -2631,34 +2696,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;
@@ -2670,7 +2740,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;
@@ -2687,9 +2757,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) ?? []
     }));
@@ -2698,7 +2768,7 @@ async function introspectMysql(params) {
     models.push(buildModel2({
       table: view,
       isView: true,
-      columns,
+      columns: columnsByTable.get(view) ?? [],
       pkByTable: new Map,
       indexes: [],
       enums,
@@ -2716,9 +2786,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) {
@@ -2749,7 +2819,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" } : {}
@@ -3281,7 +3351,7 @@ function q(name) {
 }
 
 // packages/migrate/src/execute.ts
-import { VibeError as VibeError12 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
@@ -3322,7 +3392,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 VibeError12({
+  throw new VibeError13({
     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" }
@@ -3351,7 +3421,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 VibeError12({
+  return new VibeError13({
     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 }
@@ -3407,7 +3477,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 VibeError12({
+      throw new VibeError13({
         code: "VIBE_MIGRATION",
         message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
         meta: { violations: rows }
@@ -3462,7 +3532,7 @@ async function prepareOperatorClassDiff(params) {
 }
 
 // packages/migrate/src/postgres-default-equivalence.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } 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*$`);
@@ -3481,7 +3551,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 VibeError13({ 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 VibeError14({ 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;
@@ -3495,7 +3565,7 @@ async function equivalentPostgresDefaultFunction(params) {
 }
 
 // packages/migrate/src/object-ownership.ts
-import { VibeError as VibeError14, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, qualifiedSqlName as qualifiedSqlName6, sqlObjectKey as sqlObjectKey3 } from "@vibeorm/schema";
+import { VibeError as VibeError15, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, qualifiedSqlName as qualifiedSqlName6, sqlObjectKey as sqlObjectKey3 } from "@vibeorm/schema";
 function legacyMigrationObjects(params) {
   return params.artifacts.map((artifact) => {
     const owner = artifact.owns;
@@ -3597,7 +3667,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 }))
@@ -3647,7 +3720,7 @@ function assertRetainedMigrationObjects(params) {
   const keys = new Set(params.to.map((object) => sqlObjectKey3({ identity: object.identity })));
   const removed = params.from.filter((object) => !keys.has(sqlObjectKey3({ identity: object.identity })));
   if (removed.length > 0)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Removing migration ownership requires a reviewed hand-authored migration and new desired state", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removed.map((object) => object.identity) } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Removing migration ownership requires a reviewed hand-authored migration and new desired state", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removed.map((object) => object.identity) } });
 }
 function orderedMigrationObjects(params) {
   const byKey = new Map(params.objects.map((object) => [sqlObjectKey3({ identity: object.identity }), object]));
@@ -3659,7 +3732,7 @@ function orderedMigrationObjects(params) {
     if (visited.has(key))
       return;
     if (visiting.has(key))
-      throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Migration object dependency cycle", meta: { id: object.id } });
+      throw new VibeError15({ code: "VIBE_SCHEMA_INVALID", message: "Migration object dependency cycle", meta: { id: object.id } });
     visiting.add(key);
     for (const dependency of object.dependsOn) {
       const target = byKey.get(sqlObjectKey3({ identity: dependency }));
@@ -3678,10 +3751,10 @@ function assertNamedRemovals(params) {
   const approved = new Set((params.approved ?? []).map((identity) => sqlObjectKey3({ identity })));
   const missing = params.removals.filter((identity) => !approved.has(sqlObjectKey3({ identity })));
   if (missing.length > 0)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Unmanaged removals require individually named approvals", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: missing } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Unmanaged removals require individually named approvals", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: missing } });
   const integrity = params.removals.filter((identity) => identity.kind === "constraint" || identity.kind === "index");
   if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Named constraint or index removals also require acceptIntegrityLoss", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Named constraint or index removals also require acceptIntegrityLoss", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
 }
 function assertRemovalAuthorization(params) {
   const declared = params.previous === undefined ? [] : schemaObjectIdentities({ schema: params.previous.schema, dialect: params.dialect, namespace: params.namespace });
@@ -3706,9 +3779,9 @@ function assertRemovalAuthorization(params) {
     }
   }
   if (unknown.length > 0)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Unknown object removals require individually named removeUnmanaged decisions", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: unknown } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Unknown object removals require individually named removeUnmanaged decisions", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: unknown } });
   if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Constraint or index removal requires acceptIntegrityLoss; data-loss acknowledgement does not authorize it", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Constraint or index removal requires acceptIntegrityLoss; data-loss acknowledgement does not authorize it", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
 }
 
 // packages/migrate/src/inspect-objects.ts
@@ -3793,7 +3866,7 @@ async function inspectSqlObject(params) {
       }
     }
     return { state: "present", definition: { identity: params.identity, facts, dependencies: [], format: "catalog-v2" } };
-  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError15 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError16 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
 }
 function postgresInspection(params) {
   if (!params.addresses.every((address) => typeof address === "string"))
@@ -3808,7 +3881,7 @@ function postgresInspection(params) {
   return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v2" } };
 }
 function unavailableReason(params) {
-  return params.error instanceof VibeError15 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
+  return params.error instanceof VibeError16 ? 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);
@@ -3816,7 +3889,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 VibeError15({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
+        throw new VibeError16({ 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);
@@ -3861,7 +3934,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 VibeError15({ 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 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 } });
 }
 var CATALOG_V1_OMITTED_FACTS = Object.freeze({
   function: ["definerOwner"],
@@ -3885,9 +3958,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 VibeError15({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
+    throw new VibeError16({ 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);
@@ -3910,18 +3994,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));
@@ -4090,7 +4163,7 @@ async function verifyMigrationTransition(params) {
 }
 async function verifySqliteTransitionBeforeRestore(params) {
   if (params.dialect !== "sqlite")
-    throw new VibeError15({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
+    throw new VibeError16({ 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 });
 }
@@ -4100,7 +4173,7 @@ async function verifyTransition(params) {
     for (const identity of params.removals ?? []) {
       const owner = externalObjectOwner({ identity, external });
       if (owner !== undefined)
-        throw new VibeError15({ code: "VIBE_MIGRATION", message: "Transition removals cannot target externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
+        throw new VibeError16({ 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 }) };
   }
@@ -4125,12 +4198,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 VibeError15({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
+    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
   return namespace;
 }
 function assertMigrationState(params) {
   if (!params.report.inSync)
-    throw new VibeError15({ 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 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") } });
 }
 async function deparsePostgresCheck(params) {
   const definition = await deparsePostgresCheckDefinition({ ...params, constraint: "vibeorm_check_probe" });
@@ -4144,7 +4217,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 VibeError15({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError16({ 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" });
@@ -4162,7 +4235,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 VibeError15({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
     const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
     await params.executor({ text: drop.text });
     created = false;
@@ -4173,7 +4246,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 VibeError15({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
     return check.expression;
   } finally {
     if (created) {
@@ -4200,7 +4273,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 VibeError15({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         if (live.definition.facts.definition === desired) {
           checks.push(next);
           continue;
@@ -4212,7 +4285,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 VibeError15({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError16({ 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;
       }
@@ -4225,7 +4298,7 @@ async function prepareCheckDiff(params) {
         checks.push({ name: check.name, expression: check.expression });
         continue;
       }
-      throw new VibeError15({ 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 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 } });
     }
     models.push({ ...model, checks });
   }
@@ -4252,7 +4325,7 @@ async function inspectMigrationInventory(params) {
   for (const row of rows) {
     const name = row.name;
     if (typeof name !== "string" || typeof row.kind !== "string")
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
+      throw new VibeError17({ 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;
@@ -4278,7 +4351,7 @@ async function inspectMigrationInventory(params) {
       case "constraint": {
         const constraintType = kinds[String(row.subtype)];
         if (constraintType === undefined)
-          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
         identity = { kind: "constraint", table, name, constraintType };
         break;
       }
@@ -4288,17 +4361,17 @@ async function inspectMigrationInventory(params) {
           const query = renderMysqlObjectMembers2({ dialect: getSqlDialect2({ 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 VibeError16({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
+            throw new VibeError17({ 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 VibeError16({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
         identity = candidate;
         break;
       }
       default:
-        throw new VibeError16({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
+        throw new VibeError17({ 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)) {
@@ -4343,7 +4416,7 @@ async function inspectMigrationInventory(params) {
 // packages/migrate/src/external-objects.ts
 var partitionPatterns = new WeakMap;
 function invalid2(params) {
-  return new VibeError17({ code: "VIBE_CONFIG", message: `Invalid external ownership declaration: ${params.detail}`, meta: { reason: "external-declaration-invalid", ...params.owner === undefined ? {} : { owner: params.owner } }, ...params.cause === undefined ? {} : { cause: params.cause } });
+  return new VibeError18({ code: "VIBE_CONFIG", message: `Invalid external ownership declaration: ${params.detail}`, meta: { reason: "external-declaration-invalid", ...params.owner === undefined ? {} : { owner: params.owner } }, ...params.cause === undefined ? {} : { cause: params.cause } });
 }
 function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -4431,7 +4504,7 @@ async function parseExternalObjects(params) {
       }
     return Object.freeze(result);
   }).catch((cause) => {
-    if (cause instanceof VibeError17)
+    if (cause instanceof VibeError18)
       throw cause;
     throw invalid2({ detail: "regular-expression pattern cannot be compiled", cause });
   });
@@ -4455,7 +4528,7 @@ function declaredTableOwner(params) {
     return patterns?.some(({ pattern }) => pattern.exec(params.name.name)?.[0] === params.name.name) === true;
   });
   if (matches.length > 1)
-    throw new VibeError17({ code: "VIBE_CONFIG", message: "A table is claimed by more than one external owner", meta: { reason: "external-owner-collision", identity: { kind: "table", name: params.name }, owners: matches.map((entry) => entry.owner) } });
+    throw new VibeError18({ code: "VIBE_CONFIG", message: "A table is claimed by more than one external owner", meta: { reason: "external-owner-collision", identity: { kind: "table", name: params.name }, owners: matches.map((entry) => entry.owner) } });
   return matches[0]?.owner;
 }
 function externalObjectOwner(params) {
@@ -4477,13 +4550,13 @@ function resolveExternalObjectOwnership(params) {
   if (params.external.length > 0 && params.dialect !== "postgres")
     throw unsupportedCapability7({ dialect: params.dialect, feature: "externalObjects" });
   if (params.catalog.inventory.some((object) => object.inspectionUnavailable !== undefined))
-    throw new VibeError17({ code: "VIBE_MIGRATION", message: "External ownership requires complete catalog visibility", meta: { reason: "external-inventory-unavailable", objects: params.catalog.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
+    throw new VibeError18({ code: "VIBE_MIGRATION", message: "External ownership requires complete catalog visibility", meta: { reason: "external-inventory-unavailable", objects: params.catalog.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
   const tables = new Map;
   const assign = (entry) => {
     const key = nameKey(entry.name);
     const prior = tables.get(key)?.owner ?? declaredTableOwner({ external: params.external, name: entry.name });
     if (prior !== undefined && prior !== entry.owner)
-      throw new VibeError17({ code: "VIBE_CONFIG", message: "An inherited table has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "table", name: entry.name }, owners: [prior, entry.owner] } });
+      throw new VibeError18({ code: "VIBE_CONFIG", message: "An inherited table has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "table", name: entry.name }, owners: [prior, entry.owner] } });
     if (tables.has(key))
       return false;
     tables.set(key, entry);
@@ -4514,7 +4587,7 @@ function resolveExternalObjectOwnership(params) {
       return [];
     const whole = schemaOwner({ external: params.external, namespace: edge.sequence.namespace });
     if (whole !== undefined && whole !== owner)
-      throw new VibeError17({ code: "VIBE_CONFIG", message: "An owned sequence has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "sequence", name: edge.sequence }, owners: [whole, owner] } });
+      throw new VibeError18({ code: "VIBE_CONFIG", message: "An owned sequence has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "sequence", name: edge.sequence }, owners: [whole, owner] } });
     return [{ owner, name: edge.sequence }];
   });
   const closure = { declarations: params.external, catalog: params.catalog, inventory: params.catalog.inventory, tables: [...tables.values()], sequences, owners: [], identities: [] };
@@ -4522,7 +4595,7 @@ function resolveExternalObjectOwnership(params) {
     const owner = externalObjectOwner({ external: closure, identity: { kind: "table", name: edge.table } });
     const targetOwner = externalObjectOwner({ external: closure, identity: { kind: "table", name: edge.target } });
     if (owner !== targetOwner && (owner !== undefined || targetOwner !== undefined))
-      throw new VibeError17({ code: "VIBE_MIGRATION", message: "Foreign keys cannot cross external ownership boundaries", meta: { reason: "external-cross-owner-foreign-key", name: edge.name, table: edge.table, target: edge.target, owner: owner ?? "application", targetOwner: targetOwner ?? "application" } });
+      throw new VibeError18({ code: "VIBE_MIGRATION", message: "Foreign keys cannot cross external ownership boundaries", meta: { reason: "external-cross-owner-foreign-key", name: edge.name, table: edge.table, target: edge.target, owner: owner ?? "application", targetOwner: targetOwner ?? "application" } });
   }
   const observed = new Map;
   for (const namespace of params.catalog.namespaces) {
@@ -4550,7 +4623,7 @@ function catalogName(params) {
   const namespace = params.row[params.namespace];
   const name = params.row[params.name];
   if (!identifier(namespace) || !identifier(name))
-    throw new VibeError17({ code: "VIBE_MIGRATION", message: "Malformed external ownership catalog endpoint", meta: { reason: "external-inventory-unavailable" } });
+    throw new VibeError18({ code: "VIBE_MIGRATION", message: "Malformed external ownership catalog endpoint", meta: { reason: "external-inventory-unavailable" } });
   return { namespace, name };
 }
 async function inspectExternalObjects(params) {
@@ -4563,7 +4636,7 @@ async function inspectExternalObjects(params) {
   };
   const namespaceRows = await read("namespaces");
   if (namespaceRows.some((row) => !identifier(row.namespace) || row.visible !== true))
-    throw new VibeError17({ code: "VIBE_MIGRATION", message: "External ownership cannot prove visibility of every inspected namespace", meta: { reason: "external-inventory-unavailable" } });
+    throw new VibeError18({ code: "VIBE_MIGRATION", message: "External ownership cannot prove visibility of every inspected namespace", meta: { reason: "external-inventory-unavailable" } });
   const namespaces = namespaceRows.map((row) => String(row.namespace));
   const [inherited, owned, foreignKeys] = await Promise.all([read("inheritance"), read("ownedSequences"), read("foreignKeys")]);
   const inventory = params.inventory ?? (await Promise.all(namespaces.map((namespace) => inspectMigrationInventory({ executor: params.executor, dialect: params.dialect, namespace })))).flat();
@@ -4584,7 +4657,7 @@ function assertExternalOwnershipClaims(params) {
   for (const identity of params.identities) {
     const owner = externalObjectOwner({ identity, external: params.external }) ?? (identity.kind === "namespace" ? [...params.external.tables, ...params.external.sequences].find((entry) => entry.name.namespace === identity.name)?.owner : undefined);
     if (owner !== undefined)
-      throw new VibeError17({ code: "VIBE_CONFIG", message: "Application or module declarations collide with external ownership", meta: { reason: "external-owned-object-collision", owner, identity } });
+      throw new VibeError18({ code: "VIBE_CONFIG", message: "Application or module declarations collide with external ownership", meta: { reason: "external-owned-object-collision", owner, identity } });
   }
 }
 function projectExternalSchema(params) {
@@ -4594,7 +4667,7 @@ function projectExternalSchema(params) {
   for (const model of models)
     for (const relation of model.relations)
       if (removed.has(relation.targetModel))
-        throw new VibeError17({ code: "VIBE_MIGRATION", message: "Application relations cannot depend on externally owned tables", meta: { reason: "external-cross-owner-foreign-key", model: model.name, relation: relation.name } });
+        throw new VibeError18({ code: "VIBE_MIGRATION", message: "Application relations cannot depend on externally owned tables", meta: { reason: "external-cross-owner-foreign-key", model: model.name, relation: relation.name } });
   return {
     ...schema,
     models,
@@ -4627,7 +4700,7 @@ function migrationCoverageGaps(params) {
   return [...new Map(kept.map((gap) => [JSON.stringify(gap), gap])).values()];
 }
 // packages/migrate/src/module-adoption.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { VibeError as VibeError22 } from "@vibeorm/schema";
 
 // packages/migrate/src/mysql-catalog-visibility.ts
 function hasMysqlGlobalCatalogVisibility(params) {
@@ -4645,10 +4718,10 @@ 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";
 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)];
@@ -4709,7 +4782,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;
@@ -4771,12 +4844,12 @@ 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/sql-statements.ts
-import { VibeError as VibeError19 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } 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) {
@@ -4852,7 +4925,7 @@ function splitSqlStatements(params) {
             continue;
           }
           if (dialect === "mysql" || dialect === undefined) {
-            throw new VibeError19({ 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 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 } });
           }
         }
         if (value === endQuote) {
@@ -4926,10 +4999,10 @@ function joinSqlStatements(params) {
 
 // packages/migrate/src/module-origin.ts
 import { createHash } from "crypto";
-import { VibeError as VibeError20, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
+import { VibeError as VibeError21, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
 var MODULE_ORIGIN_METADATA = Object.freeze({ filename: "module-origin.json", version: 1 });
 function invalid3() {
-  return new VibeError20({ 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 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" } });
 }
 function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -4993,7 +5066,7 @@ function assertMaterializedModuleMigration(params) {
     return;
   const restored = restoreModuleMigration({ migration, origin: migration.moduleOrigin });
   if (migration.desiredState === undefined || canonicalMigrationJson({ value: restored }) !== canonicalMigrationJson({ value: migration }))
-    throw new VibeError20({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
+    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 } });
 }
 function restoreModuleMigration(params) {
   const { migration, origin } = params;
@@ -5018,7 +5091,7 @@ function restoreModuleMigration(params) {
 // packages/migrate/src/module-adoption.ts
 var MODULE_ADOPTION_METADATA = Object.freeze({ filename: "module-adoption.json", version: 1 });
 function invalid4() {
-  return new VibeError21({ 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 VibeError22({ 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;
@@ -5053,22 +5126,22 @@ function serializeModuleAdoption(params) {
 `;
 }
 // packages/migrate/src/module-adoption-record.ts
-import { VibeError as VibeError42 } from "@vibeorm/schema";
+import { VibeError as VibeError43 } from "@vibeorm/schema";
 
 // packages/migrate/src/module-adoption-reference.ts
-import { VibeError as VibeError41, isEnumType as isEnumType9, sqlObjectKey as sqlObjectKey14 } from "@vibeorm/schema";
+import { VibeError as VibeError42, isEnumType as isEnumType9, sqlObjectKey as sqlObjectKey14 } from "@vibeorm/schema";
 
 // packages/migrate/src/module-pending.ts
-import { VibeError as VibeError37, sqlObjectKey as sqlObjectKey11, qualifiedSqlName as qualifiedSqlName10 } from "@vibeorm/schema";
+import { VibeError as VibeError38, sqlObjectKey as sqlObjectKey11, qualifiedSqlName as qualifiedSqlName11 } from "@vibeorm/schema";
 
 // packages/migrate/src/module-bundle.ts
-import { VibeError as VibeError36 } from "@vibeorm/schema";
+import { VibeError as VibeError37 } 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) {
@@ -5107,7 +5180,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 }
@@ -5158,7 +5231,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 },
@@ -5257,7 +5330,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) {
@@ -5269,7 +5342,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);
@@ -5279,7 +5352,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) => {
@@ -5302,7 +5375,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];
@@ -5343,7 +5416,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 }
@@ -5364,9 +5437,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;
@@ -5473,11 +5546,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;
@@ -5501,7 +5574,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;
@@ -5509,7 +5582,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 } : {} });
   }
@@ -5518,7 +5591,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) => {
@@ -5577,7 +5650,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,
@@ -5587,7 +5660,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,
@@ -5603,7 +5676,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 }
@@ -5708,10 +5781,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;
 }
@@ -5722,7 +5795,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 }
@@ -5824,17 +5897,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" });
@@ -5843,11 +5933,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: [],
@@ -5875,16 +5966,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 });
@@ -5894,7 +5991,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,
@@ -5918,7 +6016,7 @@ function diffSchemas(params) {
     ...buckets.addForeignKey,
     ...buckets.createJoinTable,
     ...buckets.dropEnum
-  ] });
+  ] }) };
 }
 function refuseScalarListColumns(params) {
   const { schema, dialect } = params;
@@ -5985,6 +6083,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) {
@@ -6140,7 +6272,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) {
@@ -6148,9 +6280,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 } });
     }
@@ -6170,7 +6300,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 });
@@ -6256,11 +6386,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 });
@@ -6297,7 +6427,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" }
@@ -6371,7 +6501,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)};`];
@@ -6436,7 +6566,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 }
@@ -6472,7 +6602,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 }
@@ -6492,7 +6622,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
@@ -6640,7 +6770,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
@@ -6669,7 +6799,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":
@@ -6755,7 +6885,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" }
@@ -6809,7 +6939,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":
@@ -6870,7 +7000,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 }
@@ -7005,7 +7135,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 }
@@ -7024,7 +7154,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 }
@@ -7059,7 +7189,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 }
@@ -7070,7 +7200,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) {
@@ -7218,12 +7348,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 }
@@ -7253,8 +7383,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)} (
@@ -7275,12 +7405,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 }
@@ -7302,7 +7437,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 }
@@ -7342,24 +7477,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)
@@ -7396,7 +7531,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 = [];
@@ -7463,6 +7598,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;
     }
@@ -7486,6 +7625,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) => {
@@ -7644,10 +7785,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;
@@ -7728,12 +7869,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 [];
     })
   ];
@@ -7759,8 +7900,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;
     }));
   };
@@ -7790,11 +7931,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 });
@@ -7804,7 +7945,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)
@@ -7820,7 +7961,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 });
@@ -7831,7 +7972,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 });
@@ -7847,7 +7988,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 }
@@ -8005,7 +8146,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})`;
@@ -8027,7 +8168,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 });
   } });
@@ -8045,7 +8186,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;
     }
@@ -8053,7 +8194,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 });
@@ -8072,21 +8213,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 });
@@ -8099,10 +8240,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) {
@@ -8111,7 +8252,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)
@@ -8177,7 +8318,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 }) },
@@ -8260,7 +8401,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 }) },
@@ -8322,7 +8463,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 },
@@ -8418,7 +8559,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 } },
@@ -8446,7 +8587,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 }
@@ -8481,7 +8622,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: {
@@ -8499,7 +8640,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" }
@@ -8575,7 +8716,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 }
@@ -8586,7 +8727,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: {
@@ -8606,7 +8747,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);
   }
 }
@@ -8614,15 +8755,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++;
   }
 }
@@ -8631,16 +8772,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
@@ -8674,17 +8815,17 @@ function ph(dialect, index) {
 // packages/migrate/src/module-bundle.ts
 function defineModuleMigrations(params) {
   if (!Array.isArray(params.steps) || params.steps.length === 0)
-    throw new VibeError36({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
+    throw new VibeError37({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
   const migrations = [];
   const revisions = new Set;
   let previous = null;
   for (const step of params.steps) {
     if (step.previousRevision !== previous || revisions.has(step.revision))
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
     const origin = createModuleOrigin({ moduleId: params.moduleId, dialect: params.dialect, revision: step.revision, previousRevision: step.previousRevision, contracts: step.contracts, owned: step.owned, source: step.migration });
     const predecessor = migrations.at(-1)?.moduleOrigin;
     if (predecessor !== undefined && canonicalMigrationJson({ value: predecessor.source.desiredState.to }) !== canonicalMigrationJson({ value: origin.source.desiredState.from }))
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
     validateMigrationReplay({ migrations: [origin.source], dialect: params.dialect, acceptSecurityChanges: true, acceptIntegrityLoss: true, removeUnmanaged: origin.source.desiredState?.unmanagedRemovals ?? [] });
     migrations.push(Object.freeze({ ...origin.source, moduleOrigin: origin }));
     revisions.add(step.revision);
@@ -8694,21 +8835,21 @@ function defineModuleMigrations(params) {
 }
 function moduleMigrationFiles(params) {
   if (params.bundle === null || typeof params.bundle !== "object" || !Array.isArray(params.bundle.migrations))
-    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
+    throw new VibeError37({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
   if (!/^[A-Za-z0-9_-]+$/.test(params.prefix))
-    throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
+    throw new VibeError37({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
   const bundle = defineModuleMigrations({ moduleId: params.bundle.moduleId, dialect: params.bundle.dialect, steps: params.bundle.migrations.map((migration) => {
     const origin = migration?.moduleOrigin;
     if (migration.moduleAdoption !== undefined)
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Local adoption provenance cannot be exported as immutable package source", meta: { reason: "module-adoption-author-source" } });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Local adoption provenance cannot be exported as immutable package source", meta: { reason: "module-adoption-author-source" } });
     if (origin === undefined || origin.moduleId !== params.bundle.moduleId || origin.dialect !== params.bundle.dialect)
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
     assertModuleOrigin({ value: origin });
     restoreModuleMigration({ migration, origin });
     const { name: localName, sql: localSql, downSql: localDown, moduleOrigin: localOrigin, ...actual } = migration;
     const { name: sourceName, sql: sourceSql, downSql: sourceDown, ...expected } = origin.source;
     if (localSql === undefined || localDown === undefined !== (sourceDown === undefined) || canonicalMigrationJson({ value: actual }) !== canonicalMigrationJson({ value: expected }))
-      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Module bundle metadata differs from its sealed author source", meta: { reason: "module-origin-invalid", moduleId: origin.moduleId } });
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Module bundle metadata differs from its sealed author source", meta: { reason: "module-origin-invalid", moduleId: origin.moduleId } });
     return { revision: origin.revision, previousRevision: origin.previousRevision, contracts: origin.contracts, owned: origin.owned, migration: origin.source };
   }) });
   return Object.freeze(bundle.migrations.map((migration, index) => Object.freeze({ ...migration, name: `${params.prefix}_${String(index + 1).padStart(4, "0")}` })));
@@ -8716,10 +8857,10 @@ function moduleMigrationFiles(params) {
 
 // packages/migrate/src/module-pending.ts
 function refusal3(params) {
-  return new VibeError37({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
+  return new VibeError38({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
 }
 function physicalKey(params) {
-  return sqlObjectKey11({ identity: { kind: "table", name: qualifiedSqlName10({ name: params.entry.dbName ?? params.entry.name, namespace: params.entry.namespace }) } });
+  return sqlObjectKey11({ identity: { kind: "table", name: qualifiedSqlName11({ name: params.entry.dbName ?? params.entry.name, namespace: params.entry.namespace }) } });
 }
 function composeModuleState(params) {
   const { current, from, to } = params;
@@ -8830,7 +8971,7 @@ function pendingModuleMigrations(params) {
 
 // packages/migrate/src/replay-reference.ts
 import { createHash as createHash3 } from "crypto";
-import { VibeError as VibeError38, sqlObjectKey as sqlObjectKey12, sqlObjectNamespace as sqlObjectNamespace4 } from "@vibeorm/schema";
+import { VibeError as VibeError39, sqlObjectKey as sqlObjectKey12, sqlObjectNamespace as sqlObjectNamespace4 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect10, renderMigrationServerVersion, renderReplayCoverageGaps as renderReplayCoverageGaps2, renderShadowOperation as renderShadowOperation2, SHADOW_DATABASE } from "@vibeorm/sql";
 function migrationReferenceNamespaces(params) {
   return [...new Set([params.namespace, ...params.migrations.flatMap((migration) => [
@@ -8846,7 +8987,7 @@ async function captureReplayReference(params) {
   for (const origin of params.namespaceOrigins ?? []) {
     assertModuleOrigin({ value: origin });
     if (origin.dialect !== dialect)
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "Namespace context origin uses a different dialect", meta: { reason: "module-dialect-mismatch", moduleId: origin.moduleId } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Namespace context origin uses a different dialect", meta: { reason: "module-dialect-mismatch", moduleId: origin.moduleId } });
   }
   const namespace = await migrationNamespace({ executor, dialect });
   await assertCatalogVisibility({ executor, dialect, namespace });
@@ -8855,17 +8996,17 @@ async function captureReplayReference(params) {
     const [query] = renderShadowOperation2({ dialect: sqlDialect, operation: { kind: "markerColumns" } });
     const columns = await executor({ text: query.text, values: [...query.values] });
     if (columns.length !== 1 || columns[0]?.name !== "payload" || columns[0]?.type !== "longtext" || columns[0]?.nullable !== "NO")
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "Replay changed the private shadow marker; its objects cannot be excluded from reference inspection", meta: { reason: "shadow-ownership-changed" } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Replay changed the private shadow marker; its objects cannot be excluded from reference inspection", meta: { reason: "shadow-ownership-changed" } });
   }
   if (params.privateNamespace !== undefined) {
     if (dialect !== "postgres" || params.privateNamespace !== SHADOW_DATABASE.schema)
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "Unknown private shadow namespace", meta: { reason: "shadow-ownership-invalid" } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Unknown private shadow namespace", meta: { reason: "shadow-ownership-invalid" } });
     const [inventoryQuery] = renderShadowOperation2({ dialect: sqlDialect, operation: { kind: "inventory" } });
     const privateObjects = (await executor({ text: inventoryQuery.text, values: [...inventoryQuery.values] })).filter((row) => row.namespace === params.privateNamespace);
     const [columnsQuery] = renderShadowOperation2({ dialect: sqlDialect, operation: { kind: "markerColumns" } });
     const columns = await executor({ text: columnsQuery.text, values: [...columnsQuery.values] });
     if (columns.length !== 1 || columns[0]?.name !== "payload" || columns[0]?.type !== "text" || columns[0]?.nullable !== "NO" || privateObjects.some((row) => !(row.kind === "namespace" && row.name === SHADOW_DATABASE.schema || row.kind === "relation" && row.name === SHADOW_DATABASE.table)))
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "Replay changed the private shadow namespace; its objects cannot be excluded from reference inspection", meta: { reason: "shadow-ownership-changed", objects: privateObjects } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Replay changed the private shadow namespace; its objects cannot be excluded from reference inspection", meta: { reason: "shadow-ownership-changed", objects: privateObjects } });
   }
   const namespaces = dialect === "postgres" ? [...new Set([...migrationReferenceNamespaces({ migrations: params.migrations, namespace }), ...(params.namespaceOrigins ?? []).map((origin) => moduleNamespace({ origin }))])] : [namespace];
   const external = (params.external?.length ?? 0) === 0 ? undefined : await inspectExternalObjects({ executor, dialect, external: params.external });
@@ -8876,7 +9017,7 @@ async function captureReplayReference(params) {
   }))).flat();
   const gaps = migrationCoverageGaps({ gaps: coverageRows, namespace, namespaces, external });
   if (gaps.length > 0)
-    throw new VibeError38({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Replayed history contains objects whose full definitions are not represented by migration inspection. Use reviewed SQL for changes; automatic generation and verification require supported reference coverage.", meta: { feature: "replayInventoryCoverage", dialect, namespace, objects: gaps } });
+    throw new VibeError39({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Replayed history contains objects whose full definitions are not represented by migration inspection. Use reviewed SQL for changes; automatic generation and verification require supported reference coverage.", meta: { feature: "replayInventoryCoverage", dialect, namespace, objects: gaps } });
   const rls = [...params.migrations].reverse().find((migration) => migration.rls !== undefined)?.rls?.to;
   const physical = dialect === "postgres" ? await introspectPostgres({ executor, namespaces: inspectedNamespaces, ...rls === undefined ? {} : { rlsSchema: rls, requireInstalledRls: true } }) : dialect === "mysql" ? await introspectMysql({ executor }) : await introspectSqlite({ executor });
   const privateTable = params.privateTable !== undefined && physical.models.some((model) => !model.isView && (model.dbName ?? model.name) === params.privateTable) ? params.privateTable : undefined;
@@ -8924,7 +9065,7 @@ async function captureReplayReference(params) {
 }
 
 // packages/migrate/src/verify-history.ts
-import { VibeError as VibeError40, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
+import { VibeError as VibeError41, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect11, renderReplayCoverageGaps as renderReplayCoverageGaps3 } from "@vibeorm/sql";
 
 // packages/migrate/src/compare-sqlite-primary-key.ts
@@ -8995,7 +9136,7 @@ function compareSqlitePrimaryKeyRepresentations(params) {
 }
 
 // packages/migrate/src/compare-reference-rls.ts
-import { VibeError as VibeError39 } from "@vibeorm/schema";
+import { VibeError as VibeError40 } from "@vibeorm/schema";
 function securityFacts(params) {
   return new Map(params.tables.filter((table) => table.enabled || table.force || table.policies.length > 0).map((table) => [table.table, {
     table: table.table,
@@ -9006,7 +9147,7 @@ function securityFacts(params) {
 }
 async function comparePostgresReferenceRls(params) {
   if (params.schema.rls !== undefined && params.referenceExecutor === undefined)
-    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
+    throw new VibeError40({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
   const expected = securityFacts({ tables: params.schema.rls === undefined ? [] : await readPostgresRls({ executor: params.referenceExecutor }) });
   const actual = securityFacts({ tables: await readPostgresRls({ executor: params.executor }) });
   const objects = [...new Set([...expected.keys(), ...actual.keys()])].sort().map((table) => {
@@ -9030,14 +9171,14 @@ function selectMigrationVerificationPrefix(params) {
   for (const [index, file] of params.migrations.entries()) {
     const previous = params.migrations[index - 1];
     if (seen.has(file.name) || previous !== undefined && previous.name.localeCompare(file.name) > 0) {
-      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
+      throw new VibeError41({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
     }
     seen.add(file.name);
   }
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.statementIndex < 0 || row.checksum === "" || file?.name !== row.name || file.desiredStatePending === true || migrationChecksum(file) !== row.checksum) {
-      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError41({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
     }
   }
   return params.migrations.slice(0, params.recorded.length);
@@ -9068,7 +9209,7 @@ async function verifyMigrationReference(params) {
   }))).flat();
   const gaps = migrationCoverageGaps({ gaps: coverageRows, namespace, namespaces, external });
   if (gaps.length > 0)
-    throw new VibeError40({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
+    throw new VibeError41({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
   const security = dialect === "postgres" ? await comparePostgresReferenceRls({ executor, referenceExecutor: params.referenceExecutor, schema: reference.state.schema }) : { inSync: true, objects: [] };
   const inspected = await verifyMigrationState({ executor, dialect, expected: reference.state, external, probe: "none", batch: true });
   const structural = dialect === "sqlite" ? compareSqlitePrimaryKeyRepresentations({ report: inspected }) : inspected;
@@ -9221,12 +9362,12 @@ async function mysqlComparisonFacts(params) {
   return { ...facts, members };
 }
 function referenceContextError() {
-  return new VibeError40({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
+  return new VibeError41({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
 }
 
 // packages/migrate/src/module-adoption-reference.ts
 function refusal4(params) {
-  return new VibeError41({ code: "VIBE_MIGRATION", message: "Module adoption needs complete independent source and application references with compatible ownership; no target SQL or metadata was authorized", meta: params });
+  return new VibeError42({ code: "VIBE_MIGRATION", message: "Module adoption needs complete independent source and application references with compatible ownership; no target SQL or metadata was authorized", meta: params });
 }
 function moduleAdoptionSource(params) {
   if (params.migrations.length === 0)
@@ -9336,7 +9477,7 @@ async function verifyModuleAdoptionTarget(params) {
   await assertLiveModuleOwnership({ executor: params.executor, origin, resume: true });
   const report = await verifyMigrationReference({ executor: params.executor, dialect: origin.dialect, reference: params.reference, referenceExecutor: params.referenceExecutor });
   if (!report.inSync)
-    throw new VibeError41({ code: "VIBE_MIGRATION", message: "Populated target differs from independently replayed package/application structure; no package SQL or metadata was applied", meta: { reason: "module-adoption-target-mismatch", report } });
+    throw new VibeError42({ code: "VIBE_MIGRATION", message: "Populated target differs from independently replayed package/application structure; no package SQL or metadata was applied", meta: { reason: "module-adoption-target-mismatch", report } });
 }
 
 // packages/migrate/src/history.ts
@@ -9352,10 +9493,10 @@ async function readMigrationHistory(params) {
 
 // packages/migrate/src/module-adoption-record.ts
 function refusal5(params) {
-  return new VibeError42({ code: "VIBE_MIGRATION", message: "Module adoption cannot record an incomplete, concurrent or altered history; no package SQL was executed", meta: params });
+  return new VibeError43({ code: "VIBE_MIGRATION", message: "Module adoption cannot record an incomplete, concurrent or altered history; no package SQL was executed", meta: params });
 }
 function transactionFailure(params) {
-  return params.cause instanceof VibeError42 ? params.cause : new VibeError42({ code: "VIBE_MIGRATION", message: "Module adoption recording failed; inspect the local provenance and journal before retrying", meta: { reason: "module-adoption-transaction-failed" }, cause: params.cause });
+  return params.cause instanceof VibeError43 ? params.cause : new VibeError43({ code: "VIBE_MIGRATION", message: "Module adoption recording failed; inspect the local provenance and journal before retrying", meta: { reason: "module-adoption-transaction-failed" }, cause: params.cause });
 }
 async function recordModuleAdoption(params) {
   moduleAdoptionSource(params);
@@ -9418,9 +9559,9 @@ async function recordModuleAdoption(params) {
       await record();
     }).then(undefined, async (cause) => {
       if (committed)
-        throw new VibeError42({ code: "VIBE_MIGRATION", message: "All adopted revisions committed, but filesystem lease cleanup failed; inspect the remaining publication lease before retrying", meta: { reason: "module-adoption-publication-cleanup-failed", recorded: true }, cause });
+        throw new VibeError43({ code: "VIBE_MIGRATION", message: "All adopted revisions committed, but filesystem lease cleanup failed; inspect the remaining publication lease before retrying", meta: { reason: "module-adoption-publication-cleanup-failed", recorded: true }, cause });
       await executor({ text: "ROLLBACK" }).then(undefined, (rollback) => {
-        throw new VibeError42({ code: "VIBE_MIGRATION", message: "Adoption recording failed and rollback also failed; the journal outcome is uncertain and must be inspected before recovery", meta: { reason: "module-adoption-rollback-failed" }, cause: new AggregateError([cause, rollback], "Adoption recording and rollback failed") });
+        throw new VibeError43({ code: "VIBE_MIGRATION", message: "Adoption recording failed and rollback also failed; the journal outcome is uncertain and must be inspected before recovery", meta: { reason: "module-adoption-rollback-failed" }, cause: new AggregateError([cause, rollback], "Adoption recording and rollback failed") });
       });
       throw transactionFailure({ cause });
     });
@@ -9431,14 +9572,14 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-import { VibeError as VibeError44, providerToDialect as providerToDialect5, sqlObjectKey as sqlObjectKey15, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+import { VibeError as VibeError45, providerToDialect as providerToDialect6, sqlObjectKey as sqlObjectKey15, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect14, renderShadowOperation as renderShadowOperation4, SHADOW_DATABASE as SHADOW_DATABASE3 } from "@vibeorm/sql";
 
 // packages/migrate/src/shadow-dedicated.ts
-import { SQL_NAMESPACES, VibeError as VibeError43, providerToDialect as providerToDialect4, sqlNamespaceIssue as sqlNamespaceIssue2 } from "@vibeorm/schema";
+import { SQL_NAMESPACES as SQL_NAMESPACES2, VibeError as VibeError44, providerToDialect as providerToDialect5, sqlNamespaceIssue as sqlNamespaceIssue2 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect13, renderShadowOperation as renderShadowOperation3, SHADOW_DATABASE as SHADOW_DATABASE2 } from "@vibeorm/sql";
 function refuse(params) {
-  throw new VibeError43({ code: "VIBE_MIGRATION", message: params.message, meta: { reason: params.reason, ...params.objects === undefined ? {} : { objects: params.objects } } });
+  throw new VibeError44({ code: "VIBE_MIGRATION", message: params.message, meta: { reason: params.reason, ...params.objects === undefined ? {} : { objects: params.objects } } });
 }
 function readIdentity(params) {
   const row = params.rows[0];
@@ -9506,7 +9647,7 @@ async function readMarker(params) {
   if (params.rows.length !== 1 || typeof payload !== "string")
     return refuse({ reason: "shadow-ownership-invalid", message: "Shadow ownership marker is missing or malformed; automatic claim/reset is refused." });
   const value = await Promise.resolve().then(() => JSON.parse(payload)).then((result) => result, (cause) => {
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Shadow marker is not valid JSON", meta: { reason: "shadow-ownership-invalid" }, cause });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Shadow marker is not valid JSON", meta: { reason: "shadow-ownership-invalid" }, cause });
   });
   if (value === null || typeof value !== "object" || !("version" in value) || value.version !== 1 || !("ownerKey" in value) || typeof value.ownerKey !== "string" || !("identity" in value) || typeof value.identity !== "string" || !("status" in value) || value.status !== "READY" && value.status !== "BUILDING" || !("journal" in value) || !Array.isArray(value.journal) || !value.journal.every((row) => row !== null && typeof row === "object" && ("name" in row) && typeof row.name === "string" && ("checksum" in row) && typeof row.checksum === "string"))
     return refuse({ reason: "shadow-ownership-invalid", message: "Shadow marker has an unsupported ownership or replay-journal shape." });
@@ -9520,8 +9661,8 @@ async function withDedicatedShadow(params) {
   const intendedJournal = completedJournal({ rows: params.migrations.map((migration) => ({ name: migration.name, checksum: migrationChecksum(migration), statement_index: migration.sql.length, error: null })), reason: "shadow-replay-journal-changed" });
   if (shadow.ownerKey.length === 0 || shadow.targetUrl.length === 0)
     return refuse({ reason: "shadow-identity-unavailable", message: "Reusable shadow mode requires a project owner and a resolvable deployment target for an independent identity check." });
-  const dialect = providerToDialect4({ provider: shadow.provider });
-  const declaredNamespaces = dialect === "postgres" ? migrationReferenceNamespaces({ migrations: params.migrations, namespace: SQL_NAMESPACES.postgres }).filter((namespace) => namespace !== SQL_NAMESPACES.postgres) : [];
+  const dialect = providerToDialect5({ provider: shadow.provider });
+  const declaredNamespaces = dialect === "postgres" ? migrationReferenceNamespaces({ migrations: params.migrations, namespace: SQL_NAMESPACES2.postgres }).filter((namespace) => namespace !== SQL_NAMESPACES2.postgres) : [];
   const sqlDialect = getSqlDialect13({ dialect });
   const execute = async (executor, operation) => {
     let rows = [];
@@ -9550,13 +9691,13 @@ async function withDedicatedShadow(params) {
         return refuse({ reason: "shadow-identity-changed", message: "Shadow identity changed after lease acquisition; reset is refused." });
       if (dialect === "mysql") {
         const grants = await execute(executor, { kind: "grants" }).then(undefined, (cause) => {
-          throw new VibeError43({ code: "VIBE_MIGRATION", message: "Cannot establish dedicated MySQL catalog visibility from direct grants", meta: { reason: "shadow-inventory-unavailable" }, cause });
+          throw new VibeError44({ code: "VIBE_MIGRATION", message: "Cannot establish dedicated MySQL catalog visibility from direct grants", meta: { reason: "shadow-inventory-unavailable" }, cause });
         });
         assertMysqlVisibility({ rows: grants, database: identity.database });
       }
       const existing = (await execute(executor, { kind: "markerExists" })).length > 0;
       const inventory = await execute(executor, { kind: "inventory" }).then(undefined, (cause) => {
-        throw new VibeError43({ code: "VIBE_MIGRATION", message: "Cannot inspect the complete dedicated shadow inventory; no reset was attempted", meta: { reason: "shadow-inventory-unavailable" }, cause });
+        throw new VibeError44({ code: "VIBE_MIGRATION", message: "Cannot inspect the complete dedicated shadow inventory; no reset was attempted", meta: { reason: "shadow-inventory-unavailable" }, cause });
       });
       const externalReferences = inventory.filter((row) => row.kind === "EXTERNAL FOREIGN KEY");
       if (externalReferences.length !== 0)
@@ -9609,7 +9750,7 @@ async function withDedicatedShadow(params) {
       if (remaining.length !== 0)
         return refuse({ reason: "shadow-reset-incomplete", message: "Shadow reset left objects behind. Replay was not started.", objects: remaining });
       const result = await params.runReference(executor, dialect === "mysql" ? SHADOW_DATABASE2.table : undefined).then((value) => ({ ok: true, value }), (error) => {
-        if (!(error instanceof VibeError43) || error.meta.shadowInvalid === true || error.meta.shadowReusable !== true)
+        if (!(error instanceof VibeError44) || error.meta.shadowInvalid === true || error.meta.shadowReusable !== true)
           throw error;
         return { ok: false, error };
       });
@@ -9633,13 +9774,13 @@ async function withDedicatedShadow(params) {
 function finishShadowWork(params) {
   return Promise.resolve().then(params.run).then(async (value) => {
     await Promise.resolve().then(params.cleanup).then(undefined, (cause) => {
-      throw new VibeError44({ code: "VIBE_MIGRATION", message: "Migration reference completed but its owned resource could not be cleaned. Inspect the named artifact before explicit cleanup.", meta: { cleanupReason: "shadow-cleanup-failed", artifact: params.artifact, cleanupFailure: cause instanceof VibeError44 ? cause.code : "unavailable" }, cause });
+      throw new VibeError45({ code: "VIBE_MIGRATION", message: "Migration reference completed but its owned resource could not be cleaned. Inspect the named artifact before explicit cleanup.", meta: { cleanupReason: "shadow-cleanup-failed", artifact: params.artifact, cleanupFailure: cause instanceof VibeError45 ? cause.code : "unavailable" }, cause });
     });
     return value;
   }, async (primary) => {
     const [cleanup] = await Promise.allSettled([Promise.resolve().then(params.cleanup)]);
     if (cleanup.status === "rejected")
-      throw new VibeError44({ code: primary instanceof VibeError44 ? primary.code : "VIBE_MIGRATION", message: "Migration reference failed and its owned resource could not be cleaned. Inspect the named artifact before explicit cleanup.", meta: { cleanupReason: "shadow-cleanup-failed", artifact: params.artifact, cleanupFailure: cleanup.reason instanceof VibeError44 ? cleanup.reason.code : "unavailable" }, cause: { primary, cleanup: cleanup.reason } });
+      throw new VibeError45({ code: primary instanceof VibeError45 ? primary.code : "VIBE_MIGRATION", message: "Migration reference failed and its owned resource could not be cleaned. Inspect the named artifact before explicit cleanup.", meta: { cleanupReason: "shadow-cleanup-failed", artifact: params.artifact, cleanupFailure: cleanup.reason instanceof VibeError45 ? cleanup.reason.code : "unavailable" }, cause: { primary, cleanup: cleanup.reason } });
     throw primary;
   });
 }
@@ -9651,21 +9792,21 @@ function withShadowConnection(params) {
   return finishShadowWork({ artifact: params.artifact, cleanup: () => params.connection.close(), run: () => params.connection.executor.withSession === undefined ? runPinned(params.connection.executor) : params.connection.executor.withSession({ run: runPinned }) });
 }
 async function withMigrationReference(params) {
-  const dialect = providerToDialect5({ provider: params.shadow.provider });
+  const dialect = providerToDialect6({ provider: params.shadow.provider });
   const external = params.external ?? params.replay?.external;
   const replay = { ...params.replay, external, migrations: params.migrations, dialect };
   validateMigrationReplay(replay);
   for (const origin of params.namespaceOrigins ?? []) {
     assertModuleOrigin({ value: origin });
     if (origin.dialect !== dialect)
-      throw new VibeError44({ code: "VIBE_MIGRATION", message: "Namespace context origin uses a different dialect", meta: { reason: "module-dialect-mismatch", moduleId: origin.moduleId } });
+      throw new VibeError45({ code: "VIBE_MIGRATION", message: "Namespace context origin uses a different dialect", meta: { reason: "module-dialect-mismatch", moduleId: origin.moduleId } });
   }
   const hasAdoption = params.migrations.some((migration) => migration.moduleAdoption !== undefined);
   if (hasAdoption && params.shadow.provider === "mysql")
     throw unsupportedCapability13({ dialect: "mysql", feature: "moduleAdoptionIndependentMysqlNamespace", hint: "Independent source and application databases require a proven metadata rebase before grouped adoption replay is supported" });
   const adoptionShadow = params.shadow.mode === "automatic" ? params.shadow : undefined;
   if (hasAdoption && adoptionShadow === undefined)
-    throw new VibeError44({ code: "VIBE_CONFIG", message: "Adopted history requires an independent automatic package source reference; a single dedicated shadow cannot prove both histories. Configure shadowAdminUrl.", meta: { reason: "module-adoption-automatic-shadow-required" } });
+    throw new VibeError45({ code: "VIBE_CONFIG", message: "Adopted history requires an independent automatic package source reference; a single dedicated shadow cannot prove both histories. Configure shadowAdminUrl.", meta: { reason: "module-adoption-automatic-shadow-required" } });
   const inspect = async (executor, privateTable) => {
     if ((external?.length ?? 0) > 0) {
       const ownership = await inspectExternalObjects({ executor, dialect, external });
@@ -9692,7 +9833,7 @@ async function withMigrationReference(params) {
         await withMigrationReference({ shadow: adoptionShadow, openConnection: params.openConnection, migrations: moduleAdoptionSource({ migrations: group }), replay: sourceReplay, run: async ({ executor: sourceExecutor, reference: source }) => {
           const fingerprint = moduleAdoptionReferenceFingerprint({ migrations: group, reference: source });
           if (group.some((migration) => migration.moduleAdoption?.referenceFingerprint !== fingerprint))
-            throw new VibeError44({ code: "VIBE_MIGRATION", message: "Local adoption proof does not match independently replayed immutable package source", meta: { reason: "module-adoption-reference-unverified", moduleId: first.moduleOrigin?.moduleId } });
+            throw new VibeError45({ code: "VIBE_MIGRATION", message: "Local adoption proof does not match independently replayed immutable package source", meta: { reason: "module-adoption-reference-unverified", moduleId: first.moduleOrigin?.moduleId } });
           const application = await captureReplayReference({
             executor,
             dialect,
@@ -9739,14 +9880,14 @@ async function withMigrationReference(params) {
     } });
   }
   if (!("adminUrl" in params.shadow))
-    throw new VibeError44({ code: "VIBE_CONFIG", message: "Automatic server shadows require an explicit admin URL" });
+    throw new VibeError45({ code: "VIBE_CONFIG", message: "Automatic server shadows require an explicit admin URL" });
   const { provider, adminUrl } = params.shadow;
   const url = await Promise.resolve().then(() => new URL(adminUrl)).then((value) => value, (cause) => {
-    throw new VibeError44({ code: "VIBE_CONFIG", message: "shadowAdminUrl must be an explicit server database URL", cause });
+    throw new VibeError45({ code: "VIBE_CONFIG", message: "shadowAdminUrl must be an explicit server database URL", cause });
   });
   const expected = provider === "postgresql" ? ["postgres:", "postgresql:"] : ["mysql:"];
   if (!expected.includes(url.protocol) || url.hostname.length === 0 || url.pathname.length <= 1 || [...url.searchParams.keys()].some((key) => ["database", "dbname", "host", "hostaddr", "port", "user", "socketpath", "connectionstring", "uri", "url", "service"].includes(key.toLowerCase())))
-    throw new VibeError44({ code: "VIBE_CONFIG", message: "Shadow admin URL has an unsupported protocol or conflicting connection selector", meta: { reason: "shadow-url-ambiguous" } });
+    throw new VibeError45({ code: "VIBE_CONFIG", message: "Shadow admin URL has an unsupported protocol or conflicting connection selector", meta: { reason: "shadow-url-ambiguous" } });
   const prefix = /^\/vibeorm_test(?:_|$)/.test(url.pathname) ? "vibeorm_test_shadow" : "vibeorm_shadow";
   const name = `${prefix}_${randomUUID3().replaceAll("-", "")}`;
   const connection = await params.openConnection({ provider, url: adminUrl });
@@ -9754,7 +9895,7 @@ async function withMigrationReference(params) {
     const sqlDialect = getSqlDialect14({ dialect });
     for (const query of renderShadowOperation4({ dialect: sqlDialect, operation: { kind: "createDatabase", name } })) {
       await admin({ text: query.text, values: [...query.values] }).then(undefined, (cause) => {
-        throw new VibeError44({ code: "VIBE_MIGRATION", message: "Shadow CREATE did not report success. No deletion was attempted; inspect the named artifact on the configured admin server before explicit cleanup.", meta: { reason: "shadow-create-outcome-unknown", artifact: name }, cause });
+        throw new VibeError45({ code: "VIBE_MIGRATION", message: "Shadow CREATE did not report success. No deletion was attempted; inspect the named artifact on the configured admin server before explicit cleanup.", meta: { reason: "shadow-create-outcome-unknown", artifact: name }, cause });
       });
     }
     return finishShadowWork({ artifact: name, cleanup: async () => {
@@ -9769,10 +9910,10 @@ async function withMigrationReference(params) {
 }
 // packages/migrate/src/replay-objects.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { VibeError as VibeError45, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
+import { VibeError as VibeError46, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect15 } from "@vibeorm/sql";
 function comparisonFailure(params) {
-  return params.cause instanceof VibeError45 ? params.cause : new VibeError45({ code: "VIBE_MIGRATION", message: "Authored custom SQL could not be safely compiled on the independent scratch reference. Review dependencies and provide an explicit SQL migration when replacement is not supported.", meta: { reason: "migration-object-comparison-unavailable" }, cause: params.cause });
+  return params.cause instanceof VibeError46 ? params.cause : new VibeError46({ code: "VIBE_MIGRATION", message: "Authored custom SQL could not be safely compiled on the independent scratch reference. Review dependencies and provide an explicit SQL migration when replacement is not supported.", meta: { reason: "migration-object-comparison-unavailable" }, cause: params.cause });
 }
 function leadingCommand(params) {
   const { sql } = params;
@@ -9814,11 +9955,11 @@ async function compareReplayMigrationObjects(params) {
   if (objects.length === 0)
     return params.schema;
   if (params.reference.dialect !== "postgres")
-    throw new VibeError45({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Independent authored custom-object comparison requires transactional scratch DDL. Use reviewed SQL for this dialect's custom objects.", meta: { feature: "authoredCustomObjectComparison", dialect: params.reference.dialect, objects: objects.map((object) => object.identity) } });
+    throw new VibeError46({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Independent authored custom-object comparison requires transactional scratch DDL. Use reviewed SQL for this dialect's custom objects.", meta: { feature: "authoredCustomObjectComparison", dialect: params.reference.dialect, objects: objects.map((object) => object.identity) } });
   const before = new Map(params.reference.state.definitions.map((definition) => [sqlObjectKey16({ identity: definition.identity }), definition]));
   for (const object of objects) {
     if (object.dialect !== params.reference.dialect || object.create.length === 0 || before.has(sqlObjectKey16({ identity: object.identity })) && object.drop.length === 0 || [...object.create, ...object.drop].some((sql) => /^(?:BEGIN|START|COMMIT|END|ABORT|ROLLBACK|PREPARE|VACUUM|CREATE\s+DATABASE|DROP\s+DATABASE)\b/i.test(leadingCommand({ sql }))))
-      throw new VibeError45({ code: "VIBE_MIGRATION", message: "Custom object cannot be safely dropped/recreated in a rollback-only shadow transaction. Supply a reviewed SQL migration.", meta: { reason: "migration-object-comparison-unavailable", identity: object.identity } });
+      throw new VibeError46({ code: "VIBE_MIGRATION", message: "Custom object cannot be safely dropped/recreated in a rollback-only shadow transaction. Supply a reviewed SQL migration.", meta: { reason: "migration-object-comparison-unavailable", identity: object.identity } });
   }
   const definitions = new Map;
   const sentinel = getSqlDialect15({ dialect: "postgres" }).quoteIdent({ name: `vibe_probe_${randomUUID4().replaceAll("-", "")}` });
@@ -9826,7 +9967,7 @@ async function compareReplayMigrationObjects(params) {
     await Promise.resolve().then(() => params.executor({ text: `RELEASE SAVEPOINT ${sentinel}` })).then(() => {
       return;
     }, (cause) => {
-      throw new VibeError45({ code: "VIBE_MIGRATION", message: "Authored SQL destroyed the scratch transaction or its savepoint. Discard this scratch reference; no comparison result can be trusted.", meta: { reason: "migration-object-transaction-lost", shadowInvalid: true }, cause });
+      throw new VibeError46({ code: "VIBE_MIGRATION", message: "Authored SQL destroyed the scratch transaction or its savepoint. Discard this scratch reference; no comparison result can be trusted.", meta: { reason: "migration-object-transaction-lost", shadowInvalid: true }, cause });
     });
     await params.executor({ text: `SAVEPOINT ${sentinel}` });
   };
@@ -9854,7 +9995,7 @@ async function compareReplayMigrationObjects(params) {
     for (const object of objects) {
       const inspected = await inspectSqlObject({ executor: params.executor, dialect: "postgres", identity: object.identity });
       if (inspected.state !== "present")
-        throw new VibeError45({ code: "VIBE_MIGRATION", message: "Authored custom SQL did not produce an inspectable object in the independent scratch probe.", meta: { reason: "migration-object-comparison-unavailable", identity: object.identity, state: inspected.state } });
+        throw new VibeError46({ code: "VIBE_MIGRATION", message: "Authored custom SQL did not produce an inspectable object in the independent scratch probe.", meta: { reason: "migration-object-comparison-unavailable", identity: object.identity, state: inspected.state } });
       definitions.set(sqlObjectKey16({ identity: object.identity }), inspected.definition);
     }
     for (const [key, expected] of before) {
@@ -9862,32 +10003,173 @@ async function compareReplayMigrationObjects(params) {
         continue;
       const inspected = await inspectSqlObject({ executor: params.executor, dialect: "postgres", identity: expected.identity });
       if (inspected.state !== "present" || canonicalMigrationJson({ value: inspected.definition }) !== canonicalMigrationJson({ value: expected }))
-        throw new VibeError45({ code: "VIBE_MIGRATION", message: "Custom scratch replacement changed a dependent object outside the declared replacement set. Supply reviewed SQL.", meta: { reason: "migration-object-dependency-unavailable", identity: expected.identity } });
+        throw new VibeError46({ code: "VIBE_MIGRATION", message: "Custom scratch replacement changed a dependent object outside the declared replacement set. Supply reviewed SQL.", meta: { reason: "migration-object-dependency-unavailable", identity: expected.identity } });
     }
     await checkSentinel();
   }).then(() => ({ ok: true }), (cause) => ({ ok: false, error: comparisonFailure({ cause }) }));
-  const rollback = await Promise.resolve().then(() => params.executor({ text: "ROLLBACK" })).then(() => ({ ok: true }), (cause) => ({ ok: false, error: cause instanceof VibeError45 ? cause : new VibeError45({ code: "VIBE_MIGRATION", message: "Scratch rollback failed", meta: { reason: "migration-object-rollback-failed" }, cause }) }));
+  const rollback = await Promise.resolve().then(() => params.executor({ text: "ROLLBACK" })).then(() => ({ ok: true }), (cause) => ({ ok: false, error: cause instanceof VibeError46 ? cause : new VibeError46({ code: "VIBE_MIGRATION", message: "Scratch rollback failed", meta: { reason: "migration-object-rollback-failed" }, cause }) }));
   if (!rollback.ok)
-    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Custom comparison scratch could not be rolled back. Discard the scratch reference and inspect the preserved execution and cleanup errors.", meta: { reason: "migration-object-rollback-failed", shadowInvalid: true, cleanupFailure: rollback.error }, cause: outcome.ok ? rollback.error : outcome.error });
+    throw new VibeError46({ code: "VIBE_MIGRATION", message: "Custom comparison scratch could not be rolled back. Discard the scratch reference and inspect the preserved execution and cleanup errors.", meta: { reason: "migration-object-rollback-failed", shadowInvalid: true, cleanupFailure: rollback.error }, cause: outcome.ok ? rollback.error : outcome.error });
   if (!outcome.ok)
     throw outcome.error;
   for (const object of objects) {
     const key = sqlObjectKey16({ identity: object.identity });
     const previous = before.get(key);
     if (previous !== undefined && canonicalMigrationJson({ value: previous }) !== canonicalMigrationJson({ value: definitions.get(key) }))
-      throw new VibeError45({ code: "VIBE_MIGRATION", message: "Authored custom object differs from replayed history. Supply a reviewed forward SQL migration; generation will not silently replace its body.", meta: { reason: "migration-object-replacement-required", shadowReusable: true, identity: object.identity, id: object.id } });
+      throw new VibeError46({ code: "VIBE_MIGRATION", message: "Authored custom object differs from replayed history. Supply a reviewed forward SQL migration; generation will not silently replace its body.", meta: { reason: "migration-object-replacement-required", shadowReusable: true, identity: object.identity, id: object.id } });
   }
   return { ...params.schema, migrationObjects: objects.map((object) => ({ ...object, expected: definitions.get(sqlObjectKey16({ identity: object.identity })) })) };
 }
 // packages/migrate/src/replay-plan.ts
-import { VibeError as VibeError49, sqlObjectKey as sqlObjectKey18 } from "@vibeorm/schema";
+import { VibeError as VibeError51, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
+
+// packages/migrate/src/sqlite-fts-upgrade.ts
+import { VibeError as VibeError47, sqlObjectKey as sqlObjectKey17 } from "@vibeorm/schema";
+import { sqliteFtsUpdateUpgrade } from "@vibeorm/sql";
+var actionReceipts = new WeakMap;
+function specs(params) {
+  const result = [];
+  for (const group of params.collected.groups)
+    for (const artifact of group.objects) {
+      const owner = artifact.owns;
+      const expected = artifact.expected;
+      if (owner.kind !== "trigger" || artifact.create.length !== 0 || artifact.drop.length !== 0 || expected?.identity.kind !== "trigger" || expected.identity.table.namespace !== "main" || expected.format !== "catalog-v2" || expected.facts.type !== "trigger" || typeof expected.facts.definition !== "string" || expected.dependencies.length !== 0)
+        continue;
+      const identity = { kind: "trigger", table: { namespace: "main", name: owner.table }, name: owner.name };
+      if (sqlObjectKey17({ identity }) !== sqlObjectKey17({ identity: expected.identity }))
+        continue;
+      const matches = [];
+      for (const bundle of group.objects) {
+        if (bundle.owns.kind !== "trigger" || bundle.owns.table !== owner.table || bundle.create.length !== 4 || bundle.drop.length !== 3)
+          continue;
+        const create = bundle.create[2];
+        const parsed = sqliteFtsUpdateUpgrade({ create, installed: expected.facts.definition, table: owner.table, name: owner.name });
+        if (parsed?.kind !== "tableRequired" || bundle.owns.name !== `${parsed.ftsTable}_ai`)
+          continue;
+        const tableArtifact = group.objects.find((entry) => entry.owns.kind === "table" && entry.owns.name === parsed.ftsTable && entry.create.length === 1);
+        if (tableArtifact === undefined)
+          continue;
+        const declared = sqliteFtsUpdateUpgrade({ create, installed: expected.facts.definition, table: owner.table, name: owner.name, tableDefinition: tableArtifact.create[0] });
+        if (declared?.kind !== "recognized" || declared.installed !== "current")
+          continue;
+        matches.push({ artifact, bundle, tableArtifact, identity, create, ftsTable: declared.ftsTable, currentDefinition: declared.currentDefinition });
+      }
+      if (matches.length === 1)
+        result.push(matches[0]);
+    }
+  return result;
+}
+function tableIdentity(params) {
+  return { kind: "table", name: { namespace: "main", name: params.spec.ftsTable } };
+}
+function unavailable2(params) {
+  return { identity: params.identity, ownership: "migration", state: "unavailable", reason: params.reason, differences: [] };
+}
+async function planSqliteFtsUpdates(params) {
+  const states = new Map;
+  const forcedArtifacts = new Set;
+  const before = [];
+  const after = [];
+  const checks = [];
+  for (const spec of specs(params)) {
+    const key = sqlObjectKey17({ identity: spec.identity });
+    const live = await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity: spec.identity });
+    const state = compareInspectedSqlObject({ identity: spec.identity, ownership: "migration", expected: spec.artifact.expected, live, dialect: "sqlite" });
+    states.set(key, state);
+    if (live.state === "unavailable")
+      continue;
+    const beforeTrigger = live.state === "present" && typeof live.definition.facts.definition === "string" ? live.definition.facts.definition : undefined;
+    if (live.state === "present" && beforeTrigger === undefined)
+      continue;
+    const candidate = sqliteFtsUpdateUpgrade({ create: spec.create, installed: beforeTrigger ?? spec.currentDefinition, table: spec.identity.table.name, name: spec.identity.name });
+    if (candidate?.kind !== "tableRequired")
+      continue;
+    const table = await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity: tableIdentity({ spec }) });
+    if (table.state === "unavailable") {
+      states.set(key, unavailable2({ identity: spec.identity, reason: table.reason }));
+      continue;
+    }
+    const beforeTable = table.state === "present" && typeof table.definition.facts.definition === "string" ? table.definition.facts.definition : undefined;
+    const recognized = sqliteFtsUpdateUpgrade({
+      create: spec.create,
+      installed: beforeTrigger ?? spec.currentDefinition,
+      table: spec.identity.table.name,
+      name: spec.identity.name,
+      tableDefinition: table.state === "missing" ? spec.tableArtifact.create[0] : beforeTable ?? ""
+    });
+    if (recognized?.kind !== "recognized") {
+      states.set(key, unavailable2({ identity: spec.identity, reason: "sqlite-fts-table-unverified" }));
+      continue;
+    }
+    const installBundle = table.state === "missing" || !params.installed.triggers?.has(`${spec.ftsTable}_ai`) || !params.installed.triggers?.has(`${spec.ftsTable}_ad`);
+    if (table.state === "missing")
+      forcedArtifacts.add(spec.tableArtifact.id);
+    if (installBundle)
+      forcedArtifacts.add(spec.bundle.id);
+    else if (live.state === "missing")
+      after.push(spec.create, spec.bundle.create[3]);
+    const legacy = live.state === "present" && recognized.installed === "legacy";
+    if (legacy) {
+      before.push(recognized.drop);
+      if (!installBundle)
+        after.push(spec.create);
+      states.set(key, { ...state, state: "changed", reason: "sqlite-fts-update-upgrade" });
+    }
+    checks.push({ spec, beforeTrigger, beforeTable, changes: installBundle || live.state === "missing" || legacy });
+  }
+  return { states, forcedArtifacts, before, after, checks };
+}
+function retainSqliteFtsPlan(params) {
+  if (params.fts.checks.length > 0)
+    actionReceipts.set(params.plan, { fts: params.fts, ...params.transaction === undefined ? {} : { transaction: params.transaction } });
+}
+function sqliteFtsTransaction(params) {
+  return actionReceipts.get(params.plan)?.transaction;
+}
+function stateChanged(params) {
+  return new VibeError47({ code: "VIBE_MIGRATION", message: "SQLite FTS state changed after planning; re-plan before replacing synchronization", meta: { reason: "sqlite-fts-state-changed", identity: params.identity } });
+}
+async function assertSqliteFtsApplyState(params) {
+  const receipt = actionReceipts.get(params.plan)?.fts;
+  if (receipt === undefined)
+    return;
+  for (const check of receipt.checks) {
+    if (!check.changes)
+      continue;
+    for (const observation of [{ identity: check.spec.identity, definition: check.beforeTrigger }, { identity: tableIdentity({ spec: check.spec }), definition: check.beforeTable }]) {
+      const live = await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity: observation.identity });
+      if (observation.definition === undefined ? live.state !== "missing" : live.state !== "present" || live.definition.facts.definition !== observation.definition)
+        throw stateChanged({ identity: observation.identity });
+    }
+  }
+}
+async function verifySqliteFtsApplyState(params) {
+  const receipt = actionReceipts.get(params.plan)?.fts;
+  if (receipt === undefined)
+    return;
+  for (const { spec } of receipt.checks) {
+    const live = await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity: spec.identity });
+    const expected = { identity: spec.identity, format: "catalog-v2", facts: { definition: spec.currentDefinition, type: "trigger" }, dependencies: [] };
+    const compared = compareInspectedSqlObject({ identity: spec.identity, ownership: "migration", expected, live, dialect: "sqlite" });
+    if (compared.state !== "matching")
+      throw new VibeError47({ code: "VIBE_MIGRATION", message: "SQLite FTS UPDATE synchronization did not match its independent definition after apply", meta: { reason: "migration-state-unverified", objects: [compared] } });
+    const table = await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity: tableIdentity({ spec }) });
+    if (table.state !== "present" || typeof table.definition.facts.definition !== "string" || sqliteFtsUpdateUpgrade({ create: spec.create, installed: spec.currentDefinition, table: spec.identity.table.name, name: spec.identity.name, tableDefinition: table.definition.facts.definition })?.kind !== "recognized")
+      throw stateChanged({ identity: tableIdentity({ spec }) });
+    for (const suffix of ["ai", "ad"]) {
+      const identity = { kind: "trigger", table: spec.identity.table, name: `${spec.ftsTable}_${suffix}` };
+      if ((await inspectSqlObject({ executor: params.executor, dialect: "sqlite", identity })).state !== "present")
+        throw stateChanged({ identity });
+    }
+  }
+}
 
 // packages/migrate/src/planner.ts
-import { VibeError as VibeError48, sqlObjectKey as sqlObjectKey17, qualifiedSqlName as qualifiedSqlName12 } from "@vibeorm/schema";
+import { VibeError as VibeError50, sqlObjectKey as sqlObjectKey18, qualifiedSqlName as qualifiedSqlName13 } from "@vibeorm/schema";
 import { renderSqliteRebuildObjects, sqliteDialect as sqliteDialect4 } from "@vibeorm/sql";
 
 // packages/migrate/src/artifact-probe.ts
-import { VibeError as VibeError46 } from "@vibeorm/schema";
+import { VibeError as VibeError48 } from "@vibeorm/schema";
 var SAVEPOINT = "vibeorm_artifact_probe";
 async function probeChangedArtifacts(params) {
   const { executor, namespace } = params;
@@ -9910,7 +10192,7 @@ async function probeChangedArtifacts(params) {
       await executor({ text: `RELEASE SAVEPOINT ${SAVEPOINT}` });
     }
     if (after.state !== "present")
-      throw new VibeError46({ code: "VIBE_MIGRATION", message: `Extension artifact ${artifact.id} did not produce its object when probed; its create SQL cannot be verified against the replayed history`, meta: { reason: "artifact-probe-unavailable", id: artifact.id, identity } });
+      throw new VibeError48({ code: "VIBE_MIGRATION", message: `Extension artifact ${artifact.id} did not produce its object when probed; its create SQL cannot be verified against the replayed history`, meta: { reason: "artifact-probe-unavailable", id: artifact.id, identity } });
     if (canonicalMigrationJson({ value: before.definition.facts }) === canonicalMigrationJson({ value: after.definition.facts }))
       continue;
     const definition = before.definition.facts.definition;
@@ -9920,8 +10202,8 @@ async function probeChangedArtifacts(params) {
 }
 
 // packages/migrate/src/index-predicates.ts
-import { VibeError as VibeError47 } from "@vibeorm/schema";
-import { defaultIndexName as defaultIndexName3, qualifiedSqlName as qualifiedSqlName11 } from "@vibeorm/schema";
+import { VibeError as VibeError49 } from "@vibeorm/schema";
+import { defaultIndexName as defaultIndexName3, qualifiedSqlName as qualifiedSqlName12 } from "@vibeorm/schema";
 function physicalIndexName(params) {
   return params.index.name ?? defaultIndexName3({ table: params.table, columns: params.columns, unique: params.index.kind === "unique", dialect: "postgres" });
 }
@@ -9948,7 +10230,7 @@ async function prepareIndexPredicateDiff(params) {
         indexes.push(index);
         continue;
       }
-      const deparsed = await deparseIndexPredicate({ executor: params.executor, table: qualifiedSqlName11({ name: table, namespace: live.namespace, defaultNamespace: params.namespace }), where: next.where });
+      const deparsed = await deparseIndexPredicate({ executor: params.executor, table: qualifiedSqlName12({ name: table, namespace: live.namespace, defaultNamespace: params.namespace }), where: next.where });
       indexes.push(deparsed === index.where ? { ...index, where: next.where } : index);
     }
     models.push({ ...live, indexes });
@@ -9961,7 +10243,7 @@ async function deparseIndexPredicate(params) {
     const match = /^CHECK \((.*)\)$/s.exec(definition);
     return match === null ? undefined : match[1];
   } catch (error) {
-    if (error instanceof VibeError47 && error.code === "VIBE_MIGRATION")
+    if (error instanceof VibeError49 && error.code === "VIBE_MIGRATION")
       throw error;
     return;
   }
@@ -9985,19 +10267,23 @@ async function planSchemaMigration(params) {
   assertRetainedMigrationObjects({ from: (previous?.schema.migrationObjects ?? []).filter((object) => object.identity.kind !== "namespace" || !schemaNamespaces({ schema }).includes(object.identity.name)), to: objects });
   for (const object of objects)
     if (object.dialect !== dialect)
-      throw new VibeError48({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}`, meta: { feature: "migrationObject", dialect } });
+      throw new VibeError50({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}`, meta: { feature: "migrationObject", dialect } });
   const physical = params.physical ?? (dialect === "postgres" ? await introspectPhysicalPostgres({ executor, namespaces }) : dialect === "mysql" ? await introspectMysql({ executor }) : await introspectSqlite({ executor }));
   const comparablePhysical = external === undefined ? physical : projectExternalSchema({ schema: physical, external });
   if (previous !== undefined)
     assertMigrationState({ report: await verifyMigrationState({ executor, expected: previous, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
   const inventory = params.physicalInventory ?? external?.inventory ?? (await Promise.all((dialect === "postgres" ? namespaces : [namespace]).map((scope) => inspectMigrationInventory({ executor, dialect, namespace: scope })))).flat();
   const comparisonInventory = external === undefined ? inventory : projectExternalInventory({ inventory, external });
-  const visible = normalizeSchema({ schema: physical, dialect });
+  const visibleModels = new Set(physical.models.map((model) => physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect })));
+  let visible;
   for (const object of inventory) {
     const identity = object.identity;
-    if (identity.kind !== "table" || physical.models.some((model) => physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect }) === physicalNameKey({ ...identity.name, dialect })) || visible.joinTables.has(physicalNameKey({ ...identity.name, dialect })))
+    if (identity.kind !== "table" || visibleModels.has(physicalNameKey({ ...identity.name, dialect })))
+      continue;
+    visible ??= normalizeSchema({ schema: physical, dialect });
+    if (visible.joinTables.has(physicalNameKey({ ...identity.name, dialect })))
       continue;
-    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
+    throw new VibeError50({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
   }
   const states = resolved.unavailable.map((identity) => {
     const exists = identity.kind === "column" && [physical, previous?.schema].some((source) => source?.models.some((model) => physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect }) === physicalNameKey({ ...identity.table, dialect }) && model.fields.some((field) => (field.dbName ?? field.name) === identity.column)));
@@ -10008,13 +10294,13 @@ async function planSchemaMigration(params) {
   const creates = [];
   for (const object of objects) {
     for (const dependency of object.dependsOn) {
-      if ([...objects.map((entry) => entry.identity), ...schemaObjectIdentities({ schema, dialect, namespace })].some((identity) => sqlObjectKey17({ identity }) === sqlObjectKey17({ identity: dependency })))
+      if ([...objects.map((entry) => entry.identity), ...schemaObjectIdentities({ schema, dialect, namespace })].some((identity) => sqlObjectKey18({ identity }) === sqlObjectKey18({ identity: dependency })))
         continue;
       const state = await inspectSqlObject({ executor, dialect, identity: dependency });
       if (state.state !== "present")
         states.push({ identity: dependency, ownership: "migration", state: "unavailable", reason: "dependency-unavailable", differences: [] });
     }
-    const expected = object.expected ?? previous?.definitions.find((entry) => sqlObjectKey17({ identity: entry.identity }) === sqlObjectKey17({ identity: object.identity }));
+    const expected = object.expected ?? previous?.definitions.find((entry) => sqlObjectKey18({ identity: entry.identity }) === sqlObjectKey18({ identity: object.identity }));
     const live = await inspectSqlObject({ executor, dialect, identity: object.identity });
     if (object.identity.kind === "namespace") {
       states.push({ identity: object.identity, ownership: "schema", state: live.state === "present" ? "matching" : live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
@@ -10026,14 +10312,21 @@ async function planSchemaMigration(params) {
       states.push({ identity: object.identity, ownership: "migration", state: "missing", differences: [] });
       creates.push(...object.create);
     } else {
-      const report = await verifyMigrationState({ executor, dialect, expected: { schema: { ...schema, models: [], migrationObjects: [object] }, definitions: [expected] } });
-      states.push(...report.objects);
+      states.push(compareInspectedSqlObject({ identity: object.identity, ownership: "migration", expected, live, dialect }));
     }
   }
+  for (const object of legacyObjects)
+    if (objects.some((entry) => sqlObjectKey18({ identity: entry.identity }) === sqlObjectKey18({ identity: object.identity })))
+      throw new VibeError50({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
+  const installed = await probeInstalledExtensionState({ executor, dialect, artifacts });
+  const sqliteFts = dialect === "sqlite" && collected.objects.some((artifact) => artifact.owns.kind === "trigger" && artifact.create.length === 0 && artifact.drop.length === 0 && artifact.expected !== undefined) ? await planSqliteFtsUpdates({ executor, collected, installed }) : undefined;
   for (const object of legacyObjects) {
-    if (objects.some((entry) => sqlObjectKey17({ identity: entry.identity }) === sqlObjectKey17({ identity: object.identity })))
-      throw new VibeError48({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
-    const expected = object.expected ?? previous?.definitions.find((entry) => sqlObjectKey17({ identity: entry.identity }) === sqlObjectKey17({ identity: object.identity }));
+    const qualifiedFts = sqliteFts?.states.get(sqlObjectKey18({ identity: object.identity }));
+    if (qualifiedFts !== undefined) {
+      states.push(qualifiedFts);
+      continue;
+    }
+    const expected = object.expected ?? previous?.definitions.find((entry) => sqlObjectKey18({ identity: entry.identity }) === sqlObjectKey18({ identity: object.identity }));
     if (expected === undefined)
       states.push({ identity: object.identity, ownership: "migration", state: "unavailable", reason: "legacy-definition-required", differences: [] });
     else {
@@ -10041,7 +10334,7 @@ async function planSchemaMigration(params) {
       if (live.state === "missing")
         states.push({ identity: object.identity, ownership: "migration", state: "missing", differences: [] });
       else
-        states.push(...(await verifyMigrationState({ executor, dialect, expected: { schema: { ...schema, models: [], migrationObjects: [object] }, definitions: [expected] } })).objects);
+        states.push(compareInspectedSqlObject({ identity: object.identity, ownership: "migration", expected, live, dialect }));
     }
   }
   const protectedObjects = [...legacyObjects, ...objects, ...previous?.schema.migrationObjects ?? []];
@@ -10049,16 +10342,17 @@ async function planSchemaMigration(params) {
   const checked = await prepareCheckDiff({ executor, from: stripped, to: schema, dialect, ...params.probe === undefined ? {} : { probe: params.probe }, ...previous === undefined ? {} : { previous }, ...params.replaceChecks === undefined ? {} : { replaceChecks: params.replaceChecks } });
   const exclusionsPrepared = await prepareExclusionDiff({ ...params, ...previous === undefined ? {} : { previous }, from: checked, to: schema });
   const from = dialect === "postgres" ? await prepareOperatorClassDiff({ executor, from: await prepareIndexPredicateDiff({ executor, from: exclusionsPrepared, to: schema, namespace, ...params.probe === undefined ? {} : { probe: params.probe } }), to: schema }) : exclusionsPrepared;
-  const steps = diffSchemas({ from, to: schema, dialect });
-  const known = new Set(schemaObjectIdentities({ schema: previous?.schema ?? schema, dialect, namespace }).map((identity) => sqlObjectKey17({ identity })));
-  const declaredIndexes = normalizeSchema({ schema: previous?.schema ?? schema, dialect });
+  const comparison = diffSchemasWithNormalization({ from, to: schema, dialect });
+  const steps = comparison.steps;
+  const declaredIndexes = previous === undefined ? comparison.to : normalizeSchema({ schema: previous.schema, dialect });
+  const known = new Set(schemaObjectIdentitiesFromNormalized({ schema: previous?.schema ?? schema, dialect, namespace, normalized: declaredIndexes }).map((identity) => sqlObjectKey18({ identity })));
   const physicalIndexes = normalizeSchema({ schema: physical, dialect });
   for (const [table, model] of physicalIndexes.tables)
     for (const [key, index] of model.indexes) {
       if (index.constraintName !== undefined && declaredIndexes.tables.get(table)?.indexes.has(key))
-        known.add(sqlObjectKey17({ identity: { kind: "constraint", constraintType: "unique", table: qualifiedSqlName12({ name: model.table, namespace: model.namespace, defaultNamespace: namespace }), name: index.constraintName } }));
+        known.add(sqlObjectKey18({ identity: { kind: "constraint", constraintType: "unique", table: qualifiedSqlName13({ name: model.table, namespace: model.namespace, defaultNamespace: namespace }), name: index.constraintName } }));
     }
-  const migrationOwned = new Set(protectedObjects.map((object) => sqlObjectKey17({ identity: object.identity })));
+  const migrationOwned = new Set(protectedObjects.map((object) => sqlObjectKey18({ identity: object.identity })));
   const removals = steps.flatMap((step) => {
     const identity = removalIdentity({ step, namespace });
     return identity === undefined ? [] : [identity];
@@ -10067,30 +10361,30 @@ async function planSchemaMigration(params) {
     for (const identity of removals) {
       const owner = externalObjectOwner({ external, identity });
       if (owner !== undefined)
-        throw new VibeError48({ code: "VIBE_MIGRATION", message: "Automatic DDL cannot remove externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
+        throw new VibeError50({ code: "VIBE_MIGRATION", message: "Automatic DDL cannot remove externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
     }
   const enumRemovals = new Set(removals.flatMap((identity) => identity.kind === "enum" ? [physicalNameKey({ ...identity.name, dialect })] : []));
   if (external !== undefined)
     await refuseExternalDependents({ executor, dialect, external, steps, namespace });
   const droppedTables = new Set(steps.flatMap((step) => step.kind === "dropTable" || step.kind === "dropJoinTable" ? [physicalNameKey({ name: step.table, namespace: step.namespace, dialect })] : []));
   const unmanagedRemovals = [];
-  const invalid = dialect === "sqlite" ? sqliteInvalidatedTables({ steps, from: physical }) : { rebuilt: new Set, dropped: new Set };
+  const invalid = dialect === "sqlite" && steps.length > 0 ? sqliteInvalidatedTables({ steps, from: physical }) : { rebuilt: new Set, dropped: new Set };
   if (dialect === "sqlite")
     await assertSqliteRebuildTableOptions({ executor, tables: invalid.rebuilt });
   for (const object of inventory) {
-    const key = sqlObjectKey17({ identity: object.identity });
+    const key = sqlObjectKey18({ identity: object.identity });
     const normalizedOwner = object.backingConstraint === undefined ? undefined : inventory.find((entry) => entry.identity.kind === "constraint" && entry.identity.name === object.backingConstraint && ("table" in object.identity) && entry.identity.table.name === object.identity.table.name && entry.identity.table.namespace === object.identity.table.namespace);
-    const ownership = migrationOwned.has(key) ? "migration" : known.has(key) || normalizedOwner !== undefined && known.has(sqlObjectKey17({ identity: normalizedOwner.identity })) ? "schema" : "unknown";
+    const ownership = migrationOwned.has(key) ? "migration" : known.has(key) || normalizedOwner !== undefined && known.has(sqlObjectKey18({ identity: normalizedOwner.identity })) ? "schema" : "unknown";
     const externalOwner = external === undefined ? undefined : externalObjectOwner({ identity: object.identity, external });
     if (object.inspectionUnavailable !== undefined)
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: object.inspectionUnavailable, differences: [] });
     if (object.inspectionUnavailable !== undefined && invalid.rebuilt.has("table" in object.identity ? object.identity.table.name : typeof object.identity.name === "object" ? object.identity.name.name : object.identity.name))
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "SQLite rebuild cannot discard an unrepresented constraint; declare its independent definition or use a reviewed migration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+      throw new VibeError50({ code: "VIBE_MIGRATION", message: "SQLite rebuild cannot discard an unrepresented constraint; declare its independent definition or use a reviewed migration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
     if (ownership === "unknown" && comparisonInventory.includes(object))
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: "unmanaged", differences: [] });
     let collateral = "table" in object.identity && droppedTables.has(physicalNameKey({ ...object.identity.table, dialect }));
-    const declared = protectedObjects.find((entry) => sqlObjectKey17({ identity: entry.identity }) === key);
-    if (declared?.dependsOn.some((dependency) => removals.some((identity) => sqlObjectKey17({ identity }) === sqlObjectKey17({ identity: dependency })) || ("table" in dependency) && droppedTables.has(physicalNameKey({ ...dependency.table, dialect }))))
+    const declared = protectedObjects.find((entry) => sqlObjectKey18({ identity: entry.identity }) === key);
+    if (declared?.dependsOn.some((dependency) => removals.some((identity) => sqlObjectKey18({ identity }) === sqlObjectKey18({ identity: dependency })) || ("table" in dependency) && droppedTables.has(physicalNameKey({ ...dependency.table, dialect }))))
       collateral = true;
     if (ownership === "unknown" && object.identity.kind === "function" && steps.some((step) => step.kind === "dropTable" || step.kind === "dropColumn" || step.kind === "dropJoinTable" || step.kind === "dropEnum"))
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: "dependency-inspection-unavailable", differences: [] });
@@ -10104,7 +10398,7 @@ async function planSchemaMigration(params) {
           for (const address of addresses) {
             const value = JSON.parse(String(address));
             if (!Array.isArray(value) || !Array.isArray(value[2]))
-              throw new VibeError48({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
+              throw new VibeError50({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
             const names = value[2];
             if (typeof names[0] !== "string" || typeof names[1] !== "string")
               continue;
@@ -10116,22 +10410,23 @@ async function planSchemaMigration(params) {
       }
     }
     if (dialect === "sqlite" && ownership === "unknown" && object.identity.kind === "generatedColumn" && invalid.rebuilt.has(object.identity.table.name))
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "SQLite generated-column preservation requires an independent ownership declaration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
-    const removed = collateral || removals.some((identity) => sqlObjectKey17({ identity }) === key);
+      throw new VibeError50({ code: "VIBE_MIGRATION", message: "SQLite generated-column preservation requires an independent ownership declaration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+    const removed = collateral || removals.some((identity) => sqlObjectKey18({ identity }) === key);
     if (removed && externalOwner !== undefined)
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Automatic or collateral DDL cannot remove externally owned objects", meta: { reason: "external-owned-removal", owner: externalOwner, identity: object.identity } });
+      throw new VibeError50({ code: "VIBE_MIGRATION", message: "Automatic or collateral DDL cannot remove externally owned objects", meta: { reason: "external-owned-removal", owner: externalOwner, identity: object.identity } });
     if (removed && ownership === "migration")
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
+      throw new VibeError50({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
     if (removed && ownership === "unknown" && comparisonInventory.includes(object) && object.backingConstraint === undefined)
       unmanagedRemovals.push(object.identity);
   }
   const invalidated = new Set([...invalid.rebuilt, ...invalid.dropped]);
-  const installed = await probeInstalledExtensionState({ executor, dialect, artifacts });
   const triggers = installed.triggers === undefined ? undefined : new Set(installed.triggers);
   for (const artifact of artifacts)
     if (artifact.owns.kind === "trigger" && invalidated.has(artifact.owns.table))
       triggers?.delete(artifact.owns.name);
-  const missing = planMissingArtifacts({ introspected: physical, artifacts, installed: { ...installed, ...triggers === undefined ? {} : { triggers } } });
+  const absentArtifacts = planMissingArtifacts({ introspected: physical, artifacts, installed: { ...installed, ...triggers === undefined ? {} : { triggers } } });
+  const absentIds = new Set(absentArtifacts.map((artifact) => artifact.id));
+  const missing = artifacts.filter((artifact) => absentIds.has(artifact.id) || sqliteFts?.forcedArtifacts.has(artifact.id));
   const declaredPrevious = params.previousDeclarations ?? previous?.schema;
   const previousDeclarations = declaredPrevious === undefined || external === undefined ? declaredPrevious : projectExternalSchema({ schema: declaredPrevious, external });
   const previousArtifacts = previousDeclarations === undefined ? undefined : collectExtensionArtifacts({ schema: previousDeclarations, dialect, extensions: params.extensions ?? [] });
@@ -10169,11 +10464,11 @@ async function planSchemaMigration(params) {
         continue;
       const live = await inspectSqlObject({ executor, dialect, identity });
       if (live.state !== "present" || identity.kind !== "columnDefault" && typeof live.definition.facts.columnDefinition !== "string")
-        throw new VibeError48({ code: "VIBE_MIGRATION", message: "Cannot read the verified SQLite column definition for preservation", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError50({ code: "VIBE_MIGRATION", message: "Cannot read the verified SQLite column definition for preservation", meta: { reason: "sqlite-preservation-unavailable", identity } });
       if (identity.kind === "columnDefault") {
         const definition = live.definition.facts.definition;
         if (definition !== null && typeof definition !== "string")
-          throw new VibeError48({ code: "VIBE_MIGRATION", message: "Cannot preserve SQLite default", meta: { identity } });
+          throw new VibeError50({ code: "VIBE_MIGRATION", message: "Cannot preserve SQLite default", meta: { identity } });
         const defaults = preservedDefaults.get(identity.table.name) ?? new Map;
         defaults.set(identity.column, definition);
         preservedDefaults.set(identity.table.name, defaults);
@@ -10194,25 +10489,31 @@ async function planSchemaMigration(params) {
     const expression = defaults.get(column);
     return { ...rest, ...typeof expression === "string" ? { default: { kind: "dbgenerated", sql: expression } } : {} };
   }) })) };
-  const core = renderSteps({ steps, dialect, from: dialect === "sqlite" ? physical : from, to: dialect === "mysql" ? { ...target, migrationObjects: protectedObjects } : target, sqliteRestore: restore, sqliteColumns: preservedColumns });
+  const core = steps.length === 0 ? [] : renderSteps({ steps, dialect, from: dialect === "sqlite" ? physical : from, to: dialect === "mysql" ? { ...target, migrationObjects: protectedObjects } : target, sqliteRestore: restore, sqliteColumns: preservedColumns });
   const planned = new Set([...missing, ...rebuilt].map((artifact) => artifact.id));
-  const sql = [
-    ...artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension") }),
-    ...core,
+  const extensionSql = [
+    ...sqliteFts?.before ?? [],
     ...artifactDropSql({ artifacts: rebuilt }),
-    ...artifactCreateSql({ artifacts: collected.objects.filter((artifact) => planned.has(artifact.id) && !(artifact.owns.kind === "trigger" && invalid.rebuilt.has(artifact.owns.table))) }),
+    ...artifactCreateSql({ artifacts: collected.objects.filter((artifact) => planned.has(artifact.id) && (!(artifact.owns.kind === "trigger" && invalid.rebuilt.has(artifact.owns.table)) || sqliteFts?.forcedArtifacts.has(artifact.id))) }),
+    ...sqliteFts?.after ?? [],
     ...creates
   ];
+  const atomicFts = dialect === "sqlite" && sqliteFts?.checks.some((check) => check.changes) === true && usesSelfManagedTransactions({ sql: core });
+  const setupSql = artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension") });
+  const sql = [...setupSql, ...core, ...atomicFts ? ["BEGIN;"] : [], ...extensionSql, ...atomicFts ? ["COMMIT;"] : []];
   if (sql.length === 0) {
     const definitions = [...previous?.definitions ?? []];
     for (const object of objects)
-      if (object.expected !== undefined && !definitions.some((definition) => sqlObjectKey17({ identity: definition.identity }) === sqlObjectKey17({ identity: object.identity })))
+      if (object.expected !== undefined && !definitions.some((definition) => sqlObjectKey18({ identity: definition.identity }) === sqlObjectKey18({ identity: object.identity })))
         definitions.push(object.expected);
     const report = await verifyMigrationState({ executor, dialect, expected: { schema, definitions }, ...params.probe === undefined ? {} : { probe: params.probe } });
     states.push(...report.objects);
   }
-  const blocked = states.some((state) => state.reason === "dependency-inspection-unavailable" || state.ownership !== "unknown" && state.reason !== "legacy-definition-required" && (state.state === "unavailable" || state.state === "changed" || state.state === "missing" && sql.length === 0));
-  return { physical, from, to: schema, namespace, steps, objects: states, unmanagedRemovals, blocked, sql: blocked ? [] : sql, rebuiltArtifacts };
+  const blocked = states.some((state) => state.reason === "dependency-inspection-unavailable" || state.ownership !== "unknown" && state.reason !== "legacy-definition-required" && state.reason !== "sqlite-fts-update-upgrade" && (state.state === "unavailable" || state.state === "changed" || state.state === "missing" && sql.length === 0));
+  const plan = { physical, from, to: schema, namespace, steps, objects: states, unmanagedRemovals, blocked, sql: blocked ? [] : sql, rebuiltArtifacts };
+  if (sqliteFts !== undefined)
+    retainSqliteFtsPlan({ plan, fts: sqliteFts, ...atomicFts ? { transaction: { begin: setupSql.length + core.length, commit: sql.length - 1 } } : {} });
+  return plan;
 }
 
 // packages/migrate/src/replay-plan.ts
@@ -10238,13 +10539,13 @@ async function planReplayMigration(params) {
       moduleHeads.set(migration.moduleOrigin.moduleId, migration);
   const immutableObjects = new Map([...moduleHeads.values()].flatMap((migration) => {
     const state = migration.moduleOrigin.source.desiredState.to;
-    return (state.schema.migrationObjects ?? []).map((object) => [sqlObjectKey18({ identity: object.identity }), object.expected ?? state.definitions.find((definition) => sqlObjectKey18({ identity: definition.identity }) === sqlObjectKey18({ identity: object.identity }))]);
+    return (state.schema.migrationObjects ?? []).map((object) => [sqlObjectKey19({ identity: object.identity }), object.expected ?? state.definitions.find((definition) => sqlObjectKey19({ identity: definition.identity }) === sqlObjectKey19({ identity: object.identity }))]);
   }));
   const authored = reference.dialect === "postgres" ? (await resolvePostgresTypeIdentities({ executor, schema: params.schema, previous: reference.state.schema, mode: "verify" })).schema : params.schema;
-  const compared = await compareReplayMigrationObjects({ executor, reference, schema: { ...authored, migrationObjects: (authored.migrationObjects ?? []).filter((object) => !immutableObjects.has(sqlObjectKey18({ identity: object.identity }))) } });
-  const comparedObjects = new Map((compared.migrationObjects ?? []).map((object) => [sqlObjectKey18({ identity: object.identity }), object]));
+  const compared = await compareReplayMigrationObjects({ executor, reference, schema: { ...authored, migrationObjects: (authored.migrationObjects ?? []).filter((object) => !immutableObjects.has(sqlObjectKey19({ identity: object.identity }))) } });
+  const comparedObjects = new Map((compared.migrationObjects ?? []).map((object) => [sqlObjectKey19({ identity: object.identity }), object]));
   const schema = { ...compared, migrationObjects: (params.schema.migrationObjects ?? []).map((object) => {
-    const key = sqlObjectKey18({ identity: object.identity });
+    const key = sqlObjectKey19({ identity: object.identity });
     if (!immutableObjects.has(key))
       return comparedObjects.get(key);
     const expected = immutableObjects.get(key);
@@ -10263,57 +10564,57 @@ async function planReplayMigration(params) {
     const identity = removalIdentity({ step, namespace: plan.namespace });
     return identity === undefined ? [] : [identity];
   })])
-    removals.set(sqlObjectKey18({ identity }), identity);
-  const declared = new Set((schema.migrationObjects ?? []).map((object) => sqlObjectKey18({ identity: object.identity })));
+    removals.set(sqlObjectKey19({ identity }), identity);
+  const declared = new Set((schema.migrationObjects ?? []).map((object) => sqlObjectKey19({ identity: object.identity })));
   const historicalObjects = new Map;
   for (const migration of params.migrations)
     for (const object of migration.desiredState?.to.schema.migrationObjects ?? []) {
       if (external === undefined || externalObjectOwner({ identity: object.identity, external }) === undefined)
-        historicalObjects.set(sqlObjectKey18({ identity: object.identity }), object.identity);
+        historicalObjects.set(sqlObjectKey19({ identity: object.identity }), object.identity);
     }
-  const present = new Set(reference.inventory.map((object) => sqlObjectKey18({ identity: object.identity })));
-  const retainedObjects = reference.inventory.filter((object) => !declared.has(sqlObjectKey18({ identity: object.identity })) && !removals.has(sqlObjectKey18({ identity: object.identity })) && (object.identity.kind === "function" || object.identity.kind === "trigger" || historicalObjects.has(sqlObjectKey18({ identity: object.identity })))).map((object) => object.identity);
+  const present = new Set(reference.inventory.map((object) => sqlObjectKey19({ identity: object.identity })));
+  const retainedObjects = reference.inventory.filter((object) => !declared.has(sqlObjectKey19({ identity: object.identity })) && !removals.has(sqlObjectKey19({ identity: object.identity })) && (object.identity.kind === "function" || object.identity.kind === "trigger" || historicalObjects.has(sqlObjectKey19({ identity: object.identity })))).map((object) => object.identity);
   const removedRegistrations = [...historicalObjects].filter(([key]) => present.has(key) && !declared.has(key)).map(([, identity]) => identity);
   if (removedRegistrations.length > 0)
-    throw new VibeError49({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
+    throw new VibeError51({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
   if (external !== undefined)
     assertExternalOwnershipClaims({ external, identities: [...removals.values()] });
   return { ...plan, requiredRemovals: [...removals.values()], retainedObjects, securityChanges: securityChangesOf({ steps: plan.steps }), replayRemovals: params.migrations.flatMap((migration) => migration.desiredState?.unmanagedRemovals ?? []).filter((identity) => external === undefined || externalObjectOwner({ identity, external }) === undefined) };
 }
 function assertReplayRemovals(params) {
-  const wanted = new Set([...params.plan.requiredRemovals, ...params.plan.replayRemovals].map((identity) => sqlObjectKey18({ identity })));
-  const keys = params.approved.map((identity) => sqlObjectKey18({ identity }));
+  const wanted = new Set([...params.plan.requiredRemovals, ...params.plan.replayRemovals].map((identity) => sqlObjectKey19({ identity })));
+  const keys = params.approved.map((identity) => sqlObjectKey19({ identity }));
   if (new Set(keys).size !== keys.length)
-    throw new VibeError49({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
-  const unused = params.approved.filter((identity) => !wanted.has(sqlObjectKey18({ identity })));
+    throw new VibeError51({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
+  const unused = params.approved.filter((identity) => !wanted.has(sqlObjectKey19({ identity })));
   if (unused.length > 0)
-    throw new VibeError49({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
+    throw new VibeError51({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
   assertNamedRemovals({ removals: params.plan.requiredRemovals, approved: params.approved, acceptIntegrityLoss: params.acceptIntegrityLoss });
 }
 // packages/migrate/src/baseline.ts
-import { VibeError as VibeError52, sqlObjectKey as sqlObjectKey20 } from "@vibeorm/schema";
+import { VibeError as VibeError54, sqlObjectKey as sqlObjectKey21 } from "@vibeorm/schema";
 
 // packages/migrate/src/reference-state.ts
-import { VibeError as VibeError50, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
+import { VibeError as VibeError52, sqlObjectKey as sqlObjectKey20 } from "@vibeorm/schema";
 async function captureMigrationReference(params) {
   const namespace = await migrationNamespace({ executor: params.referenceExecutor, dialect: params.dialect });
   const identities = [...schemaObjectIdentities({ schema: params.schema, dialect: params.dialect, namespace }), ...(params.schema.migrationObjects ?? []).map((object) => object.identity)];
   const definitions = [];
-  for (const identity of new Map(identities.map((identity) => [sqlObjectKey19({ identity }), identity])).values()) {
+  for (const identity of new Map(identities.map((identity) => [sqlObjectKey20({ identity }), identity])).values()) {
     if (identity.kind === "namespace")
       continue;
-    if (!params.schema.migrationObjects?.some((object) => sqlObjectKey19({ identity: object.identity }) === sqlObjectKey19({ identity })) && !(identity.kind === "constraint" && (identity.constraintType === "check" || identity.constraintType === "exclusion")))
+    if (!params.schema.migrationObjects?.some((object) => sqlObjectKey20({ identity: object.identity }) === sqlObjectKey20({ identity })) && !(identity.kind === "constraint" && (identity.constraintType === "check" || identity.constraintType === "exclusion")))
       continue;
     const result = await inspectSqlObject({ executor: params.referenceExecutor, dialect: params.dialect, identity });
     if (result.state !== "present")
-      throw new VibeError50({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
+      throw new VibeError52({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
     definitions.push(result.definition);
   }
   let schema = params.schema;
   if (params.dialect === "postgres" && schema.models.some((model) => model.fields.some((field) => field.isUnsupported === true))) {
     const resolved = await resolvePostgresTypeIdentities({ executor: params.referenceExecutor, schema, mode: "reference" });
     if (resolved.unavailable.length > 0)
-      throw new VibeError50({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
+      throw new VibeError52({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
     const physical = await introspectPhysicalPostgres({ executor: params.referenceExecutor, namespaces: ["public", ...schemaNamespaces({ schema })] });
     for (const model of resolved.schema.models)
       for (const field of model.fields) {
@@ -10321,7 +10622,7 @@ async function captureMigrationReference(params) {
           continue;
         const actual = physical.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace }) === physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace }))?.fields.find((entry) => entry.name === (field.dbName ?? field.name));
         if (actual === undefined || columnTypeKey({ field }) !== columnTypeKey({ field: actual }))
-          throw new VibeError50({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
+          throw new VibeError52({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
       }
     schema = resolved.schema;
   }
@@ -10329,13 +10630,13 @@ async function captureMigrationReference(params) {
 }
 
 // packages/migrate/src/compile-desired-state.ts
-import { VibeError as VibeError51, qualifiedSqlName as qualifiedSqlName13 } from "@vibeorm/schema";
+import { VibeError as VibeError53, qualifiedSqlName as qualifiedSqlName14 } from "@vibeorm/schema";
 import { renderExclusionSetup as renderExclusionSetup2, getSqlDialect as getSqlDialect16, renderMigrationServerVersion as renderMigrationServerVersion2 } from "@vibeorm/sql";
 async function compileDesiredState(params) {
   if (params.dialect !== "postgres")
-    throw new VibeError51({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Rollback declaration compilation requires PostgreSQL", meta: { feature: "desiredStateCompilation", dialect: params.dialect } });
+    throw new VibeError53({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Rollback declaration compilation requires PostgreSQL", meta: { feature: "desiredStateCompilation", dialect: params.dialect } });
   if (params.steps.some((step) => step.kind === "alterColumn" || step.kind === "addColumn" || step.kind === "addEnumValue"))
-    throw new VibeError51({ code: "VIBE_MIGRATION", message: "CHECK compilation after column or enum changes requires an independently built reference with the new type context", meta: { reason: "reference-required" } });
+    throw new VibeError53({ code: "VIBE_MIGRATION", message: "CHECK compilation after column or enum changes requires an independently built reference with the new type context", meta: { reason: "reference-required" } });
   const definitions = (params.schema.migrationObjects ?? []).flatMap((object) => object.expected === undefined ? [] : [object.expected]);
   await params.executor({ text: "SAVEPOINT vibeorm_desired_state" });
   try {
@@ -10344,7 +10645,7 @@ async function compileDesiredState(params) {
       await params.executor({ text });
     const models = [];
     for (const model of params.schema.models) {
-      const table = qualifiedSqlName13({ name: model.dbName ?? model.name, namespace: model.namespace });
+      const table = qualifiedSqlName14({ name: model.dbName ?? model.name, namespace: model.namespace });
       const exclusions = [];
       for (const exclusion of model.exclusions ?? []) {
         for (const text of renderExclusionSetup2({ dialect: getSqlDialect16({ dialect: "postgres" }), exclusion }))
@@ -10358,7 +10659,7 @@ async function compileDesiredState(params) {
     const query = renderMigrationServerVersion2({ dialect: getSqlDialect16({ dialect: params.dialect }) });
     const version = (await params.executor({ text: query.text, values: [] }))[0]?.version;
     if (typeof version !== "string")
-      throw new VibeError51({ code: "VIBE_MIGRATION", message: "Cannot determine definition normalization version" });
+      throw new VibeError53({ code: "VIBE_MIGRATION", message: "Cannot determine definition normalization version" });
     return { ...createDesiredState({ schema: { ...params.schema, models }, dialect: params.dialect, definitions }), normalization: { format: "catalog-v1", dialect: params.dialect, serverVersion: version } };
   } finally {
     await params.executor({ text: "ROLLBACK TO SAVEPOINT vibeorm_desired_state" });
@@ -10371,19 +10672,19 @@ function generateBaselineMigration(params) {
   const objects = orderedMigrationObjects({ objects: params.schema.migrationObjects ?? [] });
   for (const object of objects)
     if (object.dialect !== params.dialect)
-      throw new VibeError52({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
+      throw new VibeError54({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
   const prerequisites = objects.filter((object) => object.identity.kind === "postgresExtension" || object.identity.kind === "enum" || object.identity.kind === "sequence");
-  const prerequisiteKeys = new Set(prerequisites.map((object) => sqlObjectKey20({ identity: object.identity })));
+  const prerequisiteKeys = new Set(prerequisites.map((object) => sqlObjectKey21({ identity: object.identity })));
   for (const object of prerequisites) {
-    const unresolved = object.dependsOn.filter((identity) => !prerequisiteKeys.has(sqlObjectKey20({ identity })));
+    const unresolved = object.dependsOn.filter((identity) => !prerequisiteKeys.has(sqlObjectKey21({ identity })));
     if (unresolved.length > 0)
-      throw new VibeError52({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
+      throw new VibeError54({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
   }
-  const schema = { ...params.schema, migrationObjects: objects.filter((object) => !prerequisiteKeys.has(sqlObjectKey20({ identity: object.identity }))) };
+  const schema = { ...params.schema, migrationObjects: objects.filter((object) => !prerequisiteKeys.has(sqlObjectKey21({ identity: object.identity }))) };
   const generated = generateMigration({ from: { datasource: schema.datasource, models: [], enums: [], extensions: [] }, to: schema, name: params.name, dialect: params.dialect, extensions: params.extensions ?? [] });
   const sql = splitSqlStatements({ sql: joinSqlStatements({ sql: [...prerequisites.flatMap((object) => object.create), ...generated.sql] }), dialect: params.dialect });
   if (sql.length === 0)
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
+    throw new VibeError54({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
   return {
     name: generated.name,
     sql,
@@ -10395,8 +10696,8 @@ function generateBaselineMigration(params) {
 async function verifyBaselineDeclarations(params) {
   const captured = await captureMigrationReference({ referenceExecutor: params.executor, schema: params.schema, dialect: params.dialect });
   const authored = (params.schema.migrationObjects ?? []).flatMap((object) => object.expected === undefined ? [] : [object.expected]);
-  const customKeys = new Set((params.schema.migrationObjects ?? []).map((object) => sqlObjectKey20({ identity: object.identity })));
-  const customDefinitions = captured.definitions.filter((definition) => customKeys.has(sqlObjectKey20({ identity: definition.identity })) && !authored.some((entry) => sqlObjectKey20({ identity: entry.identity }) === sqlObjectKey20({ identity: definition.identity })));
+  const customKeys = new Set((params.schema.migrationObjects ?? []).map((object) => sqlObjectKey21({ identity: object.identity })));
+  const customDefinitions = captured.definitions.filter((definition) => customKeys.has(sqlObjectKey21({ identity: definition.identity })) && !authored.some((entry) => sqlObjectKey21({ identity: entry.identity }) === sqlObjectKey21({ identity: definition.identity })));
   const verify = async () => {
     const compiled = params.dialect === "postgres" ? await compileDesiredState({ ...params, schema: captured.schema, steps: [], probe: "rollback" }) : { schema: captured.schema, definitions: authored };
     const expected = { ...compiled, definitions: [...compiled.definitions, ...customDefinitions] };
@@ -10412,48 +10713,48 @@ async function verifyBaselineDeclarations(params) {
 async function verifyBaselineTarget(params) {
   const { reference } = params;
   if (reference.unavailable.length > 0 || reference.inventory.some((object) => object.inspectionUnavailable !== undefined))
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
+    throw new VibeError54({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
   const comparison = await verifyMigrationReference({ executor: params.executor, dialect: reference.dialect, reference, referenceExecutor: params.referenceExecutor }).catch((cause) => {
-    if (cause instanceof VibeError52 && cause.meta.reason === "verification-rls-reference-required")
-      throw new VibeError52({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
+    if (cause instanceof VibeError54 && cause.meta.reason === "verification-rls-reference-required")
+      throw new VibeError54({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
     throw cause;
   });
   const security = comparison.objects.filter((object) => object.reason === "native-rls-mismatch");
   if (security.length > 0)
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
+    throw new VibeError54({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
   if (comparison.unavailable.length > 0)
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
+    throw new VibeError54({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
   const report = { inSync: comparison.objects.every((object) => object.state === "matching"), objects: comparison.objects };
   assertMigrationState({ report });
   const unmanaged = comparison.unmanaged.map((object) => object.identity);
-  const extras = new Set(unmanaged.map((identity) => sqlObjectKey20({ identity })));
+  const extras = new Set(unmanaged.map((identity) => sqlObjectKey21({ identity })));
   const exclusions = params.excludeUnmanaged ?? [];
-  const excluded = new Set(exclusions.map((identity) => sqlObjectKey20({ identity })));
-  if (excluded.size !== exclusions.length || exclusions.some((identity) => !extras.has(sqlObjectKey20({ identity }))))
-    throw new VibeError52({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
-  const unreviewed = unmanaged.filter((identity) => !excluded.has(sqlObjectKey20({ identity })));
+  const excluded = new Set(exclusions.map((identity) => sqlObjectKey21({ identity })));
+  if (excluded.size !== exclusions.length || exclusions.some((identity) => !extras.has(sqlObjectKey21({ identity }))))
+    throw new VibeError54({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
+  const unreviewed = unmanaged.filter((identity) => !excluded.has(sqlObjectKey21({ identity })));
   if (unreviewed.length > 0)
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
+    throw new VibeError54({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
   return { ...report, unmanaged };
 }
 // packages/migrate/src/baseline-record.ts
-import { VibeError as VibeError53 } from "@vibeorm/schema";
+import { VibeError as VibeError55 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect17, renderStatement } from "@vibeorm/sql";
 function transactionFailure2(params) {
-  if (params.cause instanceof VibeError53)
+  if (params.cause instanceof VibeError55)
     return params.cause;
-  return new VibeError53({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
+  return new VibeError55({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
 }
 async function recordBaselineMigration(params) {
   if (params.migration.moduleOrigin !== undefined)
-    throw new VibeError53({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
+    throw new VibeError55({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
   validateMigrationReplay({ dialect: params.dialect, migrations: [params.migration], acceptSecurityChanges: params.acceptSecurityChanges });
   await withMigrationLock({ executor: params.executor, dialect: params.dialect, run: async (executor) => {
     const record = async () => {
       const assertEmpty = async () => {
         const history = await readMigrationHistory({ executor, migrations: [params.migration], dialect: params.dialect });
         if (history.recorded.length > 0)
-          throw new VibeError53({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
+          throw new VibeError55({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
       };
       await assertEmpty();
       await params.verify({ executor });
@@ -10478,14 +10779,14 @@ async function recordBaselineMigration(params) {
       await executor({ text: "COMMIT" });
     }).then(undefined, async (cause) => {
       await executor({ text: "ROLLBACK" }).then(undefined, (rollback) => {
-        throw new VibeError53({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
+        throw new VibeError55({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
       });
       throw transactionFailure2({ cause });
     });
   } });
 }
 // packages/migrate/src/down.ts
-import { VibeError as VibeError54, sqlObjectKey as sqlObjectKey21 } from "@vibeorm/schema";
+import { VibeError as VibeError56, sqlObjectKey as sqlObjectKey22 } from "@vibeorm/schema";
 function buildRollbackTarget(params) {
   const { from, to, dialect } = params;
   const skipped = [];
@@ -10589,10 +10890,10 @@ function generateDownMigration(params) {
     }
     restoreSql.push(...entry.restore);
   }
-  const previousKeys = new Set((from.migrationObjects ?? []).map((object) => sqlObjectKey21({ identity: object.identity })));
+  const previousKeys = new Set((from.migrationObjects ?? []).map((object) => sqlObjectKey22({ identity: object.identity })));
   const ownedDropSql = [];
   for (const object of orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).reverse()) {
-    if (previousKeys.has(sqlObjectKey21({ identity: object.identity })))
+    if (previousKeys.has(sqlObjectKey22({ identity: object.identity })))
       continue;
     if (object.identity.kind === "namespace") {
       skipped.push(`namespace ${object.identity.name} remains installed`);
@@ -10603,7 +10904,7 @@ function generateDownMigration(params) {
       continue;
     }
     if (object.drop.length === 0)
-      throw new VibeError54({ code: "VIBE_MIGRATION", message: `Migration object ${object.id} needs reviewed reverse SQL`, meta: { reason: "migration-object-reverse-required", id: object.id } });
+      throw new VibeError56({ code: "VIBE_MIGRATION", message: `Migration object ${object.id} needs reviewed reverse SQL`, meta: { reason: "migration-object-reverse-required", id: object.id } });
     ownedDropSql.push(...object.drop);
   }
   return {
@@ -10616,11 +10917,11 @@ function generateDownMigration(params) {
   };
 }
 // packages/migrate/src/push.ts
-import { VibeError as VibeError55, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect6, sqlObjectKey as sqlObjectKey22, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { VibeError as VibeError57, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect7, sqlObjectKey as sqlObjectKey23, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
 import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES4 } from "@vibeorm/sql";
 async function push(params) {
   assertValidSchemaIR4({ schema: params.schema });
-  const dialect = providerToDialect6({ provider: params.schema.datasource.provider });
+  const dialect = providerToDialect7({ provider: params.schema.datasource.provider });
   if (params.rebuildArtifacts === true && dialect !== "postgres")
     throw unsupportedCapability14({ dialect, feature: "rebuilding extension artifacts on push (rebuildArtifacts)", hint: "drop the extension's objects by hand and push again; the transactional rebuild exists on PostgreSQL only" });
   if (dialect !== "postgres")
@@ -10660,11 +10961,11 @@ async function pushChanges(params) {
   if (params.dryRun === true)
     return { steps, applied: [], planned: sql, securityChanges, objects: plan.objects, blocked: plan.blocked, unmanagedRemovals: plan.unmanagedRemovals };
   if (plan.blocked)
-    throw new VibeError55({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
+    throw new VibeError57({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
   assertSecurityAcknowledgement({ securityChanges, ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
   const destructive = steps.filter((step) => step.destructive);
   if (destructive.length > 0 && params.acceptDataLoss !== true)
-    throw new VibeError55({ code: "VIBE_MIGRATION", message: `push refused: ${destructive.length} destructive step(s) would lose data; pass acceptDataLoss: true: ${destructive.map((step) => describeStep({ step })).join("; ")}`, meta: { destructive: destructive.map((step) => describeStep({ step })) } });
+    throw new VibeError57({ code: "VIBE_MIGRATION", message: `push refused: ${destructive.length} destructive step(s) would lose data; pass acceptDataLoss: true: ${destructive.map((step) => describeStep({ step })).join("; ")}`, meta: { destructive: destructive.map((step) => describeStep({ step })) } });
   assertRemovalAuthorization({
     steps,
     dialect,
@@ -10673,16 +10974,26 @@ async function pushChanges(params) {
     ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss },
     ...params.removeUnmanaged === undefined ? {} : { removeUnmanaged: params.removeUnmanaged }
   });
-  const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey22({ identity })));
-  const unapproved = plan.unmanagedRemovals.filter((identity) => !approved.has(sqlObjectKey22({ identity })));
+  const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey23({ identity })));
+  const unapproved = plan.unmanagedRemovals.filter((identity) => !approved.has(sqlObjectKey23({ identity })));
   if (unapproved.length > 0)
-    throw new VibeError55({ code: "VIBE_MIGRATION", message: "DDL would remove unmanaged dependent objects; approve their exact identities", meta: { reason: "unmanaged-removal-required", objects: unapproved } });
+    throw new VibeError57({ code: "VIBE_MIGRATION", message: "DDL would remove unmanaged dependent objects; approve their exact identities", meta: { reason: "unmanaged-removal-required", objects: unapproved } });
   const wrap = dialect !== "postgres" && DIALECT_CAPABILITIES4[dialect].transactionalDdl && !usesSelfManagedTransactions({ sql });
+  const ftsTransaction = dialect === "sqlite" ? sqliteFtsTransaction({ plan }) : undefined;
   if (wrap)
     await executor({ text: "BEGIN" });
   try {
-    for (const statement of sql)
+    if (dialect === "sqlite" && ftsTransaction === undefined)
+      await assertSqliteFtsApplyState({ plan, executor });
+    for (const [index, statement] of sql.entries()) {
+      if (ftsTransaction?.commit === index)
+        await verifySqliteFtsApplyState({ plan, executor });
       await executeStatement({ executor, statement, dialect });
+      if (ftsTransaction?.begin === index)
+        await assertSqliteFtsApplyState({ plan, executor });
+    }
+    if (dialect === "sqlite" && ftsTransaction === undefined)
+      await verifySqliteFtsApplyState({ plan, executor });
     if ((schema.migrationObjects?.length ?? 0) > 0)
       assertMigrationState({ report: await verifyMigrationState({ executor, dialect, expected: createDesiredState({ schema: { ...schema, models: [] }, dialect }), ...params.external === undefined ? {} : { external: params.external } }) });
     if (wrap)
@@ -10694,7 +11005,7 @@ async function pushChanges(params) {
       } catch {}
     } else if (dialect === "sqlite")
       await cleanupSelfManagedFailure({ executor });
-    throw new VibeError55({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
+    throw new VibeError57({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
   }
   return { steps, applied: sql, securityChanges, objects: plan.objects, desiredState: createDesiredState({ schema: plan.to, dialect }) };
 }
@@ -10709,11 +11020,11 @@ async function pull(params) {
   }
 }
 // packages/migrate/src/module-export.ts
-import { VibeError as VibeError56, providerToDialect as providerToDialect7 } from "@vibeorm/schema";
+import { VibeError as VibeError58, providerToDialect as providerToDialect8 } from "@vibeorm/schema";
 function runtimeSchema(params) {
   const byName = (left, right) => left.name.localeCompare(right.name);
   return {
-    datasource: { provider: providerToDialect7({ provider: params.schema.datasource.provider }) },
+    datasource: { provider: providerToDialect8({ provider: params.schema.datasource.provider }) },
     models: [...params.schema.models].sort(byName),
     enums: [...params.schema.enums].sort(byName),
     extensions: [...params.schema.extensions].sort(byName),
@@ -10724,13 +11035,13 @@ function emitModuleMigrationExport(params) {
   moduleMigrationFiles({ bundle: params.bundle, prefix: "export" });
   const origin = params.bundle.migrations.at(-1).moduleOrigin;
   if (!origin.contracts.includes(params.contract))
-    throw new VibeError56({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
+    throw new VibeError58({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
   if (params.client !== undefined) {
     const { module, schema } = params.client;
-    if (module.id !== origin.moduleId || module.revision !== origin.revision || module.contract !== params.contract || providerToDialect7({ provider: schema.datasource.provider }) !== origin.dialect)
-      throw new VibeError56({ code: "VIBE_CONFIG", message: "The generated module identity, revision or contract differs from its migration head", meta: { reason: "module-client-head-mismatch", moduleId: origin.moduleId } });
+    if (module.id !== origin.moduleId || module.revision !== origin.revision || module.contract !== params.contract || providerToDialect8({ provider: schema.datasource.provider }) !== origin.dialect)
+      throw new VibeError58({ code: "VIBE_CONFIG", message: "The generated module identity, revision or contract differs from its migration head", meta: { reason: "module-client-head-mismatch", moduleId: origin.moduleId } });
     if (canonicalMigrationJson({ value: runtimeSchema({ schema }) }) !== canonicalMigrationJson({ value: runtimeSchema({ schema: origin.source.desiredState.to.schema }) }))
-      throw new VibeError56({ code: "VIBE_CONFIG", message: "The generated module schema differs from its immutable migration head", meta: { reason: "module-client-schema-mismatch", moduleId: origin.moduleId } });
+      throw new VibeError58({ code: "VIBE_CONFIG", message: "The generated module schema differs from its immutable migration head", meta: { reason: "module-client-schema-mismatch", moduleId: origin.moduleId } });
   }
   const expectation = { moduleId: origin.moduleId, revision: origin.revision, artifactChecksum: origin.artifactChecksum, contract: params.contract };
   return [
@@ -10749,16 +11060,16 @@ export const moduleReadiness = Object.freeze(${JSON.stringify(expectation)});
   ];
 }
 // packages/migrate/src/module-readiness.ts
-import { VibeError as VibeError57 } from "@vibeorm/schema";
+import { VibeError as VibeError59 } from "@vibeorm/schema";
 async function inspectModuleReadiness(params) {
   const ids = new Set;
   for (const expected of params.modules) {
     if (ids.has(expected.moduleId) || !expected.moduleId || !expected.revision || !expected.contract || !/^[a-f0-9]{64}$/.test(expected.artifactChecksum))
-      throw new VibeError57({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
+      throw new VibeError59({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
     ids.add(expected.moduleId);
   }
   if (params.compatibility !== undefined && params.compatibility !== "exact" && params.compatibility !== "contract")
-    throw new VibeError57({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
+    throw new VibeError59({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
   const records = await readModuleJournal(params);
   const heads = moduleHistoryHeads({ records });
   const unresolved = [...records.values()].some(({ row, entry }) => row.error !== undefined || row.statementIndex < 0 || entry !== undefined && (!entry.complete || row.statementIndex !== entry.migration.sql.length));
@@ -10793,7 +11104,7 @@ async function inspectModuleReadiness(params) {
   return { ready: !unresolved && modules.every((module) => (module.revision === "matching" || module.revision === "compatible") && module.structural.status !== "drifted"), modules };
 }
 // packages/migrate/src/adoption.ts
-import { VibeError as VibeError58 } from "@vibeorm/schema";
+import { VibeError as VibeError60 } from "@vibeorm/schema";
 async function adoptMigration(params) {
   const report = await verifyMigrationState({ executor: params.executor, expected: params.reference, dialect: params.dialect });
   assertMigrationState({ report });
@@ -10809,11 +11120,11 @@ function deployedDesiredState(params) {
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.checksum === "" || file?.name !== row.name || migrationChecksum(file) !== row.checksum)
-      throw new VibeError58({ code: "VIBE_MIGRATION", message: "Desired state requires complete, checksum-verified migration history", meta: { reason: "desired-state-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError60({ code: "VIBE_MIGRATION", message: "Desired state requires complete, checksum-verified migration history", meta: { reason: "desired-state-history-unverified", migration: row.name, state: row.state } });
   }
   const applied = new Set(params.recorded.map((row) => row.name));
   if (params.migrations.some((migration) => applied.has(migration.name) && migration.desiredStatePending === true))
-    throw new VibeError58({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
+    throw new VibeError60({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
   const last = [...params.migrations].reverse().find((migration) => applied.has(migration.name));
   return last?.desiredState?.to;
 }
@@ -10928,4 +11239,4 @@ export {
   withMigrationReference
 };
 
-//# debugId=CC107738F16DF7A964756E2164756E21
+//# debugId=F91BB3120BEADA3064756E2164756E21