@vibeorm/migrate 2.3.0 → 2.4.0

package/dist/index.js

@@ -307,10 +307,10 @@ import { VibeError as VibeError18, sqlObjectKey as sqlObjectKey6 } from "@vibeor
 import { getSqlDialect as getSqlDialect3, renderModuleDependencyQuery } from "@vibeorm/sql";
 
 // packages/migrate/src/object-ownership.ts
-import { VibeError as VibeError7, sqlObjectKey as sqlObjectKey2, enumStorageOf as enumStorageOf2 } from "@vibeorm/schema";
+import { VibeError as VibeError7, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, sqlObjectKey as sqlObjectKey2 } from "@vibeorm/schema";
 
 // packages/migrate/src/normalize.ts
-import { VibeError as VibeError6, enumStorageOf, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { VibeError as VibeError6, defaultForeignKeyName, defaultIndexName, enumStorageOf, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 
 // packages/migrate/src/relations.ts
 import { implicitJoinTable, isImplicitManyToManyRelation } from "@vibeorm/schema";
@@ -360,6 +360,49 @@ var SCALAR_TO_PG = {
 var CANONICAL_EQUIVALENTS = {
   DateTime: ["timestamptz(3)", "timestamptz(6)"]
 };
+var CANONICAL_UDT = {
+  text: "String",
+  bool: "Boolean",
+  int4: "Int",
+  int8: "BigInt",
+  float8: "Float",
+  numeric: "Decimal",
+  timestamptz: "DateTime",
+  jsonb: "Json",
+  bytea: "Bytes"
+};
+var NON_CANONICAL_UDT = {
+  varchar: "String",
+  bpchar: "String",
+  uuid: "String",
+  bit: "String",
+  varbit: "String",
+  xml: "String",
+  inet: "String",
+  citext: "String",
+  int2: "Int",
+  oid: "Int",
+  float4: "Float",
+  money: "Decimal",
+  timestamp: "DateTime",
+  date: "DateTime",
+  time: "DateTime",
+  timetz: "DateTime",
+  json: "Json"
+};
+var SPELLING_TO_UDT = {
+  integer: "int4",
+  bigint: "int8",
+  smallint: "int2",
+  boolean: "bool",
+  doubleprecision: "float8",
+  real: "float4",
+  char: "bpchar"
+};
+function scalarForBuiltinType(params) {
+  const udt = SPELLING_TO_UDT[params.name] ?? params.name;
+  return CANONICAL_UDT[udt] ?? NON_CANONICAL_UDT[udt];
+}
 var NATIVE_ALIASES = {
   charactervarying: "varchar",
   character: "char",
@@ -379,7 +422,11 @@ var NATIVE_ALIASES = {
   timestampwithtimezone: "timestamptz",
   timestampwithouttimezone: "timestamp",
   timewithtimezone: "timetz",
-  timewithouttimezone: "time"
+  timewithouttimezone: "time",
+  bitvarying: "varbit"
+};
+var IMPLICIT_MODIFIERS = {
+  bit: "(1)"
 };
 function normalizeNativeType(params) {
   const compact = params.raw.toLowerCase().replace(/\s+/g, "");
@@ -387,7 +434,7 @@ function normalizeNativeType(params) {
   if (match === null)
     return compact;
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
-  return `${base}${match[2] ?? ""}${match[3] ?? ""}`;
+  return `${base}${match[2] ?? IMPLICIT_MODIFIERS[base] ?? ""}${match[3] ?? ""}`;
 }
 function parseUnsupportedPostgresType(params) {
   const temporal = /^\s*(time(?:stamp)?)\s*(\(\s*\d+\s*\))?\s+(with|without)\s+time\s+zone\s*((?:\[\s*\]\s*)*)$/i.exec(params.raw);
@@ -408,6 +455,11 @@ function columnTypeKey(params) {
       return `u:${field.nativeType ?? ""}`;
     const evidence = field.nativeTypeIdentity;
     const namespace = evidence !== undefined && evidence.source === field.nativeType ? evidence.namespace : parsed.namespace;
+    const scalar = namespace === undefined || namespace === "pg_catalog" ? scalarForBuiltinType({ name: parsed.name }) : undefined;
+    if (scalar !== undefined) {
+      const { isUnsupported: _unsupported, nativeTypeIdentity: _identity, ...rest } = field;
+      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList } });
+    }
     return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
   if (isEnumType(field.type)) {
@@ -496,8 +548,12 @@ function defaultFingerprint(params) {
     }
     case "enumValue":
       return `enum:${def.value}`;
-    case "dbgenerated":
-      return `db:${def.sql.trim()}`;
+    case "dbgenerated": {
+      const sql = def.sql.trim();
+      if (/^now\(\)$/i.test(sql) || /^current_timestamp(\(\d\))?$/i.test(sql))
+        return "now";
+      return `db:${sql}`;
+    }
   }
 }
 function defaultSql(params) {
@@ -988,8 +1044,8 @@ function normalizeModel(params) {
     });
   }
   const pk = normalizePk({ model });
-  const indexes = normalizeIndexes({ model, table });
-  const fks = normalizeFks({ model, table, schema });
+  const indexes = normalizeIndexes({ model, table, dialect });
+  const fks = normalizeFks({ model, table, schema, dialect });
   const checks = new Map;
   for (const check of model.checks ?? [])
     checks.set(check.name, check.expression);
@@ -1003,7 +1059,7 @@ function normalizePk(params) {
   return model.fields.filter((field) => field.isId).map((field) => field.dbName ?? field.name);
 }
 function normalizeIndexes(params) {
-  const { model, table } = params;
+  const { model, table, dialect } = params;
   const result = new Map;
   const add = (index) => {
     const unique = index.kind === "unique";
@@ -1022,7 +1078,7 @@ function normalizeIndexes(params) {
     const key = indexComparisonKey({ unique, kind, columns, where, nullsNotDistinct });
     if (result.has(key))
       return;
-    const name = index.name ?? `${table}_${columns.map((column) => column.name).join("_")}_${unique ? "key" : "idx"}`;
+    const name = index.name ?? defaultIndexName({ table, columns: columns.map((column) => column.name), unique, dialect });
     result.set(key, {
       key,
       name,
@@ -1228,7 +1284,7 @@ function normalizeFks(params) {
       continue;
     result.set(key, {
       key,
-      constraintName: relation.constraintName ?? `${table}_${columns.join("_")}_fkey`,
+      constraintName: relation.constraintName ?? defaultForeignKeyName({ table, columns, dialect: params.dialect }),
       columns,
       refTable,
       refColumns,
@@ -1371,7 +1427,7 @@ function removalIdentity(params) {
     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` };
+      return { kind: "constraint", constraintType: "primaryKey", table, name: step.constraintName ?? defaultPrimaryKeyName({ table: step.table, dialect: "postgres" }) };
     default:
       return;
   }
@@ -1390,7 +1446,7 @@ function schemaObjectIdentities(params) {
       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` } });
+        result.push({ kind: "sequence", name: { namespace: params.namespace, name: postgresGeneratedObjectName({ name1: name, name2: column, label: "seq" }) } });
     }
     for (const exclusion of model.model.exclusions ?? [])
       result.push({ kind: "constraint", constraintType: "exclusion", table, name: exclusion.name });
@@ -1404,15 +1460,15 @@ function schemaObjectIdentities(params) {
     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`) });
+      result.push({ kind: "constraint", constraintType: "primaryKey", table, name: model.model.primaryKeyConstraintName ?? (params.dialect === "mysql" ? "PRIMARY" : defaultPrimaryKeyName({ table: name, dialect: params.dialect })) });
   }
   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}` });
+    const derived = implicitJoinTableObjectNames({ table: name });
+    result.push({ kind: "column", table, column: "A" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyA });
+    result.push({ kind: "column", table, column: "B" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyB });
+    result.push({ kind: "index", table, name: derived.uniqueIndex }, { kind: "index", table, name: derived.indexB });
   }
   for (const name of normalized.views.keys())
     result.push({ kind: "view", name: { namespace: params.namespace, name } });
@@ -1487,7 +1543,7 @@ function assertRemovalAuthorization(params) {
 }
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError17, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
+import { VibeError as VibeError17, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/exclusions.ts
@@ -2233,18 +2289,17 @@ async function introspectPostgres(params) {
   if (params.inTransaction !== true)
     await executor({ text: "BEGIN" });
   try {
-    const savedPath = params.inTransaction === true ? await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "readSearchPath" })) : undefined;
-    const searchPath = savedPath?.[0]?.searchPath;
-    if (params.inTransaction === true && typeof searchPath !== "string")
+    const savedPath = await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "readSearchPath" }));
+    const searchPath = savedPath[0]?.searchPath;
+    if (typeof searchPath !== "string")
       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 VibeError13)
         throw 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 });
     });
