@vibeorm/migrate 2.0.2 → 2.1.1

package/dist/index.js

@@ -3,6 +3,10 @@
 function describeStep(params) {
   const { step } = params;
   switch (step.kind) {
+    case "addExclusion":
+      return `add exclusion "${step.exclusion.name}" on "${step.table}"`;
+    case "dropExclusion":
+      return `drop exclusion "${step.exclusion.name}" on "${step.table}"`;
     case "enableRls":
       return `enable native RLS on "${step.table}"`;
     case "forceRls":
@@ -67,6 +71,7 @@ function describeStep(params) {
 }
 // packages/migrate/src/differ.ts
 import { isEnumType as isEnumType6, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 
 // packages/migrate/src/enum-values.ts
 import { isEnumType, unsupportedCapability } from "@vibeorm/schema";
@@ -423,13 +428,27 @@ var ENUM_CHECK_PATTERN = /CONSTRAINT "((?:[^"]|"")+)_enum_((?:[^"]|"")+)" CHECK
 function parseSqliteNamedChecks(params) {
   const { tableSql } = params;
   const result = [];
-  for (const match of tableSql.matchAll(/CONSTRAINT "((?:[^"]|"")+)" CHECK\s*\(/g)) {
-    const name = match[1].replaceAll('""', '"');
+  for (const match of tableSql.matchAll(/\bCONSTRAINT\s+(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))\s+CHECK\s*\(/gi)) {
+    const name = match[1]?.replaceAll('""', '"') ?? match[2]?.replaceAll("``", "`") ?? match[3] ?? match[4];
     const open = (match.index ?? 0) + match[0].length - 1;
     let depth = 0;
     let close = -1;
+    let quote;
     for (let index = open;index < tableSql.length; index++) {
       const char = tableSql[index];
+      if (quote !== undefined) {
+        if (char === quote) {
+          if (tableSql[index + 1] === quote)
+            index++;
+          else
+            quote = undefined;
+        }
+        continue;
+      }
+      if (char === "'" || char === '"' || char === "`") {
+        quote = char;
+        continue;
+      }
       if (char === "(")
         depth += 1;
       else if (char === ")") {
@@ -742,6 +761,7 @@ function normalizeIndexes(params) {
     result.set(key, {
       key,
       name,
+      ...index.constraintName === undefined ? {} : { constraintName: index.constraintName },
       kind,
       unique,
       columns,
@@ -945,7 +965,7 @@ function normalizeFks(params) {
       continue;
     result.set(key, {
       key,
-      constraintName: `${table}_${columns.join("_")}_fkey`,
+      constraintName: relation.constraintName ?? `${table}_${columns.join("_")}_fkey`,
       columns,
       refTable,
       refColumns,
@@ -1242,6 +1262,9 @@ function planRenames(params) {
 // packages/migrate/src/differ.ts
 function diffSchemas(params) {
   const dialect = params.dialect ?? "postgres";
+  for (const schema of [params.from, params.to])
+    if (dialect !== "postgres" && schema.models.some((model) => (model.exclusions?.length ?? 0) > 0))
+      throw unsupportedCapability6({ dialect, feature: "exclusionConstraints" });
   assertRlsDialect({ schema: params.from, dialect });
   assertRlsDialect({ schema: params.to, dialect });
   if (dialect !== "postgres")
@@ -1251,6 +1274,8 @@ function diffSchemas(params) {
   const from = normalizeSchema({ schema: params.from, dialect });
   const to = normalizeSchema({ schema: params.to, dialect });
   const buckets = {
+    dropExclusion: [],
+    addExclusion: [],
     dropView: [],
     createEnum: [],
     addEnumValue: [],
@@ -1276,6 +1301,23 @@ function diffSchemas(params) {
   diffViews({ from, to, buckets });
   diffJoinTables({ from, to, buckets });
   diffTables({ from, to, buckets, dialect });
+  for (const model of params.to.models) {
+    const table = model.dbName ?? model.name;
+    const previous = params.from.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    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 VibeError7({ 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, exclusion: before, destructive: false });
+      buckets.addExclusion.push({ kind: "addExclusion", table, exclusion, destructive: false });
+    }
+    for (const exclusion of previous?.exclusions ?? [])
+      if (!model.exclusions?.some((entry) => entry.name === exclusion.name))
+        buckets.dropExclusion.push({ kind: "dropExclusion", table, exclusion, destructive: false });
+  }
   refuseDependentEnumStorageChanges({ from, to, buckets, dialect });
   return withRlsSteps({ from: params.from, to: params.to, steps: [
     ...renamed.steps,
@@ -1283,6 +1325,7 @@ function diffSchemas(params) {
     ...buckets.createEnum,
     ...buckets.addEnumValue,
     ...buckets.dropForeignKey,
+    ...buckets.dropExclusion,
     ...buckets.dropIndex,
     ...buckets.dropJoinTable,
     ...buckets.dropTable,
@@ -1294,6 +1337,7 @@ function diffSchemas(params) {
     ...buckets.addPrimaryKey,
     ...buckets.dropCheck,
     ...buckets.addCheck,
+    ...buckets.addExclusion,
     ...buckets.createIndex,
     ...buckets.addForeignKey,
     ...buckets.createJoinTable,
@@ -1421,6 +1465,7 @@ function createWholeTable(params) {
     table: table.table,
     columns: [...table.columns.values()].map((column) => column.field),
     primaryKey: table.pk,
+    ...table.model.primaryKeyConstraintName === undefined ? {} : { primaryKeyConstraintName: table.model.primaryKeyConstraintName },
     checks: [...table.checks].map(([name, expression]) => ({ name, expression })),
     destructive: false
   });
@@ -1467,6 +1512,9 @@ function diffOneTable(params) {
       changes.push("nullability");
     if (before.defaultKey !== column.defaultKey)
       changes.push("default");
+    const collationChanged = dialect === "mysql" && column.field.collation !== undefined && before.field.collation?.toLowerCase() !== column.field.collation.toLowerCase();
+    if (collationChanged)
+      changes.push("collation");
     if (changes.length === 0)
       continue;
     const storageChange = isEnumStringTransition({ from: before.field, to: column.field });
@@ -1501,7 +1549,7 @@ function diffOneTable(params) {
       from: before.field,
       to: column.field,
       changes,
-      destructive: narrowingType
+      destructive: narrowingType || collationChanged
     });
   }
   for (const [name] of previous.columns) {
@@ -1513,20 +1561,26 @@ function diffOneTable(params) {
   const pkAfter = current.pk.join(",");
   if (pkBefore !== pkAfter) {
     if (previous.pk.length > 0) {
-      buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, destructive: false });
+      buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, destructive: false, ...previous.model.primaryKeyConstraintName === undefined ? {} : { constraintName: previous.model.primaryKeyConstraintName } });
     }
     if (current.pk.length > 0) {
       buckets.addPrimaryKey.push({
         kind: "addPrimaryKey",
         table,
         columns: current.pk,
+        ...current.model.primaryKeyConstraintName === undefined ? {} : { constraintName: current.model.primaryKeyConstraintName },
         destructive: false
       });
     }
   }
   for (const [name, expression] of current.checks) {
-    if (previous.checks.has(name))
+    const before = previous.checks.get(name);
+    if (before === expression)
       continue;
+    if (before !== undefined && previous.model.checks?.some((check) => check.name === name && check.catalogExpression === true))
+      throw new VibeError7({ 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, name, destructive: false });
     buckets.addCheck.push({ kind: "addCheck", table, name, expression, destructive: false });
   }
   for (const [name] of previous.checks) {
@@ -1552,7 +1606,7 @@ function diffOneTable(params) {
   for (const [key, index] of previous.indexes) {
     if (current.indexes.has(key))
       continue;
-    buckets.dropIndex.push({ kind: "dropIndex", name: index.name, table, destructive: false });
+    buckets.dropIndex.push({ kind: "dropIndex", name: index.name, table, destructive: false, ...index.constraintName === undefined ? {} : { constraintName: index.constraintName } });
   }
   for (const [key, fk] of current.fks) {
     const before = previous.fks.get(key);
@@ -1601,9 +1655,13 @@ function diffOneTable(params) {
     });
   }
 }
+// packages/migrate/src/ddl/render.ts
+import { VibeError as VibeError11, sqlObjectKey } from "@vibeorm/schema";
+
 // packages/migrate/src/ddl/postgres.ts
-import { VibeError as VibeError7, isEnumType as isEnumType7 } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect3, renderRlsPolicyPath } from "@vibeorm/sql";
+import { renderExclusionDdl } from "@vibeorm/sql";
+import { VibeError as VibeError8, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect3, renderRlsPolicyPath, renderConstraintOwnedIndexDrop } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
   return params.steps.flatMap((step) => renderStep({ step }));
@@ -1638,7 +1696,7 @@ function refuseSameTransactionEnumUse(params) {
       const found = use(field);
       if (found === undefined)
         continue;
-      throw new VibeError7({
+      throw new VibeError8({
         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" }
@@ -1649,6 +1707,9 @@ function refuseSameTransactionEnumUse(params) {
 function renderStep(params) {
   const { step } = params;
   switch (step.kind) {
+    case "addExclusion":
+    case "dropExclusion":
+      return renderExclusionDdl({ dialect: postgresDialect3, table: step.table, exclusion: step.exclusion, operation: step.kind === "addExclusion" ? "add" : "drop" });
     case "enableRls":
     case "forceRls":
     case "disableRls":
@@ -1671,7 +1732,7 @@ function renderStep(params) {
       const lines = step.columns.map((column) => `  ${columnDefSql({ field: column })}`);
       if (step.primaryKey.length > 0) {
         const pkCols = step.primaryKey.map((column) => q(column)).join(", ");
-        lines.push(`  CONSTRAINT ${q(`${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
+        lines.push(`  CONSTRAINT ${q(step.primaryKeyConstraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
       }
       for (const check of step.checks ?? []) {
         lines.push(`  CONSTRAINT ${q(check.name)} CHECK (${check.expression})`);
@@ -1683,7 +1744,7 @@ ${lines.join(`,
     }
     case "dropTable":
     case "dropJoinTable":
-      return [`DROP TABLE ${q(step.table)} CASCADE;`];
+      return [`DROP TABLE ${q(step.table)};`];
     case "dropView":
       return [`DROP VIEW IF EXISTS ${q(step.table)};`];
     case "addColumn":
@@ -1703,6 +1764,11 @@ ${lines.join(`,
       ];
     }
     case "dropIndex":
+      if (step.constraintName !== undefined) {
+        if (step.table === undefined)
+          throw new VibeError8({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
+        return [renderConstraintOwnedIndexDrop({ dialect: postgresDialect3, table: step.table, constraint: step.constraintName }).text];
+      }
       return [`DROP INDEX ${q(step.name)};`];
     case "addCheck":
       return [
@@ -1753,18 +1819,18 @@ ${lines.join(`,
     case "addPrimaryKey": {
       const cols = step.columns.map((column) => q(column)).join(", ");
       return [
-        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(`${step.table}_pkey`)} PRIMARY KEY (${cols});`
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(step.constraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${cols});`
       ];
     }
     case "dropPrimaryKey":
-      return [`ALTER TABLE ${q(step.table)} DROP CONSTRAINT ${q(`${step.table}_pkey`)};`];
+      return [`ALTER TABLE ${q(step.table)} DROP CONSTRAINT ${q(step.constraintName ?? `${step.table}_pkey`)};`];
   }
 }
 function columnDefSql(params) {
   const { field } = params;
   const name = q(field.dbName ?? field.name);
   if (field.default?.kind === "autoincrement" && !isIdentityColumn({ field })) {
-    throw new VibeError7({
+    throw new VibeError8({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -1800,7 +1866,7 @@ function renderAlterColumn(params) {
   }
   if (step.changes.includes("default") || droppedDefault) {
     if (step.to.default?.kind === "autoincrement") {
-      throw new VibeError7({
+      throw new VibeError8({
         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 }
@@ -1816,7 +1882,7 @@ function q(name) {
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError8, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError9, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { sqliteDialect } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -1885,7 +1951,7 @@ function renderSqliteSteps(params) {
         continue;
       const awaitsNewParent = [...toNorm?.tables.get(table)?.fks.values() ?? []].some((fk) => createdTables.has(fk.refTable));
       if (awaitsNewParent) {
-        throw new VibeError8({
+        throw new VibeError9({
           code: "VIBE_MIGRATION",
           message: `cannot order this sqlite migration safely: rebuilding "${table}" must happen BEFORE the dropped table(s) it references (${[
             ...droppedTables
@@ -1905,11 +1971,16 @@ function renderSqliteSteps(params) {
     return renderTableRebuild({
       table,
       from: fromNorm,
-      to: toNorm
+      to: toNorm,
+      restore: params.restore?.get(table) ?? [],
+      preservedColumns: params.preservedColumns?.get(table) ?? new Map
     });
   };
   for (const step of steps) {
     switch (step.kind) {
+      case "addExclusion":
+      case "dropExclusion":
+        throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "createEnum":
       case "dropEnum":
       case "addEnumValue":
@@ -1994,7 +2065,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 VibeError8({
+          throw new VibeError9({
             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" }
@@ -2046,6 +2117,9 @@ function classifyRebuilds(params) {
   };
   for (const step of steps) {
     switch (step.kind) {
+      case "addExclusion":
+      case "dropExclusion":
+        throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "alterColumn":
       case "dropForeignKey":
       case "addPrimaryKey":
@@ -2095,7 +2169,7 @@ function renderTableRebuild(params) {
   const source = from.tables.get(table);
   const target = to.tables.get(table);
   if (source === undefined || target === undefined) {
-    throw new VibeError8({
+    throw new VibeError9({
       code: "VIBE_MIGRATION",
       message: `cannot rebuild "${table}" \u2014 the table is missing from the ${source === undefined ? "from" : "to"} schema`,
       meta: { table }
@@ -2117,9 +2191,10 @@ function renderTableRebuild(params) {
       onDelete: CASCADE_ACTION_SQL[fk.onDelete],
       onUpdate: CASCADE_ACTION_SQL[fk.onUpdate]
     })),
-    enums: to.enums
+    enums: to.enums,
+    preservedColumns: params.preservedColumns
   }));
-  const common = [...target.columns.keys()].filter((name) => source.columns.has(name));
+  const common = [...new Set([...target.columns.keys(), ...params.preservedColumns.keys()])].filter((name) => params.preservedColumns.get(name)?.generated !== true && (source.columns.has(name) || params.preservedColumns.has(name)));
   if (common.length > 0) {
     const cols = common.map((name) => q2(name)).join(", ");
     statements.push(`INSERT INTO ${q2(tmp)} (${cols}) SELECT ${cols} FROM ${q2(table)};`);
@@ -2136,7 +2211,7 @@ function renderTableRebuild(params) {
       nullsNotDistinct: index.nullsNotDistinct
     }));
   }
-  statements.push("PRAGMA foreign_key_check;", "COMMIT;", "PRAGMA foreign_keys=ON;");
+  statements.push(...params.restore, "PRAGMA foreign_key_check;", "COMMIT;", "PRAGMA foreign_keys=ON;");
   return statements;
 }
 function isCheapAddColumn(params) {
@@ -2182,12 +2257,16 @@ function canCheapDropColumn(params) {
 function createTableSql(params) {
   const { table, constraintTable, columns, primaryKey, fks, enums } = params;
   const autoincrementPk = autoincrementPkColumn({ columns, primaryKey });
-  const lines = columns.map((field) => `  ${columnDefSql2({
+  const lines = columns.map((field) => `  ${params.preservedColumns?.get(field.dbName ?? field.name)?.sql ?? columnDefSql2({
     field,
     constraintTable,
     enums,
     inlinePkAutoincrement: (field.dbName ?? field.name) === autoincrementPk
   })}`);
+  for (const [name, column] of params.preservedColumns ?? []) {
+    if (!columns.some((field) => (field.dbName ?? field.name) === name))
+      lines.push(`  ${column.sql}`);
+  }
   if (primaryKey.length > 0 && autoincrementPk === undefined) {
     lines.push(`  PRIMARY KEY (${primaryKey.map((column) => q2(column)).join(", ")})`);
   }
@@ -2217,7 +2296,7 @@ function columnDefSql2(params) {
   const { field, constraintTable, enums, inlinePkAutoincrement } = params;
   const name = field.dbName ?? field.name;
   if (field.default?.kind === "autoincrement" && !inlinePkAutoincrement) {
-    throw new VibeError8({
+    throw new VibeError9({
       code: "VIBE_MIGRATION",
       message: `autoincrement on sqlite requires "${field.name}" to be the single-column Int or BigInt primary key`,
       meta: { field: field.name }
@@ -2236,7 +2315,7 @@ function columnDefSql2(params) {
     const enumName = field.type.enum;
     const values = resolveEnumValues({ name: enumName, enums });
     if (values === undefined) {
-      throw new VibeError8({
+      throw new VibeError9({
         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 }
@@ -2271,7 +2350,7 @@ function requireSchemas(params) {
   const { step, fromNorm, toNorm } = params;
   if (fromNorm !== undefined && toNorm !== undefined)
     return;
-  throw new VibeError8({
+  throw new VibeError9({
     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 }
@@ -2282,7 +2361,7 @@ function q2(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect2 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps)
@@ -2400,11 +2479,14 @@ ${lines.join(`,
       return [
         `ALTER TABLE ${q3(step.table)} ADD CONSTRAINT ${q3(step.name)} CHECK (${step.expression});`
       ];
+    case "addExclusion":
+    case "dropExclusion":
+      throw new VibeError10({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
     case "dropCheck":
       return [`ALTER TABLE ${q3(step.table)} DROP CHECK ${q3(step.name)};`];
     case "dropIndex": {
       if (step.table === undefined) {
-        throw new VibeError9({
+        throw new VibeError10({
           code: "VIBE_MIGRATION",
           message: `dropIndex "${step.name}" carries no table \u2014 mysql's DROP INDEX requires one`,
           meta: { index: step.name }
@@ -2460,7 +2542,7 @@ function columnDefSql3(params) {
   const name = q3(field.dbName ?? field.name);
   const autoincrement = field.default?.kind === "autoincrement";
   if (autoincrement && field.type !== "Int" && field.type !== "BigInt") {
-    throw new VibeError9({
+    throw new VibeError10({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -2468,7 +2550,7 @@ function columnDefSql3(params) {
   }
   let def = `${name} ${mysqlColumnTypeSql({ field, enums })}`;
   if (field.collation !== undefined)
-    def += ` COLLATE ${field.collation}`;
+    def += ` COLLATE ${q3(field.collation)}`;
   if (!field.isOptional)
     def += " NOT NULL";
   if (autoincrement)
@@ -2482,15 +2564,16 @@ 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 VibeError9({
+    throw new VibeError10({
       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 }
     });
   }
-  if (step.changes.includes("type") || step.changes.includes("nullability")) {
+  if (step.changes.includes("type") || step.changes.includes("nullability") || step.changes.includes("collation")) {
+    const field = step.to.type === "String" && step.to.collation === undefined && step.from.collation !== undefined ? { ...step.to, collation: step.from.collation } : step.to;
     return [
-      `ALTER TABLE ${q3(step.table)} MODIFY COLUMN ${columnDefSql3({ field: step.to, enums })};`
+      `ALTER TABLE ${q3(step.table)} MODIFY COLUMN ${columnDefSql3({ field, enums })};`
     ];
   }
   const defaultExpr = mysqlDefaultSql({ field: step.to });
@@ -2507,17 +2590,64 @@ function inlineIndexSql(params) {
 }
 
 // packages/migrate/src/ddl/render.ts
+function declaredSqlitePreservation(params) {
+  const restore = new Map;
+  const columns = new Map;
+  let to = params.to;
+  if (params.from === undefined || to === undefined || (params.from.migrationObjects?.length ?? 0) === 0)
+    return { to, restore, columns };
+  const invalid = sqliteInvalidatedTables({ steps: params.steps, from: params.from });
+  const retained = new Set((to.migrationObjects ?? []).map((object) => sqlObjectKey({ identity: object.identity })));
+  for (const object of params.from.migrationObjects ?? []) {
+    const identity = object.identity;
+    if (!("table" in identity) || identity.table.namespace !== "main" || !invalid.rebuilt.has(identity.table.name) || !retained.has(sqlObjectKey({ identity })))
+      continue;
+    const facts = object.expected?.facts;
+    if (facts === undefined)
+      throw new VibeError11({ 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 VibeError11({ 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 VibeError11({ 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 VibeError11({ 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)
+          return field;
+        const { default: ignored, ...rest } = field;
+        return { ...rest, ...expression === null ? {} : { default: { kind: "dbgenerated", sql: expression } } };
+      }) }) };
+    }
+  }
+  return { to, restore, columns };
+}
 function renderSteps(params) {
   const { steps, dialect, from, to } = params;
   switch (dialect) {
     case "postgres":
       return renderPostgresSteps({ steps });
-    case "sqlite":
+    case "sqlite": {
+      const preserved = declaredSqlitePreservation({ ...params, ...from === undefined ? {} : { from }, ...to === undefined ? {} : { to } });
       return renderSqliteSteps({
         steps,
+        restore: params.sqliteRestore ?? preserved.restore,
+        preservedColumns: params.sqliteColumns ?? preserved.columns,
         ...from === undefined ? {} : { from },
-        ...to === undefined ? {} : { to }
+        ...preserved.to === undefined ? {} : { to: preserved.to }
       });
+    }
     case "mysql":
       return renderMysqlSteps({
         steps,
@@ -2527,11 +2657,12 @@ function renderSteps(params) {
   }
 }
 // packages/migrate/src/introspect/postgres.ts
+import { renderExclusionCatalog } from "@vibeorm/sql";
 import { parsePgArrayLiteral } from "@vibeorm/sql";
 import { scalarListDefault as scalarListDefault2 } from "@vibeorm/schema";
 import { exactIntegerLiteral } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect5, renderRlsReadinessQuery } from "@vibeorm/sql";
-import { VibeError as VibeError11 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 
 // packages/migrate/src/journal-table.ts
 var MIGRATIONS_TABLE_NAME = "_vibe_migrations";
@@ -2583,6 +2714,7 @@ function addFkRelations(params) {
       type: "manyToOne",
       fields: group.columns,
       references: group.refColumns,
+      constraintName: group.constraintName,
       onDelete: group.onDelete,
       onUpdate: group.onUpdate,
       isList: false,
@@ -2710,7 +2842,7 @@ function lowerFirst(value) {
 }
 
 // packages/migrate/src/introspect/postgres-rls.ts
-import { VibeError as VibeError10, assertValidSchemaIR as assertValidSchemaIR2 } from "@vibeorm/schema";
+import { VibeError as VibeError12, assertValidSchemaIR as assertValidSchemaIR2 } from "@vibeorm/schema";
 import { NATIVE_RLS, postgresDialect as postgresDialect4, renderRlsPolicy as renderRlsPolicy2 } from "@vibeorm/sql";
 var CATALOG_SQL = `SELECT c.relname AS table_name, c.relrowsecurity AS enabled,
   c.relforcerowsecurity AS force, p.polname AS policy_name, p.polcmd AS command,
@@ -2741,7 +2873,7 @@ async function readPostgresRls(params) {
   return [...tables.values()];
 }
 function conflict(params) {
-  throw new VibeError10({
+  throw new VibeError12({
     code: "VIBE_MIGRATION",
     message: `Native RLS on public.${params.table} cannot be managed safely (${params.attributes.join(", ")}). Review the live policies and restore the deployed declaration, or remove conflicting policies explicitly with administrator credentials. Supply rlsSchema/previousSchema for the deployed policy; no policy is deleted or adopted automatically.`,
     meta: params
@@ -2963,8 +3095,13 @@ var INDEXES_QUERY = `
   SELECT
     tablename AS table_name,
     indexname AS index_name,
-    indexdef AS index_def
-  FROM pg_indexes
+    indexdef AS index_def,
+    con.conname AS backing_constraint,
+    con.contype AS backing_constraint_type
+  FROM pg_indexes ix
+  JOIN pg_catalog.pg_namespace ns ON ns.nspname = ix.schemaname
+  JOIN pg_catalog.pg_class idx ON idx.relnamespace = ns.oid AND idx.relname = ix.indexname
+  LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = idx.oid AND con.contype IN ('p', 'u', 'x')
   WHERE schemaname = 'public'
   ORDER BY tablename, indexname;
 `;
@@ -2976,11 +3113,11 @@ async function introspectPostgres(params) {
     const savedPath = params.inTransaction === true ? await executor(renderRlsReadinessQuery({ dialect: postgresDialect5, query: "readSearchPath" })) : undefined;
     const searchPath = savedPath?.[0]?.searchPath;
     if (params.inTransaction === true && typeof searchPath !== "string")
-      throw new VibeError11({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
+      throw new VibeError13({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
     const matched = await verifyPostgresRls({ executor, ...params.rlsSchema === undefined ? {} : { schema: params.rlsSchema }, ...params.requireInstalledRls === undefined ? {} : { requireInstalled: params.requireInstalledRls } }).then((verified) => verified, (error) => {
-      if (error instanceof VibeError11)
+      if (error instanceof VibeError13)
         throw error;
-      throw new VibeError11({ code: "VIBE_MIGRATION", message: "Native RLS verification could not complete. Check migration privileges and supply the deployed schema as previousSchema/rlsSchema before changing referenced columns.", meta: { reason: "rls-verification-unavailable" }, cause: error });
+      throw new VibeError13({ code: "VIBE_MIGRATION", message: "Native RLS verification could not complete. Check migration privileges and supply the deployed schema as previousSchema/rlsSchema before changing referenced columns.", meta: { reason: "rls-verification-unavailable" }, cause: error });
     });
     const physical = await introspectPhysicalPostgres({ executor });
     if (typeof searchPath === "string")
@@ -2993,7 +3130,7 @@ async function introspectPostgres(params) {
 }
 async function introspectPhysicalPostgres(params) {
   const { executor } = params;
-  const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows, checkRows] = await Promise.all([
+  const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows, checkRows, exclusionRows] = await Promise.all([
     executor({ text: TABLES_QUERY }),
     executor({ text: VIEWS_QUERY }),
     executor({ text: COLUMNS_QUERY }),
@@ -3001,7 +3138,8 @@ async function introspectPhysicalPostgres(params) {
     executor({ text: FOREIGN_KEYS_QUERY }),
     executor({ text: ENUMS_QUERY }),
     executor({ text: INDEXES_QUERY }),
-    executor({ text: CHECKS_QUERY })
+    executor({ text: CHECKS_QUERY }),
+    executor({ text: renderExclusionCatalog({ dialect: postgresDialect5 }) })
   ]);
   const tables = tableRows.map((row) => row.table_name);
   const views = viewRows.map((row) => row.table_name);
@@ -3035,6 +3173,7 @@ async function introspectPhysicalPostgres(params) {
   }
   const enumNames = new Set(enums.map((entry) => entry.name));
   const pkByTable = new Map;
+  const pkNames = new Map;
   const uniquesByConstraint = new Map;
   const constraintNames = new Set;
   for (const row of constraintRows) {
@@ -3043,6 +3182,7 @@ async function introspectPhysicalPostgres(params) {
     const columnName = row.column_name;
     constraintNames.add(constraintName);
     if (row.constraint_type === "PRIMARY KEY") {
+      pkNames.set(table, constraintName);
       const list = pkByTable.get(table);
       if (list === undefined)
         pkByTable.set(table, [columnName]);
@@ -3063,16 +3203,17 @@ async function introspectPhysicalPostgres(params) {
     const expression = stripCheckDefinition({ definition: String(row.definition ?? "") });
     const list = checksByTable.get(table);
     if (list === undefined)
-      checksByTable.set(table, [{ name, expression }]);
+      checksByTable.set(table, [{ name, expression, catalogExpression: true }]);
     else
-      list.push({ name, expression });
+      list.push({ name, expression, catalogExpression: true });
   }
   const fkGroupsByName = new Map;
   for (const row of fkRows) {
     const constraintName = row.constraint_name;
-    const existing = fkGroupsByName.get(constraintName);
+    const key = JSON.stringify([row.table_name, constraintName]);
+    const existing = fkGroupsByName.get(key);
     if (existing === undefined) {
-      fkGroupsByName.set(constraintName, {
+      fkGroupsByName.set(key, {
         constraintName,
         table: row.table_name,
         columns: [row.column_name],
@@ -3095,6 +3236,8 @@ async function introspectPhysicalPostgres(params) {
   }));
   const indexes = [];
   for (const row of indexRows) {
+    if (row.backing_constraint_type === "x")
+      continue;
     const parsed = parseIndexDef({
       table: row.table_name,
       name: row.index_name,
@@ -3123,10 +3266,12 @@ async function introspectPhysicalPostgres(params) {
       isView: false,
       columns,
       pkByTable,
+      pkNames,
       uniquesByConstraint,
       constraintNames,
       indexes,
       enumNames,
+      exclusions: exclusionRows.filter((row) => row.table_name === table).map((row) => ({ name: String(row.constraint_name), definition: String(row.definition), requiredExtensions: [], catalogDefinition: true })),
       checks: checksByTable.get(table) ?? []
     }));
   }
@@ -3136,6 +3281,7 @@ async function introspectPhysicalPostgres(params) {
       isView: true,
       columns,
       pkByTable,
+      pkNames,
       uniquesByConstraint,
       constraintNames,
       indexes: [],
@@ -3163,8 +3309,7 @@ function buildModel(params) {
       continue;
     if (unique.columns.length === 1)
       uniqueSingles.add(unique.columns[0]);
-    if (unique.columns.length !== 1 || name !== `${table}_${unique.columns[0]}_key`)
-      multiUniques.push({ name, columns: unique.columns });
+    multiUniques.push({ name, columns: unique.columns });
   }
   const tableIndexes = indexes.filter((index) => index.table === table && !constraintNames.has(index.name));
   for (const index of tableIndexes) {
@@ -3179,6 +3324,7 @@ function buildModel(params) {
   for (const unique of multiUniques) {
     modelIndexes.push({
       name: unique.name,
+      constraintName: unique.name,
       kind: "unique",
       fields: unique.columns.map((name) => ({ name }))
     });
@@ -3203,9 +3349,11 @@ function buildModel(params) {
     fields,
     relations: [],
     indexes: modelIndexes,
+    ...params.exclusions?.length ? { exclusions: params.exclusions } : {},
     ...params.checks.length === 0 ? {} : { checks: params.checks },
     isView,
-    ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
+    ...pk.length > 1 ? { primaryKey: { fields: pk } } : {},
+    ...params.pkNames.get(table) === undefined ? {} : { primaryKeyConstraintName: params.pkNames.get(table) }
   };
 }
 function stripCheckDefinition(params) {
@@ -3426,7 +3574,7 @@ function toNumberOrNull(value) {
 }
 // packages/migrate/src/introspect/sqlite.ts
 import { exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
-import { sqliteDialect as sqliteDialect2 } from "@vibeorm/sql";
+import { sqliteDialect as sqliteDialect2, sqliteTableConstraints } from "@vibeorm/sql";
 var SQLITE_ACTION_TO_CASCADE = {
   "NO ACTION": "NoAction",
   RESTRICT: "Restrict",
@@ -3490,7 +3638,7 @@ async function introspectSqlite(params) {
     indexes.push(...tableIndexes);
     uniqueSinglesByTable.set(table.name, uniqueSingles);
     modelIndexesByTable.set(table.name, modelIndexes);
-    fkGroups.push(...await readForeignKeys({ executor, table: table.name, columns }));
+    fkGroups.push(...await readForeignKeys({ executor, table: table.name, columns, tableSql: table.sql ?? "" }));
   }
   const joinTables = new Map;
   for (const table of tables) {
@@ -3689,7 +3837,7 @@ async function readForeignKeys(params) {
     }
   }
   return [...groups.values()].map((group) => ({
-    constraintName: `${table}_${group.columns.join("_")}_fkey`,
+    constraintName: sqliteTableConstraints({ sql: params.tableSql }).find((clause) => clause.named && clause.type === "foreignKey" && JSON.stringify(clause.columns) === JSON.stringify(group.columns))?.name ?? `${table}_${group.columns.join("_")}_fkey`,
     table,
     columns: group.columns,
     refTable: group.refTable,
@@ -3729,7 +3877,7 @@ function buildModel2(params) {
     fields,
     relations: [],
     indexes: [...modelIndexes],
-    ...params.checks.length === 0 ? {} : { checks: params.checks },
+    ...params.checks.length === 0 ? {} : { checks: params.checks.map((check) => ({ ...check, catalogExpression: true })) },
     isView,
     ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
   };
@@ -3800,6 +3948,7 @@ var COLUMNS_QUERY2 = `
     column_type,
     is_nullable,
     column_default,
+    collation_name,
     extra,
     ordinal_position
   FROM information_schema.columns
@@ -3878,9 +4027,9 @@ async function introspectMysql(params) {
     const expression = stripBalancedOuterParens(String(catalogField({ row, name: "definition" }) ?? ""));
     const list = checksByTable.get(table);
     if (list === undefined)
-      checksByTable.set(table, [{ name, expression }]);
+      checksByTable.set(table, [{ name, expression, catalogExpression: true }]);
     else
-      list.push({ name, expression });
+      list.push({ name, expression, catalogExpression: true });
   }
   const tables = tableRows.map((row) => catalogField({ row, name: "table_name" }));
   const views = viewRows.map((row) => catalogField({ row, name: "table_name" }));
@@ -3890,6 +4039,7 @@ async function introspectMysql(params) {
     columnType: catalogField({ row, name: "column_type" }),
     nullable: catalogField({ row, name: "is_nullable" }) === "YES",
     columnDefault: catalogField({ row, name: "column_default" }) ?? null,
+    collation: catalogField({ row, name: "collation_name" }) ?? null,
     extra: (catalogField({ row, name: "extra" }) ?? "").toLowerCase()
   }));
   const rulesByConstraint = new Map;
@@ -4046,7 +4196,8 @@ function buildModel3(params) {
       isUpdatedAt: false,
       ...defaultValue === undefined ? {} : { default: defaultValue },
       ...mapped.nativeType === undefined ? {} : { nativeType: mapped.nativeType },
-      ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
+      ...mapped.isUnsupported === true ? { isUnsupported: true } : {},
+      ...mapped.type === "String" && column.collation !== null ? { collation: column.collation } : {}
     };
   });
   const modelIndexes = [];
@@ -4188,17 +4339,17 @@ function isNumericScalar2(params) {
 }
 // packages/migrate/src/runner.ts
 import { createHash } from "crypto";
-import { VibeError as VibeError15 } from "@vibeorm/schema";
+import { VibeError as VibeError21 } from "@vibeorm/schema";
 import {
-  DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2,
-  getSqlDialect as getSqlDialect2,
+  DIALECT_CAPABILITIES as DIALECT_CAPABILITIES3,
+  getSqlDialect as getSqlDialect3,
   renderMigrationSessionRead,
   renderMigrationSessionRestore,
   renderMigrationSessionSet
 } from "@vibeorm/sql";
 
 // packages/migrate/src/execution.ts
-import { VibeError as VibeError12 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
 var EXECUTION_SIDECAR_FILENAME = "execution.json";
 var EXECUTION_SIDECAR_VERSION = 1;
 function isDefaultExecution(params) {
@@ -4237,7 +4388,7 @@ ${lines.join(`
 `)}`;
 }
 function invalid(params) {
-  return new VibeError12({
+  return new VibeError14({
     code: "VIBE_MIGRATION",
     message: `invalid execution metadata for migration "${params.migration}": ${params.detail}`,
     meta: { reason: "execution-metadata-invalid", migration: params.migration }
@@ -4288,7 +4439,7 @@ function parseExecutionSidecar(params) {
   try {
     parsed = JSON.parse(params.text);
   } catch (error) {
-    throw new VibeError12({
+    throw new VibeError14({
       code: "VIBE_MIGRATION",
       message: `invalid execution metadata for migration "${migration}": not valid JSON`,
       meta: { reason: "execution-metadata-invalid", migration },
@@ -4315,6 +4466,13 @@ function describeMigrationRisks(params) {
   const risks = [];
   for (const step of steps) {
     switch (step.kind) {
+      case "dropExclusion":
+      case "dropCheck":
+      case "dropForeignKey":
+      case "dropPrimaryKey":
+      case "dropIndex":
+        risks.push({ kind: "integrityLoss", detail: `${step.kind} removes a constraint or index; integrity and dependent objects must be checked separately from row loss`, ..."table" in step && step.table !== undefined ? { table: step.table } : {} });
+        break;
       case "alterColumn":
         if (step.changes.includes("type")) {
           risks.push({ kind: "tableRewrite", table: step.table, detail: `changing the type of "${step.table}"."${step.column}" rewrites every row of the table while holding ACCESS EXCLUSIVE` });
@@ -4350,8 +4508,11 @@ function describeMigrationRisks(params) {
         risks.push({ kind: "exclusiveLock", table: step.table, detail: `renaming "${step.table}"."${step.from}" to "${step.to}" takes ACCESS EXCLUSIVE and breaks every client still using the old name` });
         break;
       case "dropTable":
-      case "dropColumn":
       case "dropJoinTable":
+        risks.push({ kind: "integrityLoss", table: step.table, detail: `${step.kind} also removes the table's constraints and indexes; their integrity loss requires separate acknowledgement` });
+        risks.push({ kind: "exclusiveLock", detail: `${step.kind} takes ACCESS EXCLUSIVE and is not recoverable by re-running the migration` });
+        break;
+      case "dropColumn":
         risks.push({ kind: "exclusiveLock", detail: `${step.kind} takes ACCESS EXCLUSIVE and is not recoverable by re-running the migration` });
         break;
       default:
@@ -4368,7 +4529,7 @@ function describeMigrationRisks(params) {
 }
 
 // packages/migrate/src/recovery.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
 import {
   getSqlDialect,
   renderColumnStateQuery,
@@ -4377,7 +4538,7 @@ import {
   renderRelationStateQuery
 } from "@vibeorm/sql";
 function conflict2(params) {
-  return new VibeError13({
+  return new VibeError15({
     code: "VIBE_MIGRATION",
     message: params.message,
     meta: { reason: params.reason, ...params.meta }
@@ -4605,7 +4766,7 @@ function artifactCreateSql(params) {
 }
 
 // packages/migrate/src/execute.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { VibeError as VibeError16 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
@@ -4646,7 +4807,7 @@ function assertSelfManagedResumeSafe(params) {
   const completedIndex = params.direction === "up" ? params.start + 1 : -(params.start + 2);
   const rewind = selfManagedResumeStart({ sql: params.sql, start: params.start });
   const retryIndex = params.direction === "up" ? rewind : -(rewind + 1);
-  throw new VibeError14({
+  throw new VibeError16({
     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" }
@@ -4675,7 +4836,7 @@ function unsupportedScript(params) {
   const { migration, direction, index, problem, found } = params;
   const subject = direction === "down" ? `the down script of migration "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${params.statements}`;
-  return new VibeError14({
+  return new VibeError16({
     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 }
@@ -4731,7 +4892,7 @@ async function executeStatement(params) {
     const rows = await executor({ text: statement, values: [] });
     if (rows.length > 0) {
       const sample = rows.slice(0, 5).map((row) => `${String(row.table)} rowid ${String(row.rowid)} \u2192 ${String(row.parent)}`).join("; ");
-      throw new VibeError14({
+      throw new VibeError16({
         code: "VIBE_MIGRATION",
         message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
         meta: { violations: rows }
@@ -4749,6 +4910,767 @@ async function cleanupSelfManagedFailure(params) {
     await params.executor({ text: "PRAGMA foreign_keys=ON;" });
   } catch {}
 }
+// packages/migrate/src/desired-state.ts
+import { VibeError as VibeError17, assertValidSchemaIR as assertValidSchemaIR3, 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) {
+  assertValidSchemaIR3({ schema: params.schema });
+  const provider = providerToDialect({ provider: params.schema.datasource.provider }) === params.dialect ? params.schema.datasource.provider : params.dialect === "postgres" ? "postgresql" : params.dialect;
+  const schema = { ...params.schema, datasource: { provider } };
+  const definitions = params.definitions ?? (schema.migrationObjects ?? []).flatMap((object) => object.expected === undefined ? [] : [object.expected]);
+  const seen = new Set;
+  for (const definition of definitions) {
+    if (!isSqlObjectDefinition(definition))
+      throw invalid2({ migration: "declaration", detail: "malformed expected definition" });
+    const key = sqlObjectKey2({ identity: definition.identity });
+    if (seen.has(key))
+      throw invalid2({ migration: "declaration", detail: `duplicate definition ${key}` });
+    seen.add(key);
+  }
+  return { schema, definitions };
+}
+function invalid2(params) {
+  return new VibeError17({ code: "VIBE_MIGRATION", message: `Invalid desired state for migration "${params.migration}": ${params.detail}`, meta: { reason: "desired-state-invalid", migration: params.migration }, ...params.cause === undefined ? {} : { cause: params.cause } });
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function keysOnly(value, allowed) {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+function modelShape(value) {
+  if (!record(value) || typeof value.name !== "string" || !Array.isArray(value.fields) || !Array.isArray(value.relations) || !Array.isArray(value.indexes))
+    return false;
+  return value.fields.every((field) => record(field) && typeof field.name === "string" && (typeof field.type === "string" || record(field.type) && typeof field.type.enum === "string") && ["isId", "isUnique", "isOptional", "isList"].every((key) => typeof field[key] === "boolean")) && value.relations.every(record) && value.indexes.every((index) => record(index) && Array.isArray(index.fields) && index.fields.every(record)) && (value.checks === undefined || Array.isArray(value.checks) && value.checks.every((check) => record(check) && typeof check.name === "string" && typeof check.expression === "string"));
+}
+function state(value) {
+  if (!record(value) || !keysOnly(value, ["schema", "definitions", "normalization"]) || !record(value.schema) || !Array.isArray(value.definitions) || !value.definitions.every(isSqlObjectDefinition))
+    return false;
+  const schema = value.schema;
+  return record(schema.datasource) && ["postgresql", "pglite", "sqlite", "mysql"].includes(String(schema.datasource.provider)) && keysOnly(schema, ["datasource", "models", "enums", "extensions", "rls", "migrationObjects"]) && keysOnly(schema.datasource, ["provider"]) && Array.isArray(schema.models) && schema.models.every(modelShape) && Array.isArray(schema.enums) && schema.enums.every((entry) => record(entry) && typeof entry.name === "string" && Array.isArray(entry.values) && entry.values.every((label) => typeof label === "string")) && Array.isArray(schema.extensions) && schema.extensions.every(record) && (value.normalization === undefined || record(value.normalization) && value.normalization.format === "catalog-v1" && ["postgres", "sqlite", "mysql"].includes(String(value.normalization.dialect)) && typeof value.normalization.serverVersion === "string");
+}
+function assertDesiredState(params) {
+  const value = params.value;
+  if (!record(value) || !keysOnly(value, ["version", "dialect", "from", "to", "down", "unmanagedRemovals"]) || value.version !== 1 || !["postgres", "sqlite", "mysql"].includes(String(value.dialect)) || !state(value.from) || !state(value.to) || value.down !== undefined && !state(value.down)) {
+    throw invalid2({ migration: params.migration, detail: "unsupported version or malformed state" });
+  }
+  if (value.unmanagedRemovals !== undefined && (!Array.isArray(value.unmanagedRemovals) || !value.unmanagedRemovals.every(isSqlObjectIdentity)))
+    throw invalid2({ migration: params.migration, detail: "malformed unmanaged-removal identities" });
+  for (const entry of [value.from, value.to, ...value.down === undefined ? [] : [value.down]]) {
+    assertValidSchemaIR3({ schema: entry.schema });
+    if (providerToDialect({ provider: entry.schema.datasource.provider }) !== value.dialect)
+      throw invalid2({ migration: params.migration, detail: "schema provider differs from sidecar dialect" });
+    if (entry.normalization !== undefined && entry.normalization.dialect !== value.dialect)
+      throw invalid2({ migration: params.migration, detail: "normalization dialect differs from sidecar dialect" });
+    const keys = entry.definitions.map((definition) => sqlObjectKey2({ identity: definition.identity }));
+    if (new Set(keys).size !== keys.length)
+      throw invalid2({ migration: params.migration, detail: "duplicate definition" });
+  }
+}
+function canonicalMigrationJson(params) {
+  const value = params.value;
+  if (Array.isArray(value))
+    return `[${value.map((entry) => canonicalMigrationJson({ value: entry })).join(",")}]`;
+  if (record(value))
+    return `{${Object.keys(value).filter((key) => value[key] !== undefined).sort().map((key) => `${JSON.stringify(key)}:${canonicalMigrationJson({ value: value[key] })}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+}
+function desiredStateChecksumSuffix(params) {
+  if (params.desiredState === undefined)
+    return "";
+  assertDesiredState({ value: params.desiredState, migration: "checksum" });
+  return `
+-- vibeorm:desired-state ${canonicalMigrationJson({ value: params.desiredState })}`;
+}
+function serializeDesiredStateSidecar(params) {
+  assertDesiredState({ value: params.desiredState, migration: "serialize" });
+  return JSON.stringify(params.desiredState, null, 2) + `
+`;
+}
+function parseDesiredStateSidecar(params) {
+  try {
+    const value = JSON.parse(params.text);
+    const checked = { value, migration: params.migration };
+    assertDesiredState(checked);
+    return checked.value;
+  } catch (cause) {
+    throw invalid2({ migration: params.migration, detail: "malformed metadata", cause });
+  }
+}
+
+// packages/migrate/src/exclusions.ts
+import { randomUUID } from "crypto";
+import { VibeError as VibeError18, sqlObjectKey as sqlObjectKey3 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect6, renderExclusionCatalog as renderExclusionCatalog2, renderExclusionProbe } from "@vibeorm/sql";
+async function deparseExclusion(params) {
+  const probe = `vibe_exclusion_${randomUUID().replaceAll("-", "")}`;
+  await params.executor({ text: "SAVEPOINT vibe_exclusion_probe" });
+  try {
+    for (const text of renderExclusionProbe({ dialect: postgresDialect6, table: params.table, probe, definition: params.definition }))
+      await params.executor({ text });
+    const rows = await params.executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6, probe }) });
+    if (typeof rows[0]?.definition !== "string")
+      throw new VibeError18({ code: "VIBE_MIGRATION", message: "Exclusion probe unavailable", meta: { reason: "exclusion-inspection-unavailable" } });
+    return rows[0].definition;
+  } finally {
+    await params.executor({ text: "ROLLBACK TO SAVEPOINT vibe_exclusion_probe" });
+    await params.executor({ text: "RELEASE SAVEPOINT vibe_exclusion_probe" });
+  }
+}
+async function prepareExclusionDiff(params) {
+  const models = [];
+  for (const model of params.from.models) {
+    const table = model.dbName ?? model.name;
+    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    const exclusions = [];
+    for (const before of model.exclusions ?? []) {
+      const next = target?.exclusions?.find((entry) => entry.name === before.name);
+      if (next === undefined || next.definition === before.definition) {
+        exclusions.push(before);
+        continue;
+      }
+      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: "public", name: table }, name: before.name };
+      if (params.probe === "rollback") {
+        const normalized = await deparseExclusion({ executor: params.executor, table, definition: next.definition });
+        exclusions.push(normalized === before.definition ? next : { name: before.name, definition: before.definition, requiredExtensions: before.requiredExtensions });
+        continue;
+      }
+      const previous = params.previous?.schema.models.find((entry) => (entry.dbName ?? entry.name) === table)?.exclusions?.find((entry) => entry.name === before.name);
+      if (previous !== undefined) {
+        exclusions.push(previous);
+        continue;
+      }
+      if (params.replaceChecks?.some((entry) => sqlObjectKey3({ identity: entry }) === sqlObjectKey3({ identity }))) {
+        exclusions.push({ name: before.name, definition: before.definition, requiredExtensions: before.requiredExtensions });
+        continue;
+      }
+      throw new VibeError18({ code: "VIBE_MIGRATION", message: "Exclusion equivalence requires a rollback probe or explicit replacement", meta: { reason: "explicit-replacement-required", identity } });
+    }
+    models.push({ ...model, exclusions });
+  }
+  return { ...params.from, models };
+}
+async function verifyExclusions(params) {
+  if (!params.expected.schema.models.some((model) => (model.exclusions?.length ?? 0) > 0))
+    return [];
+  const rows = await params.executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6 }) });
+  const objects = [];
+  for (const model of params.expected.schema.models)
+    for (const exclusion of model.exclusions ?? []) {
+      const table = model.dbName ?? model.name;
+      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: "public", name: table }, name: exclusion.name };
+      const row = rows.find((entry) => entry.table_name === table && entry.constraint_name === exclusion.name);
+      if (row === undefined) {
+        objects.push({ identity, ownership: "schema", state: "missing", differences: [] });
+        continue;
+      }
+      const differences = ["validated", "valid", "ready"].flatMap((attribute) => row[attribute] === true ? [] : [{ attribute, expected: true, actual: row[attribute] }]);
+      const independentlyVerified = params.expected.definitions.some((entry) => sqlObjectKey3({ identity: entry.identity }) === sqlObjectKey3({ identity }));
+      const definition = independentlyVerified ? row.definition : params.probe === "rollback" ? await deparseExclusion({ executor: params.executor, table, definition: exclusion.definition }) : (exclusion.normalizationSource === exclusion.definition ? exclusion.normalizedDefinition : undefined) ?? exclusion.definition;
+      if (definition !== row.definition)
+        differences.push({ attribute: "definition", expected: definition, actual: row.definition });
+      objects.push({ identity, ownership: "schema", state: differences.length === 0 ? "matching" : params.probe === "rollback" ? "changed" : "unavailable", differences });
+    }
+  return objects;
+}
+
+// packages/migrate/src/inspect-objects.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { VibeError as VibeError20, sqlObjectKey as sqlObjectKey5, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect2, renderMigrationObjectQuery, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2 } from "@vibeorm/sql";
+
+// packages/migrate/src/object-ownership.ts
+import { VibeError as VibeError19, sqlObjectKey as sqlObjectKey4 } from "@vibeorm/schema";
+function legacyMigrationObjects(params) {
+  return params.artifacts.map((artifact) => {
+    const owner = artifact.owns;
+    const table = "table" in owner ? { namespace: params.namespace, name: owner.table } : undefined;
+    let identity;
+    switch (owner.kind) {
+      case "postgresExtension":
+      case "table":
+        identity = { kind: owner.kind, name: { namespace: params.namespace, name: owner.name } };
+        break;
+      case "column":
+        identity = { kind: "column", table, column: owner.column };
+        break;
+      case "index":
+      case "trigger":
+        identity = { kind: owner.kind, table, name: owner.name };
+        break;
+    }
+    return { id: artifact.id, dialect: params.dialect, identity, create: artifact.create, drop: artifact.drop, dependsOn: artifact.expected?.dependencies ?? [], ...artifact.expected === undefined ? {} : { expected: artifact.expected } };
+  });
+}
+function preserveMigrationObjects(params) {
+  const namespace = params.namespace ?? (params.to.datasource.provider === "sqlite" ? "main" : "public");
+  const objects = params.objects.filter((object) => ("table" in object.identity ? object.identity.table.namespace : object.identity.name.namespace) === namespace);
+  const models = params.from.models.flatMap((model) => {
+    const table = model.dbName ?? model.name;
+    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    if (objects.some((object) => (object.identity.kind === "table" || object.identity.kind === "view") && object.identity.name.name === table))
+      return [];
+    const owners = objects.map((object) => object.identity).filter((identity) => ("table" in identity) && identity.table.name === table);
+    return [{
+      ...model,
+      fields: model.fields.flatMap((field) => {
+        const column = field.dbName ?? field.name;
+        if (owners.some((owner) => owner.kind === "column" && owner.column === column))
+          return [];
+        if (owners.some((owner) => (owner.kind === "columnDefault" || owner.kind === "generatedColumn") && owner.column === column)) {
+          const authored = target?.fields.find((entry) => (entry.dbName ?? entry.name) === column);
+          if (authored === undefined)
+            return [field];
+          const { default: ignored, ...rest } = field;
+          return [{ ...rest, ...authored.default === undefined ? {} : { default: authored.default } }];
+        }
+        return [field];
+      }),
+      exclusions: (model.exclusions ?? []).filter((exclusion) => !owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "exclusion" && owner.name === exclusion.name)),
+      checks: (model.checks ?? []).filter((check) => !owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "check" && owner.name === check.name)),
+      indexes: model.indexes.filter((index) => !owners.some((owner) => owner.kind === "index" && owner.name === index.name)),
+      relations: model.relations.filter((relation) => !owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "foreignKey" && owner.name === relation.constraintName))
+    }];
+  });
+  return { ...params.from, models };
+}
+function sqlitePreservedSchema(params) {
+  return { ...params.to, models: params.to.models.map((model) => {
+    const table = model.dbName ?? model.name;
+    const before = params.from.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    if (before === undefined)
+      return model;
+    const owners = params.objects.map((object) => object.identity).filter((owner) => ("table" in owner) && owner.table.namespace === "main" && owner.table.name === table);
+    return {
+      ...model,
+      checks: [...model.checks ?? [], ...(before.checks ?? []).filter((check) => !model.checks?.some((entry) => entry.name === check.name) && owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "check" && owner.name === check.name))],
+      indexes: [...model.indexes, ...before.indexes.filter((index) => !model.indexes.some((entry) => entry.name === index.name) && owners.some((owner) => owner.kind === "index" && owner.name === index.name))],
+      relations: [...model.relations, ...before.relations.filter((relation) => !model.relations.some((entry) => entry.constraintName === relation.constraintName) && owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "foreignKey" && owner.name === relation.constraintName))]
+    };
+  }) };
+}
+function removalIdentity(params) {
+  const { step, namespace } = params;
+  const table = "table" in step && step.table !== undefined ? { namespace, name: step.table } : undefined;
+  switch (step.kind) {
+    case "dropTable":
+    case "dropJoinTable":
+      return { kind: "table", name: table };
+    case "dropView":
+      return { kind: "view", name: table };
+    case "dropColumn":
+      return { kind: "column", table, column: step.column };
+    case "alterColumn":
+      return step.changes.includes("default") && step.from.default !== undefined ? { kind: "columnDefault", table, column: step.column } : undefined;
+    case "dropIndex":
+      return table === undefined ? undefined : step.constraintName === undefined ? { kind: "index", table, name: step.name } : { kind: "constraint", constraintType: "unique", table, name: step.constraintName };
+    case "dropExclusion":
+      return { kind: "constraint", constraintType: "exclusion", table, name: step.exclusion.name };
+    case "dropCheck":
+      return { kind: "constraint", constraintType: "check", table, name: step.name };
+    case "dropForeignKey":
+      return { kind: "constraint", constraintType: "foreignKey", table, name: step.constraintName };
+    case "dropPrimaryKey":
+      return { kind: "constraint", constraintType: "primaryKey", table, name: step.constraintName ?? `${step.table}_pkey` };
+    default:
+      return;
+  }
+}
+function schemaObjectIdentities(params) {
+  const normalized = normalizeSchema({ schema: params.schema, dialect: params.dialect });
+  const result = [];
+  for (const [name, model] of normalized.tables) {
+    const table = { namespace: params.namespace, name };
+    result.push({ kind: "table", name: table });
+    for (const [column, definition] of model.columns) {
+      result.push({ kind: "column", table, column });
+      if (definition.defaultKey !== null)
+        result.push({ kind: "columnDefault", table, column });
+      if (params.dialect === "postgres" && definition.field.default?.kind === "autoincrement")
+        result.push({ kind: "sequence", name: { namespace: params.namespace, name: `${name}_${column}_seq` } });
+    }
+    for (const exclusion of model.model.exclusions ?? [])
+      result.push({ kind: "constraint", constraintType: "exclusion", table, name: exclusion.name });
+    for (const check of model.checks.keys())
+      result.push({ kind: "constraint", constraintType: "check", table, name: check });
+    for (const index of model.indexes.values()) {
+      result.push({ kind: "index", table, name: index.name });
+      if (index.constraintName !== undefined)
+        result.push({ kind: "constraint", constraintType: "unique", table, name: index.constraintName });
+    }
+    for (const fk of model.fks.values())
+      result.push({ kind: "constraint", constraintType: "foreignKey", table, name: fk.constraintName });
+    if (model.pk.length > 0)
+      result.push({ kind: "constraint", constraintType: "primaryKey", table, name: model.model.primaryKeyConstraintName ?? (params.dialect === "mysql" ? "PRIMARY" : `${name}_pkey`) });
+  }
+  for (const name of normalized.joinTables.keys()) {
+    const table = { namespace: params.namespace, name };
+    result.push({ kind: "table", name: table });
+    for (const column of ["A", "B"])
+      result.push({ kind: "column", table, column }, { kind: "constraint", constraintType: "foreignKey", table, name: `${name}_${column}_fkey` });
+    for (const suffix of ["AB_unique", "B_index"])
+      result.push({ kind: "index", table, name: `${name}_${suffix}` });
+  }
+  for (const name of normalized.views.keys())
+    result.push({ kind: "view", name: { namespace: params.namespace, name } });
+  return result;
+}
+function assertRetainedMigrationObjects(params) {
+  const keys = new Set(params.to.map((object) => sqlObjectKey4({ identity: object.identity })));
+  const removed = params.from.filter((object) => !keys.has(sqlObjectKey4({ identity: object.identity })));
+  if (removed.length > 0)
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Removing migration ownership requires a reviewed hand-authored migration and new desired state", meta: { reason: "migration-object-removal-review-required", objects: removed.map((object) => object.identity) } });
+}
+function orderedMigrationObjects(params) {
+  const byKey = new Map(params.objects.map((object) => [sqlObjectKey4({ identity: object.identity }), object]));
+  const result = [];
+  const visiting = new Set;
+  const visited = new Set;
+  const visit = (object) => {
+    const key = sqlObjectKey4({ identity: object.identity });
+    if (visited.has(key))
+      return;
+    if (visiting.has(key))
+      throw new VibeError19({ 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(sqlObjectKey4({ identity: dependency }));
+      if (target !== undefined)
+        visit(target);
+    }
+    visiting.delete(key);
+    visited.add(key);
+    result.push(object);
+  };
+  for (const object of params.objects)
+    visit(object);
+  return result;
+}
+function assertNamedRemovals(params) {
+  const approved = new Set((params.approved ?? []).map((identity) => sqlObjectKey4({ identity })));
+  const missing = params.removals.filter((identity) => !approved.has(sqlObjectKey4({ identity })));
+  if (missing.length > 0)
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Unmanaged removals require individually named approvals", meta: { reason: "unmanaged-removal-required", objects: missing } });
+  const integrity = params.removals.filter((identity) => identity.kind === "constraint" || identity.kind === "index");
+  if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Named constraint or index removals also require acceptIntegrityLoss", meta: { reason: "integrity-acknowledgement-required", objects: integrity } });
+}
+function assertRemovalAuthorization(params) {
+  const declared = params.previous === undefined ? [] : schemaObjectIdentities({ schema: params.previous.schema, dialect: params.dialect, namespace: params.namespace });
+  const known = new Set(declared.map((identity) => sqlObjectKey4({ identity })));
+  const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey4({ identity })));
+  const unknown = [];
+  const integrity = [];
+  for (const step of params.steps) {
+    const identity = removalIdentity({ step, namespace: params.namespace });
+    if (identity === undefined)
+      continue;
+    const key = sqlObjectKey4({ identity });
+    if (!known.has(key) && !approved.has(key))
+      unknown.push(identity);
+    if (identity.kind === "constraint" || identity.kind === "index")
+      integrity.push(identity);
+    if (step.kind === "dropTable" || step.kind === "dropJoinTable") {
+      for (const child of [...declared, ...params.removeUnmanaged ?? []]) {
+        if ((child.kind === "constraint" || child.kind === "index") && child.table.namespace === params.namespace && child.table.name === step.table)
+          integrity.push(child);
+      }
+    }
+  }
+  if (unknown.length > 0)
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Unknown object removals require individually named removeUnmanaged decisions", meta: { reason: "unmanaged-removal-required", objects: unknown } });
+  if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Constraint or index removal requires acceptIntegrityLoss; data-loss acknowledgement does not authorize it", meta: { reason: "integrity-acknowledgement-required", objects: integrity } });
+}
+
+// packages/migrate/src/inspect-objects.ts
+function factsOf(params) {
+  const facts = {};
+  for (const [name, value] of Object.entries(params.row)) {
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      facts[name] = value;
+    else if (Array.isArray(value) && value.every((entry) => typeof entry === "string"))
+      facts[name] = value;
+    else
+      return;
+  }
+  return facts;
+}
+async function inspectSqlObject(params) {
+  return Promise.resolve().then(async () => {
+    const namespace = "table" in params.identity ? params.identity.table.namespace : params.identity.name.namespace;
+    if (params.dialect === "mysql")
+      await assertCatalogVisibility({ executor: params.executor, dialect: params.dialect, namespace });
+    const query = renderMigrationObjectQuery({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
+    const rows = await params.executor({ text: query.text, values: [...query.values] });
+    if (rows.length === 0)
+      return { state: "missing" };
+    if (rows.length !== 1)
+      return { state: "unavailable", reason: "ambiguous-catalog-identity" };
+    let facts = factsOf({ row: rows[0] });
+    if (facts === undefined)
+      return { state: "unavailable", reason: "unsupported-catalog-value" };
+    if (params.dialect === "mysql" && (params.identity.kind === "function" || params.identity.kind === "view") && facts.definition === null)
+      return { state: "unavailable", reason: "definition-not-visible" };
+    if (params.dialect === "sqlite" && params.identity.kind === "constraint") {
+      const name = params.identity.name;
+      if (params.identity.constraintType === "check") {
+        const check = parseSqliteNamedChecks({ tableSql: String(facts.definition ?? "") }).find((entry) => entry.name === name);
+        if (check === undefined)
+          return { state: "missing" };
+        facts = { type: "check", definition: check.expression };
+      } else {
+        const constraintType = params.identity.constraintType;
+        const constraint = sqliteTableConstraints2({ sql: String(facts.definition ?? "") }).find((entry) => entry.name === name && entry.type === constraintType);
+        if (constraint === undefined)
+          return { state: "unavailable", reason: "constraint-definition-inspection-unavailable" };
+        facts = { type: constraint.type, definition: constraint.sql };
+      }
+    }
+    if (params.dialect === "sqlite" && (params.identity.kind === "column" || params.identity.kind === "columnDefault" || params.identity.kind === "generatedColumn")) {
+      const column = params.identity.column;
+      const clause = sqliteColumnClauses({ sql: String(facts.tableDefinition ?? "") }).find((entry) => entry.name === column);
+      if (clause === undefined)
+        return { state: "unavailable", reason: "column-definition-inspection-unavailable" };
+      const { tableDefinition: ignored, ...attributes } = facts;
+      facts = { ...attributes, columnDefinition: clause.sql };
+    }
+    if (params.identity.kind === "columnDefault")
+      facts = { definition: facts.definition ?? null };
+    if (params.dialect === "postgres") {
+      const query2 = renderMigrationDependencies({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
+      const rows2 = await params.executor({ text: query2.text, values: [...query2.values] });
+      if (rows2.some((row) => typeof row.address !== "string"))
+        return { state: "unavailable", reason: "dependency-inspection-unavailable" };
+      facts = { ...facts, dependencyAddresses: rows2.map((row) => String(row.address)).sort() };
+    }
+    if (params.dialect === "mysql") {
+      const query2 = renderMysqlObjectMembers({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
+      if (query2 !== undefined) {
+        const rows2 = await params.executor({ text: query2.text, values: [...query2.values] });
+        if (params.identity.kind === "function" && rows2.length === 0)
+          return { state: "unavailable", reason: "function-signature-unavailable" };
+        if (params.identity.kind === "function") {
+          const signature = rows2.filter((row) => row.mode !== null).map((row) => ({ namespace: "mysql", name: String(row.type) }));
+          if (canonicalMigrationJson({ value: signature }) !== canonicalMigrationJson({ value: params.identity.argumentTypes }))
+            return { state: "missing" };
+        }
+        facts = { ...facts, members: rows2.map((row) => canonicalMigrationJson({ value: row })) };
+      }
+    }
+    const dependencies = [];
+    if (params.identity.kind === "trigger" && params.dialect === "postgres") {
+      if (facts.functionArguments !== "")
+        return { state: "unavailable", reason: "trigger-function-signature-unavailable" };
+      dependencies.push({ kind: "function", name: { namespace: String(facts.functionNamespace), name: String(facts.functionName) }, argumentTypes: [] });
+    }
+    return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v1" } };
+  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError20 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+}
+async function assertCatalogVisibility(params) {
+  if (params.dialect !== "mysql")
+    return;
+  const query = renderMigrationVisibility({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace });
+  const rows = await params.executor({ text: query.text, values: [...query.values] });
+  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 VibeError20({ 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 } });
+}
+function compare(params) {
+  const differences = [];
+  for (const key of new Set([...Object.keys(params.expected.facts), ...Object.keys(params.live.facts)])) {
+    const expected2 = params.expected.facts[key];
+    const actual2 = params.live.facts[key];
+    if (expected2 === undefined !== (actual2 === undefined) || canonicalMigrationJson({ value: expected2 }) !== canonicalMigrationJson({ value: actual2 }))
+      differences.push({ attribute: key, expected: expected2, actual: actual2 });
+  }
+  const expected = params.expected.dependencies.map((identity) => sqlObjectKey5({ identity })).sort();
+  const actual = params.live.dependencies.map((identity) => sqlObjectKey5({ identity })).sort();
+  if (JSON.stringify(expected) !== JSON.stringify(actual))
+    differences.push({ attribute: "dependencies", expected, actual });
+  return differences;
+}
+function assertProbeMode(params) {
+  if (params.probe !== undefined && params.probe !== "none" && DIALECT_CAPABILITIES2[params.dialect].checkNormalization !== params.probe)
+    throw new VibeError20({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
+}
+async function verifyMigrationState(params) {
+  assertProbeMode({ dialect: params.dialect, probe: params.probe });
+  const declarations = params.expected.schema.migrationObjects ?? [];
+  const owned = new Set(declarations.map((object) => sqlObjectKey5({ identity: object.identity })));
+  const definitions = new Map(params.expected.definitions.map((definition) => [sqlObjectKey5({ identity: definition.identity }), definition]));
+  const identities = new Map(params.expected.definitions.map((definition) => [sqlObjectKey5({ identity: definition.identity }), definition.identity]));
+  for (const object of declarations)
+    identities.set(sqlObjectKey5({ identity: object.identity }), object.identity);
+  const objects = [];
+  for (const [key, identity] of identities) {
+    const ownership = owned.has(key) ? "migration" : "schema";
+    const expected = definitions.get(key);
+    const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+    if (live.state !== "present") {
+      objects.push({ identity, ownership, state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
+    } else if (expected === undefined) {
+      objects.push({ identity, ownership, state: "unavailable", reason: "independent-definition-required", differences: [] });
+    } else {
+      const differences = compare({ expected, live: live.definition });
+      objects.push({ identity, ownership, state: differences.length === 0 ? "matching" : "changed", differences });
+    }
+  }
+  if (params.expected.schema.models.length > 0 || params.expected.schema.enums.length > 0)
+    objects.push(...await verifySchemaObjects(params));
+  if (params.dialect === "postgres")
+    objects.push(...await verifyExclusions(params));
+  return { inSync: objects.every((object) => object.state === "matching"), objects };
+}
+async function verifySchemaObjects(params) {
+  const physical = params.dialect === "postgres" ? await introspectPhysicalPostgres({ executor: params.executor }) : params.dialect === "mysql" ? await introspectMysql({ executor: params.executor }) : await introspectSqlite({ executor: params.executor });
+  const expected = normalizeSchema({ schema: params.expected.schema, dialect: params.dialect });
+  const actual = normalizeSchema({ schema: physical, dialect: params.dialect });
+  const objects = [];
+  const namespace = await migrationNamespace({ executor: params.executor, dialect: params.dialect });
+  for (const [name, desired] of expected.tables) {
+    const table = { namespace, name };
+    const live = actual.tables.get(name);
+    if (live === undefined) {
+      const presence = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity: { kind: "table", name: table } });
+      objects.push({ identity: { kind: "table", name: table }, ownership: "schema", state: presence.state === "missing" ? "missing" : "unavailable", ...presence.state === "missing" ? {} : { reason: "schema-definition-not-visible" }, differences: [] });
+      continue;
+    }
+    const differences = [];
+    const pin = (attribute, expected2, actual2) => {
+      if (canonicalMigrationJson({ value: expected2 }) !== canonicalMigrationJson({ value: actual2 }))
+        differences.push({ attribute, expected: expected2, actual: actual2 });
+    };
+    pin("primaryKey", desired.pk, live.pk);
+    for (const [column, field] of desired.columns) {
+      const stored = live.columns.get(column);
+      pin(`columns.${column}.type`, field.typeKey, stored?.typeKey);
+      pin(`columns.${column}.nullable`, field.nullable, stored?.nullable);
+      if (params.dialect === "mysql" && field.field.collation !== undefined) {
+        pin(`columns.${column}.collation`, field.field.collation.toLowerCase(), stored?.field.collation?.toLowerCase());
+      }
+      const ownedDefault = params.expected.schema.migrationObjects?.some((object) => (object.identity.kind === "columnDefault" || object.identity.kind === "generatedColumn") && object.identity.table.namespace === namespace && object.identity.table.name === name && object.identity.column === column);
+      if (!ownedDefault)
+        pin(`columns.${column}.default`, field.defaultKey, stored?.defaultKey);
+    }
+    for (const [key, fk] of desired.fks) {
+      const stored = live.fks.get(key);
+      pin(`foreignKeys.${fk.constraintName}`, { columns: fk.columns, refTable: fk.refTable, refColumns: fk.refColumns, onDelete: fk.onDelete, onUpdate: fk.onUpdate }, stored === undefined ? undefined : { columns: stored.columns, refTable: stored.refTable, refColumns: stored.refColumns, onDelete: stored.onDelete, onUpdate: stored.onUpdate });
+      if (params.dialect === "postgres" && stored !== undefined) {
+        const identity = { kind: "constraint", constraintType: "foreignKey", table, name: stored.constraintName };
+        if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
+          continue;
+        const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+        if (inspection.state !== "present") {
+          objects.push({ identity, ownership: "schema", state: inspection.state, differences: [], ...inspection.state === "unavailable" ? { reason: inspection.reason } : {} });
+        } else {
+          const differences2 = ["validated", "triggersEnabled"].flatMap((attribute) => inspection.definition.facts[attribute] === true ? [] : [{ attribute, expected: true, actual: inspection.definition.facts[attribute] }]);
+          objects.push({ identity, ownership: "schema", state: differences2.length === 0 ? "matching" : "changed", differences: differences2 });
+        }
+      }
+    }
+    for (const [key, index] of desired.indexes) {
+      pin(`indexes.${index.name}`, key, live.indexes.get(key)?.key);
+      if (params.dialect !== "postgres" || !live.indexes.has(key))
+        continue;
+      const identity = { kind: "index", table, name: live.indexes.get(key).name };
+      if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
+        continue;
+      const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+      if (inspection.state !== "present") {
+        objects.push({ identity, ownership: "schema", state: inspection.state, differences: [], ...inspection.state === "unavailable" ? { reason: inspection.reason } : {} });
+      } else {
+        const differences2 = ["valid", "ready"].flatMap((attribute) => inspection.definition.facts[attribute] === true ? [] : [{ attribute, expected: true, actual: inspection.definition.facts[attribute] }]);
+        objects.push({ identity, ownership: "schema", state: differences2.length === 0 ? "matching" : "changed", differences: differences2 });
+      }
+    }
+    objects.push({ identity: { kind: "table", name: table }, ownership: "schema", state: differences.length === 0 ? "matching" : "changed", differences });
+    for (const [check, expression] of desired.checks) {
+      const identity = { kind: "constraint", constraintType: "check", table, name: check };
+      if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
+        continue;
+      const stored = live.checks.get(check);
+      if (stored === undefined) {
+        objects.push({ identity, ownership: "schema", state: "missing", differences: [] });
+        continue;
+      }
+      if (params.dialect !== "sqlite") {
+        const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+        if (inspection.state !== "present") {
+          objects.push({ identity, ownership: "schema", state: inspection.state, differences: [] });
+          continue;
+        }
+        const disabled = params.dialect === "postgres" ? inspection.definition.facts.validated !== true : inspection.definition.facts.enforced !== "YES";
+        if (disabled) {
+          objects.push({ identity, ownership: "schema", state: "changed", differences: [{ attribute: params.dialect === "postgres" ? "validated" : "enforced", expected: params.dialect === "postgres" ? true : "YES", actual: params.dialect === "postgres" ? inspection.definition.facts.validated : inspection.definition.facts.enforced }] });
+          continue;
+        }
+      }
+      if (stored === expression) {
+        objects.push({ identity, ownership: "schema", state: "matching", differences: [] });
+        continue;
+      }
+      if (params.dialect === "postgres" && params.probe === "rollback") {
+        const normalized = await deparsePostgresCheck({ executor: params.executor, table, expression, probe: "rollback" });
+        const read = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+        const actual2 = read.state === "present" ? read.definition.facts.definition : undefined;
+        objects.push({ identity, ownership: "schema", state: normalized === actual2 ? "matching" : "changed", differences: normalized === actual2 ? [] : [{ attribute: "definition", expected: normalized, actual: actual2 }] });
+      } else if (params.dialect === "mysql" && params.probe === "temporary") {
+        const normalized = await deparseMysqlCheck({ executor: params.executor, table, expression, probe: "temporary" });
+        const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+        const actual2 = inspection.state === "present" ? inspection.definition.facts.definition : undefined;
+        const match = normalized === actual2;
+        objects.push({ identity, ownership: "schema", state: inspection.state === "unavailable" ? "unavailable" : match ? "matching" : "changed", differences: match ? [] : [{ attribute: "definition", expected: normalized, actual: actual2 }] });
+      } else
+        objects.push({ identity, ownership: "schema", state: "unavailable", reason: "explicit-replacement-required", differences: [{ attribute: "definition", expected: expression, actual: stored }] });
+    }
+  }
+  for (const [name, join] of expected.joinTables) {
+    const stored = actual.joinTables.get(name);
+    const shape = (value) => value === undefined ? undefined : { a: { table: value.a.table, column: value.a.column }, b: { table: value.b.table, column: value.b.column } };
+    const matching = canonicalMigrationJson({ value: shape(join) }) === canonicalMigrationJson({ value: shape(stored) });
+    objects.push({ identity: { kind: "table", name: { namespace, name } }, ownership: "schema", state: stored === undefined ? "missing" : matching ? "matching" : "changed", differences: matching ? [] : [{ attribute: "joinTable", expected: shape(join), actual: shape(stored) }] });
+  }
+  for (const [name] of expected.views) {
+    if (!params.expected.definitions.some((definition) => definition.identity.kind === "view" && definition.identity.name.namespace === namespace && definition.identity.name.name === name))
+      objects.push({ identity: { kind: "view", name: { namespace, name } }, ownership: "schema", state: actual.views.has(name) ? "unavailable" : "missing", reason: "independent-definition-required", differences: [] });
+  }
+  return objects;
+}
+async function verifyMigrationTransition(params) {
+  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: params.to, ...params.probe === undefined ? {} : { probe: params.probe } });
+  const namespace = await migrationNamespace(params);
+  const identities = (state2) => [...schemaObjectIdentities({ schema: state2.schema, dialect: params.dialect, namespace }), ...(state2.schema.migrationObjects ?? []).map((object) => object.identity), ...state2.definitions.map((definition) => definition.identity)];
+  const retained = new Set(identities(params.to).map((identity) => sqlObjectKey5({ identity })));
+  const removed = new Map([...identities(params.from).filter((identity) => !retained.has(sqlObjectKey5({ identity }))), ...params.removals ?? []].map((identity) => [sqlObjectKey5({ identity }), identity]));
+  const objects = [...report.objects];
+  for (const identity of removed.values()) {
+    const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+    const absent = live.state === "missing" || identity.kind === "columnDefault" && live.state === "present" && live.definition.facts.definition === null;
+    if (!absent)
+      objects.push({ identity, ownership: "schema", state: live.state === "unavailable" ? "unavailable" : "changed", reason: live.state === "unavailable" ? live.reason : "expected-absent", differences: [{ attribute: "presence", expected: false, actual: live.state === "present" ? true : undefined }] });
+  }
+  return { inSync: report.inSync && objects.every((object) => object.state === "matching"), objects };
+}
+async function migrationNamespace(params) {
+  if (params.dialect !== "mysql")
+    return params.dialect === "sqlite" ? "main" : "public";
+  const query = renderMigrationNamespace({ dialect: getSqlDialect2({ dialect: params.dialect }) });
+  const rows = await params.executor({ text: query.text, values: [] });
+  const namespace = rows[0]?.namespace;
+  if (typeof namespace !== "string" || namespace.length === 0)
+    throw new VibeError20({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
+  return namespace;
+}
+function assertMigrationState(params) {
+  if (!params.report.inSync)
+    throw new VibeError20({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", objects: params.report.objects.filter((object) => object.state !== "matching") } });
+}
+async function deparsePostgresCheck(params) {
+  const definition = await deparsePostgresCheckDefinition({ ...params, constraint: "vibeorm_check_probe" });
+  return String(definition.facts.definition);
+}
+async function deparsePostgresCheckDefinition(params) {
+  const name = "vibeorm_check_probe";
+  await params.executor({ text: "SAVEPOINT vibeorm_check_probe" });
+  try {
+    const query = renderCheckProbe({ dialect: getSqlDialect2({ dialect: "postgres" }), table: params.table, expression: params.expression, name });
+    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 VibeError20({ 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" });
+    await params.executor({ text: "RELEASE SAVEPOINT vibeorm_check_probe" });
+  }
+}
+async function deparseMysqlCheck(params) {
+  const probe = `vibe_check_${randomUUID2().replaceAll("-", "")}`;
+  const dialect = getSqlDialect2({ dialect: "mysql" });
+  const clone = renderMysqlCheckProbe({ dialect, probe, operation: "clone", table: params.table });
+  await params.executor({ text: clone.text });
+  let created = true;
+  try {
+    const read = renderMysqlCheckProbe({ dialect, probe, operation: "read" });
+    const source = await params.executor({ text: read.text, values: [] });
+    const definition = source[0]?.["Create Table"];
+    if (typeof definition !== "string")
+      throw new VibeError20({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
+    const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
+    await params.executor({ text: drop.text });
+    created = false;
+    const add = renderMysqlCheckProbe({ dialect, probe, operation: "add", expression: params.expression, definition });
+    await params.executor({ text: add.text });
+    created = true;
+    const rows = await params.executor({ text: read.text, values: [] });
+    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 VibeError20({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
+    return check.expression;
+  } finally {
+    if (created) {
+      const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
+      await params.executor({ text: drop.text });
+    }
+  }
+}
+async function prepareCheckDiff(params) {
+  assertProbeMode({ dialect: params.dialect, probe: params.probe });
+  const models = [];
+  for (const model of params.from.models) {
+    const table = model.dbName ?? model.name;
+    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    const checks = [];
+    for (const check of model.checks ?? []) {
+      const next = target?.checks?.find((entry) => entry.name === check.name);
+      if (next === undefined || next.expression === check.expression) {
+        checks.push({ name: check.name, expression: check.expression });
+        continue;
+      }
+      const identity = { kind: "constraint", constraintType: "check", table: { namespace: await migrationNamespace({ executor: params.executor, dialect: params.dialect }), name: table }, name: check.name };
+      if (params.dialect === "postgres" && params.probe === "rollback") {
+        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 VibeError20({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+        if (live.definition.facts.definition === desired) {
+          checks.push(next);
+          continue;
+        }
+        checks.push({ name: check.name, expression: check.expression });
+        continue;
+      }
+      if (params.dialect === "mysql" && params.probe === "temporary") {
+        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 VibeError20({ 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;
+      }
+      const previous = params.previous?.schema.models.find((entry) => (entry.dbName ?? entry.name) === table)?.checks?.find((entry) => entry.name === check.name);
+      if (previous !== undefined) {
+        checks.push(previous.expression === next.expression ? next : { name: check.name, expression: check.expression });
+        continue;
+      }
+      if (params.replaceChecks?.some((entry) => sqlObjectKey5({ identity: entry }) === sqlObjectKey5({ identity }))) {
+        checks.push({ name: check.name, expression: check.expression });
+        continue;
+      }
+      throw new VibeError20({ 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 });
+  }
+  return { ...params.from, models };
+}
 
 // packages/migrate/src/runner.ts
 function migrationRlsSecurityChanges(params) {
@@ -4832,11 +5754,11 @@ function assertNativeMigrationMetadata(params) {
   const native = params.migration.rls !== undefined || params.sql.some((sql2) => containsNativeRlsSql({ sql: sql2, dialect: params.dialect }));
   if (!native)
     return;
-  if (!DIALECT_CAPABILITIES2[params.dialect].nativeRowLevelSecurity) {
-    throw new VibeError15({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
+  if (!DIALECT_CAPABILITIES3[params.dialect].nativeRowLevelSecurity) {
+    throw new VibeError21({ 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 VibeError15({ 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 VibeError21({ 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;
@@ -4876,11 +5798,27 @@ async function ensureMigrationsTable(params) {
 function migrationChecksum(params) {
   const suffix = executionChecksumSuffix({ ...params.execution === undefined ? {} : { execution: params.execution } });
   return createHash("sha256").update(params.sql.join(`
-`) + suffix).digest("hex");
+`) + suffix + (params.desiredStatePending === true ? `
+-- vibeorm:desired-state unfinalized-v1` : "") + desiredStateChecksumSuffix({ ...params.desiredState === undefined ? {} : { desiredState: params.desiredState } }) + (params.desiredState === undefined ? "" : `
+-- vibeorm:down ${JSON.stringify(params.downSql ?? null)}${executionChecksumSuffix({ ...params.downExecution === undefined ? {} : { execution: params.downExecution } })}`)).digest("hex");
 }
 function checksumOf(params) {
   const { migration } = params;
-  return migrationChecksum({ sql: migration.sql, ...migration.execution === undefined ? {} : { execution: migration.execution } });
+  return migrationChecksum(migration);
+}
+async function assertForwardStart(params) {
+  const state2 = params.migration.desiredState;
+  if (state2 === undefined)
+    return;
+  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state2.from, ...params.probe === undefined ? {} : { probe: params.probe } });
+  if (report.inSync)
+    return;
+  if (state2.down !== undefined) {
+    const restored = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state2.down, ...params.probe === undefined ? {} : { probe: params.probe } });
+    if (restored.inSync)
+      return;
+  }
+  assertMigrationState({ report });
 }
 function generateMigration(params) {
   const { from, to, name } = params;
@@ -4891,9 +5829,10 @@ function generateMigration(params) {
     extensions: params.extensions ?? []
   });
   const allArtifacts = [...artifacts.setup, ...artifacts.objects];
-  const strippedFrom = stripExtensionArtifacts({ schema: from, artifacts: allArtifacts });
+  assertRetainedMigrationObjects({ from: from.migrationObjects ?? [], to: to.migrationObjects ?? [] });
+  const strippedFrom = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: from, artifacts: allArtifacts }), to, objects: [...from.migrationObjects ?? [], ...to.migrationObjects ?? []] });
   const steps = diffSchemas({ from: strippedFrom, to, dialect, ...params.renames === undefined ? {} : { renames: params.renames } });
-  const coreSql = renderSteps({ steps, dialect, from: strippedFrom, to });
+  const coreSql = renderSteps({ steps, dialect, from: dialect === "sqlite" ? from : strippedFrom, to: dialect === "sqlite" ? sqlitePreservedSchema({ from, to, objects: [...from.migrationObjects ?? [], ...to.migrationObjects ?? []] }) : to });
   const missing = planMissingArtifacts({ introspected: from, artifacts: allArtifacts });
   const sql2 = [
     ...artifactCreateSql({
@@ -4902,6 +5841,16 @@ function generateMigration(params) {
     ...coreSql,
     ...artifactCreateSql({
       artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
+    }),
+    ...orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).flatMap((object) => {
+      if (object.dialect !== dialect)
+        throw new VibeError21({ 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 VibeError21({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", id: object.id } });
+      return [];
     })
   ];
   return {
@@ -4910,13 +5859,21 @@ function generateMigration(params) {
     destructive: steps.some((step) => step.destructive),
     ...securityChangesOf({ steps }).length === 0 ? {} : { securityChanges: securityChangesOf({ steps }) },
     ...from.rls === undefined && to.rls === undefined ? {} : { rls: { from, to } },
-    ...params.execution === undefined ? {} : { execution: params.execution }
+    ...params.execution === undefined ? {} : { execution: params.execution },
+    desiredState: params.desiredState ?? { version: 1, dialect, from: createDesiredState({ schema: from, dialect }), to: createDesiredState({ schema: to, dialect }) }
   };
 }
 async function applyMigrations(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
   for (const migration of migrations) {
+    if (migration.desiredStatePending === true)
+      throw new VibeError21({ 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 VibeError21({ 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 });
   }
@@ -4930,7 +5887,7 @@ async function applyMigrations(params) {
       const stored = recorded.get(migration.name);
       if (stored !== undefined) {
         if (stored.statementIndex < 0) {
-          throw new VibeError15({
+          throw new VibeError21({
             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 }
@@ -4942,6 +5899,10 @@ async function applyMigrations(params) {
           continue;
         }
         assertResumable({ migration, stored });
+        assertNamedRemovals({ removals: migration.desiredState?.unmanagedRemovals ?? [], approved: params.removeUnmanaged, acceptIntegrityLoss: params.acceptIntegrityLoss });
+        if (migration.desiredState !== undefined)
+          assertRemovalAuthorization({ steps: diffSchemas({ from: migration.desiredState.from.schema, to: migration.desiredState.to.schema, dialect }), previous: migration.desiredState.from, dialect, namespace: dialect === "sqlite" ? "main" : "public", ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss } });
+        assertSecurityAcknowledgement({ securityChanges: [...migration.securityChanges ?? [], ...migrationRlsSecurityChanges({ migration, down: false })], ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
         await withSessionLimits({
           executor,
           dialect,
@@ -4951,6 +5912,7 @@ async function applyMigrations(params) {
             dialect,
             migration,
             start: stored.statementIndex,
+            ...params.probe === undefined ? {} : { probe: params.probe },
             insertRecord: false,
             ...stored.error === undefined ? {} : { storedError: stored.error }
           })
@@ -4958,19 +5920,35 @@ async function applyMigrations(params) {
         applied.push(migration.name);
         continue;
       }
+      assertNamedRemovals({ removals: migration.desiredState?.unmanagedRemovals ?? [], approved: params.removeUnmanaged, acceptIntegrityLoss: params.acceptIntegrityLoss });
+      if (migration.desiredState !== undefined) {
+        const state2 = migration.desiredState;
+        assertRemovalAuthorization({ steps: diffSchemas({ from: state2.from.schema, to: state2.to.schema, dialect }), previous: state2.from, dialect, namespace: dialect === "sqlite" ? "main" : "public", ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss } });
+      }
       assertSecurityAcknowledgement({ securityChanges: [...migration.securityChanges ?? [], ...migrationRlsSecurityChanges({ migration, down: false })], ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
       if (usesStatementBookkeeping({ dialect, sql: migration.sql, ...migration.execution === undefined ? {} : { execution: migration.execution } })) {
         await withSessionLimits({
           executor,
           dialect,
           ...migration.execution === undefined ? {} : { execution: migration.execution },
-          run: () => runNonTransactional({ executor, dialect, migration, start: 0, insertRecord: true })
+          run: () => runNonTransactional({ executor, dialect, migration, start: 0, insertRecord: true, ...params.probe === undefined ? {} : { probe: params.probe } })
         });
       } else {
-        await runTransactional({ executor, dialect, migration });
+        await runTransactional({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
       }
       applied.push(migration.name);
     }
+    const final = migrations.at(-1);
+    if (final?.desiredState !== undefined) {
+      if (params.probe === "rollback")
+        await executor({ text: "BEGIN" });
+      try {
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: final.desiredState.from, to: final.desiredState.to, removals: final.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+      } finally {
+        if (params.probe === "rollback")
+          await executor({ text: "ROLLBACK" });
+      }
+    }
     return { applied, skipped };
   } finally {
     await releaseLock({ executor, dialect });
@@ -5050,14 +6028,22 @@ async function resolveMigration(params) {
 async function rollbackMigration(params) {
   const { executor, migration } = params;
   const dialect = params.dialect ?? "postgres";
+  if (migration.desiredStatePending === true)
+    throw new VibeError21({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   const downSql = migration.downSql;
   if (downSql === undefined) {
-    throw new VibeError15({
+    throw new VibeError21({
       code: "VIBE_MIGRATION",
       message: `migration "${migration.name}" has no down.sql \u2014 it predates down-migration support; roll it back manually, then repair with resolveMigration (as: "rolled-back")`,
       meta: { migration: migration.name }
     });
   }
+  if (migration.desiredState !== undefined) {
+    assertDesiredState({ value: migration.desiredState, migration: migration.name });
+    if (migration.desiredState.dialect !== dialect)
+      throw new VibeError21({ 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 });
   assertExecutable({ migration, execution: migration.downExecution, sql: downSql, dialect });
   assertSecurityAcknowledgement({ securityChanges: [...migration.downSecurityChanges ?? [], ...migrationRlsSecurityChanges({ migration, down: true })], ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
@@ -5067,7 +6053,7 @@ async function rollbackMigration(params) {
     const recorded = await recordedRows({ executor, dialect });
     const stored = recorded.get(migration.name);
     if (stored === undefined) {
-      throw new VibeError15({
+      throw new VibeError21({
         code: "VIBE_MIGRATION",
         message: `migration "${migration.name}" is not recorded as applied \u2014 nothing to roll back`,
         meta: { migration: migration.name }
@@ -5078,7 +6064,7 @@ async function rollbackMigration(params) {
     if (!resumingDown) {
       const partialUp = !isCompleteRecord({ dialect, migration, stored });
       if (partialUp) {
-        throw new VibeError15({
+        throw new VibeError21({
           code: "VIBE_MIGRATION",
           message: `migration "${migration.name}" is only partially applied (${stored.statementIndex} of ${migration.sql.length} statement(s)) \u2014 its down migration mirrors the FULL up; re-run applyMigrations to finish it (it resumes), or repair with resolveMigration`,
           meta: { migration: migration.name, statementIndex: stored.statementIndex }
@@ -5097,11 +6083,12 @@ async function rollbackMigration(params) {
           migration,
           downSql,
           start,
+          ...params.probe === undefined ? {} : { probe: params.probe },
           ...stored.error === undefined ? {} : { storedError: stored.error }
         })
       });
     } else {
-      await runTransactionalDown({ executor, dialect, migration, downSql });
+      await runTransactionalDown({ executor, dialect, migration, downSql, ...params.probe === undefined ? {} : { probe: params.probe } });
     }
   } finally {
     await releaseLock({ executor, dialect });
@@ -5114,11 +6101,15 @@ async function runTransactionalDown(params) {
   if (wrap)
     await executor({ text: "BEGIN" });
   try {
+    if (migration.desiredState !== undefined)
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.to, inTransaction: true, requireInstalledRls: true });
     for (const statement of downSql) {
       await executeStatement({ executor, statement, dialect });
     }
+    if (migration.desiredState !== undefined)
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.from, inTransaction: true, requireInstalledRls: true });
     await executor({
@@ -5135,7 +6126,7 @@ async function runTransactionalDown(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError15({
+    throw new VibeError21({
       code: "VIBE_MIGRATION",
       message: `rollback of "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name },
@@ -5166,10 +6157,15 @@ async function runNonTransactionalDown(params) {
   if (marks && start < downSql.length && resumeOperation === undefined && inflightStatement({ ...params.storedError === undefined ? {} : { error: params.storedError } }) === start) {
     throw uncertainStatement({ migration: migration.name, statements: downSql, index: start, dialect, direction: "down" });
   }
-  if (start === 0)
+  if (start === 0) {
+    if (migration.desiredState !== undefined)
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     await recordProgress(0);
+  }
   let cursor = start;
   if (resumeOperation !== undefined && await establishOperationState({ executor, dialect, operation: resumeOperation }) === "satisfied") {
+    if (start + 1 === downSql.length && migration.desiredState !== undefined)
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     await recordProgress(start + 1);
     cursor = start + 1;
   }
@@ -5184,10 +6180,17 @@ async function runNonTransactionalDown(params) {
     }
     if (atomic)
       await executor({ text: "BEGIN" });
+    let executed = false;
     try {
-      if (commitsBlock)
+      if (commitsBlock) {
+        if (migration.desiredState !== undefined && downSql.slice(index + 1).every((statement) => /^\s*PRAGMA\s+foreign_keys\s*=\s*ON\s*;?\s*$/i.test(statement)))
+          assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
         await recordProgress(index + 1);
+      }
       await executeStatement({ executor, statement: downSql[index], dialect });
+      executed = true;
+      if (index === downSql.length - 1 && migration.desiredState !== undefined)
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
       if (atomic) {
         await recordProgress(index + 1);
         await executor({ text: "COMMIT" });
@@ -5198,10 +6201,10 @@ async function runNonTransactionalDown(params) {
       try {
         await executor({
           text: `UPDATE ${table} SET ${q5(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q5(dialect, "name")} = ${ph(dialect, 2)}`,
-          values: [error instanceof Error ? error.message : String(error), migration.name]
+          values: [executed && marks ? `${INFLIGHT_PREFIX}${index}` : error instanceof Error ? error.message : String(error), migration.name]
         });
       } catch {}
-      throw new VibeError15({
+      throw new VibeError21({
         code: "VIBE_MIGRATION",
         message: `rollback of "${migration.name}" failed at down statement ${index + 1} of ${downSql.length}: ${error instanceof Error ? error.message : String(error)} \u2014 progress is recorded; re-running the rollback resumes from this statement`,
         meta: { migration: migration.name, statementIndex: index },
@@ -5211,6 +6214,8 @@ async function runNonTransactionalDown(params) {
     if (!atomic && !commitsBlock)
       await recordProgress(index + 1);
   }
+  if (migration.desiredState !== undefined)
+    assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
   await executor({
     text: `DELETE FROM ${table} WHERE ${q5(dialect, "name")} = ${ph(dialect, 1)}`,
     values: [migration.name]
@@ -5226,10 +6231,11 @@ async function runTransactional(params) {
     const limits = migration.execution;
     if (wrap && dialect === "postgres" && limits !== undefined) {
       if ((limits.lockTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect2({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect3({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
       if ((limits.statementTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect2({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect3({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
     }
+    await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.from, inTransaction: true, requireInstalledRls: true });
     let statementIndex = 0;
@@ -5237,6 +6243,8 @@ async function runTransactional(params) {
       await executeStatement({ executor, statement, dialect });
       statementIndex += 1;
     }
+    if (migration.desiredState !== undefined)
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.to, inTransaction: true, requireInstalledRls: true });
     await executor({
@@ -5253,7 +6261,7 @@ async function runTransactional(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError15({
+    throw new VibeError21({
       code: "VIBE_MIGRATION",
       message: `migration "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name },
@@ -5274,6 +6282,11 @@ async function runNonTransactional(params) {
   const marks = marksInflight({ dialect, ...execution === undefined ? {} : { execution } });
   const start = selfManaged ? selfManagedResumeStart({ sql: migration.sql, start: params.start }) : params.start;
   if (insertRecord) {
+    if (migration.desiredState !== undefined) {
+      await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
+      if (migration.sql.length === 0)
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+    }
     await executor({
       text: `INSERT INTO ${table} (${q5(dialect, "name")}, ${q5(dialect, "checksum")}, ${q5(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, 0)`,
       values: [migration.name, checksumOf({ migration })]
@@ -5289,8 +6302,10 @@ async function runNonTransactional(params) {
   if (marks && !insertRecord && start < migration.sql.length) {
     const operation = declared ? operationFor({ ...execution === undefined ? {} : { execution }, statement: start }) : undefined;
     if (operation !== undefined) {
-      const state = await establishOperationState({ executor, dialect, operation });
-      if (state === "satisfied") {
+      const state2 = await establishOperationState({ executor, dialect, operation });
+      if (state2 === "satisfied") {
+        if (start + 1 === migration.sql.length && migration.desiredState !== undefined)
+          assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
         await checkpoint(start + 1);
         cursor = start + 1;
       }
@@ -5309,10 +6324,17 @@ async function runNonTransactional(params) {
     }
     if (atomic)
       await executor({ text: "BEGIN" });
+    let executed = false;
     try {
-      if (commitsBlock)
+      if (commitsBlock) {
+        if (migration.desiredState !== undefined && migration.sql.slice(index + 1).every((statement) => /^\s*PRAGMA\s+foreign_keys\s*=\s*ON\s*;?\s*$/i.test(statement)))
+          assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
         await checkpoint(index + 1);
+      }
       await executeStatement({ executor, statement: migration.sql[index], dialect });
+      executed = true;
+      if (index === migration.sql.length - 1 && migration.desiredState !== undefined)
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
       if (atomic) {
         await checkpoint(index + 1);
         await executor({ text: "COMMIT" });
@@ -5323,12 +6345,12 @@ async function runNonTransactional(params) {
       try {
         await executor({
           text: `UPDATE ${table} SET ${q5(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q5(dialect, "name")} = ${ph(dialect, 2)}`,
-          values: [error instanceof Error ? error.message : String(error), migration.name]
+          values: [executed && marks ? `${INFLIGHT_PREFIX}${index}` : error instanceof Error ? error.message : String(error), migration.name]
         });
       } catch {}
       const sqlState = sqlStateOf(error);
       const timeout = sqlState === "55P03" ? "lock-timeout" : sqlState === "57014" ? "statement-timeout" : undefined;
-      throw new VibeError15({
+      throw new VibeError21({
         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) \u2014 another session holds a conflicting lock. Nothing of this statement was applied; progress is recorded and re-running resumes here.` : 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) \u2014 progress is recorded and re-running resumes here.` : `migration "${migration.name}" failed at statement ${index + 1} of ${migration.sql.length}: ${error instanceof Error ? error.message : String(error)} \u2014 progress is recorded; re-running applyMigrations resumes from this statement`,
         meta: { migration: migration.name, statementIndex: index, ...timeout === undefined ? {} : { reason: timeout, sqlState } },
@@ -5352,7 +6374,7 @@ async function acquireLock(params) {
     });
     const acquired = Number(rows[0]?.vibe_lock) === 1;
     if (!acquired) {
-      throw new VibeError15({
+      throw new VibeError21({
         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 }
@@ -5389,7 +6411,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 VibeError15({
+  return new VibeError21({
     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: {
@@ -5406,7 +6428,7 @@ function assertExecutable(params) {
   if (execution === undefined || isDefaultExecution({ execution }))
     return;
   if (dialect !== "postgres") {
-    throw new VibeError15({
+    throw new VibeError21({
       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" }
@@ -5429,7 +6451,7 @@ async function withSessionLimits(params) {
   const statement = execution?.statementTimeoutMs ?? 0;
   if (dialect !== "postgres" || lock === 0 && statement === 0)
     return params.run();
-  const sqlDialect = getSqlDialect2({ dialect });
+  const sqlDialect = getSqlDialect3({ dialect });
   const previous = (await executor({ text: renderMigrationSessionRead({ dialect: sqlDialect }).text, values: [] }))[0];
   if (lock > 0)
     await executor({ text: renderMigrationSessionSet({ dialect: sqlDialect, setting: "lock_timeout", milliseconds: lock }).text });
@@ -5451,7 +6473,7 @@ function usesStatementBookkeeping(params) {
   const { dialect, sql: sql2 } = params;
   if (params.execution?.transaction === "none")
     return true;
-  if (!DIALECT_CAPABILITIES2[dialect].transactionalDdl)
+  if (!DIALECT_CAPABILITIES3[dialect].transactionalDdl)
     return true;
   return dialect === "sqlite" && usesSelfManagedTransactions({ sql: sql2 });
 }
@@ -5487,7 +6509,7 @@ function assertChecksumMatches(params) {
   const actual = checksumOf({ migration });
   if (stored === actual)
     return;
-  throw new VibeError15({
+  throw new VibeError21({
     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 }
@@ -5498,7 +6520,7 @@ function assertResumable(params) {
   const actual = checksumOf({ migration });
   if (stored.checksum === actual)
     return;
-  throw new VibeError15({
+  throw new VibeError21({
     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: {
@@ -5510,12 +6532,13 @@ function assertResumable(params) {
   });
 }
 function q5(dialect, name) {
-  return getSqlDialect2({ dialect }).quoteIdent({ name });
+  return getSqlDialect3({ dialect }).quoteIdent({ name });
 }
 function ph(dialect, index) {
-  return getSqlDialect2({ dialect }).placeholder({ index });
+  return getSqlDialect3({ dialect }).placeholder({ index });
 }
 // packages/migrate/src/down.ts
+import { VibeError as VibeError22, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
 function buildRollbackTarget(params) {
   const { from, to, dialect } = params;
   const skipped = [];
@@ -5539,7 +6562,18 @@ function buildRollbackTarget(params) {
     patched = true;
     return { ...enumDef, values: [...enumDef.values, ...added] };
   });
-  return { target: patched ? { ...from, enums } : from, skipped };
+  const models = dialect !== "mysql" ? from.models : from.models.map((model) => {
+    const afterModel = to.models.find((candidate) => (candidate.dbName ?? candidate.name) === (model.dbName ?? model.name));
+    return { ...model, fields: model.fields.map((field) => {
+      const after = afterModel?.fields.find((candidate) => (candidate.dbName ?? candidate.name) === (field.dbName ?? field.name));
+      if (field.type !== "String" || field.collation !== undefined || after?.collation === undefined)
+        return field;
+      patched = true;
+      skipped.push(`column "${model.dbName ?? model.name}"."${field.dbName ?? field.name}": previous collation was not recorded; "${after.collation}" is retained`);
+      return { ...field, collation: after.collation };
+    }) };
+  });
+  return { target: patched ? { ...from, enums, models } : from, skipped };
 }
 function forceReAddedColumnsNullable(params) {
   return params.steps.map((step) => {
@@ -5557,7 +6591,8 @@ function generateDownMigration(params) {
     extensions: params.extensions ?? []
   });
   const allArtifacts = [...artifacts.setup, ...artifacts.objects];
-  const strippedFrom = stripExtensionArtifacts({ schema: from, artifacts: allArtifacts });
+  const owned = [...from.migrationObjects ?? [], ...to.migrationObjects ?? []];
+  const strippedFrom = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: from, artifacts: allArtifacts }), to: from, objects: owned });
   const { target, skipped } = buildRollbackTarget({ from: strippedFrom, to, dialect });
   const toViewNames = new Set(to.models.filter((model) => model.isView).map((model) => model.dbName ?? model.name));
   for (const model of target.models) {
@@ -5571,7 +6606,11 @@ function generateDownMigration(params) {
   const steps = forceReAddedColumnsNullable({
     steps: diffSchemas({ from: to, to: target, dialect })
   });
-  const coreSql = renderSteps({ steps, dialect, from: to, to: target });
+  const restored = { ...target, models: target.models.map((model) => ({ ...model, fields: model.fields.map((field) => {
+    const added = steps.find((step) => step.kind === "addColumn" && step.table === (model.dbName ?? model.name) && (step.column.dbName ?? step.column.name) === (field.dbName ?? field.name));
+    return added?.kind === "addColumn" ? { ...field, isOptional: added.column.isOptional } : field;
+  }) })) };
+  const coreSql = renderSteps({ steps, dialect, from: to, to: dialect === "sqlite" ? sqlitePreservedSchema({ from, to: restored, objects: from.migrationObjects ?? [] }) : restored });
   const created = planMissingArtifacts({ introspected: from, artifacts: allArtifacts });
   const artifactDropSql = [];
   for (const artifact of [...created].reverse()) {
@@ -5581,93 +6620,403 @@ function generateDownMigration(params) {
     }
     artifactDropSql.push(...artifact.drop);
   }
+  const previousKeys = new Set((from.migrationObjects ?? []).map((object) => sqlObjectKey6({ identity: object.identity })));
+  const ownedDropSql = [];
+  for (const object of orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).reverse()) {
+    if (previousKeys.has(sqlObjectKey6({ identity: object.identity })))
+      continue;
+    if (object.identity.kind === "postgresExtension") {
+      skipped.push(`extension ${object.id} remains installed`);
+      continue;
+    }
+    if (object.drop.length === 0)
+      throw new VibeError22({ 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 {
     name,
-    sql: [...artifactDropSql, ...coreSql],
+    target: restored,
+    sql: [...ownedDropSql, ...artifactDropSql, ...coreSql],
     destructive: steps.some((step) => step.destructive),
     ...securityChangesOf({ steps }).length === 0 ? {} : { securityChanges: securityChangesOf({ steps }) },
     skipped
   };
 }
 // packages/migrate/src/push.ts
-import { VibeError as VibeError16, assertValidSchemaIR as assertValidSchemaIR3, providerToDialect } from "@vibeorm/schema";
-import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES3, sqliteDialect as sqliteDialect3, renderDiagnostic } from "@vibeorm/sql";
+import { VibeError as VibeError25, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect2, sqlObjectKey as sqlObjectKey9 } from "@vibeorm/schema";
+import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES4 } from "@vibeorm/sql";
+
+// packages/migrate/src/planner.ts
+import { VibeError as VibeError24, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
+import { renderSqliteRebuildObjects, sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
+
+// packages/migrate/src/inventory.ts
+import { VibeError as VibeError23, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey7 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect4, renderMigrationInventory, renderSqliteColumnInventory, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
+async function inspectMigrationInventory(params) {
+  await assertCatalogVisibility(params);
+  const query = renderMigrationInventory({ dialect: getSqlDialect4({ dialect: params.dialect }), namespace: params.namespace });
+  const rows = await params.executor({ text: query.text, values: [...query.values] });
+  const objects = [];
+  const kinds = {
+    c: "check",
+    f: "foreignKey",
+    x: "exclusion",
+    u: "unique",
+    p: "primaryKey",
+    CHECK: "check",
+    "FOREIGN KEY": "foreignKey",
+    UNIQUE: "unique",
+    "PRIMARY KEY": "primaryKey"
+  };
+  for (const row of rows) {
+    const name = row.name;
+    if (typeof name !== "string" || typeof row.kind !== "string")
+      throw new VibeError23({ 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;
+    switch (row.kind) {
+      case "table":
+      case "view":
+      case "sequence":
+        identity = { kind: row.kind, name: qualified };
+        break;
+      case "trigger":
+      case "index":
+        identity = { kind: row.kind, table, name };
+        break;
+      case "column":
+      case "columnDefault":
+      case "generatedColumn":
+        identity = { kind: row.kind, table, column: name };
+        break;
+      case "constraint": {
+        const constraintType = kinds[String(row.subtype)];
+        if (constraintType === undefined)
+          throw new VibeError23({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
+        identity = { kind: "constraint", table, name, constraintType };
+        break;
+      }
+      case "function": {
+        let argumentTypes = JSON.parse(String(row.signature));
+        if (params.dialect === "mysql") {
+          const query2 = renderMysqlObjectMembers2({ dialect: getSqlDialect4({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
+          const members = await params.executor({ text: query2.text, values: [...query2.values] });
+          if (members.length === 0)
+            throw new VibeError23({ 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 VibeError23({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
+        identity = candidate;
+        break;
+      }
+      default:
+        throw new VibeError23({ 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)) {
+      const clauses = sqliteTableConstraints3({ sql: row.definition });
+      for (const constraint of clauses) {
+        if (constraint.type === "check")
+          continue;
+        const name2 = constraint.named ? constraint.name : constraint.type === "primaryKey" ? `${qualified.name}_pkey` : constraint.type === "foreignKey" ? `${qualified.name}_${constraint.columns.join("_")}_fkey` : constraint.name;
+        objects.push({ identity: { kind: "constraint", constraintType: constraint.type, table: qualified, name: name2 }, ...constraint.type === "unique" && !constraint.named ? { inspectionUnavailable: "sqlite-anonymous-unique-constraint" } : {} });
+      }
+      const checks = parseSqliteNamedChecks({ tableSql: row.definition });
+      for (const check of checks)
+        objects.push({ identity: { kind: "constraint", constraintType: "check", table: qualified, name: check.name } });
+      if ([...row.definition.matchAll(/\bCHECK\s*\(/gi)].length > checks.length)
+        objects.push({ identity: { kind: "table", name: qualified }, inspectionUnavailable: "sqlite-unnamed-check-definition-unavailable" });
+      const query2 = renderSqliteColumnInventory({ dialect: getSqlDialect4({ dialect: params.dialect }), namespace: params.namespace, table: name });
+      const columns = await params.executor({ text: query2.text, values: [...query2.values] });
+      if (columns.some((column) => Number(column.pk) > 0) && !clauses.some((clause) => clause.type === "primaryKey"))
+        objects.push({ identity: { kind: "constraint", constraintType: "primaryKey", table: qualified, name: `${qualified.name}_pkey` } });
+      const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect4({ dialect: params.dialect }), namespace: params.namespace, table: name });
+      const foreignKeys = await params.executor({ text: fkQuery.text, values: [...fkQuery.values] });
+      const groups = new Map;
+      for (const fk of foreignKeys)
+        groups.set(Number(fk.id), [...groups.get(Number(fk.id)) ?? [], String(fk.from)]);
+      for (const fields of groups.values()) {
+        if (clauses.some((clause) => clause.type === "foreignKey" && JSON.stringify(clause.columns) === JSON.stringify(fields)))
+          continue;
+        objects.push({ identity: { kind: "constraint", constraintType: "foreignKey", table: qualified, name: `${qualified.name}_${fields.join("_")}_fkey` }, inspectionUnavailable: "sqlite-inline-foreign-key-definition-unavailable" });
+      }
+      for (const column of columns) {
+        objects.push({ identity: { kind: "column", table: qualified, column: String(column.name) } });
+        if (Number(column.hidden) > 1)
+          objects.push({ identity: { kind: "generatedColumn", table: qualified, column: String(column.name) } });
+        else if (column.definition !== null && column.definition !== undefined)
+          objects.push({ identity: { kind: "columnDefault", table: qualified, column: String(column.name) } });
+      }
+    }
+  }
+  return [...new Map(objects.map((object) => [sqlObjectKey7({ identity: object.identity }), object])).values()];
+}
+
+// packages/migrate/src/planner.ts
+async function planSchemaMigration(params) {
+  const { executor, schema, dialect } = params;
+  const namespace = params.namespace ?? await migrationNamespace({ executor, dialect });
+  const collected = collectExtensionArtifacts({ schema, dialect, extensions: params.extensions ?? [] });
+  const artifacts = [...collected.setup, ...collected.objects];
+  const legacyObjects = legacyMigrationObjects({ artifacts, dialect, namespace });
+  const objects = orderedMigrationObjects({ objects: schema.migrationObjects ?? [] });
+  assertRetainedMigrationObjects({ from: params.previous?.schema.migrationObjects ?? [], to: objects });
+  for (const object of objects)
+    if (object.dialect !== dialect)
+      throw new VibeError24({ 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 }) : dialect === "mysql" ? await introspectMysql({ executor }) : await introspectSqlite({ executor }));
+  if (params.previous !== undefined)
+    assertMigrationState({ report: await verifyMigrationState({ executor, expected: params.previous, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+  const inventory = await inspectMigrationInventory({ executor, dialect, namespace });
+  for (const object of inventory) {
+    const identity = object.identity;
+    if (identity.kind !== "table" || physical.models.some((model) => (model.dbName ?? model.name) === identity.name.name) || normalizeSchema({ schema: physical, dialect }).joinTables.has(identity.name.name))
+      continue;
+    throw new VibeError24({ 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 = [];
+  if (dialect === "mysql" && inventory.some((object) => object.identity.kind === "view" || object.identity.kind === "function" || object.identity.kind === "trigger") && params.previous === undefined && physical.models.length > 0)
+    states.push(...inventory.filter((object) => object.identity.kind === "view" || object.identity.kind === "function" || object.identity.kind === "trigger").map((object) => ({ identity: object.identity, ownership: "unknown", state: "unavailable", reason: "dependency-inspection-unavailable", differences: [] })));
+  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) => sqlObjectKey8({ identity }) === sqlObjectKey8({ identity: dependency })))
+        continue;
+      const state2 = await inspectSqlObject({ executor, dialect, identity: dependency });
+      if (state2.state !== "present")
+        states.push({ identity: dependency, ownership: "migration", state: "unavailable", reason: "dependency-unavailable", differences: [] });
+    }
+    const expected = object.expected ?? params.previous?.definitions.find((entry) => sqlObjectKey8({ identity: entry.identity }) === sqlObjectKey8({ identity: object.identity }));
+    const live = await inspectSqlObject({ executor, dialect, identity: object.identity });
+    if (expected === undefined)
+      states.push({ identity: object.identity, ownership: "migration", state: "unavailable", differences: [], reason: "independent-definition-required" });
+    else if (live.state === "missing") {
+      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);
+    }
+  }
+  for (const object of legacyObjects) {
+    if (objects.some((entry) => sqlObjectKey8({ identity: entry.identity }) === sqlObjectKey8({ identity: object.identity })))
+      throw new VibeError24({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
+    const expected = object.expected ?? params.previous?.definitions.find((entry) => sqlObjectKey8({ identity: entry.identity }) === sqlObjectKey8({ identity: object.identity }));
+    if (expected === undefined)
+      states.push({ identity: object.identity, ownership: "migration", state: "unavailable", reason: "legacy-definition-required", differences: [] });
+    else {
+      const live = await inspectSqlObject({ executor, dialect, identity: object.identity });
+      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);
+    }
+  }
+  const protectedObjects = [...legacyObjects, ...objects, ...params.previous?.schema.migrationObjects ?? []];
+  const stripped = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: physical, artifacts }), to: schema, objects: protectedObjects, namespace });
+  const checked = await prepareCheckDiff({ executor, from: stripped, to: schema, dialect, ...params.probe === undefined ? {} : { probe: params.probe }, ...params.previous === undefined ? {} : { previous: params.previous }, ...params.replaceChecks === undefined ? {} : { replaceChecks: params.replaceChecks } });
+  const from = await prepareExclusionDiff({ ...params, from: checked, to: schema });
+  const steps = diffSchemas({ from, to: schema, dialect });
+  const known = new Set(schemaObjectIdentities({ schema: params.previous?.schema ?? schema, dialect, namespace }).map((identity) => sqlObjectKey8({ identity })));
+  const declaredIndexes = normalizeSchema({ schema: params.previous?.schema ?? schema, dialect });
+  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(sqlObjectKey8({ identity: { kind: "constraint", constraintType: "unique", table: { namespace, name: table }, name: index.constraintName } }));
+    }
+  const migrationOwned = new Set(protectedObjects.map((object) => sqlObjectKey8({ identity: object.identity })));
+  const removals = steps.flatMap((step) => {
+    const identity = removalIdentity({ step, namespace });
+    return identity === undefined ? [] : [identity];
+  });
+  const droppedTables = new Set(steps.flatMap((step) => step.kind === "dropTable" || step.kind === "dropJoinTable" ? [step.table] : []));
+  const unmanagedRemovals = [];
+  const invalid3 = dialect === "sqlite" ? sqliteInvalidatedTables({ steps, from: physical }) : { rebuilt: new Set, dropped: new Set };
+  for (const object of inventory) {
+    const key = sqlObjectKey8({ 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);
+    const ownership = migrationOwned.has(key) ? "migration" : known.has(key) || normalizedOwner !== undefined && known.has(sqlObjectKey8({ identity: normalizedOwner.identity })) ? "schema" : "unknown";
+    if (object.inspectionUnavailable !== undefined)
+      states.push({ identity: object.identity, ownership, state: "unavailable", reason: object.inspectionUnavailable, differences: [] });
+    if (object.inspectionUnavailable !== undefined && invalid3.rebuilt.has("table" in object.identity ? object.identity.table.name : object.identity.name.name))
+      throw new VibeError24({ 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")
+      states.push({ identity: object.identity, ownership, state: "unavailable", reason: "unmanaged", differences: [] });
+    let collateral = "table" in object.identity && object.identity.table.namespace === namespace && droppedTables.has(object.identity.table.name);
+    const declared = protectedObjects.find((entry) => sqlObjectKey8({ identity: entry.identity }) === key);
+    if (declared?.dependsOn.some((dependency) => removals.some((identity) => sqlObjectKey8({ identity }) === sqlObjectKey8({ identity: dependency })) || ("table" in dependency) && dependency.table.namespace === namespace && droppedTables.has(dependency.table.name)))
+      collateral = true;
+    if (ownership === "unknown" && object.identity.kind === "function" && steps.some((step) => step.kind === "dropTable" || step.kind === "dropColumn" || step.kind === "dropJoinTable"))
+      states.push({ identity: object.identity, ownership, state: "unavailable", reason: "dependency-inspection-unavailable", differences: [] });
+    if (dialect === "postgres" && steps.some((step) => step.kind === "dropTable" || step.kind === "dropColumn" || step.kind === "dropJoinTable")) {
+      const inspected = await inspectSqlObject({ executor, dialect, identity: object.identity });
+      if (inspected.state !== "present") {
+        states.push({ identity: object.identity, ownership, state: "unavailable", reason: "dependency-inspection-unavailable", differences: [] });
+      } else {
+        const addresses = inspected.definition.facts.dependencyAddresses;
+        if (Array.isArray(addresses))
+          for (const address of addresses) {
+            const value = JSON.parse(String(address));
+            if (!Array.isArray(value) || !Array.isArray(value[2]))
+              throw new VibeError24({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
+            const names = value[2];
+            if (names[0] !== namespace || typeof names[1] !== "string")
+              continue;
+            if (droppedTables.has(names[1]) || steps.some((step) => step.kind === "dropColumn" && step.table === names[1] && step.column === names[2]))
+              collateral = true;
+          }
+      }
+    }
+    if (dialect === "sqlite" && ownership === "unknown" && object.identity.kind === "generatedColumn" && invalid3.rebuilt.has(object.identity.table.name))
+      throw new VibeError24({ 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) => sqlObjectKey8({ identity }) === key);
+    if (removed && ownership === "migration")
+      throw new VibeError24({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
+    if (removed && ownership === "unknown" && object.backingConstraint === undefined)
+      unmanagedRemovals.push(object.identity);
+  }
+  const invalidated = new Set([...invalid3.rebuilt, ...invalid3.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 restore = new Map;
+  const preservedColumns = new Map;
+  const preservedDefaults = new Map;
+  if (invalid3.rebuilt.size > 0) {
+    const query = renderSqliteRebuildObjects({ dialect: sqliteDialect3 });
+    const rows = await executor({ text: query.text, values: [] });
+    const targetIndexes = normalizeSchema({ schema, dialect });
+    for (const row of rows) {
+      const table = String(row.tbl_name);
+      if (!invalid3.rebuilt.has(table) || typeof row.sql !== "string")
+        continue;
+      if (row.type === "index" && (steps.some((step) => step.kind === "dropIndex" && step.table === table && step.name === row.name) || [...targetIndexes.tables.get(table)?.indexes.values() ?? []].some((index) => index.name === row.name)))
+        continue;
+      const statements = restore.get(table) ?? [];
+      statements.push(row.sql);
+      restore.set(table, statements);
+    }
+    for (const object of protectedObjects) {
+      const identity = object.identity;
+      if (identity.kind !== "column" && identity.kind !== "columnDefault" && identity.kind !== "generatedColumn" || !invalid3.rebuilt.has(identity.table.name))
+        continue;
+      const live = await inspectSqlObject({ executor, dialect, identity });
+      if (live.state !== "present" || identity.kind !== "columnDefault" && typeof live.definition.facts.columnDefinition !== "string")
+        throw new VibeError24({ 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 VibeError24({ 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);
+      } else {
+        const columns = preservedColumns.get(identity.table.name) ?? new Map;
+        columns.set(identity.column, { sql: String(live.definition.facts.columnDefinition), generated: Number(live.definition.facts.generated) > 1 });
+        preservedColumns.set(identity.table.name, columns);
+      }
+    }
+  }
+  const preserved = dialect === "sqlite" ? sqlitePreservedSchema({ from: physical, to: schema, objects: protectedObjects }) : schema;
+  const target = { ...preserved, models: preserved.models.map((model) => ({ ...model, fields: model.fields.map((field) => {
+    const defaults = preservedDefaults.get(model.dbName ?? model.name);
+    const column = field.dbName ?? field.name;
+    if (!defaults?.has(column))
+      return field;
+    const { default: ignored, ...rest } = field;
+    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: target, sqliteRestore: restore, sqliteColumns: preservedColumns });
+  const sql2 = [
+    ...artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension") }),
+    ...core,
+    ...artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension" && !(artifact.owns.kind === "trigger" && invalid3.rebuilt.has(artifact.owns.table))) }),
+    ...creates
+  ];
+  if (sql2.length === 0) {
+    const definitions = [...params.previous?.definitions ?? []];
+    for (const object of objects)
+      if (object.expected !== undefined && !definitions.some((definition) => sqlObjectKey8({ identity: definition.identity }) === sqlObjectKey8({ 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((state2) => state2.reason === "dependency-inspection-unavailable" || state2.ownership !== "unknown" && state2.reason !== "legacy-definition-required" && (state2.state === "unavailable" || state2.state === "changed" || state2.state === "missing" && sql2.length === 0));
+  return { physical, from, namespace, steps, objects: states, unmanagedRemovals, blocked, sql: blocked ? [] : sql2 };
+}
+
+// packages/migrate/src/push.ts
 async function push(params) {
-  const { executor, schema } = params;
-  assertValidSchemaIR3({ schema });
-  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  assertValidSchemaIR4({ schema: params.schema });
+  const dialect = providerToDialect2({ provider: params.schema.datasource.provider });
   if (dialect !== "postgres")
     return pushChanges({ ...params, dialect });
-  await executor({ text: "BEGIN" });
+  await params.executor({ text: "BEGIN" });
   let committed = false;
   try {
     const result = await pushChanges({ ...params, dialect });
     if (params.dryRun !== true) {
-      await executor({ text: "COMMIT" });
+      await params.executor({ text: "COMMIT" });
       committed = true;
     }
     return result;
   } finally {
     if (!committed)
-      await executor({ text: "ROLLBACK" });
+      await params.executor({ text: "ROLLBACK" });
   }
 }
 async function pushChanges(params) {
   const { executor, schema, dialect } = params;
-  const artifacts = collectExtensionArtifacts({
+  const physical = dialect === "postgres" ? await introspectPostgres({ executor, rlsSchema: params.previousSchema ?? schema, inTransaction: true, requireInstalledRls: params.previousSchema !== undefined }) : undefined;
+  const plan = await planSchemaMigration({
+    executor,
     schema,
     dialect,
-    extensions: params.extensions ?? []
+    ...physical === undefined ? {} : { physical },
+    ...params.previousState === undefined ? {} : { previous: params.previousState },
+    ...params.extensions === undefined ? {} : { extensions: params.extensions },
+    ...params.probe === undefined ? {} : { probe: params.probe },
+    ...params.replaceChecks === undefined ? {} : { replaceChecks: params.replaceChecks }
   });
-  const allArtifacts = [...artifacts.setup, ...artifacts.objects];
-  const introspected = dialect === "postgres" ? await introspectPostgres({ executor, rlsSchema: params.previousSchema ?? schema, inTransaction: true, requireInstalledRls: params.previousSchema !== undefined }) : await introspectDialect({ executor, dialect });
-  const from = stripExtensionArtifacts({ schema: introspected, artifacts: allArtifacts });
-  const steps = diffSchemas({ from, to: schema, dialect });
+  const { steps, sql: sql2 } = plan;
   const securityChanges = securityChangesOf({ steps });
-  if (params.dryRun !== true)
-    assertSecurityAcknowledgement({ securityChanges, ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
+  if (params.dryRun === true)
+    return { steps, applied: [], planned: sql2, securityChanges, objects: plan.objects, blocked: plan.blocked, unmanagedRemovals: plan.unmanagedRemovals };
+  if (plan.blocked)
+    throw new VibeError25({ 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 (params.dryRun !== true && destructive.length > 0 && params.acceptDataLoss !== true) {
-    throw new VibeError16({
-      code: "VIBE_MIGRATION",
-      message: `push refused: ${destructive.length} destructive step(s) would lose data \u2014 pass acceptDataLoss: true to proceed:
-${destructive.map((step) => `  - ${describeStep({ step })}`).join(`
-`)}`,
-      meta: { destructive: destructive.map((step) => describeStep({ step })) }
-    });
-  }
-  const installed = await probeInstalledExtensionState({
-    executor,
+  if (destructive.length > 0 && params.acceptDataLoss !== true)
+    throw new VibeError25({ 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,
-    artifacts: allArtifacts
-  });
-  const invalid2 = dialect === "sqlite" ? sqliteInvalidatedTables({ steps, from }) : { rebuilt: new Set, dropped: new Set };
-  const invalidated = new Set([...invalid2.rebuilt, ...invalid2.dropped]);
-  const restoreSql = invalid2.rebuilt.size > 0 ? await captureUnownedSqliteTriggers({ executor, tables: invalid2.rebuilt, artifacts: allArtifacts }) : [];
-  const missing = planMissingArtifacts({
-    introspected,
-    artifacts: allArtifacts,
-    installed: forgetInvalidatedArtifacts({ installed, artifacts: allArtifacts, invalidated })
+    namespace: plan.namespace,
+    ...params.previousState === undefined ? {} : { previous: params.previousState },
+    ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss },
+    ...params.removeUnmanaged === undefined ? {} : { removeUnmanaged: params.removeUnmanaged }
   });
-  const setupSql = artifactCreateSql({
-    artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
-  });
-  const objectSql = artifactCreateSql({
-    artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
-  });
-  const coreSql = renderSteps({ steps, dialect, from, to: schema });
-  const sql2 = [...setupSql, ...coreSql, ...restoreSql, ...objectSql];
-  if (params.dryRun === true)
-    return { steps, applied: [], planned: sql2, securityChanges };
-  if (sql2.length === 0)
-    return { steps, applied: [] };
-  const wrap = dialect !== "postgres" && DIALECT_CAPABILITIES3[dialect].transactionalDdl && !usesSelfManagedTransactions({ sql: sql2 });
+  const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey9({ identity })));
+  const unapproved = plan.unmanagedRemovals.filter((identity) => !approved.has(sqlObjectKey9({ identity })));
+  if (unapproved.length > 0)
+    throw new VibeError25({ 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: sql2 });
   if (wrap)
     await executor({ text: "BEGIN" });
   try {
-    for (const statement of sql2) {
+    for (const statement of sql2)
       await executeStatement({ executor, statement, dialect });
-    }
+    if ((schema.migrationObjects?.length ?? 0) > 0)
+      assertMigrationState({ report: await verifyMigrationState({ executor, dialect, expected: createDesiredState({ schema: { ...schema, models: [] }, dialect }) }) });
     if (wrap)
       await executor({ text: "COMMIT" });
   } catch (error) {
@@ -5675,71 +7024,178 @@ ${destructive.map((step) => `  - ${describeStep({ step })}`).join(`
       try {
         await executor({ text: "ROLLBACK" });
       } catch {}
-    } else if (dialect === "sqlite") {
+    } else if (dialect === "sqlite")
       await cleanupSelfManagedFailure({ executor });
-    }
-    throw new VibeError16({
-      code: "VIBE_MIGRATION",
-      message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`,
-      meta: { statements: sql2 },
-      cause: error
-    });
+    throw new VibeError25({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql2 }, cause: error });
   }
-  return { steps, applied: sql2, ...securityChanges.length === 0 ? {} : { securityChanges } };
+  return { steps, applied: sql2, securityChanges, objects: plan.objects, desiredState: createDesiredState({ schema, dialect }) };
 }
-function forgetInvalidatedArtifacts(params) {
-  const { installed, artifacts, invalidated } = params;
-  if (invalidated.size === 0 || installed.triggers === undefined)
-    return installed;
-  const surviving = new Set(installed.triggers);
-  for (const artifact of artifacts) {
-    if (artifact.owns.kind !== "trigger")
+async function pull(params) {
+  switch (params.dialect ?? "postgres") {
+    case "postgres":
+      return introspectPostgres({ executor: params.executor });
+    case "sqlite":
+      return introspectSqlite({ executor: params.executor });
+    case "mysql":
+      return introspectMysql({ executor: params.executor });
+  }
+}
+// packages/migrate/src/reference-state.ts
+import { VibeError as VibeError26, sqlObjectKey as sqlObjectKey10 } 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((identity2) => [sqlObjectKey10({ identity: identity2 }), identity2])).values()) {
+    if (!params.schema.migrationObjects?.some((object) => sqlObjectKey10({ identity: object.identity }) === sqlObjectKey10({ identity })) && !(identity.kind === "constraint" && identity.constraintType === "check"))
       continue;
-    if (invalidated.has(artifact.owns.table))
-      surviving.delete(artifact.owns.name);
+    const result = await inspectSqlObject({ executor: params.referenceExecutor, dialect: params.dialect, identity });
+    if (result.state !== "present")
+      throw new VibeError26({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
+    definitions.push(result.definition);
+  }
+  return createDesiredState({ schema: params.schema, dialect: params.dialect, definitions });
+}
+// packages/migrate/src/compile-desired-state.ts
+import { VibeError as VibeError27 } from "@vibeorm/schema";
+import { renderExclusionSetup, getSqlDialect as getSqlDialect5, renderMigrationServerVersion } from "@vibeorm/sql";
+async function compileDesiredState(params) {
+  if (params.dialect !== "postgres")
+    throw new VibeError27({ 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 VibeError27({ 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 {
+    const newObjects = params.steps.filter((step) => step.kind === "createTable" || step.kind === "createEnum" || step.kind === "addEnumValue");
+    for (const text of renderSteps({ steps: newObjects, dialect: "postgres" }))
+      await params.executor({ text });
+    const models = [];
+    for (const model of params.schema.models) {
+      const table = { namespace: "public", name: model.dbName ?? model.name };
+      const exclusions = [];
+      for (const exclusion of model.exclusions ?? []) {
+        for (const text of renderExclusionSetup({ dialect: getSqlDialect5({ dialect: "postgres" }), exclusion }))
+          await params.executor({ text });
+        exclusions.push({ ...exclusion, normalizationSource: exclusion.definition, normalizedDefinition: await deparseExclusion({ executor: params.executor, table: table.name, definition: exclusion.definition }) });
+      }
+      models.push({ ...model, ...exclusions.length ? { exclusions } : {} });
+      for (const check of model.checks ?? [])
+        definitions.push(await deparsePostgresCheckDefinition({ executor: params.executor, table, expression: check.expression, constraint: check.name, probe: "rollback" }));
+    }
+    const query = renderMigrationServerVersion({ dialect: getSqlDialect5({ dialect: params.dialect }) });
+    const version = (await params.executor({ text: query.text, values: [] }))[0]?.version;
+    if (typeof version !== "string")
+      throw new VibeError27({ 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" });
+    await params.executor({ text: "RELEASE SAVEPOINT vibeorm_desired_state" });
   }
-  return { ...installed, triggers: surviving };
 }
-async function captureUnownedSqliteTriggers(params) {
-  const { executor, tables, artifacts } = params;
-  const owned = new Set(artifacts.flatMap((artifact) => artifact.owns.kind === "trigger" ? [artifact.owns.name] : []));
-  const rows = await executor(renderDiagnostic({ dialect: sqliteDialect3, query: "sqliteTriggers" }));
-  return rows.filter((row) => tables.has(String(row["tbl_name"])) && !owned.has(String(row["name"])) && typeof row["sql"] === "string").map((row) => `${String(row["sql"]).trimEnd().replace(/;$/, "")};`);
+// packages/migrate/src/history.ts
+import { VibeError as VibeError28 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect6, renderMigrationHistoryQuery } from "@vibeorm/sql";
+var MISSING_TABLE_IDENTIFIERS = new Set(["42P01", "42S02", "ER_NO_SUCH_TABLE"]);
+function isMissingTable(params) {
+  let current = params.cause;
+  for (let depth = 0;depth < 6 && current !== null && typeof current === "object"; depth++) {
+    const record2 = current;
+    for (const key of ["code", "errno", "sqlState"]) {
+      const value = record2[key];
+      if (typeof value === "string" && MISSING_TABLE_IDENTIFIERS.has(value))
+        return true;
+    }
+    current = record2.cause;
+  }
+  return false;
 }
-async function pull(params) {
-  return introspectDialect({ executor: params.executor, dialect: params.dialect ?? "postgres" });
+async function readMigrationHistory(params) {
+  const namespace = await migrationNamespace({ executor: params.executor, dialect: params.dialect });
+  if (params.dialect === "sqlite") {
+    const presence = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity: { kind: "table", name: { namespace, name: "_vibe_migrations" } } });
+    if (presence.state === "missing")
+      return { tablePresent: false, recorded: [] };
+    if (presence.state === "unavailable")
+      throw new VibeError28({ code: "VIBE_MIGRATION", message: "Migration history inspection unavailable", meta: { reason: "history-unavailable" } });
+  }
+  const query = renderMigrationHistoryQuery({ dialect: getSqlDialect6({ dialect: params.dialect }), namespace });
+  const rows = await params.executor({ text: query.text, values: [] }).catch((cause) => {
+    if (isMissingTable({ cause }))
+      return;
+    throw new VibeError28({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
+  });
+  if (rows === undefined)
+    return { tablePresent: false, recorded: [] };
+  const byName = new Map(params.migrations.map((migration) => [migration.name, migration]));
+  const recorded = [];
+  for (const row of rows) {
+    if (typeof row.name !== "string" || typeof row.checksum !== "string" || !Number.isSafeInteger(Number(row.statement_index)))
+      throw new VibeError28({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
+    const migration = byName.get(row.name);
+    const statementIndex = Number(row.statement_index);
+    recorded.push({ name: row.name, checksum: row.checksum, statementIndex, state: migration === undefined ? "unknown-file" : row.checksum !== migrationChecksum(migration) ? "mismatched" : statementIndex < 0 ? "rolling-back" : statementIndex < migration.sql.length || row.error !== null && row.error !== undefined ? "partial" : "applied" });
+  }
+  return { tablePresent: true, recorded };
+}
+// packages/migrate/src/adoption.ts
+import { VibeError as VibeError29 } from "@vibeorm/schema";
+async function adoptMigration(params) {
+  const report = await verifyMigrationState({ executor: params.executor, expected: params.reference, dialect: params.dialect });
+  assertMigrationState({ report });
+  return {
+    name: params.name,
+    sql: [],
+    downSql: [],
+    destructive: false,
+    desiredState: { version: 1, dialect: params.dialect, from: params.reference, to: params.reference }
+  };
 }
-async function introspectDialect(params) {
-  const { executor, dialect } = params;
-  switch (dialect) {
-    case "postgres":
-      return introspectPostgres({ executor });
-    case "sqlite":
-      return introspectSqlite({ executor });
-    case "mysql":
-      return introspectMysql({ executor });
+function deployedDesiredState(params) {
+  for (const row of params.recorded) {
+    if (row.state !== "applied" || row.checksum === "")
+      throw new VibeError29({ 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 VibeError29({ 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));
+  if (last !== undefined && last.desiredState === undefined && params.migrations.some((migration) => applied.has(migration.name) && migration.desiredState !== undefined))
+    throw new VibeError29({ code: "VIBE_MIGRATION", message: "A later metadata-free migration invalidates the earlier desired-state baseline; adopt an independent current reference", meta: { reason: "desired-state-history-unverified", migration: last.name } });
+  return last?.desiredState?.to;
 }
 export {
+  verifyMigrationState,
   stripExtensionArtifacts,
   serializeExecutionSidecar,
+  serializeDesiredStateSidecar,
+  schemaObjectIdentities,
   rollbackMigration,
   resolveMigration,
   renderSteps,
+  removalIdentity,
   recordedMigrations,
+  readMigrationHistory,
   push,
   pull,
   probeInstalledExtensionState,
+  prepareCheckDiff,
+  planSchemaMigration,
   planRenames,
   planMissingArtifacts,
   parseExecutionSidecar,
+  parseDesiredStateSidecar,
   operationFor,
   migrationStatus,
+  migrationNamespace,
   migrationChecksum,
+  legacyMigrationObjects,
   isDefaultExecution,
   introspectSqlite,
   introspectPostgres,
   introspectMysql,
+  inspectSqlObject,
+  inspectMigrationInventory,
   generateMigration,
   generateDownMigration,
   executionChecksumSuffix,
@@ -5750,13 +7206,26 @@ export {
   describeStep,
   describeOperation,
   describeMigrationRisks,
+  deployedDesiredState,
+  deparsePostgresCheckDefinition,
+  deparsePostgresCheck,
+  deparseMysqlCheck,
+  createDesiredState,
+  compileDesiredState,
   collectExtensionArtifacts,
+  captureMigrationReference,
   assertValidExecution,
+  assertRemovalAuthorization,
+  assertProbeMode,
+  assertMigrationState,
   artifactCreateSql,
   applyMigrations,
+  adoptMigration,
+  UNFINALIZED_DESIRED_STATE,
   MIGRATIONS_TABLE_NAME,
   EXECUTION_SIDECAR_VERSION,
-  EXECUTION_SIDECAR_FILENAME
+  EXECUTION_SIDECAR_FILENAME,
+  DESIRED_STATE_METADATA
 };
 
-//# debugId=A821378E4DC91CC064756E2164756E21
+//# debugId=EA05FB5D6F27037864756E2164756E21