+    await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
     const physical = await introspectPhysicalPostgres({ executor });
-    if (typeof searchPath === "string")
-      await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
     return projectPostgresRls({ physical, ...params.rlsSchema === undefined ? {} : { declared: params.rlsSchema }, matched });
   } finally {
     if (params.inTransaction !== true)
@@ -2521,27 +2576,6 @@ function buildField(params) {
     ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
   };
 }
-var CANONICAL_UDT = {
-  text: "String",
-  bool: "Boolean",
-  int4: "Int",
-  int8: "BigInt",
-  float8: "Float",
-  numeric: "Decimal",
-  timestamptz: "DateTime",
-  jsonb: "Json",
-  bytea: "Bytes"
-};
-var NON_CANONICAL_UDT = {
-  varchar: "String",
-  bpchar: "String",
-  uuid: "String",
-  int2: "Int",
-  float4: "Float",
-  timestamp: "DateTime",
-  date: "DateTime",
-  json: "Json"
-};
 function reverseMapType(params) {
   const { column, enumNames } = params;
   const isList = column.dataType === "ARRAY";
@@ -2597,8 +2631,10 @@ function withModifier(params) {
   }
   if (udt === "bpchar")
     return "char";
-  if (udt === "timestamp" && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
-    return `timestamp(${column.datetimePrecision})`;
+  if ((udt === "bit" || udt === "varbit") && column.charMaxLength !== null)
+    return `${udt}(${column.charMaxLength})`;
+  if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
+    return `${udt}(${column.datetimePrecision})`;
   }
   return udt;
 }
@@ -4348,7 +4384,7 @@ async function inspectMigrationInventory(params) {
       for (const constraint of clauses) {
         if (constraint.type === "check")
           continue;
-        const name = constraint.named ? constraint.name : constraint.type === "primaryKey" ? `${qualified.name}_pkey` : constraint.type === "foreignKey" ? `${qualified.name}_${constraint.columns.join("_")}_fkey` : constraint.name;
+        const name = constraint.named ? constraint.name : constraint.type === "primaryKey" ? defaultPrimaryKeyName2({ table: qualified.name, dialect: "sqlite" }) : constraint.type === "foreignKey" ? defaultForeignKeyName2({ table: qualified.name, columns: constraint.columns, dialect: "sqlite" }) : constraint.name;
         objects.push({ identity: { kind: "constraint", constraintType: constraint.type, table: qualified, name }, ...constraint.type === "unique" && !constraint.named ? { inspectionUnavailable: "sqlite-anonymous-unique-constraint" } : {} });
       }
       const checks = parseSqliteNamedChecks({ tableSql: row.definition });
@@ -4359,7 +4395,7 @@ async function inspectMigrationInventory(params) {
       const query = renderSqliteColumnInventory2({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const columns = await params.executor({ text: query.text, values: [...query.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` } });
+        objects.push({ identity: { kind: "constraint", constraintType: "primaryKey", table: qualified, name: defaultPrimaryKeyName2({ table: qualified.name, dialect: "sqlite" }) } });
       const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const foreignKeys = await params.executor({ text: fkQuery.text, values: [...fkQuery.values] });
       const groups = new Map;
@@ -4368,7 +4404,7 @@ async function inspectMigrationInventory(params) {
       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" });
+        objects.push({ identity: { kind: "constraint", constraintType: "foreignKey", table: qualified, name: defaultForeignKeyName2({ table: qualified.name, columns: fields, dialect: "sqlite" }) }, inspectionUnavailable: "sqlite-inline-foreign-key-definition-unavailable" });
       }
       for (const column of columns) {
         objects.push({ identity: { kind: "column", table: qualified, column: String(column.name) } });
@@ -5641,7 +5677,7 @@ import { VibeError as VibeError31, sqlObjectKey as sqlObjectKey9 } from "@vibeor
 
 // packages/migrate/src/ddl/postgres.ts
 import { renderExclusionSetup } from "@vibeorm/sql";
-import { VibeError as VibeError28, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { VibeError as VibeError28, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect8, renderRlsPolicyPath } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
@@ -5713,7 +5749,7 @@ function renderStep(params) {
       const lines = step.columns.map((column) => `  ${columnDefSql({ field: column })}`);
       if (step.primaryKey.length > 0) {
         const pkCols = step.primaryKey.map((column) => q2(column)).join(", ");
-        lines.push(`  CONSTRAINT ${q2(step.primaryKeyConstraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
+        lines.push(`  CONSTRAINT ${q2(step.primaryKeyConstraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${pkCols})`);
       }
       for (const check of step.checks ?? []) {
         lines.push(`  CONSTRAINT ${q2(check.name)} CHECK (${check.expression})`);
@@ -5786,25 +5822,26 @@ ${lines.join(`,
     case "createJoinTable": {
       const aType = columnTypeSql({ field: { ...step.a.field, isList: false } });
       const bType = columnTypeSql({ field: { ...step.b.field, isList: false } });
+      const names = implicitJoinTableObjectNames2({ table: step.table });
       return [
         `CREATE TABLE ${publicName(step.table)} (
   "A" ${aType} NOT NULL,
   "B" ${bType} NOT NULL
 );`,
-        `CREATE UNIQUE INDEX ${q2(`${step.table}_AB_unique`)} ON ${publicName(step.table)} ("A", "B");`,
-        `CREATE INDEX ${q2(`${step.table}_B_index`)} ON ${publicName(step.table)} ("B");`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${publicName(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${publicName(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+        `CREATE UNIQUE INDEX ${q2(names.uniqueIndex)} ON ${publicName(step.table)} ("A", "B");`,
+        `CREATE INDEX ${q2(names.indexB)} ON ${publicName(step.table)} ("B");`,
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${publicName(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${publicName(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
       ];
     }
     case "addPrimaryKey": {
       const cols = step.columns.map((column) => q2(column)).join(", ");
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${cols});`
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${cols});`
       ];
     }
     case "dropPrimaryKey":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName ?? `${step.table}_pkey`)};`];
+      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))};`];
   }
 }
 function columnDefSql(params) {
@@ -5866,7 +5903,7 @@ function q2(name) {
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError29, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError29, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -6064,12 +6101,13 @@ function renderSqliteSteps(params) {
       case "createJoinTable": {
         const aType = sqliteStorageType({ field: { ...step.a.field, isList: false } });
         const bType = sqliteStorageType({ field: { ...step.b.field, isList: false } });
+        const names = implicitJoinTableObjectNames3({ table: step.table });
         statements.push(`CREATE TABLE ${q3(step.table)} (
   "A" ${aType} NOT NULL,
   "B" ${bType} NOT NULL,
-  CONSTRAINT ${q3(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${q3(step.a.table)} (${q3(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE,
-  CONSTRAINT ${q3(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${q3(step.b.table)} (${q3(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE
-);`, `CREATE UNIQUE INDEX ${q3(`${step.table}_AB_unique`)} ON ${q3(step.table)} ("A", "B");`, `CREATE INDEX ${q3(`${step.table}_B_index`)} ON ${q3(step.table)} ("B");`);
+  CONSTRAINT ${q3(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${q3(step.a.table)} (${q3(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT ${q3(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${q3(step.b.table)} (${q3(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE
+);`, `CREATE UNIQUE INDEX ${q3(names.uniqueIndex)} ON ${q3(step.table)} ("A", "B");`, `CREATE INDEX ${q3(names.indexB)} ON ${q3(step.table)} ("B");`);
         break;
       }
       case "addColumn":
@@ -6435,7 +6473,7 @@ function q3(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError30, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError30, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect3 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps) {
@@ -6614,15 +6652,16 @@ ${lines.join(`,
     case "createJoinTable": {
       const aType = mysqlColumnTypeSql({ field: { ...step.a.field, isList: false }, enums });
       const bType = mysqlColumnTypeSql({ field: { ...step.b.field, isList: false }, enums });
+      const names = implicitJoinTableObjectNames4({ table: step.table });
       return [
         `CREATE TABLE ${q4(step.table)} (
   \`A\` ${aType} NOT NULL,
   \`B\` ${bType} NOT NULL
 );`,
-        `CREATE UNIQUE INDEX ${q4(`${step.table}_AB_unique`)} ON ${q4(step.table)} (\`A\`, \`B\`);`,
-        `CREATE INDEX ${q4(`${step.table}_B_index`)} ON ${q4(step.table)} (\`B\`);`,
-        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(`${step.table}_A_fkey`)} FOREIGN KEY (\`A\`) REFERENCES ${q4(step.a.table)} (${q4(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
-        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(`${step.table}_B_fkey`)} FOREIGN KEY (\`B\`) REFERENCES ${q4(step.b.table)} (${q4(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+        `CREATE UNIQUE INDEX ${q4(names.uniqueIndex)} ON ${q4(step.table)} (\`A\`, \`B\`);`,
+        `CREATE INDEX ${q4(names.indexB)} ON ${q4(step.table)} (\`B\`);`,
+        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(names.foreignKeyA)} FOREIGN KEY (\`A\`) REFERENCES ${q4(step.a.table)} (${q4(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(names.foreignKeyB)} FOREIGN KEY (\`B\`) REFERENCES ${q4(step.b.table)} (${q4(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
       ];
     }
     case "addPrimaryKey":
@@ -8395,11 +8434,61 @@ async function compareReplayMigrationObjects(params) {
   return { ...params.schema, migrationObjects: objects.map((object) => ({ ...object, expected: definitions.get(sqlObjectKey11({ identity: object.identity })) })) };
 }
 // packages/migrate/src/replay-plan.ts
-import { VibeError as VibeError38, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
+import { VibeError as VibeError39, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
 
 // packages/migrate/src/planner.ts
-import { VibeError as VibeError37, sqlObjectKey as sqlObjectKey12 } from "@vibeorm/schema";
+import { VibeError as VibeError38, sqlObjectKey as sqlObjectKey12 } from "@vibeorm/schema";
 import { renderSqliteRebuildObjects, sqliteDialect as sqliteDialect4 } from "@vibeorm/sql";
+
+// packages/migrate/src/index-predicates.ts
+import { VibeError as VibeError37 } from "@vibeorm/schema";
+import { defaultIndexName as defaultIndexName2 } from "@vibeorm/schema";
+function physicalIndexName(params) {
+  return params.index.name ?? defaultIndexName2({ table: params.table, columns: params.columns, unique: params.index.kind === "unique", dialect: "postgres" });
+}
+async function prepareIndexPredicateDiff(params) {
+  if (params.probe !== "rollback")
+    return params.from;
+  const models = [];
+  for (const live of params.from.models) {
+    const table = live.dbName ?? live.name;
+    const authored = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    if (authored === undefined || !live.indexes.some((index) => index.where !== undefined)) {
+      models.push(live);
+      continue;
+    }
+    const authoredByName = new Map;
+    for (const index of authored.indexes) {
+      const columns = index.fields.map((entry) => authored.fields.find((candidate) => candidate.name === entry.name)?.dbName ?? entry.name);
+      authoredByName.set(physicalIndexName({ index, table, columns }), index);
+    }
+    const indexes = [];
+    for (const index of live.indexes) {
+      const next = index.name === undefined ? undefined : authoredByName.get(index.name);
+      if (index.where === undefined || next?.where === undefined || next.where === index.where) {
+        indexes.push(index);
+        continue;
+      }
+      const deparsed = await deparseIndexPredicate({ executor: params.executor, table: { namespace: params.namespace, name: table }, where: next.where });
+      indexes.push(deparsed === index.where ? { ...index, where: next.where } : index);
+    }
+    models.push({ ...live, indexes });
+  }
+  return { ...params.from, models };
+}
+async function deparseIndexPredicate(params) {
+  try {
+    const definition = await deparsePostgresCheck({ executor: params.executor, table: params.table, expression: params.where, probe: "rollback" });
+    const match = /^CHECK \((.*)\)$/s.exec(definition);
+    return match === null ? undefined : match[1];
+  } catch (error) {
+    if (error instanceof VibeError37 && error.code === "VIBE_MIGRATION")
+      throw error;
+    return;
+  }
+}
+
+// packages/migrate/src/planner.ts
 async function planSchemaMigration(params) {
   const { executor, dialect } = params;
   const resolved = dialect === "postgres" ? await resolvePostgresTypeIdentities({ executor, schema: params.schema, ...params.previous === undefined ? {} : { previous: params.previous.schema }, mode: "verify" }) : { schema: params.schema, unavailable: [] };
@@ -8412,7 +8501,7 @@ async function planSchemaMigration(params) {
   assertRetainedMigrationObjects({ from: params.previous?.schema.migrationObjects ?? [], to: objects });
   for (const object of objects)
     if (object.dialect !== dialect)
-      throw new VibeError37({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}`, meta: { feature: "migrationObject", dialect } });
+      throw new VibeError38({ 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 } }) });
@@ -8421,7 +8510,7 @@ async function planSchemaMigration(params) {
     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 VibeError37({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
+    throw new VibeError38({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
   }
   const states = resolved.unavailable.map((identity) => {
     const exists = identity.kind === "column" && [physical, params.previous?.schema].some((source) => source?.models.some((model) => (model.dbName ?? model.name) === identity.table.name && model.fields.some((field) => (field.dbName ?? field.name) === identity.column)));
@@ -8452,7 +8541,7 @@ async function planSchemaMigration(params) {
   }
   for (const object of legacyObjects) {
     if (objects.some((entry) => sqlObjectKey12({ identity: entry.identity }) === sqlObjectKey12({ identity: object.identity })))
-      throw new VibeError37({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
+      throw new VibeError38({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
     const expected = object.expected ?? params.previous?.definitions.find((entry) => sqlObjectKey12({ identity: entry.identity }) === sqlObjectKey12({ identity: object.identity }));
     if (expected === undefined)
       states.push({ identity: object.identity, ownership: "migration", state: "unavailable", reason: "legacy-definition-required", differences: [] });
@@ -8467,7 +8556,8 @@ async function planSchemaMigration(params) {
   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 exclusionsPrepared = await prepareExclusionDiff({ ...params, from: checked, to: schema });
+  const from = dialect === "postgres" ? await prepareIndexPredicateDiff({ executor, from: exclusionsPrepared, to: schema, namespace, ...params.probe === undefined ? {} : { probe: params.probe } }) : exclusionsPrepared;
   const steps = diffSchemas({ from, to: schema, dialect });
   const known = new Set(schemaObjectIdentities({ schema: params.previous?.schema ?? schema, dialect, namespace }).map((identity) => sqlObjectKey12({ identity })));
   const declaredIndexes = normalizeSchema({ schema: params.previous?.schema ?? schema, dialect });
@@ -8494,7 +8584,7 @@ async function planSchemaMigration(params) {
     if (object.inspectionUnavailable !== undefined)
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: object.inspectionUnavailable, differences: [] });
     if (object.inspectionUnavailable !== undefined && invalid.rebuilt.has("table" in object.identity ? object.identity.table.name : object.identity.name.name))
-      throw new VibeError37({ code: "VIBE_MIGRATION", message: "SQLite rebuild cannot discard an unrepresented constraint; declare its independent definition or use a reviewed migration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+      throw new VibeError38({ 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);
@@ -8513,7 +8603,7 @@ async function planSchemaMigration(params) {
           for (const address of addresses) {
             const value = JSON.parse(String(address));
             if (!Array.isArray(value) || !Array.isArray(value[2]))
-              throw new VibeError37({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
+              throw new VibeError38({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
             const names = value[2];
             if (names[0] !== namespace || typeof names[1] !== "string")
               continue;
@@ -8523,10 +8613,10 @@ async function planSchemaMigration(params) {
       }
     }
     if (dialect === "sqlite" && ownership === "unknown" && object.identity.kind === "generatedColumn" && invalid.rebuilt.has(object.identity.table.name))
-      throw new VibeError37({ code: "VIBE_MIGRATION", message: "SQLite generated-column preservation requires an independent ownership declaration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+      throw new VibeError38({ 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) => sqlObjectKey12({ identity }) === key);
     if (removed && ownership === "migration")
-      throw new VibeError37({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
+      throw new VibeError38({ 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);
   }
@@ -8560,11 +8650,11 @@ async function planSchemaMigration(params) {
         continue;
       const live = await inspectSqlObject({ executor, dialect, identity });
       if (live.state !== "present" || identity.kind !== "columnDefault" && typeof live.definition.facts.columnDefinition !== "string")
-        throw new VibeError37({ code: "VIBE_MIGRATION", message: "Cannot read the verified SQLite column definition for preservation", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError38({ 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 VibeError37({ code: "VIBE_MIGRATION", message: "Cannot preserve SQLite default", meta: { identity } });
+          throw new VibeError38({ 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);
@@ -8647,24 +8737,24 @@ async function planReplayMigration(params) {
   const retainedObjects = reference.inventory.filter((object) => !declared.has(sqlObjectKey13({ identity: object.identity })) && !removals.has(sqlObjectKey13({ identity: object.identity })) && (object.identity.kind === "function" || object.identity.kind === "trigger" || historicalObjects.has(sqlObjectKey13({ identity: object.identity })))).map((object) => object.identity);
   const removedRegistrations = [...historicalObjects].filter(([key]) => present.has(key) && !declared.has(key)).map(([, identity]) => identity);
   if (removedRegistrations.length > 0)
-    throw new VibeError38({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
+    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
   return { ...plan, requiredRemovals: [...removals.values()], retainedObjects, securityChanges: securityChangesOf({ steps: plan.steps }), replayRemovals: params.migrations.flatMap((migration) => migration.desiredState?.unmanagedRemovals ?? []) };
 }
 function assertReplayRemovals(params) {
   const wanted = new Set([...params.plan.requiredRemovals, ...params.plan.replayRemovals].map((identity) => sqlObjectKey13({ identity })));
   const keys = params.approved.map((identity) => sqlObjectKey13({ identity }));
   if (new Set(keys).size !== keys.length)
-    throw new VibeError38({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
+    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
   const unused = params.approved.filter((identity) => !wanted.has(sqlObjectKey13({ identity })));
   if (unused.length > 0)
-    throw new VibeError38({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
+    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
   assertNamedRemovals({ removals: params.plan.requiredRemovals, approved: params.approved, acceptIntegrityLoss: params.acceptIntegrityLoss });
 }
 // packages/migrate/src/baseline.ts
-import { VibeError as VibeError43, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
+import { VibeError as VibeError44, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
 
 // packages/migrate/src/reference-state.ts
-import { VibeError as VibeError39, sqlObjectKey as sqlObjectKey14 } from "@vibeorm/schema";
+import { VibeError as VibeError40, sqlObjectKey as sqlObjectKey14 } 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)];
@@ -8674,14 +8764,14 @@ async function captureMigrationReference(params) {
       continue;
     const result = await inspectSqlObject({ executor: params.referenceExecutor, dialect: params.dialect, identity });
     if (result.state !== "present")
-      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
+      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
     definitions.push(result.definition);
   }
   let schema = params.schema;
   if (params.dialect === "postgres" && schema.models.some((model) => model.fields.some((field) => field.isUnsupported === true))) {
     const resolved = await resolvePostgresTypeIdentities({ executor: params.referenceExecutor, schema, mode: "reference" });
     if (resolved.unavailable.length > 0)
-      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
+      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
     const physical = await introspectPhysicalPostgres({ executor: params.referenceExecutor });
     for (const model of resolved.schema.models)
       for (const field of model.fields) {
@@ -8689,7 +8779,7 @@ async function captureMigrationReference(params) {
           continue;
         const actual = physical.models.find((entry) => entry.name === (model.dbName ?? model.name))?.fields.find((entry) => entry.name === (field.dbName ?? field.name));
         if (actual === undefined || columnTypeKey({ field }) !== columnTypeKey({ field: actual }))
-          throw new VibeError39({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
+          throw new VibeError40({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
       }
     schema = resolved.schema;
   }
@@ -8697,13 +8787,13 @@ async function captureMigrationReference(params) {
 }
 
 // packages/migrate/src/compile-desired-state.ts
-import { VibeError as VibeError40 } from "@vibeorm/schema";
+import { VibeError as VibeError41 } from "@vibeorm/schema";
 import { renderExclusionSetup as renderExclusionSetup2, getSqlDialect as getSqlDialect12, renderMigrationServerVersion as renderMigrationServerVersion2 } from "@vibeorm/sql";
 async function compileDesiredState(params) {
   if (params.dialect !== "postgres")
-    throw new VibeError40({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Rollback declaration compilation requires PostgreSQL", meta: { feature: "desiredStateCompilation", dialect: params.dialect } });
+    throw new VibeError41({ 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 VibeError40({ code: "VIBE_MIGRATION", message: "CHECK compilation after column or enum changes requires an independently built reference with the new type context", meta: { reason: "reference-required" } });
+    throw new VibeError41({ 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 {
@@ -8726,7 +8816,7 @@ async function compileDesiredState(params) {
     const query = renderMigrationServerVersion2({ dialect: getSqlDialect12({ dialect: params.dialect }) });
     const version = (await params.executor({ text: query.text, values: [] }))[0]?.version;
     if (typeof version !== "string")
-      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Cannot determine definition normalization version" });
+      throw new VibeError41({ 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" });
@@ -8735,7 +8825,7 @@ async function compileDesiredState(params) {
 }
 
 // packages/migrate/src/verify-history.ts
-import { VibeError as VibeError42, sqlObjectKey as sqlObjectKey15 } from "@vibeorm/schema";
+import { VibeError as VibeError43, sqlObjectKey as sqlObjectKey15 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect13, renderReplayCoverageGaps as renderReplayCoverageGaps2 } from "@vibeorm/sql";
 
 // packages/migrate/src/compare-sqlite-primary-key.ts
@@ -8808,7 +8898,7 @@ function compareSqlitePrimaryKeyRepresentations(params) {
 }
 
 // packages/migrate/src/compare-reference-rls.ts
-import { VibeError as VibeError41 } from "@vibeorm/schema";
+import { VibeError as VibeError42 } from "@vibeorm/schema";
 function securityFacts(params) {
   return new Map(params.tables.filter((table) => table.enabled || table.force || table.policies.length > 0).map((table) => [table.table, {
     table: table.table,
@@ -8819,7 +8909,7 @@ function securityFacts(params) {
 }
 async function comparePostgresReferenceRls(params) {
   if (params.schema.rls !== undefined && params.referenceExecutor === undefined)
-    throw new VibeError41({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
+    throw new VibeError42({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
   const expected = securityFacts({ tables: params.schema.rls === undefined ? [] : await readPostgresRls({ executor: params.referenceExecutor }) });
   const actual = securityFacts({ tables: await readPostgresRls({ executor: params.executor }) });
   const objects = [...new Set([...expected.keys(), ...actual.keys()])].sort().map((table) => {
@@ -8843,14 +8933,14 @@ function selectMigrationVerificationPrefix(params) {
   for (const [index, file] of params.migrations.entries()) {
     const previous = params.migrations[index - 1];
     if (seen.has(file.name) || previous !== undefined && previous.name.localeCompare(file.name) > 0) {
-      throw new VibeError42({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
+      throw new VibeError43({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
     }
     seen.add(file.name);
   }
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.statementIndex < 0 || row.checksum === "" || file?.name !== row.name || file.desiredStatePending === true || migrationChecksum(file) !== row.checksum) {
-      throw new VibeError42({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError43({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
     }
   }
   return params.migrations.slice(0, params.recorded.length);
@@ -8867,7 +8957,7 @@ async function verifyMigrationReference(params) {
   const coverage = renderReplayCoverageGaps2({ dialect: getSqlDialect13({ dialect }), namespace });
   const gaps = await executor({ text: coverage.text, values: [...coverage.values] });
   if (gaps.length > 0)
-    throw new VibeError42({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
+    throw new VibeError43({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
   const security = dialect === "postgres" ? await comparePostgresReferenceRls({ executor, referenceExecutor: params.referenceExecutor, schema: reference.state.schema }) : { inSync: true, objects: [] };
   const inspected = await verifyMigrationState({ executor, dialect, expected: reference.state, probe: "none", batch: true });
   const structural = dialect === "sqlite" ? compareSqlitePrimaryKeyRepresentations({ report: inspected }) : inspected;
@@ -9014,7 +9104,7 @@ async function mysqlComparisonFacts(params) {
   return { ...facts, members };
 }
 function referenceContextError() {
-  return new VibeError42({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
+  return new VibeError43({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
 }
 
 // packages/migrate/src/baseline.ts
@@ -9022,19 +9112,19 @@ function generateBaselineMigration(params) {
   const objects = orderedMigrationObjects({ objects: params.schema.migrationObjects ?? [] });
   for (const object of objects)
     if (object.dialect !== params.dialect)
-      throw new VibeError43({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
+      throw new VibeError44({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
   const prerequisites = objects.filter((object) => object.identity.kind === "postgresExtension" || object.identity.kind === "enum" || object.identity.kind === "sequence");
   const prerequisiteKeys = new Set(prerequisites.map((object) => sqlObjectKey16({ identity: object.identity })));
   for (const object of prerequisites) {
     const unresolved = object.dependsOn.filter((identity) => !prerequisiteKeys.has(sqlObjectKey16({ identity })));
     if (unresolved.length > 0)
-      throw new VibeError43({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
+      throw new VibeError44({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
   }
   const schema = { ...params.schema, migrationObjects: objects.filter((object) => !prerequisiteKeys.has(sqlObjectKey16({ identity: object.identity }))) };
   const generated = generateMigration({ from: { datasource: schema.datasource, models: [], enums: [], extensions: [] }, to: schema, name: params.name, dialect: params.dialect, extensions: params.extensions ?? [] });
   const sql = splitSqlStatements({ sql: joinSqlStatements({ sql: [...prerequisites.flatMap((object) => object.create), ...generated.sql] }), dialect: params.dialect });
   if (sql.length === 0)
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
   return {
     name: generated.name,
     sql,
@@ -9063,17 +9153,17 @@ async function verifyBaselineDeclarations(params) {
 async function verifyBaselineTarget(params) {
   const { reference } = params;
   if (reference.unavailable.length > 0 || reference.inventory.some((object) => object.inspectionUnavailable !== undefined))
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
   const comparison = await verifyMigrationReference({ executor: params.executor, dialect: reference.dialect, reference, referenceExecutor: params.referenceExecutor }).catch((cause) => {
-    if (cause instanceof VibeError43 && cause.meta.reason === "verification-rls-reference-required")
-      throw new VibeError43({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
+    if (cause instanceof VibeError44 && cause.meta.reason === "verification-rls-reference-required")
+      throw new VibeError44({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
     throw cause;
   });
   const security = comparison.objects.filter((object) => object.reason === "native-rls-mismatch");
   if (security.length > 0)
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
   if (comparison.unavailable.length > 0)
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
   const report = { inSync: comparison.objects.every((object) => object.state === "matching"), objects: comparison.objects };
   assertMigrationState({ report });
   const unmanaged = comparison.unmanaged.map((object) => object.identity);
@@ -9081,14 +9171,14 @@ async function verifyBaselineTarget(params) {
   const exclusions = params.excludeUnmanaged ?? [];
   const excluded = new Set(exclusions.map((identity) => sqlObjectKey16({ identity })));
   if (excluded.size !== exclusions.length || exclusions.some((identity) => !extras.has(sqlObjectKey16({ identity }))))
-    throw new VibeError43({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
+    throw new VibeError44({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
   const unreviewed = unmanaged.filter((identity) => !excluded.has(sqlObjectKey16({ identity })));
   if (unreviewed.length > 0)
-    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
+    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
   return { ...report, unmanaged };
 }
 // packages/migrate/src/baseline-record.ts
-import { VibeError as VibeError44 } from "@vibeorm/schema";
+import { VibeError as VibeError45 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect15, renderStatement } from "@vibeorm/sql";
 
 // packages/migrate/src/history.ts
@@ -9104,20 +9194,20 @@ async function readMigrationHistory(params) {
 
 // packages/migrate/src/baseline-record.ts
 function transactionFailure(params) {
-  if (params.cause instanceof VibeError44)
+  if (params.cause instanceof VibeError45)
     return params.cause;
-  return new VibeError44({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
+  return new VibeError45({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
 }
 async function recordBaselineMigration(params) {
   if (params.migration.moduleOrigin !== undefined)
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
   validateMigrationReplay({ dialect: params.dialect, migrations: [params.migration], acceptSecurityChanges: params.acceptSecurityChanges });
   await withMigrationLock({ executor: params.executor, dialect: params.dialect, run: async (executor) => {
     const record = async () => {
       const assertEmpty = async () => {
         const history = await readMigrationHistory({ executor, migrations: [params.migration], dialect: params.dialect });
         if (history.recorded.length > 0)
-          throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
+          throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
       };
       await assertEmpty();
       await params.verify({ executor });
@@ -9142,14 +9232,14 @@ async function recordBaselineMigration(params) {
       await executor({ text: "COMMIT" });
     }).then(undefined, async (cause) => {
       await executor({ text: "ROLLBACK" }).then(undefined, (rollback) => {
-        throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
+        throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
       });
       throw transactionFailure({ cause });
     });
   } });
 }
 // packages/migrate/src/down.ts
-import { VibeError as VibeError45, sqlObjectKey as sqlObjectKey17 } from "@vibeorm/schema";
+import { VibeError as VibeError46, sqlObjectKey as sqlObjectKey17 } from "@vibeorm/schema";
 function buildRollbackTarget(params) {
   const { from, to, dialect } = params;
   const skipped = [];
@@ -9244,7 +9334,7 @@ function generateDownMigration(params) {
       continue;
     }
     if (object.drop.length === 0)
-      throw new VibeError45({ code: "VIBE_MIGRATION", message: `Migration object ${object.id} needs reviewed reverse SQL`, meta: { reason: "migration-object-reverse-required", id: object.id } });
+      throw new VibeError46({ 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 {
@@ -9257,7 +9347,7 @@ function generateDownMigration(params) {
   };
 }
 // packages/migrate/src/push.ts
-import { VibeError as VibeError46, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect4, sqlObjectKey as sqlObjectKey18 } from "@vibeorm/schema";
+import { VibeError as VibeError47, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect4, sqlObjectKey as sqlObjectKey18 } from "@vibeorm/schema";
 import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES4 } from "@vibeorm/sql";
 async function push(params) {
   assertValidSchemaIR4({ schema: params.schema });
@@ -9267,7 +9357,7 @@ async function push(params) {
   await params.executor({ text: "BEGIN" });
   let committed = false;
   try {
-    const result = await pushChanges({ ...params, dialect });
+    const result = await pushChanges({ ...params, dialect, probe: params.probe ?? "rollback" });
     if (params.dryRun !== true) {
       await params.executor({ text: "COMMIT" });
       committed = true;
@@ -9296,11 +9386,11 @@ async function pushChanges(params) {
   if (params.dryRun === true)
     return { steps, applied: [], planned: sql, securityChanges, objects: plan.objects, blocked: plan.blocked, unmanagedRemovals: plan.unmanagedRemovals };
   if (plan.blocked)
-    throw new VibeError46({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
+    throw new VibeError47({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
   assertSecurityAcknowledgement({ securityChanges, ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
   const destructive = steps.filter((step) => step.destructive);
   if (destructive.length > 0 && params.acceptDataLoss !== true)
-    throw new VibeError46({ code: "VIBE_MIGRATION", message: `push refused: ${destructive.length} destructive step(s) would lose data; pass acceptDataLoss: true: ${destructive.map((step) => describeStep({ step })).join("; ")}`, meta: { destructive: destructive.map((step) => describeStep({ step })) } });
+    throw new VibeError47({ 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,
@@ -9312,7 +9402,7 @@ async function pushChanges(params) {
   const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey18({ identity })));
   const unapproved = plan.unmanagedRemovals.filter((identity) => !approved.has(sqlObjectKey18({ identity })));
   if (unapproved.length > 0)
-    throw new VibeError46({ code: "VIBE_MIGRATION", message: "DDL would remove unmanaged dependent objects; approve their exact identities", meta: { reason: "unmanaged-removal-required", objects: unapproved } });
+    throw new VibeError47({ 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 });
   if (wrap)
     await executor({ text: "BEGIN" });
@@ -9330,7 +9420,7 @@ async function pushChanges(params) {
       } catch {}
     } else if (dialect === "sqlite")
       await cleanupSelfManagedFailure({ executor });
-    throw new VibeError46({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
+    throw new VibeError47({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
   }
   return { steps, applied: sql, securityChanges, objects: plan.objects, desiredState: createDesiredState({ schema: plan.to, dialect }) };
 }
@@ -9345,23 +9435,23 @@ async function pull(params) {
   }
 }
 // packages/migrate/src/module-export.ts
-import { VibeError as VibeError48 } from "@vibeorm/schema";
+import { VibeError as VibeError49 } from "@vibeorm/schema";
 
 // packages/migrate/src/module-bundle.ts
-import { VibeError as VibeError47 } from "@vibeorm/schema";
+import { VibeError as VibeError48 } from "@vibeorm/schema";
 function defineModuleMigrations(params) {
   if (!Array.isArray(params.steps) || params.steps.length === 0)
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
   const migrations = [];
   const revisions = new Set;
   let previous = null;
   for (const step of params.steps) {
     if (step.previousRevision !== previous || revisions.has(step.revision))
-      throw new VibeError47({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
+      throw new VibeError48({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
     const origin = createModuleOrigin({ moduleId: params.moduleId, dialect: params.dialect, revision: step.revision, previousRevision: step.previousRevision, contracts: step.contracts, owned: step.owned, source: step.migration });
     const predecessor = migrations.at(-1)?.moduleOrigin;
     if (predecessor !== undefined && canonicalMigrationJson({ value: predecessor.source.desiredState.to }) !== canonicalMigrationJson({ value: origin.source.desiredState.from }))
-      throw new VibeError47({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
+      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
     validateMigrationReplay({ migrations: [origin.source], dialect: params.dialect, acceptSecurityChanges: true, acceptIntegrityLoss: true, removeUnmanaged: origin.source.desiredState?.unmanagedRemovals ?? [] });
     migrations.push(Object.freeze({ ...origin.source, moduleOrigin: origin }));
     revisions.add(step.revision);
@@ -9371,13 +9461,13 @@ function defineModuleMigrations(params) {
 }
 function moduleMigrationFiles(params) {
   if (params.bundle === null || typeof params.bundle !== "object" || !Array.isArray(params.bundle.migrations))
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
   if (!/^[A-Za-z0-9_-]+$/.test(params.prefix))
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
   const bundle = defineModuleMigrations({ moduleId: params.bundle.moduleId, dialect: params.bundle.dialect, steps: params.bundle.migrations.map((migration) => {
     const origin = migration?.moduleOrigin;
     if (origin === undefined || origin.moduleId !== params.bundle.moduleId || origin.dialect !== params.bundle.dialect)
-      throw new VibeError47({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
+      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
     assertModuleOrigin({ value: origin });
     restoreModuleMigration({ migration, origin });
     return { revision: origin.revision, previousRevision: origin.previousRevision, contracts: origin.contracts, owned: origin.owned, migration: origin.source };
@@ -9390,7 +9480,7 @@ function emitModuleMigrationExport(params) {
   moduleMigrationFiles({ bundle: params.bundle, prefix: "export" });
   const origin = params.bundle.migrations.at(-1).moduleOrigin;
   if (!origin.contracts.includes(params.contract))
-    throw new VibeError48({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
+    throw new VibeError49({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
   const expectation = { moduleId: origin.moduleId, revision: origin.revision, artifactChecksum: origin.artifactChecksum, contract: params.contract };
   return [
     { name: "migrations.js", content: `// Generated immutable migration data; no driver, filesystem or runner import.
@@ -9407,9 +9497,9 @@ export const moduleReadiness = Object.freeze(${JSON.stringify(expectation)});
   ];
 }
 // packages/migrate/src/module-pending.ts
-import { VibeError as VibeError49, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
+import { VibeError as VibeError50, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
 function refusal3(params) {
-  return new VibeError49({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
+  return new VibeError50({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
 }
 function compose(params) {
   const { current, from, to } = params;
@@ -9517,16 +9607,16 @@ function pendingModuleMigrations(params) {
   return Object.freeze(result);
 }
 // packages/migrate/src/module-readiness.ts
-import { VibeError as VibeError50 } from "@vibeorm/schema";
+import { VibeError as VibeError51 } from "@vibeorm/schema";
 async function inspectModuleReadiness(params) {
   const ids = new Set;
   for (const expected of params.modules) {
     if (ids.has(expected.moduleId) || !expected.moduleId || !expected.revision || !expected.contract || !/^[a-f0-9]{64}$/.test(expected.artifactChecksum))
-      throw new VibeError50({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
+      throw new VibeError51({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
     ids.add(expected.moduleId);
   }
   if (params.compatibility !== undefined && params.compatibility !== "exact" && params.compatibility !== "contract")
-    throw new VibeError50({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
+    throw new VibeError51({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
   const records = await readModuleJournal(params);
   const heads = moduleHistoryHeads({ records });
   const unresolved = [...records.values()].some(({ row, entry }) => row.error !== undefined || row.statementIndex < 0 || entry !== undefined && (!entry.complete || row.statementIndex !== entry.migration.sql.length));
@@ -9560,7 +9650,7 @@ async function inspectModuleReadiness(params) {
   return { ready: !unresolved && modules.every((module) => (module.revision === "matching" || module.revision === "compatible") && module.structural.status !== "drifted"), modules };
 }
 // packages/migrate/src/adoption.ts
-import { VibeError as VibeError51 } from "@vibeorm/schema";
+import { VibeError as VibeError52 } from "@vibeorm/schema";
 async function adoptMigration(params) {
   const report = await verifyMigrationState({ executor: params.executor, expected: params.reference, dialect: params.dialect });
   assertMigrationState({ report });
@@ -9576,11 +9666,11 @@ function deployedDesiredState(params) {
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.checksum === "" || file?.name !== row.name || migrationChecksum(file) !== row.checksum)
-      throw new VibeError51({ code: "VIBE_MIGRATION", message: "Desired state requires complete, checksum-verified migration history", meta: { reason: "desired-state-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError52({ 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 VibeError51({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
+    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
   const last = [...params.migrations].reverse().find((migration) => applied.has(migration.name));
   return last?.desiredState?.to;
 }
@@ -9672,4 +9762,4 @@ export {
   withMigrationReference
 };
 
-//# debugId=077A2093537C73C664756E2164756E21
+//# debugId=AA96882D3F595BC864756E2164756E21