@vibeorm/migrate 2.2.0 → 2.3.0

package/dist/fs.js

@@ -1,6 +1,22 @@
 // @bun
+// packages/migrate/src/mysql-catalog-visibility.ts
+function hasMysqlGlobalCatalogVisibility(params) {
+  let visible = false;
+  for (const row of params.rows) {
+    const values = Object.values(row);
+    if (values.length !== 1 || typeof values[0] !== "string" || !values[0].startsWith("GRANT "))
+      return false;
+    const grant = /^GRANT ([A-Z_ ,]+) ON \*\.\* TO /.exec(values[0]);
+    const privileges = grant?.[1]?.split(", ") ?? [];
+    if (privileges.some((privilege) => privilege === "SHOW VIEW" || privilege === "SELECT" || privilege === "ALL PRIVILEGES"))
+      visible = true;
+  }
+  return visible;
+}
+
 // packages/migrate/src/module-ownership.ts
-import { VibeError as VibeError16, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
+import { VibeError as VibeError17, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect3, renderModuleDependencyQuery } from "@vibeorm/sql";
 
 // packages/migrate/src/desired-state.ts
 import { VibeError, assertValidSchemaIR, isSqlObjectDefinition, isSqlObjectIdentity, providerToDialect, sqlObjectKey } from "@vibeorm/schema";
@@ -38,7 +54,7 @@ function keysOnly(value, allowed) {
 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"));
+  return value.fields.every((field) => record(field) && typeof field.name === "string" && (field.nativeTypeIdentity === undefined || record(field.nativeTypeIdentity) && keysOnly(field.nativeTypeIdentity, ["source", "namespace"]) && field.isUnsupported === true && typeof field.nativeTypeIdentity.source === "string" && field.nativeTypeIdentity.source === field.nativeType && typeof field.nativeTypeIdentity.namespace === "string" && field.nativeTypeIdentity.namespace.length > 0) && (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))
@@ -138,7 +154,7 @@ function detectImplicitM2MPairs(params) {
 
 // packages/migrate/src/postgres-types.ts
 import { VibeError as VibeError2, isEnumType, scalarListDefault, serializeJsonDefault } from "@vibeorm/schema";
-import { POSTGRES_CODECS, postgresDialect, toPgArrayLiteral } from "@vibeorm/sql";
+import { POSTGRES_CODECS, postgresDialect, toPgArrayLiteral, parsePostgresTypeName, renderPostgresTypeName } from "@vibeorm/sql";
 var SCALAR_TO_PG = {
   String: "text",
   Boolean: "boolean",
@@ -182,11 +198,26 @@ function normalizeNativeType(params) {
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
   return `${base}${match[2] ?? ""}${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);
+  if (temporal !== null)
+    return parsePostgresTypeName({ raw: `${temporal[1].toLowerCase()}${temporal[3].toLowerCase() === "with" ? "tz" : ""}${temporal[2] ?? ""}${temporal[4] ?? ""}` });
+  const parsed = parsePostgresTypeName(params);
+  if (parsed !== undefined || /["']/.test(params.raw))
+    return parsed;
+  const base = params.raw.toLowerCase().replace(/\s+/g, "").replace(/\(.*\)|\[\]/g, "");
+  return NATIVE_ALIASES[base] === undefined ? undefined : parsePostgresTypeName({ raw: normalizeNativeType(params) });
+}
 function columnTypeKey(params) {
   const { field } = params;
   const listSuffix = field.isList ? "[]" : "";
   if (field.isUnsupported === true) {
-    return `u:${normalizeNativeType({ raw: field.nativeType ?? "" })}`;
+    const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
+    if (parsed === undefined)
+      return `u:${field.nativeType ?? ""}`;
+    const evidence = field.nativeTypeIdentity;
+    const namespace = evidence !== undefined && evidence.source === field.nativeType ? evidence.namespace : parsed.namespace;
+    return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
   if (isEnumType(field.type)) {
     return `e:${field.type.enum}${listSuffix}`;
@@ -218,6 +249,10 @@ function columnTypeSql(params) {
         meta: { field: field.name }
       });
     }
+    const parsed = parseUnsupportedPostgresType({ raw: field.nativeType });
+    const evidence = field.nativeTypeIdentity;
+    if (parsed !== undefined && evidence?.source === field.nativeType)
+      return renderPostgresTypeName({ dialect: postgresDialect, type: { ...parsed, namespace: evidence.namespace, array: parsed.array || field.isList } });
     return field.nativeType;
   }
   const listSuffix = field.isList ? "[]" : "";
@@ -1196,7 +1231,7 @@ function assertRetainedMigrationObjects(params) {
   const keys = new Set(params.to.map((object) => sqlObjectKey2({ identity: object.identity })));
   const removed = params.from.filter((object) => !keys.has(sqlObjectKey2({ identity: object.identity })));
   if (removed.length > 0)
-    throw new VibeError6({ 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) } });
+    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Removing migration ownership requires a reviewed hand-authored migration and new desired state", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removed.map((object) => object.identity) } });
 }
 function orderedMigrationObjects(params) {
   const byKey = new Map(params.objects.map((object) => [sqlObjectKey2({ identity: object.identity }), object]));
@@ -1227,10 +1262,10 @@ function assertNamedRemovals(params) {
   const approved = new Set((params.approved ?? []).map((identity) => sqlObjectKey2({ identity })));
   const missing = params.removals.filter((identity) => !approved.has(sqlObjectKey2({ identity })));
   if (missing.length > 0)
-    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Unmanaged removals require individually named approvals", meta: { reason: "unmanaged-removal-required", objects: missing } });
+    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Unmanaged removals require individually named approvals", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: missing } });
   const integrity = params.removals.filter((identity) => identity.kind === "constraint" || identity.kind === "index");
   if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
-    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Named constraint or index removals also require acceptIntegrityLoss", meta: { reason: "integrity-acknowledgement-required", objects: integrity } });
+    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Named constraint or index removals also require acceptIntegrityLoss", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
 }
 function assertRemovalAuthorization(params) {
   const declared = params.previous === undefined ? [] : schemaObjectIdentities({ schema: params.previous.schema, dialect: params.dialect, namespace: params.namespace });
@@ -1255,14 +1290,14 @@ function assertRemovalAuthorization(params) {
     }
   }
   if (unknown.length > 0)
-    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Unknown object removals require individually named removeUnmanaged decisions", meta: { reason: "unmanaged-removal-required", objects: unknown } });
+    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Unknown object removals require individually named removeUnmanaged decisions", meta: { reason: "unmanaged-removal-required", shadowReusable: true, objects: unknown } });
   if (integrity.length > 0 && params.acceptIntegrityLoss !== true)
-    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Constraint or index removal requires acceptIntegrityLoss; data-loss acknowledgement does not authorize it", meta: { reason: "integrity-acknowledgement-required", objects: integrity } });
+    throw new VibeError6({ code: "VIBE_MIGRATION", message: "Constraint or index removal requires acceptIntegrityLoss; data-loss acknowledgement does not authorize it", meta: { reason: "integrity-acknowledgement-required", shadowReusable: true, objects: integrity } });
 }
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError15, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect2, renderMigrationInventory, renderSqliteColumnInventory, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
+import { VibeError as VibeError16, 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
 import { randomUUID } from "crypto";
@@ -1342,16 +1377,16 @@ async function verifyExclusions(params) {
 
 // packages/migrate/src/inspect-objects.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { VibeError as VibeError14, sqlObjectKey as sqlObjectKey4, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2 } from "@vibeorm/schema";
-import { getSqlDialect, renderMigrationObjectQuery, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2 } from "@vibeorm/sql";
+import { VibeError as VibeError15, sqlObjectKey as sqlObjectKey4, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2 } from "@vibeorm/schema";
+import { getSqlDialect, renderMigrationObjectBatch, renderMigrationObjectQuery, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2, renderSqliteColumnInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/introspect/postgres.ts
 import { renderExclusionCatalog as renderExclusionCatalog2 } 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 { postgresDialect as postgresDialect6, renderRlsReadinessQuery } from "@vibeorm/sql";
+import { VibeError as VibeError12 } from "@vibeorm/schema";
 
 // packages/migrate/src/journal-table.ts
 var MIGRATIONS_TABLE_NAME = "_vibe_migrations";
@@ -1543,12 +1578,58 @@ function lowerFirst(value) {
   return value.charAt(0).toLowerCase() + value.slice(1);
 }
 
+// packages/migrate/src/postgres-type-identity.ts
+import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect3, renderPostgresTypeIdentity } from "@vibeorm/sql";
+async function resolvePostgresTypeIdentities(params) {
+  const unavailable = [];
+  const models = [];
+  for (const model of params.schema.models) {
+    const table = { namespace: "public", name: model.dbName ?? model.name };
+    const previous = params.previous?.models.find((entry) => (entry.dbName ?? entry.name) === table.name);
+    const fields = [];
+    for (const field of model.fields) {
+      if (field.isUnsupported !== true) {
+        fields.push(field);
+        continue;
+      }
+      const column = field.dbName ?? field.name;
+      const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
+      const evidence = field.nativeTypeIdentity;
+      if (evidence !== undefined && (evidence.source !== field.nativeType || parsed?.namespace !== undefined && parsed.namespace !== evidence.namespace)) {
+        throw new VibeError9({ code: "VIBE_MIGRATION", message: "PostgreSQL type evidence no longer matches its declaration; recapture the independent reference", meta: { reason: "type-reference-invalid", shadowReusable: true, table: table.name, column } });
+      }
+      const prior = previous?.fields.find((entry) => (entry.dbName ?? entry.name) === column && entry.isUnsupported === true);
+      const priorType = parseUnsupportedPostgresType({ raw: prior?.nativeType ?? "" });
+      const priorNamespace = prior?.nativeTypeIdentity?.source === prior?.nativeType ? prior?.nativeTypeIdentity?.namespace : priorType?.namespace;
+      let namespace = parsed?.namespace ?? evidence?.namespace ?? (priorType?.name === parsed?.name ? priorNamespace : undefined);
+      if (params.mode === "catalog" || params.mode === "reference" || namespace === undefined) {
+        const source = params.mode === "catalog" ? { table, column } : { type: { name: parsed?.name ?? "", ...namespace === undefined && params.mode === "reference" ? {} : { namespace: namespace ?? "pg_catalog" } } };
+        const query = renderPostgresTypeIdentity({ dialect: postgresDialect3, source });
+        const rows = parsed === undefined && params.mode !== "catalog" ? [] : await params.executor({ text: query.text, values: [...query.values] }).then((rows) => rows, (cause) => {
+          throw new VibeError9({ code: "VIBE_MIGRATION", message: "PostgreSQL type identity inspection failed", meta: { reason: "type-inspection-unavailable", table: table.name, column }, cause });
+        });
+        const resolved = rows.length === 1 ? rows[0] : undefined;
+        namespace = typeof resolved?.namespace === "string" && (resolved.name === parsed?.name || parsed === undefined && params.mode === "catalog") ? resolved.namespace : undefined;
+      }
+      if (parsed === undefined && params.mode !== "catalog" || namespace === undefined || field.nativeType === undefined) {
+        unavailable.push({ kind: "column", table, column });
+        fields.push(field);
+      } else {
+        fields.push({ ...field, nativeTypeIdentity: { source: field.nativeType, namespace } });
+      }
+    }
+    models.push({ ...model, fields });
+  }
+  return { schema: { ...params.schema, models }, unavailable };
+}
+
 // packages/migrate/src/introspect/postgres-rls.ts
-import { VibeError as VibeError10, assertValidSchemaIR as assertValidSchemaIR3 } from "@vibeorm/schema";
-import { NATIVE_RLS, postgresDialect as postgresDialect4, renderRlsPolicy as renderRlsPolicy2 } from "@vibeorm/sql";
+import { VibeError as VibeError11, assertValidSchemaIR as assertValidSchemaIR3 } from "@vibeorm/schema";
+import { NATIVE_RLS, postgresDialect as postgresDialect5, renderRlsPolicy as renderRlsPolicy2 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/rls.ts
-import { VibeError as VibeError9, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { VibeError as VibeError10, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 import * as sql from "@vibeorm/sql";
 function isRlsProtected(params) {
   return params.model.rls !== undefined && params.model.rls !== "unprotected";
@@ -1664,7 +1745,7 @@ function renderRlsStep(params) {
       return [renderer(common).text];
     }
     default:
-      throw new VibeError9({ code: "VIBE_MIGRATION", message: "Expected a native RLS migration step" });
+      throw new VibeError10({ code: "VIBE_MIGRATION", message: "Expected a native RLS migration step" });
   }
 }
 function securityChangesOf(params) {
@@ -1673,7 +1754,7 @@ function securityChangesOf(params) {
 function assertSecurityAcknowledgement(params) {
   if (params.securityChanges.length === 0 || params.acceptSecurityChanges === true)
     return;
-  throw new VibeError9({
+  throw new VibeError10({
     code: "VIBE_MIGRATION",
     message: `Security changes require acceptSecurityChanges: true; acceptDataLoss does not authorize them:
 ${params.securityChanges.join(`
@@ -1700,19 +1781,19 @@ async function readPostgresRls(params) {
   const tables = new Map;
   for (const row of rows) {
     const table = String(row.table_name);
-    let state2 = tables.get(table);
-    if (state2 === undefined) {
-      state2 = { table, enabled: row.enabled === true, force: row.force === true, policies: [] };
-      tables.set(table, state2);
+    let state = tables.get(table);
+    if (state === undefined) {
+      state = { table, enabled: row.enabled === true, force: row.force === true, policies: [] };
+      tables.set(table, state);
     }
     if (row.policy_name !== null && row.policy_name !== undefined) {
-      state2.policies.push({ name: String(row.policy_name), command: String(row.command), permissive: row.permissive === true, roles: String(row.roles), using: row.using_expression === null ? null : String(row.using_expression), withCheck: row.check_expression === null ? null : String(row.check_expression), comment: row.comment === null ? null : String(row.comment) });
+      state.policies.push({ name: String(row.policy_name), command: String(row.command), permissive: row.permissive === true, roles: String(row.roles), using: row.using_expression === null ? null : String(row.using_expression), withCheck: row.check_expression === null ? null : String(row.check_expression), comment: row.comment === null ? null : String(row.comment) });
     }
   }
   return [...tables.values()];
 }
 function conflict(params) {
-  throw new VibeError10({
+  throw new VibeError11({
     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
@@ -1725,32 +1806,32 @@ async function verifyPostgresRls(params) {
   await executor({ text: "SET LOCAL search_path = ''" });
   const declared = new Map((schema?.models ?? []).map((model) => [model.dbName ?? model.name, model]));
   let tables = await readPostgresRls({ executor });
-  for (const state2 of tables) {
-    const model = declared.get(state2.table);
-    if (!state2.enabled && !state2.force && state2.policies.length === 0 && (model === undefined || !isRlsProtected({ model })))
+  for (const state of tables) {
+    const model = declared.get(state.table);
+    if (!state.enabled && !state.force && state.policies.length === 0 && (model === undefined || !isRlsProtected({ model })))
       continue;
-    await executor({ text: `LOCK TABLE "public".${postgresDialect4.quoteIdent({ name: state2.table })} IN ACCESS EXCLUSIVE MODE` });
+    await executor({ text: `LOCK TABLE "public".${postgresDialect5.quoteIdent({ name: state.table })} IN ACCESS EXCLUSIVE MODE` });
   }
   tables = await readPostgresRls({ executor });
   const matched = new Set;
-  for (const state2 of tables) {
-    const model = declared.get(state2.table);
-    const active = state2.enabled || state2.force || state2.policies.length > 0;
+  for (const state of tables) {
+    const model = declared.get(state.table);
+    const active = state.enabled || state.force || state.policies.length > 0;
     if (schema === undefined && active)
-      conflict({ table: state2.table, reason: "rls-unmanaged", attributes: ["security metadata cannot be exported losslessly without a trusted declaration"] });
+      conflict({ table: state.table, reason: "rls-unmanaged", attributes: ["security metadata cannot be exported losslessly without a trusted declaration"] });
     if (model === undefined || !isRlsProtected({ model })) {
       if (active)
-        conflict({ table: state2.table, reason: "rls-conflict", attributes: ["unexpected native policies or RLS flags"] });
+        conflict({ table: state.table, reason: "rls-conflict", attributes: ["unexpected native policies or RLS flags"] });
       continue;
     }
     if (!active && params.requireInstalled !== true)
       continue;
-    const unknown = state2.policies.filter((policy2) => policy2.name !== NATIVE_RLS.policyName);
+    const unknown = state.policies.filter((policy) => policy.name !== NATIVE_RLS.policyName);
     if (unknown.length > 0)
-      conflict({ table: state2.table, reason: "rls-conflict", attributes: unknown.map((policy2) => `unexpected policy ${policy2.name}`) });
-    const policy = state2.policies.find((entry) => entry.name === NATIVE_RLS.policyName);
+      conflict({ table: state.table, reason: "rls-conflict", attributes: unknown.map((policy) => `unexpected policy ${policy.name}`) });
+    const policy = state.policies.find((entry) => entry.name === NATIVE_RLS.policyName);
     if (policy === undefined)
-      conflict({ table: state2.table, reason: "rls-drift", attributes: ["missing policy"] });
+      conflict({ table: state.table, reason: "rls-drift", attributes: ["missing policy"] });
     const structure = [
       ...policy.command !== "*" ? ["command"] : [],
       ...!policy.permissive ? ["permissiveness"] : [],
@@ -1758,27 +1839,27 @@ async function verifyPostgresRls(params) {
       ...policy.withCheck === null ? ["missing WITH CHECK"] : []
     ];
     if (structure.length > 0)
-      conflict({ table: state2.table, reason: "rls-conflict", attributes: structure });
-    const attributes = [...!state2.enabled ? ["enabled"] : [], ...!state2.force ? ["force"] : []];
+      conflict({ table: state.table, reason: "rls-conflict", attributes: structure });
+    const attributes = [...!state.enabled ? ["enabled"] : [], ...!state.force ? ["force"] : []];
     await executor({ text: "SAVEPOINT vibeorm_rls_probe" });
     let probe;
     try {
-      const rendered = renderRlsPolicy2({ dialect: postgresDialect4, schema, model: model.name, policyName: PROBE });
+      const rendered = renderRlsPolicy2({ dialect: postgresDialect5, schema, model: model.name, policyName: PROBE });
       await executor({ text: rendered.text });
-      probe = (await readPostgresRls({ executor })).find((entry) => entry.table === state2.table)?.policies.find((entry) => entry.name === PROBE);
+      probe = (await readPostgresRls({ executor })).find((entry) => entry.table === state.table)?.policies.find((entry) => entry.name === PROBE);
     } finally {
       await executor({ text: "ROLLBACK TO SAVEPOINT vibeorm_rls_probe" });
       await executor({ text: "RELEASE SAVEPOINT vibeorm_rls_probe" });
     }
     if (probe === undefined)
-      conflict({ table: state2.table, reason: "rls-drift", attributes: ["probe unavailable"] });
+      conflict({ table: state.table, reason: "rls-drift", attributes: ["probe unavailable"] });
     if (policy.using !== probe.using)
       attributes.push("using");
     if (policy.withCheck !== probe.withCheck)
       attributes.push("withCheck");
     if (attributes.length > 0)
-      conflict({ table: state2.table, reason: "rls-drift", attributes });
-    matched.add(state2.table);
+      conflict({ table: state.table, reason: "rls-drift", attributes });
+    matched.add(state.table);
   }
   if (params.requireInstalled === true) {
     for (const [table, model] of declared) {
@@ -1961,18 +2042,18 @@ async function introspectPostgres(params) {
   if (params.inTransaction !== true)
     await executor({ text: "BEGIN" });
   try {
-    const savedPath = params.inTransaction === true ? await executor(renderRlsReadinessQuery({ dialect: postgresDialect5, query: "readSearchPath" })) : undefined;
+    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")
-      throw new VibeError11({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
+      throw new VibeError12({ 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 VibeError12)
         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 VibeError12({ 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")
-      await executor(renderRlsReadinessQuery({ dialect: postgresDialect5, query: "setSearchPath", searchPath }));
+      await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
     return projectPostgresRls({ physical, ...params.rlsSchema === undefined ? {} : { declared: params.rlsSchema }, matched });
   } finally {
     if (params.inTransaction !== true)
@@ -1990,7 +2071,7 @@ async function introspectPhysicalPostgres(params) {
     executor({ text: ENUMS_QUERY }),
     executor({ text: INDEXES_QUERY }),
     executor({ text: CHECKS_QUERY }),
-    executor({ text: renderExclusionCatalog2({ dialect: postgresDialect5 }) })
+    executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6 }) })
   ]);
   const tables = tableRows.map((row) => row.table_name);
   const views = viewRows.map((row) => row.table_name);
@@ -2158,12 +2239,15 @@ async function introspectPhysicalPostgres(params) {
   }
   addFkRelations({ models, fkGroups, joinTables });
   addJoinTableRelations({ models, joinTables });
-  return {
+  const resolved = await resolvePostgresTypeIdentities({ executor, mode: "catalog", schema: {
     datasource: { provider: "postgresql" },
     models,
     enums,
     extensions: []
-  };
+  } });
+  if (resolved.unavailable.length > 0)
+    throw new VibeError12({ code: "VIBE_MIGRATION", message: "PostgreSQL column type identity could not be read", meta: { reason: "type-inspection-unavailable", columns: resolved.unavailable } });
+  return resolved.schema;
 }
 function buildModel(params) {
   const { table, isView, columns, pkByTable, uniquesByConstraint, constraintNames, indexes, enumNames } = params;
@@ -3132,8 +3216,8 @@ async function readIndexes(params) {
     }
     let where;
     if (partial) {
-      const sql2 = indexSqlByName.get(name);
-      const match = sql2?.match(/\sWHERE\s+(.*)$/is);
+      const sql = indexSqlByName.get(name);
+      const match = sql?.match(/\sWHERE\s+(.*)$/is);
       where = match?.[1]?.trim();
     }
     tableIndexes.push({
@@ -3164,17 +3248,17 @@ async function readIndexes(params) {
 var PLAIN_INDEX_COLUMN = /^"((?:[^"]|"")+)"(?:\s+(ASC|DESC))?$/i;
 var CAST_REAL_INDEX_COLUMN = /^CAST\s*\(\s*"((?:[^"]|"")+)"\s+AS\s+REAL\s*\)(?:\s+(ASC|DESC))?$/i;
 function parseIndexColumnsFromSql(params) {
-  const { sql: sql2 } = params;
-  if (sql2 === null)
+  const { sql } = params;
+  if (sql === null)
     return null;
-  const onMatch = /\sON\s+"(?:[^"]|"")+"\s*\(/i.exec(sql2);
+  const onMatch = /\sON\s+"(?:[^"]|"")+"\s*\(/i.exec(sql);
   if (onMatch === null)
     return null;
   const open = onMatch.index + onMatch[0].length - 1;
   let listDepth = 0;
   let close = -1;
-  for (let index = open;index < sql2.length; index++) {
-    const char = sql2[index];
+  for (let index = open;index < sql.length; index++) {
+    const char = sql[index];
     if (char === "(")
       listDepth += 1;
     else if (char === ")") {
@@ -3187,7 +3271,7 @@ function parseIndexColumnsFromSql(params) {
   }
   if (close === -1)
     return null;
-  const list = sql2.slice(open + 1, close);
+  const list = sql.slice(open + 1, close);
   const terms = [];
   let depth = 0;
   let start = 0;
@@ -3328,7 +3412,7 @@ function q(name) {
 }
 
 // packages/migrate/src/execute.ts
-import { VibeError as VibeError12 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
@@ -3349,9 +3433,9 @@ function classifySelfManagedStatement(params) {
   return "plain";
 }
 function selfManagedResumeStart(params) {
-  const { sql: sql2, start } = params;
+  const { sql, start } = params;
   for (let index = start - 1;index >= 0; index -= 1) {
-    const control = classifySelfManagedStatement({ statement: sql2[index] });
+    const control = classifySelfManagedStatement({ statement: sql[index] });
     if (control === "endTransaction" || control === "abandon" || control === "fkOn")
       return start;
     if (control === "fkOff")
@@ -3369,7 +3453,7 @@ function assertSelfManagedResumeSafe(params) {
   const completedIndex = params.direction === "up" ? params.start + 1 : -(params.start + 2);
   const rewind = selfManagedResumeStart({ sql: params.sql, start: params.start });
   const retryIndex = params.direction === "up" ? rewind : -(rewind + 1);
-  throw new VibeError12({
+  throw new VibeError13({
     code: "VIBE_MIGRATION",
     message: `migration "${params.migration}" has a legacy sqlite checkpoint at ${params.direction} COMMIT (statement ${params.start + 1}). The block may already have committed; replay is refused. Inspect the block's effects. If it committed, set its journal statement_index to ${completedIndex} and error to NULL to resume the remaining statements. Only if the entire block did not commit, set statement_index to ${retryIndex} and error to NULL to retry the block. Do not mark the whole migration applied unless all remaining statements also ran.`,
     meta: { reason: "uncertain-statement", migration: params.migration, statementIndex: params.start, direction: params.direction, dialect: "sqlite" }
@@ -3398,37 +3482,37 @@ function unsupportedScript(params) {
   const { migration, direction, index, problem, found } = params;
   const subject = direction === "down" ? `the down script of migration "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${params.statements}`;
-  return new VibeError12({
+  return new VibeError13({
     code: "VIBE_MIGRATION",
     message: `${subject} manages its own sqlite transactions, and ${position} breaks the shape recovery depends on: ${found}. ` + `A table-rebuild block must be written exactly as \`${SUPPORTED_BLOCK_SHAPE}\`. ` + "Inside that block a crash rolls everything back, so a resume can replay it safely. " + "A statement that sits in a foreign-keys-off region with no transaction around it commits on its own, " + "and the resume would run it a second time with no error raised either time. " + "Nothing has been executed. Move the statement after `PRAGMA foreign_keys=ON`, where it commits together " + "with its own journal checkpoint, or give it its own `BEGIN;` and `COMMIT;`. " + 'See "Self-managed sqlite scripts" in docs/migrations.md.',
     meta: { reason: "unsupported-self-managed-script", problem, migration, statementIndex: index, direction }
   });
 }
 function assertSupportedSelfManagedScript(params) {
-  const { sql: sql2, migration, direction } = params;
-  const statements = sql2.length;
+  const { sql, migration, direction } = params;
+  const statements = sql.length;
   const refuse = (index, problem, found) => unsupportedScript({ migration, direction, index, statements, problem, found });
-  let state2 = "outside";
+  let state = "outside";
   let openedAt = -1;
   for (let index = 0;index < statements; index += 1) {
-    const control = classifySelfManagedStatement({ statement: sql2[index] });
-    if (state2 === "fkOff") {
+    const control = classifySelfManagedStatement({ statement: sql[index] });
+    if (state === "fkOff") {
       if (control !== "begin") {
         throw refuse(index, "fk-off-without-transaction", "`PRAGMA foreign_keys=OFF` is not followed by `BEGIN;`");
       }
-      state2 = "inBlock";
+      state = "inBlock";
       continue;
     }
-    if (state2 === "committed") {
+    if (state === "committed") {
       if (control !== "fkOn") {
         throw refuse(index, "commit-without-restore", "`COMMIT;` is not followed by `PRAGMA foreign_keys=ON;`");
       }
-      state2 = "outside";
+      state = "outside";
       continue;
     }
-    if (state2 === "inBlock") {
+    if (state === "inBlock") {
       if (control === "endTransaction") {
-        state2 = "committed";
+        state = "committed";
         continue;
       }
       if (control === "plain")
@@ -3436,7 +3520,7 @@ function assertSupportedSelfManagedScript(params) {
       throw refuse(index, "unsupported-control-in-block", "transaction or pragma control appears inside an open rebuild block");
     }
     if (control === "fkOff") {
-      state2 = "fkOff";
+      state = "fkOff";
       openedAt = index;
       continue;
     }
@@ -3444,8 +3528,8 @@ function assertSupportedSelfManagedScript(params) {
       throw refuse(index, "transaction-control-outside-block", "transaction control appears outside any rebuild block");
     }
   }
-  if (state2 !== "outside") {
-    throw refuse(openedAt, state2 === "committed" ? "commit-without-restore" : "unclosed-block", state2 === "committed" ? "the block commits but never restores foreign keys with `PRAGMA foreign_keys=ON;`" : "`PRAGMA foreign_keys=OFF` is never closed by `COMMIT;` and `PRAGMA foreign_keys=ON;`");
+  if (state !== "outside") {
+    throw refuse(openedAt, state === "committed" ? "commit-without-restore" : "unclosed-block", state === "committed" ? "the block commits but never restores foreign keys with `PRAGMA foreign_keys=ON;`" : "`PRAGMA foreign_keys=OFF` is never closed by `COMMIT;` and `PRAGMA foreign_keys=ON;`");
   }
 }
 async function executeStatement(params) {
@@ -3454,7 +3538,7 @@ async function executeStatement(params) {
     const rows = await executor({ text: statement, values: [] });
     if (rows.length > 0) {
       const sample = rows.slice(0, 5).map((row) => `${String(row.table)} rowid ${String(row.rowid)} \u2192 ${String(row.parent)}`).join("; ");
-      throw new VibeError12({
+      throw new VibeError13({
         code: "VIBE_MIGRATION",
         message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
         meta: { violations: rows }
@@ -3474,8 +3558,8 @@ async function cleanupSelfManagedFailure(params) {
 }
 
 // packages/migrate/src/postgres-default-equivalence.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect6, renderPostgresDefaultFunctionIdentity } from "@vibeorm/sql";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect7, renderPostgresDefaultFunctionIdentity } from "@vibeorm/sql";
 var IDENTIFIER = '(?:"(?:[^"\\u0000]|"")+"|[A-Za-z_][A-Za-z_0-9$]*)';
 var CALL = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*\\(\\s*\\)\\s*$`);
 function parseCall(params) {
@@ -3491,9 +3575,9 @@ async function equivalentPostgresDefaultFunction(params) {
   const observed = parseCall({ expression: params.actual });
   if (expected?.namespace === undefined || observed === undefined)
     return false;
-  const query = renderPostgresDefaultFunctionIdentity({ dialect: postgresDialect6, table: params.table, column: params.column });
+  const query = renderPostgresDefaultFunctionIdentity({ dialect: postgresDialect7, table: params.table, column: params.column });
   const rows = await params.executor({ text: query.text, values: [...query.values] }).catch((cause) => {
-    throw new VibeError13({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
+    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
   });
   if (rows.length !== 1)
     return false;
@@ -3545,9 +3629,17 @@ async function inspectSqlObject(params) {
       } 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 (constraint === undefined && constraintType === "primaryKey" && name === `${params.identity.table.name}_pkey`) {
+          const query = renderSqliteColumnInventory({ dialect: getSqlDialect({ dialect: "sqlite" }), namespace: params.identity.table.namespace, table: params.identity.table.name });
+          const columns = (await params.executor({ text: query.text, values: [...query.values] })).filter((column) => Number(column.pk) > 0).sort((a, b) => Number(a.pk) - Number(b.pk));
+          if (columns.length === 0)
+            return { state: "missing" };
+          facts = { type: "primaryKey", columns: columns.map((column) => String(column.name)) };
+        } else {
+          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")) {
@@ -3561,34 +3653,84 @@ async function inspectSqlObject(params) {
     if (params.identity.kind === "columnDefault")
       facts = { definition: facts.definition ?? null };
     if (params.dialect === "postgres") {
-      const query2 = renderMigrationDependencies({ dialect: getSqlDialect({ 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() };
+      const query = renderMigrationDependencies({ dialect: getSqlDialect({ dialect: params.dialect }), identity: params.identity });
+      const rows = await params.executor({ text: query.text, values: [...query.values] });
+      return postgresInspection({ identity: params.identity, facts, addresses: rows.map((row) => row.address) });
     }
     if (params.dialect === "mysql") {
-      const query2 = renderMysqlObjectMembers({ dialect: getSqlDialect({ 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)
+      const query = renderMysqlObjectMembers({ dialect: getSqlDialect({ dialect: params.dialect }), identity: params.identity });
+      if (query !== undefined) {
+        const rows = await params.executor({ text: query.text, values: [...query.values] });
+        if (params.identity.kind === "function" && rows.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) }));
+          const signature = rows.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 })) };
+        facts = { ...facts, members: rows.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-v2" } };
+  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError15 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+}
+function postgresInspection(params) {
+  if (!params.addresses.every((address) => typeof address === "string"))
+    return { state: "unavailable", reason: "dependency-inspection-unavailable" };
+  const facts = { ...params.identity.kind === "columnDefault" ? { definition: params.facts.definition ?? null } : params.facts, dependencyAddresses: [...params.addresses].sort() };
+  const dependencies = [];
+  if (params.identity.kind === "trigger") {
+    if (params.facts.functionArguments !== "")
+      return { state: "unavailable", reason: "trigger-function-signature-unavailable" };
+    dependencies.push({ kind: "function", name: { namespace: String(params.facts.functionNamespace), name: String(params.facts.functionName) }, argumentTypes: [] });
+  }
+  return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v2" } };
+}
+function unavailableReason(params) {
+  return params.error instanceof VibeError15 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
+}
+async function readBatch(params) {
+  const positions = new Set(params.batch.positions);
+  return Promise.resolve().then(async () => {
+    const rows = new Map;
+    for (const row of await params.executor({ text: params.batch.text, values: [...params.batch.values] })) {
+      if (typeof row.position !== "number" || !Number.isInteger(row.position) || !positions.has(row.position))
+        throw new VibeError15({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
+      const matches = rows.get(row.position) ?? [];
+      matches.push(row);
+      rows.set(row.position, matches);
+    }
+    return { ok: true, rows };
+  }).then((outcome) => outcome, (error) => ({ ok: false, reason: unavailableReason({ error }) }));
+}
+function batchedInspection(params) {
+  if (params.matches.length === 0)
+    return { state: "missing" };
+  if (params.matches.length !== 1)
+    return { state: "unavailable", reason: "ambiguous-catalog-identity" };
+  const row = params.matches[0];
+  const facts = row.facts !== null && typeof row.facts === "object" && !Array.isArray(row.facts) ? factsOf({ row: row.facts }) : undefined;
+  if (facts === undefined || !Array.isArray(row.dependencyAddresses))
+    return { state: "unavailable", reason: "unsupported-catalog-value" };
+  return postgresInspection({ identity: params.identity, facts, addresses: row.dependencyAddresses });
+}
+async function inspectSqlObjects(params) {
+  if (params.dialect !== "postgres") {
+    const results = [];
+    for (const identity of params.identities)
+      results.push(await inspectSqlObject({ ...params, identity }));
+    return results;
+  }
+  return Promise.resolve().then(async () => {
+    const results = params.identities.map(() => ({ state: "unavailable", reason: "catalog-query-failed" }));
+    for (const batch of renderMigrationObjectBatch({ dialect: getSqlDialect({ dialect: params.dialect }), identities: params.identities })) {
+      const outcome = await readBatch({ executor: params.executor, batch });
+      for (const position of batch.positions) {
+        results[position] = outcome.ok ? batchedInspection({ identity: params.identities[position], matches: outcome.rows.get(position) ?? [] }) : { state: "unavailable", reason: outcome.reason };
+      }
     }
-    return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v1" } };
-  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError14 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+    return results;
+  }).then((result) => result, (error) => params.identities.map(() => ({ state: "unavailable", reason: unavailableReason({ error }) })));
 }
 async function assertCatalogVisibility(params) {
   if (params.dialect !== "mysql")
@@ -3598,15 +3740,23 @@ async function assertCatalogVisibility(params) {
   const grants = new Set(rows.map((row) => row.privilege));
   const missing = ["SELECT", "TRIGGER", "SHOW VIEW", "EXECUTE"].filter((privilege) => !grants.has(privilege));
   if (missing.length > 0)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
 }
+var CATALOG_V1_OMITTED_FACTS = Object.freeze({
+  function: ["definerOwner"],
+  column: ["collationNamespace", "collationName"],
+  generatedColumn: ["collationNamespace", "collationName"]
+});
 function compare(params) {
   const differences = [];
+  const omitted = params.expected.format === "catalog-v1" ? CATALOG_V1_OMITTED_FACTS[params.expected.identity.kind] ?? [] : [];
   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 });
+    if (omitted.includes(key) && !Object.hasOwn(params.expected.facts, key))
+      continue;
+    const expected = params.expected.facts[key];
+    const actual = params.live.facts[key];
+    if (expected === undefined !== (actual === undefined) || canonicalMigrationJson({ value: expected }) !== canonicalMigrationJson({ value: actual }))
+      differences.push({ attribute: key, expected, actual });
   }
   const expected = params.expected.dependencies.map((identity) => sqlObjectKey4({ identity })).sort();
   const actual = params.live.dependencies.map((identity) => sqlObjectKey4({ identity })).sort();
@@ -3616,7 +3766,7 @@ function compare(params) {
 }
 function assertProbeMode(params) {
   if (params.probe !== undefined && params.probe !== "none" && DIALECT_CAPABILITIES2[params.dialect].checkNormalization !== params.probe)
-    throw new VibeError14({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
+    throw new VibeError15({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
 }
 async function verifyMigrationState(params) {
   return verifyState(params);
@@ -3630,10 +3780,13 @@ async function verifyState(params) {
   for (const object of declarations)
     identities.set(sqlObjectKey4({ identity: object.identity }), object.identity);
   const objects = [];
+  const inspections = params.batch === true ? await inspectSqlObjects({ ...params, identities: [...identities.values()] }) : undefined;
+  let position = 0;
   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 });
+    const live = inspections === undefined ? await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity }) : inspections[position];
+    position++;
     if (live.state !== "present") {
       objects.push({ identity, ownership, state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
     } else if (expected === undefined) {
@@ -3653,9 +3806,10 @@ async function verifyState(params) {
 }
 async function verifySchemaObjects(params) {
   const physical = params.dialect === "postgres" ? await introspectPhysicalPostgres({ executor: params.executor }) : params.dialect === "mysql" ? await introspectMysql({ executor: params.executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor: params.executor }) : await introspectSqlite({ executor: params.executor });
-  const expected = normalizeSchema({ schema: params.expected.schema, dialect: params.dialect });
+  const resolved = params.dialect === "postgres" ? await resolvePostgresTypeIdentities({ executor: params.executor, schema: params.expected.schema, mode: "verify" }) : { schema: params.expected.schema, unavailable: [] };
+  const expected = normalizeSchema({ schema: resolved.schema, dialect: params.dialect });
   const actual = normalizeSchema({ schema: physical, dialect: params.dialect });
-  const objects = [];
+  const objects = resolved.unavailable.map((identity) => ({ identity, ownership: "schema", state: "unavailable", reason: "type-reference-required", differences: [] }));
   const namespace = await migrationNamespace({ executor: params.executor, dialect: params.dialect });
   const sqliteTableOptions = params.dialect === "sqlite" && expected.tables.size > 0 ? await params.executor({ text: "PRAGMA main.table_list;", values: [] }) : undefined;
   if (params.dialect === "postgres")
@@ -3690,9 +3844,9 @@ async function verifySchemaObjects(params) {
       }
     }
     const differences = [];
-    const pin = (attribute, expected2, actual2) => {
-      if (canonicalMigrationJson({ value: expected2 }) !== canonicalMigrationJson({ value: actual2 }))
-        differences.push({ attribute, expected: expected2, actual: actual2 });
+    const pin = (attribute, expected, actual) => {
+      if (canonicalMigrationJson({ value: expected }) !== canonicalMigrationJson({ value: actual }))
+        differences.push({ attribute, expected, actual });
     };
     pin("primaryKey", desired.pk, live.pk);
     for (const [column, field] of desired.columns) {
@@ -3722,8 +3876,8 @@ async function verifySchemaObjects(params) {
         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 });
+          const differences = ["validated", "triggersEnabled"].flatMap((attribute) => inspection.definition.facts[attribute] === true ? [] : [{ attribute, expected: true, actual: inspection.definition.facts[attribute] }]);
+          objects.push({ identity, ownership: "schema", state: differences.length === 0 ? "matching" : "changed", differences });
         }
       }
     }
@@ -3738,8 +3892,8 @@ async function verifySchemaObjects(params) {
       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 });
+        const differences = ["valid", "ready"].flatMap((attribute) => inspection.definition.facts[attribute] === true ? [] : [{ attribute, expected: true, actual: inspection.definition.facts[attribute] }]);
+        objects.push({ identity, ownership: "schema", state: differences.length === 0 ? "matching" : "changed", differences });
       }
     }
     objects.push({ identity: { kind: "table", name: table }, ownership: "schema", state: differences.length === 0 ? "matching" : "changed", differences });
@@ -3771,14 +3925,14 @@ async function verifySchemaObjects(params) {
       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 }] });
+        const actual = read.state === "present" ? read.definition.facts.definition : undefined;
+        objects.push({ identity, ownership: "schema", state: normalized === actual ? "matching" : "changed", differences: normalized === actual ? [] : [{ attribute: "definition", expected: normalized, actual }] });
       } 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 }] });
+        const actual = inspection.state === "present" ? inspection.definition.facts.definition : undefined;
+        const match = normalized === actual;
+        objects.push({ identity, ownership: "schema", state: inspection.state === "unavailable" ? "unavailable" : match ? "matching" : "changed", differences: match ? [] : [{ attribute: "definition", expected: normalized, actual }] });
       } else
         objects.push({ identity, ownership: "schema", state: "unavailable", reason: "explicit-replacement-required", differences: [{ attribute: "definition", expected: expression, actual: stored }] });
     }
@@ -3800,14 +3954,14 @@ async function verifyMigrationTransition(params) {
 }
 async function verifySqliteTransitionBeforeRestore(params) {
   if (params.dialect !== "sqlite")
-    throw new VibeError14({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
+    throw new VibeError15({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
   await executeStatement({ executor: params.executor, dialect: "sqlite", statement: "PRAGMA foreign_key_check;" });
   return verifyTransition({ ...params, sqliteRestorePending: true });
 }
 async function verifyTransition(params) {
   const report = await verifyState({ executor: params.executor, dialect: params.dialect, expected: params.to, ...params.sqliteRestorePending === true ? { sqliteRestorePending: true } : {}, ...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 identities = (state) => [...schemaObjectIdentities({ schema: state.schema, dialect: params.dialect, namespace }), ...(state.schema.migrationObjects ?? []).map((object) => object.identity), ...state.definitions.map((definition) => definition.identity)];
   const retained = new Set(identities(params.to).map((identity) => sqlObjectKey4({ identity })));
   const removed = new Map([...identities(params.from).filter((identity) => !retained.has(sqlObjectKey4({ identity }))), ...params.removals ?? []].map((identity) => [sqlObjectKey4({ identity }), identity]));
   const objects = [...report.objects];
@@ -3826,12 +3980,12 @@ async function migrationNamespace(params) {
   const rows = await params.executor({ text: query.text, values: [] });
   const namespace = rows[0]?.namespace;
   if (typeof namespace !== "string" || namespace.length === 0)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
   return namespace;
 }
 function assertMigrationState(params) {
   if (!params.report.inSync)
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", objects: params.report.objects.filter((object) => object.state !== "matching") } });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", shadowReusable: true, objects: params.report.objects.filter((object) => object.state !== "matching") } });
 }
 async function deparsePostgresCheck(params) {
   const definition = await deparsePostgresCheckDefinition({ ...params, constraint: "vibeorm_check_probe" });
@@ -3845,7 +3999,7 @@ async function deparsePostgresCheckDefinition(params) {
     await params.executor({ text: query.text });
     const result = await inspectSqlObject({ executor: params.executor, dialect: "postgres", identity: { kind: "constraint", constraintType: "check", table: params.table, name } });
     if (result.state !== "present" || typeof result.definition.facts.definition !== "string")
-      throw new VibeError14({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError15({ 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" });
@@ -3863,7 +4017,7 @@ async function deparseMysqlCheck(params) {
     const source = await params.executor({ text: read.text, values: [] });
     const definition = source[0]?.["Create Table"];
     if (typeof definition !== "string")
-      throw new VibeError14({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
+      throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
     const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
     await params.executor({ text: drop.text });
     created = false;
@@ -3874,7 +4028,7 @@ async function deparseMysqlCheck(params) {
     const normalizedDefinition = rows[0]?.["Create Table"];
     const check = typeof normalizedDefinition === "string" ? parseSqliteNamedChecks({ tableSql: normalizedDefinition }).find((entry) => entry.name === probe) : undefined;
     if (check === undefined)
-      throw new VibeError14({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError15({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
     return check.expression;
   } finally {
     if (created) {
@@ -3901,7 +4055,7 @@ async function prepareCheckDiff(params) {
         const desired = await deparsePostgresCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "rollback" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError14({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError15({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         if (live.definition.facts.definition === desired) {
           checks.push(next);
           continue;
@@ -3913,7 +4067,7 @@ async function prepareCheckDiff(params) {
         const desired = await deparseMysqlCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "temporary" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError14({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError15({ 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;
       }
@@ -3926,7 +4080,7 @@ async function prepareCheckDiff(params) {
         checks.push({ name: check.name, expression: check.expression });
         continue;
       }
-      throw new VibeError14({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
+      throw new VibeError15({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
     }
     models.push({ ...model, checks });
   }
@@ -3953,7 +4107,7 @@ async function inspectMigrationInventory(params) {
   for (const row of rows) {
     const name = row.name;
     if (typeof name !== "string" || typeof row.kind !== "string")
-      throw new VibeError15({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
+      throw new VibeError16({ 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;
@@ -3975,27 +4129,27 @@ async function inspectMigrationInventory(params) {
       case "constraint": {
         const constraintType = kinds[String(row.subtype)];
         if (constraintType === undefined)
-          throw new VibeError15({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError16({ 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: getSqlDialect2({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
-          const members = await params.executor({ text: query2.text, values: [...query2.values] });
+          const query = renderMysqlObjectMembers2({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
+          const members = await params.executor({ text: query.text, values: [...query.values] });
           if (members.length === 0)
-            throw new VibeError15({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
+            throw new VibeError16({ 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 VibeError15({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
         identity = candidate;
         break;
       }
       default:
-        throw new VibeError15({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
+        throw new VibeError16({ 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)) {
@@ -4003,16 +4157,16 @@ async function inspectMigrationInventory(params) {
       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 name = 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 }, ...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: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
-      const columns = await params.executor({ text: query2.text, values: [...query2.values] });
+      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` } });
       const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
@@ -4039,7 +4193,7 @@ async function inspectMigrationInventory(params) {
 
 // packages/migrate/src/module-ownership.ts
 function refusal(params) {
-  return new VibeError16({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
+  return new VibeError17({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
 }
 function identities(params) {
   return [...schemaObjectIdentities({ schema: params.state.schema, dialect: params.dialect, namespace: params.namespace }), ...(params.state.schema.migrationObjects ?? []).map((object) => object.identity), ...params.state.definitions.map((definition) => definition.identity)];
@@ -4055,14 +4209,14 @@ function moduleNamespace(params) {
 function moduleOwnedObjects(params) {
   const { desiredState } = params;
   const namespace = params.namespace ?? (desiredState.dialect === "sqlite" ? "main" : "public");
-  const all = [desiredState.from, desiredState.to, ...desiredState.down === undefined ? [] : [desiredState.down]].flatMap((state2) => identities({ state: state2, dialect: desiredState.dialect, namespace }));
+  const all = [desiredState.from, desiredState.to, ...desiredState.down === undefined ? [] : [desiredState.down]].flatMap((state) => identities({ state, dialect: desiredState.dialect, namespace }));
   return [...new Map(all.map((identity) => [sqlObjectKey6({ identity }), identity])).values()].sort((a, b) => sqlObjectKey6({ identity: a }).localeCompare(sqlObjectKey6({ identity: b })));
 }
 function assertModuleOwnership(params) {
   const { origin } = params;
-  const state2 = origin.source.desiredState;
+  const state = origin.source.desiredState;
   const namespace = moduleNamespace({ origin });
-  const expected = moduleOwnedObjects({ desiredState: state2, namespace });
+  const expected = moduleOwnedObjects({ desiredState: state, namespace });
   const owned = new Set(origin.owned.map((identity) => sqlObjectKey6({ identity })));
   if (expected.length !== owned.size || expected.some((identity) => !owned.has(sqlObjectKey6({ identity }))))
     throw refusal({ reason: "module-ownership-invalid", moduleId: origin.moduleId });
@@ -4071,10 +4225,10 @@ function assertModuleOwnership(params) {
     if (name?.namespace !== namespace || name.name === "_vibe_migrations")
       throw refusal({ reason: "module-ownership-invalid", moduleId: origin.moduleId, identity });
   }
-  for (const target of [state2.from, state2.to, ...state2.down === undefined ? [] : [state2.down]]) {
+  for (const target of [state.from, state.to, ...state.down === undefined ? [] : [state.down]]) {
     if (target.schema.rls !== undefined || target.schema.extensions.length > 0)
       throw refusal({ reason: "module-schema-unsupported", moduleId: origin.moduleId });
-    for (const dependency of [...target.definitions.flatMap((definition) => definition.dependencies), ...(target.schema.migrationObjects ?? []).flatMap((object) => object.dependsOn), ...state2.unmanagedRemovals ?? []]) {
+    for (const dependency of [...target.definitions.flatMap((definition) => definition.dependencies), ...(target.schema.migrationObjects ?? []).flatMap((object) => object.dependsOn), ...state.unmanagedRemovals ?? []]) {
       if (!owned.has(sqlObjectKey6({ identity: dependency })))
         throw refusal({ reason: "module-external-dependency", moduleId: origin.moduleId, identity: dependency });
     }
@@ -4095,10 +4249,39 @@ function assertModuleOwnership(params) {
       throw refusal({ reason: "module-source-state-mismatch", moduleId: origin.moduleId });
     return { ...actual, schema: { ...actual.schema, models: actual.schema.models.filter((model) => !tables.has(model.dbName ?? model.name)), enums: actual.schema.enums.filter((entry) => !enums.has(entry.dbName ?? entry.name)), migrationObjects: (actual.schema.migrationObjects ?? []).filter((object) => !owned.has(sqlObjectKey6({ identity: object.identity }))) }, definitions: actual.definitions.filter((definition) => !owned.has(sqlObjectKey6({ identity: definition.identity }))) };
   };
-  const before = canonicalMigrationJson({ value: rest(local.from, state2.from) });
-  if (before !== canonicalMigrationJson({ value: rest(local.to, state2.to) }) || before !== canonicalMigrationJson({ value: rest(local.down ?? local.from, state2.down ?? state2.from) }))
+  const before = canonicalMigrationJson({ value: rest(local.from, state.from) });
+  if (before !== canonicalMigrationJson({ value: rest(local.to, state.to) }) || before !== canonicalMigrationJson({ value: rest(local.down ?? local.from, state.down ?? state.from) }))
     throw refusal({ reason: "module-mutates-application-state", moduleId: origin.moduleId });
 }
+function dependencyUnavailable(params) {
+  return new VibeError17({ code: "VIBE_MIGRATION", message: "Cannot establish module foreign-key dependencies across namespaces. MySQL requires direct global SHOW VIEW (or SELECT) without partial revokes; SHOW VIEW exposes metadata without granting external row reads. Restore catalog visibility before retrying", meta: { reason: "module-dependency-unavailable", moduleId: params.origin.moduleId }, ...params.cause === undefined ? {} : { cause: params.cause } });
+}
+async function assertCrossNamespaceModuleDependencies(params) {
+  const { executor, origin } = params;
+  const dialect = getSqlDialect3({ dialect: origin.dialect });
+  const query = renderModuleDependencyQuery({ dialect, operation: { kind: "foreignKeys", namespace: params.namespace, tables: [...params.tables] } });
+  if (query === undefined)
+    return;
+  const visibility = renderModuleDependencyQuery({ dialect, operation: { kind: "visibility" } });
+  if (visibility !== undefined) {
+    const rows = await executor({ text: visibility.text, values: [...visibility.values] }).then(undefined, (cause) => {
+      throw dependencyUnavailable({ origin, cause });
+    });
+    if (!hasMysqlGlobalCatalogVisibility({ rows }))
+      throw dependencyUnavailable({ origin });
+  }
+  const rows = await executor({ text: query.text, values: [...query.values] }).then(undefined, (cause) => {
+    throw dependencyUnavailable({ origin, cause });
+  });
+  const flags = [true, false, 0, 1, "0", "1"];
+  for (const row of rows) {
+    const { constraint_name: name, source_namespace: namespace, source_table: table, target_namespace: targetNamespace, target_table: targetTable, source_owned: source, target_owned: target } = row;
+    if (typeof name !== "string" || name.length === 0 || typeof namespace !== "string" || namespace.length === 0 || typeof table !== "string" || table.length === 0 || typeof targetNamespace !== "string" || targetNamespace.length === 0 || typeof targetTable !== "string" || targetTable.length === 0 || !flags.includes(source) || !flags.includes(target) || Number(source) + Number(target) === 0)
+      throw dependencyUnavailable({ origin });
+    if (Number(source) !== Number(target))
+      throw refusal({ reason: "module-external-dependency", moduleId: origin.moduleId, identity: { kind: "constraint", constraintType: "foreignKey", table: { namespace, name: table }, name } });
+  }
+}
 async function assertLiveModuleOwnership(params) {
   const { executor, origin } = params;
   const namespace = moduleNamespace({ origin });
@@ -4108,6 +4291,7 @@ async function assertLiveModuleOwnership(params) {
   const before = new Set(identities({ state: origin.source.desiredState.from, dialect: origin.dialect, namespace }).map((identity) => sqlObjectKey6({ identity })));
   const owned = new Set(origin.owned.map((identity) => sqlObjectKey6({ identity })));
   const tables = new Set(origin.owned.flatMap((identity) => identity.kind === "table" ? [identity.name.name] : []));
+  await assertCrossNamespaceModuleDependencies({ executor, origin, namespace, tables });
   for (const object of inventory) {
     const key = sqlObjectKey6({ identity: object.identity });
     if (params.resume !== true && owned.has(key) && !before.has(key))
@@ -4117,7 +4301,7 @@ async function assertLiveModuleOwnership(params) {
     if (object.inspectionUnavailable !== undefined && (owned.has(key) || ("table" in object.identity) && tables.has(object.identity.table.name)))
       throw refusal({ reason: "module-dependency-unavailable", moduleId: origin.moduleId, identity: object.identity });
   }
-  const physical = origin.dialect === "postgres" ? await introspectPhysicalPostgres({ executor }) : origin.dialect === "mysql" ? await introspectMysql({ executor }) : await introspectSqlite({ executor });
+  const physical = origin.dialect === "postgres" ? await introspectPhysicalPostgres({ executor }) : origin.dialect === "mysql" ? await introspectMysql({ executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor }) : await introspectSqlite({ executor });
   for (const model of physical.models)
     for (const relation of model.relations) {
       const target = physical.models.find((candidate) => candidate.name === relation.targetModel);
@@ -4125,13 +4309,23 @@ async function assertLiveModuleOwnership(params) {
         throw refusal({ reason: "module-external-dependency", moduleId: origin.moduleId });
     }
 }
+async function assertApplicationModuleState(params) {
+  for (const origin of params.origins) {
+    await assertLiveModuleOwnership({ executor: params.executor, origin, resume: true, ...params.sqliteRestorePending === true ? { sqliteRestorePending: true } : {} });
+    const state = origin.source.desiredState;
+    const options = { executor: params.executor, dialect: origin.dialect, from: state.from, to: state.to, removals: state.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } };
+    const report = params.sqliteRestorePending === true ? await verifySqliteTransitionBeforeRestore(options) : await verifyMigrationTransition(options);
+    if (!report.inSync)
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: `Application SQL cannot change objects owned by module ${origin.moduleId}; use its reviewed module upgrade`, meta: { reason: "module-application-mutation", moduleId: origin.moduleId, report } });
+  }
+}
 
 // packages/migrate/src/sql-statements.ts
-import { VibeError as VibeError17 } from "@vibeorm/schema";
+import { VibeError as VibeError18 } from "@vibeorm/schema";
 var COMPOUND_BODY_HEADER = /^(?:\s|--[^\n]*\n|\/\*[\s\S]*?\*\/)*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY)\s+)?(?:DEFINER\s*=\s*\S+\s+)?(?:TRIGGER|PROCEDURE|FUNCTION|EVENT)\b/i;
 var BLOCK_OPENERS = new Set(["BEGIN", "CASE", "IF", "LOOP", "WHILE", "REPEAT"]);
 function splitSqlStatements(params) {
-  const { sql: sql2, dialect } = params;
+  const { sql, dialect } = params;
   const statements = [];
   let current = "";
   let hasContent = false;
@@ -4149,65 +4343,65 @@ function splitSqlStatements(params) {
     compound = false;
     afterEnd = false;
   };
-  while (i < sql2.length) {
-    const ch = sql2[i];
-    const next = sql2[i + 1];
-    if (ch === "-" && next === "-" && (dialect !== "mysql" || /\s/.test(sql2[i + 2] ?? `
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === "-" && next === "-" && (dialect !== "mysql" || /\s/.test(sql[i + 2] ?? `
 `)) || ch === "#" && dialect === "mysql") {
-      while (i < sql2.length && sql2[i] !== `
+      while (i < sql.length && sql[i] !== `
 `) {
-        current += sql2[i];
+        current += sql[i];
         i++;
       }
       continue;
     }
     if (ch === "/" && next === "*") {
-      current += sql2.slice(i, i + 2);
+      current += sql.slice(i, i + 2);
       i += 2;
       let depth = 1;
-      while (i < sql2.length && depth > 0) {
-        if (sql2[i] === "/" && sql2[i + 1] === "*" && (dialect === undefined || dialect === "postgres")) {
+      while (i < sql.length && depth > 0) {
+        if (sql[i] === "/" && sql[i + 1] === "*" && (dialect === undefined || dialect === "postgres")) {
           depth++;
           current += "/*";
           i += 2;
-        } else if (sql2[i] === "*" && sql2[i + 1] === "/") {
+        } else if (sql[i] === "*" && sql[i + 1] === "/") {
           depth--;
           current += "*/";
           i += 2;
         } else {
-          current += sql2[i];
+          current += sql[i];
           i++;
         }
       }
       continue;
     }
-    const escapeString = (dialect === undefined || dialect === "postgres") && (ch === "e" || ch === "E") && next === "'" && !/[A-Za-z0-9_$]/.test(sql2[i - 1] ?? "");
+    const escapeString = (dialect === undefined || dialect === "postgres") && (ch === "e" || ch === "E") && next === "'" && !/[A-Za-z0-9_$]/.test(sql[i - 1] ?? "");
     if (escapeString) {
       current += ch;
       i++;
     }
-    const quote = sql2[i];
+    const quote = sql[i];
     if (escapeString || quote === "'" || quote === '"' || quote === "`" && dialect !== "postgres" || quote === "[" && (dialect === undefined || dialect === "sqlite")) {
       hasContent = true;
       const endQuote = quote === "[" ? "]" : quote;
       current += quote;
       i++;
-      while (i < sql2.length) {
-        const value = sql2[i];
+      while (i < sql.length) {
+        const value = sql[i];
         current += value;
         if (value === "\\" && (quote === "'" || quote === '"')) {
           if (escapeString) {
-            if (sql2[i + 1] !== undefined)
-              current += sql2[i + 1];
+            if (sql[i + 1] !== undefined)
+              current += sql[i + 1];
             i += 2;
             continue;
           }
           if (dialect === "mysql" || dialect === undefined) {
-            throw new VibeError17({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
+            throw new VibeError18({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
           }
         }
         if (value === endQuote) {
-          if (quote !== "[" && sql2[i + 1] === endQuote) {
+          if (quote !== "[" && sql[i + 1] === endQuote) {
             current += endQuote;
             i += 2;
             continue;
@@ -4219,14 +4413,14 @@ function splitSqlStatements(params) {
       }
       continue;
     }
-    if (ch === "$" && (dialect === undefined || dialect === "postgres") && !/[A-Za-z0-9_$]/.test(sql2[i - 1] ?? "")) {
-      const tagMatch = /^\$(?:[A-Za-z_][A-Za-z_0-9]*)?\$/.exec(sql2.slice(i));
+    if (ch === "$" && (dialect === undefined || dialect === "postgres") && !/[A-Za-z0-9_$]/.test(sql[i - 1] ?? "")) {
+      const tagMatch = /^\$(?:[A-Za-z_][A-Za-z_0-9]*)?\$/.exec(sql.slice(i));
       if (tagMatch !== null) {
         hasContent = true;
         const tag = tagMatch[0];
-        const end = sql2.indexOf(tag, i + tag.length);
-        const stop = end === -1 ? sql2.length : end + tag.length;
-        current += sql2.slice(i, stop);
+        const end = sql.indexOf(tag, i + tag.length);
+        const stop = end === -1 ? sql.length : end + tag.length;
+        current += sql.slice(i, stop);
         i = stop;
         continue;
       }
@@ -4241,14 +4435,14 @@ function splitSqlStatements(params) {
       i++;
       continue;
     }
-    const word = /^[A-Za-z_][A-Za-z_0-9]*/.exec(sql2.slice(i))?.[0];
+    const word = /^[A-Za-z_][A-Za-z_0-9]*/.exec(sql.slice(i))?.[0];
     if (word !== undefined) {
       hasContent = true;
       if (!compound && COMPOUND_BODY_HEADER.test(current + word))
         compound = true;
       if (compound) {
         const upper = word.toUpperCase();
-        const rest = sql2.slice(i + word.length);
+        const rest = sql.slice(i + word.length);
         const opens = !afterEnd && (upper === "BEGIN" || blockDepth > 0 && BLOCK_OPENERS.has(upper) && !/^\s*\(/.test(rest) && !(upper === "IF" && /^\s+(?:NOT\s+)?EXISTS\b/i.test(rest)));
         afterEnd = upper === "END";
         if (opens)
@@ -4277,10 +4471,10 @@ function joinSqlStatements(params) {
 
 // packages/migrate/src/module-origin.ts
 import { createHash } from "crypto";
-import { VibeError as VibeError18, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey7 } from "@vibeorm/schema";
+import { VibeError as VibeError19, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey7 } from "@vibeorm/schema";
 var MODULE_ORIGIN_METADATA = Object.freeze({ filename: "module-origin.json", version: 1 });
 function invalid2() {
-  return new VibeError18({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
+  return new VibeError19({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
 }
 function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -4344,7 +4538,7 @@ function assertMaterializedModuleMigration(params) {
     return;
   const restored = restoreModuleMigration({ migration, origin: migration.moduleOrigin });
   if (migration.desiredState === undefined || canonicalMigrationJson({ value: restored }) !== canonicalMigrationJson({ value: migration }))
-    throw new VibeError18({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
+    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
 }
 function restoreModuleMigration(params) {
   const { migration, origin } = params;
@@ -4353,7 +4547,7 @@ function restoreModuleMigration(params) {
     const actual = migration[key];
     if (actual === undefined)
       continue;
-    const normalized = (sql2) => sql2.flatMap((text) => splitSqlStatements({ sql: text, dialect: origin.dialect }));
+    const normalized = (sql) => sql.flatMap((text) => splitSqlStatements({ sql: text, dialect: origin.dialect }));
     if (canonicalMigrationJson({ value: normalized(actual) }) !== canonicalMigrationJson({ value: normalized(origin.source[key] ?? []) }))
       throw invalid2();
   }
@@ -4367,13 +4561,13 @@ function restoreModuleMigration(params) {
 // packages/migrate/src/fs.ts
 import { readFile, readdir } from "fs/promises";
 import { join } from "path";
-import { VibeError as VibeError31, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
+import { VibeError as VibeError33, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
 
 // packages/migrate/src/migration-checksum.ts
 import { createHash as createHash2 } from "crypto";
 
 // packages/migrate/src/execution.ts
-import { VibeError as VibeError19 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } from "@vibeorm/schema";
 var EXECUTION_SIDECAR_FILENAME = "execution.json";
 var EXECUTION_SIDECAR_VERSION = 1;
 function isDefaultExecution(params) {
@@ -4412,7 +4606,7 @@ ${lines.join(`
 `)}`;
 }
 function invalid3(params) {
-  return new VibeError19({
+  return new VibeError20({
     code: "VIBE_MIGRATION",
     message: `invalid execution metadata for migration "${params.migration}": ${params.detail}`,
     meta: { reason: "execution-metadata-invalid", migration: params.migration }
@@ -4463,7 +4657,7 @@ function parseExecutionSidecar(params) {
   try {
     parsed = JSON.parse(params.text);
   } catch (error) {
-    throw new VibeError19({
+    throw new VibeError20({
       code: "VIBE_MIGRATION",
       message: `invalid execution metadata for migration "${migration}": not valid JSON`,
       meta: { reason: "execution-metadata-invalid", migration },
@@ -4561,16 +4755,35 @@ function migrationChecksum(params) {
 -- vibeorm:down ${JSON.stringify(params.downSql ?? null)}${executionChecksumSuffix({ ...params.downExecution === undefined ? {} : { execution: params.downExecution } })}`)).digest("hex");
 }
 
+// packages/migrate/src/shadow-guard.ts
+import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect4, renderShadowOperation } from "@vibeorm/sql";
+var replayExecutors = new WeakSet;
+async function assertDatabaseNotShadow(params) {
+  if (params.dialect === "sqlite" || replayExecutors.has(params.executor))
+    return;
+  const [query] = renderShadowOperation({ dialect: getSqlDialect4({ dialect: params.dialect }), operation: { kind: "markerExists" } });
+  const rows = await params.executor({ text: query.text, values: [...query.values] });
+  if (rows.length !== 0)
+    throw new VibeError21({ code: "VIBE_MIGRATION", message: "This database is claimed as a disposable migration shadow. Application migrations must use the deployment target.", meta: { reason: "shadow-database-is-not-target" } });
+}
+function runShadowReplay(params) {
+  replayExecutors.add(params.executor);
+  return Promise.resolve().then(params.run).finally(() => {
+    replayExecutors.delete(params.executor);
+  });
+}
+
 // packages/migrate/src/module-history.ts
-import { VibeError as VibeError20, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
+import { VibeError as VibeError22, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
 function refusal2(params) {
-  return new VibeError20({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
+  return new VibeError22({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
 }
 function moduleHistoryHeads(params) {
   const heads = new Map;
   const revisions = new Map;
-  for (const record3 of params.records.values()) {
-    const origin = record3.entry?.migration.moduleOrigin;
+  for (const record of params.records.values()) {
+    const origin = record.entry?.migration.moduleOrigin;
     if (origin === undefined)
       continue;
     const previous = heads.get(origin.moduleId);
@@ -4583,10 +4796,21 @@ function moduleHistoryHeads(params) {
       throw refusal2({ reason: "module-predecessor-state", moduleId: origin.moduleId });
     seen.add(origin.revision);
     revisions.set(origin.moduleId, seen);
-    heads.set(origin.moduleId, record3);
+    heads.set(origin.moduleId, record);
   }
   return heads;
 }
+function applicationModuleOrigins(params) {
+  if (params.migration.moduleOrigin !== undefined || params.migration.desiredState !== undefined)
+    return [];
+  const origins = [];
+  for (const [moduleId, head] of moduleHistoryHeads(params)) {
+    if (!head.entry.complete || head.row.error !== undefined || head.row.statementIndex !== head.entry.migration.sql.length)
+      throw refusal2({ reason: "module-chain-incomplete", moduleId });
+    origins.push(head.entry.migration.moduleOrigin);
+  }
+  return origins;
+}
 function preserves(params) {
   const tables = new Set(params.expected.schema.models.map((model) => model.dbName ?? model.name));
   const enums = new Set(params.expected.schema.enums.map((entry) => entry.dbName ?? entry.name));
@@ -4617,9 +4841,9 @@ function assertModuleUpgradeHistory(params) {
       owners.set(key, origin.moduleId);
     }
   };
-  for (const record3 of params.records.values())
-    if (record3.entry !== undefined)
-      register(record3.entry.migration);
+  for (const record of params.records.values())
+    if (record.entry !== undefined)
+      register(record.entry.migration);
   for (const migration of params.migrations) {
     const stored = params.records.get(migration.name);
     const origin = migration.moduleOrigin;
@@ -4631,7 +4855,7 @@ function assertModuleUpgradeHistory(params) {
     if (origin === undefined) {
       for (const [moduleId, head] of heads) {
         if (migration.desiredState === undefined)
-          throw refusal2({ reason: "module-application-state-required", moduleId });
+          continue;
         const expected = head.entry.migration.moduleOrigin.source.desiredState.to;
         for (const actual of [migration.desiredState.from, migration.desiredState.to, migration.desiredState.down ?? migration.desiredState.from])
           preserves({ actual, expected, moduleId });
@@ -4658,22 +4882,22 @@ function assertModuleUpgradeHistory(params) {
 }
 
 // packages/migrate/src/module-journal.ts
-import { VibeError as VibeError22 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect3, MODULE_JOURNAL_COLUMN, renderModuleJournal } from "@vibeorm/sql";
+import { VibeError as VibeError24 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect5, MODULE_JOURNAL_COLUMN, renderModuleJournal } from "@vibeorm/sql";
 
 // packages/migrate/src/journal-read.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { VibeError as VibeError23 } from "@vibeorm/schema";
 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 record3 = current;
+    const record = current;
     for (const key of ["code", "errno", "sqlState"]) {
-      const value = record3[key];
+      const value = record[key];
       if (typeof value === "string" && MISSING_TABLE_IDENTIFIERS.has(value))
         return true;
     }
-    current = record3.cause;
+    current = record.cause;
   }
   return false;
 }
@@ -4686,7 +4910,7 @@ async function readJournalRows(params) {
       if (presence.state === "missing")
         return;
     }
-    throw new VibeError21({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
+    throw new VibeError23({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
   });
   if (rows === undefined)
     return;
@@ -4694,7 +4918,7 @@ async function readJournalRows(params) {
   for (const row of rows) {
     const index = row.statement_index;
     if (typeof row.name !== "string" || typeof row.checksum !== "string" || typeof index !== "number" && typeof index !== "string" || typeof index === "string" && !/^-?\d+$/.test(index) || !Number.isSafeInteger(Number(index)) || row.module_origin !== null && row.module_origin !== undefined && typeof row.module_origin !== "string" || row.error !== null && row.error !== undefined && typeof row.error !== "string" || result.has(row.name)) {
-      throw new VibeError21({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
+      throw new VibeError23({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
     }
     result.set(row.name, { checksum: row.checksum, statementIndex: Number(index), ...typeof row.error === "string" ? { error: row.error } : {}, ...typeof row.module_origin === "string" ? { moduleEntry: row.module_origin } : {} });
   }
@@ -4703,7 +4927,7 @@ async function readJournalRows(params) {
 
 // packages/migrate/src/module-journal.ts
 function invalid4() {
-  return new VibeError22({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
+  return new VibeError24({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
 }
 function parseModuleJournalEntry(params) {
   return parseMigrationMetadata({ text: params.text, failure: invalid4, parse: (value) => {
@@ -4719,7 +4943,7 @@ function parseModuleJournalEntry(params) {
   } });
 }
 async function readModuleJournal(params) {
-  const query = renderModuleJournal({ dialect: getSqlDialect3({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: { kind: "read" } });
+  const query = renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: { kind: "read" } });
   const rows = await readJournalRows({ ...params, query });
   return new Map([...rows ?? []].map(([name, row]) => {
     const entry = row.moduleEntry === undefined ? undefined : parseModuleJournalEntry({ text: row.moduleEntry, name, checksum: row.checksum });
@@ -4729,14 +4953,14 @@ async function readModuleJournal(params) {
   }));
 }
 async function ensureModuleJournal(params) {
-  const dialect = getSqlDialect3({ dialect: params.dialect });
+  const dialect = getSqlDialect5({ dialect: params.dialect });
   const columns = await params.executor(renderModuleJournal({ dialect, table: MIGRATIONS_TABLE_NAME, operation: { kind: "columns" } }));
   if (columns.some((row) => row.name === MODULE_JOURNAL_COLUMN))
     return;
   await params.executor(renderModuleJournal({ dialect, table: MIGRATIONS_TABLE_NAME, operation: { kind: "addColumn" } }));
 }
 async function insertModuleJournal(params) {
-  await params.executor(renderModuleJournal({ dialect: getSqlDialect3({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
+  await params.executor(renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
     kind: "insert",
     name: params.migration.name,
     checksum: migrationChecksum(params.migration),
@@ -4745,7 +4969,7 @@ async function insertModuleJournal(params) {
   } }));
 }
 async function completeModuleJournal(params) {
-  await params.executor(renderModuleJournal({ dialect: getSqlDialect3({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
+  await params.executor(renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
     kind: "complete",
     name: params.migration.name,
     entry: canonicalMigrationJson({ value: { version: 1, migration: params.migration, complete: true } })
@@ -4762,19 +4986,19 @@ function moduleRecordComplete(params) {
 }
 
 // packages/migrate/src/runner.ts
-import { VibeError as VibeError30 } from "@vibeorm/schema";
+import { VibeError as VibeError32 } from "@vibeorm/schema";
 import {
   DIALECT_CAPABILITIES as DIALECT_CAPABILITIES3,
-  getSqlDialect as getSqlDialect5,
+  getSqlDialect as getSqlDialect7,
   renderMigrationSessionRead,
   renderMigrationSessionRestore,
   renderMigrationSessionSet
 } from "@vibeorm/sql";
 
 // packages/migrate/src/recovery.ts
-import { VibeError as VibeError23 } from "@vibeorm/schema";
+import { VibeError as VibeError25 } from "@vibeorm/schema";
 import {
-  getSqlDialect as getSqlDialect4,
+  getSqlDialect as getSqlDialect6,
   renderColumnStateQuery,
   renderConstraintStateQuery,
   renderIndexStateQuery,
@@ -4788,7 +5012,7 @@ function constraintUnverifiable(params) {
   });
 }
 function conflict2(params) {
-  return new VibeError23({
+  return new VibeError25({
     code: "VIBE_MIGRATION",
     message: params.message,
     meta: { reason: params.reason, ...params.meta }
@@ -4813,7 +5037,7 @@ function sameShape(params) {
 }
 async function establishOperationState(params) {
   const { executor, operation } = params;
-  const dialect = getSqlDialect4({ dialect: params.dialect });
+  const dialect = getSqlDialect6({ dialect: params.dialect });
   const run = async (query) => executor({ text: query.text, values: [...query.values] });
   switch (operation.kind) {
     case "createIndexConcurrently": {
@@ -4893,10 +5117,10 @@ async function establishOperationState(params) {
 
 // packages/migrate/src/differ.ts
 import { isEnumType as isEnumType6, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
-import { VibeError as VibeError25 } from "@vibeorm/schema";
+import { VibeError as VibeError27 } from "@vibeorm/schema";
 
 // packages/migrate/src/renames.ts
-import { VibeError as VibeError24 } from "@vibeorm/schema";
+import { VibeError as VibeError26 } from "@vibeorm/schema";
 function tableOf(model) {
   return model.dbName ?? model.name;
 }
@@ -4907,7 +5131,7 @@ function hasColumn(params) {
   return params.model.fields.some((field) => (field.dbName ?? field.name) === params.column);
 }
 function ambiguous(params) {
-  return new VibeError24({
+  return new VibeError26({
     code: "VIBE_MIGRATION",
     message: `rename refused: ${params.detail}`,
     meta: { reason: "rename-ambiguous", ...params.meta }
@@ -5055,7 +5279,7 @@ function diffSchemas(params) {
       if (before?.definition === exclusion.definition)
         continue;
       if (before?.catalogDefinition)
-        throw new VibeError25({ code: "VIBE_MIGRATION", message: "Exclusion comparison requires normalized evidence", meta: { reason: "exclusion-inspection-unavailable", table, name: exclusion.name } });
+        throw new VibeError27({ 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 });
@@ -5267,7 +5491,7 @@ function diffOneTable(params) {
       changes.push("collation");
     if (changes.length === 0)
       continue;
-    if (changes.includes("type") && [...previous.checks].some(([name2, expression]) => current.checks.get(name2) === expression)) {
+    if (changes.includes("type") && [...previous.checks].some(([name, expression]) => current.checks.get(name) === expression)) {
       throw unsupportedCapability6({ dialect, feature: "alterColumnWithRetainedCheck", hint: "CHECK dependencies and type compatibility are not proven; use a reviewed migration that replaces and revalidates the affected constraints" });
     }
     const storageChange = isEnumStringTransition({ from: before.field, to: column.field });
@@ -5331,7 +5555,7 @@ function diffOneTable(params) {
     if (before === expression)
       continue;
     if (before !== undefined && previous.model.checks?.some((check) => check.name === name && check.catalogExpression === true))
-      throw new VibeError25({ code: "VIBE_MIGRATION", message: "Unequal catalog CHECK text requires normalized evidence or explicit replacement through the live planner", meta: { reason: "check-inspection-unavailable", table, name } });
+      throw new VibeError27({ 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 });
@@ -5410,12 +5634,12 @@ function diffOneTable(params) {
 }
 
 // packages/migrate/src/ddl/render.ts
-import { VibeError as VibeError29, sqlObjectKey as sqlObjectKey9 } from "@vibeorm/schema";
+import { VibeError as VibeError31, sqlObjectKey as sqlObjectKey9 } from "@vibeorm/schema";
 
 // packages/migrate/src/ddl/postgres.ts
 import { renderExclusionSetup } from "@vibeorm/sql";
-import { VibeError as VibeError26, isEnumType as isEnumType7 } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect7, renderRlsPolicyPath } from "@vibeorm/sql";
+import { VibeError as VibeError28, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect8, renderRlsPolicyPath } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
   return params.steps.flatMap((step) => renderStep({ step }));
@@ -5449,7 +5673,7 @@ function refuseSameTransactionEnumUse(params) {
       const found = use(field);
       if (found === undefined)
         continue;
-      throw new VibeError26({
+      throw new VibeError28({
         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" }
@@ -5461,7 +5685,7 @@ function renderStep(params) {
   const { step } = params;
   switch (step.kind) {
     case "addExclusion":
-      return [...renderExclusionSetup({ dialect: postgresDialect7, exclusion: step.exclusion }), `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.exclusion.name)} ${step.exclusion.definition};`];
+      return [...renderExclusionSetup({ dialect: postgresDialect8, exclusion: step.exclusion }), `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.exclusion.name)} ${step.exclusion.definition};`];
     case "dropExclusion":
       return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.exclusion.name)};`];
     case "enableRls":
@@ -5470,7 +5694,7 @@ function renderStep(params) {
     case "noForceRls":
     case "createPolicy":
     case "dropPolicy":
-      return step.kind === "createPolicy" ? [renderRlsPolicyPath({ dialect: postgresDialect7, stage: "save" }).text, renderRlsPolicyPath({ dialect: postgresDialect7, stage: "empty" }).text, ...renderRlsStep({ step, dialect: "postgres" }), renderRlsPolicyPath({ dialect: postgresDialect7, stage: "restore" }).text] : renderRlsStep({ step, dialect: "postgres" });
+      return step.kind === "createPolicy" ? [renderRlsPolicyPath({ dialect: postgresDialect8, stage: "save" }).text, renderRlsPolicyPath({ dialect: postgresDialect8, stage: "empty" }).text, ...renderRlsStep({ step, dialect: "postgres" }), renderRlsPolicyPath({ dialect: postgresDialect8, stage: "restore" }).text] : renderRlsStep({ step, dialect: "postgres" });
     case "createEnum": {
       const name = step.enumDef.dbName ?? step.enumDef.name;
       const values = step.enumDef.values.map((value) => quotePgString({ value })).join(", ");
@@ -5520,7 +5744,7 @@ ${lines.join(`,
     case "dropIndex":
       if (step.constraintName !== undefined) {
         if (step.table === undefined)
-          throw new VibeError26({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
+          throw new VibeError28({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
         return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName)};`];
       }
       return [`DROP INDEX ${publicName(step.name)};`];
@@ -5584,7 +5808,7 @@ function columnDefSql(params) {
   const { field } = params;
   const name = q2(field.dbName ?? field.name);
   if (field.default?.kind === "autoincrement" && !isIdentityColumn({ field })) {
-    throw new VibeError26({
+    throw new VibeError28({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -5620,7 +5844,7 @@ function renderAlterColumn(params) {
   }
   if (step.changes.includes("default") || droppedDefault) {
     if (step.to.default?.kind === "autoincrement") {
-      throw new VibeError26({
+      throw new VibeError28({
         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 }
@@ -5635,11 +5859,11 @@ function publicName(name) {
   return `${q2("public")}.${q2(name)}`;
 }
 function q2(name) {
-  return postgresDialect7.quoteIdent({ name });
+  return postgresDialect8.quoteIdent({ name });
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError27, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError29, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -5779,7 +6003,7 @@ function renderSqliteSteps(params) {
         continue;
       const awaitsNewParent = [...toNorm?.tables.get(table)?.fks.values() ?? []].some((fk) => createdTables.has(fk.refTable));
       if (awaitsNewParent) {
-        throw new VibeError27({
+        throw new VibeError29({
           code: "VIBE_MIGRATION",
           message: `cannot order this sqlite migration safely: rebuilding "${table}" must happen BEFORE the dropped table(s) it references (${[
             ...droppedTables
@@ -5808,7 +6032,7 @@ function renderSqliteSteps(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError27({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError29({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "createEnum":
       case "dropEnum":
       case "addEnumValue":
@@ -5893,7 +6117,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 VibeError27({
+          throw new VibeError29({
             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" }
@@ -5947,7 +6171,7 @@ function classifyRebuilds(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError27({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError29({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "alterColumn":
       case "dropForeignKey":
       case "addPrimaryKey":
@@ -6008,7 +6232,7 @@ function renderTableRebuild(params) {
   const source = from.tables.get(table);
   const target = to.tables.get(table);
   if (source === undefined || target === undefined) {
-    throw new VibeError27({
+    throw new VibeError29({
       code: "VIBE_MIGRATION",
       message: `cannot rebuild "${table}" \u2014 the table is missing from the ${source === undefined ? "from" : "to"} schema`,
       meta: { table }
@@ -6143,7 +6367,7 @@ function columnDefSql2(params) {
   const { field, constraintTable, enums, inlinePkAutoincrement } = params;
   const name = field.dbName ?? field.name;
   if (field.default?.kind === "autoincrement" && !inlinePkAutoincrement) {
-    throw new VibeError27({
+    throw new VibeError29({
       code: "VIBE_MIGRATION",
       message: `autoincrement on sqlite requires "${field.name}" to be the single-column Int or BigInt primary key`,
       meta: { field: field.name }
@@ -6162,7 +6386,7 @@ function columnDefSql2(params) {
     const enumName = field.type.enum;
     const values = resolveEnumValues({ name: enumName, enums });
     if (values === undefined) {
-      throw new VibeError27({
+      throw new VibeError29({
         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 }
@@ -6197,7 +6421,7 @@ function requireSchemas(params) {
   const { step, fromNorm, toNorm } = params;
   if (fromNorm !== undefined && toNorm !== undefined)
     return;
-  throw new VibeError27({
+  throw new VibeError29({
     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 }
@@ -6208,7 +6432,7 @@ function q3(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError28, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError30, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect3 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps) {
@@ -6350,12 +6574,12 @@ ${lines.join(`,
       ];
     case "addExclusion":
     case "dropExclusion":
-      throw new VibeError28({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
+      throw new VibeError30({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
     case "dropCheck":
       return [`ALTER TABLE ${q4(step.table)} DROP CHECK ${q4(step.name)};`];
     case "dropIndex": {
       if (step.table === undefined) {
-        throw new VibeError28({
+        throw new VibeError30({
           code: "VIBE_MIGRATION",
           message: `dropIndex "${step.name}" carries no table \u2014 mysql's DROP INDEX requires one`,
           meta: { index: step.name }
@@ -6411,7 +6635,7 @@ function columnDefSql3(params) {
   const name = q4(field.dbName ?? field.name);
   const autoincrement = field.default?.kind === "autoincrement";
   if (autoincrement && field.type !== "Int" && field.type !== "BigInt") {
-    throw new VibeError28({
+    throw new VibeError30({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -6433,7 +6657,7 @@ function renderAlterColumn2(params) {
   const { step, enums } = params;
   assertEnumStringTransition({ from: step.from, to: step.to, dialect: "mysql", table: step.table, column: step.column });
   if (step.to.default?.kind === "autoincrement" && step.from.default?.kind !== "autoincrement") {
-    throw new VibeError28({
+    throw new VibeError30({
       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 }
@@ -6465,32 +6689,32 @@ function declaredSqlitePreservation(params) {
   let to = params.to;
   if (params.from === undefined || to === undefined || (params.from.migrationObjects?.length ?? 0) === 0)
     return { to, restore, columns };
-  const invalid5 = sqliteInvalidatedTables({ steps: params.steps, from: params.from });
+  const invalid = sqliteInvalidatedTables({ steps: params.steps, from: params.from });
   const retained = new Set((to.migrationObjects ?? []).map((object) => sqlObjectKey9({ identity: object.identity })));
   for (const object of params.from.migrationObjects ?? []) {
     const identity = object.identity;
-    if (!("table" in identity) || identity.table.namespace !== "main" || !invalid5.rebuilt.has(identity.table.name) || !retained.has(sqlObjectKey9({ identity })))
+    if (!("table" in identity) || identity.table.namespace !== "main" || !invalid.rebuilt.has(identity.table.name) || !retained.has(sqlObjectKey9({ identity })))
       continue;
     const facts = object.expected?.facts;
     if (facts === undefined)
-      throw new VibeError29({ code: "VIBE_MIGRATION", message: "SQLite rebuild requires independently declared preservation definitions", meta: { reason: "sqlite-preservation-unavailable", identity } });
+      throw new VibeError31({ 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 VibeError29({ code: "VIBE_MIGRATION", message: "Missing SQLite restoration SQL", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError31({ 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 VibeError29({ code: "VIBE_MIGRATION", message: "Missing SQLite column clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError31({ 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 VibeError29({ code: "VIBE_MIGRATION", message: "Missing SQLite default clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError31({ 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)
@@ -6634,19 +6858,19 @@ function planMissingArtifacts(params) {
 }
 async function probeInstalledExtensionState(params) {
   const { executor, dialect, artifacts } = params;
-  const state2 = {};
+  const state = {};
   if (dialect === "postgres" && artifacts.some((artifact) => artifact.owns.kind === "postgresExtension")) {
     const rows = await executor({ text: "SELECT extname FROM pg_extension" });
-    state2.pgExtensions = new Set(rows.map((row) => String(row["extname"])));
+    state.pgExtensions = new Set(rows.map((row) => String(row["extname"])));
   }
   if (dialect === "sqlite" && artifacts.some((artifact) => artifact.owns.kind === "trigger")) {
     const rows = await executor({
       text: "SELECT name FROM sqlite_master WHERE type = 'trigger'",
       values: []
     });
-    state2.triggers = new Set(rows.map((row) => String(row["name"])));
+    state.triggers = new Set(rows.map((row) => String(row["name"])));
   }
-  return state2;
+  return state;
 }
 function artifactCreateSql(params) {
   return params.artifacts.flatMap((artifact) => [...artifact.create]);
@@ -6659,29 +6883,29 @@ function migrationRlsSecurityChanges(params) {
   return securityChangesOf({ steps: withRlsSteps({ from: params.down ? source.to : source.from, to: params.down ? source.from : source.to, steps: [] }) });
 }
 function containsNativeRlsSql(params) {
-  const { sql: sql2, dialect } = params;
+  const { sql, dialect } = params;
   const tokens = [];
   let i = 0;
-  while (i < sql2.length) {
-    const ch = sql2[i];
+  while (i < sql.length) {
+    const ch = sql[i];
     if (/\s/.test(ch)) {
       i++;
       continue;
     }
-    if (sql2.startsWith("--", i) || dialect === "mysql" && ch === "#") {
-      const end = sql2.indexOf(`
+    if (sql.startsWith("--", i) || dialect === "mysql" && ch === "#") {
+      const end = sql.indexOf(`
 `, i);
-      i = end === -1 ? sql2.length : end + 1;
+      i = end === -1 ? sql.length : end + 1;
       continue;
     }
-    if (sql2.startsWith("/*", i)) {
+    if (sql.startsWith("/*", i)) {
       let depth = 1;
       i += 2;
-      while (i < sql2.length && depth > 0) {
-        if (sql2.startsWith("/*", i)) {
+      while (i < sql.length && depth > 0) {
+        if (sql.startsWith("/*", i)) {
           depth++;
           i += 2;
-        } else if (sql2.startsWith("*/", i)) {
+        } else if (sql.startsWith("*/", i)) {
           depth--;
           i += 2;
         } else
@@ -6691,15 +6915,15 @@ function containsNativeRlsSql(params) {
     }
     if (ch === "'" || ch === '"' || ch === "`" || dialect === "sqlite" && ch === "[") {
       const endQuote = ch === "[" ? "]" : ch;
-      const backslash = dialect === "mysql" || ch === "'" && /(?:^|[^\w$])[eE]$/.test(sql2.slice(0, i));
+      const backslash = dialect === "mysql" || ch === "'" && /(?:^|[^\w$])[eE]$/.test(sql.slice(0, i));
       i++;
-      while (i < sql2.length) {
-        if (backslash && sql2[i] === "\\") {
+      while (i < sql.length) {
+        if (backslash && sql[i] === "\\") {
           i += 2;
           continue;
         }
-        if (sql2[i] === endQuote) {
-          if (sql2[i + 1] === endQuote) {
+        if (sql[i] === endQuote) {
+          if (sql[i + 1] === endQuote) {
             i += 2;
             continue;
           }
@@ -6712,15 +6936,15 @@ function containsNativeRlsSql(params) {
       continue;
     }
     if (ch === "$") {
-      const tag = /^(?:\$\$|\$[A-Za-z_][A-Za-z_0-9]*\$)/.exec(sql2.slice(i))?.[0];
+      const tag = /^(?:\$\$|\$[A-Za-z_][A-Za-z_0-9]*\$)/.exec(sql.slice(i))?.[0];
       if (tag !== undefined) {
-        const end = sql2.indexOf(tag, i + tag.length);
-        i = end === -1 ? sql2.length : end + tag.length;
+        const end = sql.indexOf(tag, i + tag.length);
+        i = end === -1 ? sql.length : end + tag.length;
         tokens.push("@");
         continue;
       }
     }
-    const word = /^[A-Za-z_][A-Za-z_0-9$]*/.exec(sql2.slice(i))?.[0];
+    const word = /^[A-Za-z_][A-Za-z_0-9$]*/.exec(sql.slice(i))?.[0];
     tokens.push(word === undefined ? ch : word.toUpperCase());
     i += word?.length ?? 1;
   }
@@ -6730,14 +6954,14 @@ function containsNativeRlsSql(params) {
   });
 }
 function assertNativeMigrationMetadata(params) {
-  const native = params.migration.rls !== undefined || params.sql.some((sql2) => containsNativeRlsSql({ sql: sql2, dialect: params.dialect }));
+  const native = params.migration.rls !== undefined || params.sql.some((sql) => containsNativeRlsSql({ sql, dialect: params.dialect }));
   if (!native)
     return;
   if (!DIALECT_CAPABILITIES3[params.dialect].nativeRowLevelSecurity) {
-    throw new VibeError30({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
+    throw new VibeError32({ 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 VibeError30({ 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 VibeError32({ 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;
@@ -6779,14 +7003,14 @@ function checksumOf(params) {
   return migrationChecksum(migration);
 }
 async function assertForwardStart(params) {
-  const state2 = params.migration.desiredState;
-  if (state2 === undefined)
+  const state = params.migration.desiredState;
+  if (state === undefined)
     return;
-  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state2.from, ...params.probe === undefined ? {} : { probe: params.probe } });
+  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.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 (state.down !== undefined) {
+    const restored = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.down, ...params.probe === undefined ? {} : { probe: params.probe } });
     if (restored.inSync)
       return;
   }
@@ -6806,7 +7030,7 @@ function generateMigration(params) {
   const steps = diffSchemas({ from: strippedFrom, to, dialect, ...params.renames === undefined ? {} : { renames: params.renames } });
   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 = [
+  const sql = [
     ...artifactCreateSql({
       artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
     }),
@@ -6816,18 +7040,18 @@ function generateMigration(params) {
     }),
     ...orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).flatMap((object) => {
       if (object.dialect !== dialect)
-        throw new VibeError30({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}` });
+        throw new VibeError32({ 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 VibeError30({ 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 } });
+        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", shadowReusable: true, id: object.id } });
       return [];
     })
   ];
   return {
     name,
-    sql: sql2,
+    sql,
     destructive: steps.some((step) => step.destructive),
     ...securityChangesOf({ steps }).length === 0 ? {} : { securityChanges: securityChangesOf({ steps }) },
     ...from.rls === undefined && to.rls === undefined ? {} : { rls: { from, to } },
@@ -6835,6 +7059,25 @@ function generateMigration(params) {
     desiredState: params.desiredState ?? { version: 1, dialect, from: createDesiredState({ schema: from, dialect }), to: createDesiredState({ schema: to, dialect }) }
   };
 }
+async function withMigrationLock(params) {
+  const runLocked = async (executor) => {
+    await acquireLock({ executor, dialect: params.dialect });
+    return Promise.resolve().then(async () => {
+      await assertDatabaseNotShadow({ executor, dialect: params.dialect });
+      return params.run(executor);
+    }).then(async (value) => {
+      await releaseLock({ executor, dialect: params.dialect });
+      return value;
+    }, (cause) => releaseLock({ executor, dialect: params.dialect }).then(() => {
+      throw cause;
+    }, (cleanupCause) => {
+      if (cause instanceof VibeError32)
+        throw new VibeError32({ code: cause.code, message: cause.message, meta: { ...cause.meta, cleanupCause }, cause });
+      throw cause;
+    }));
+  };
+  return params.executor.withSession === undefined ? runLocked(params.executor) : params.executor.withSession({ run: runLocked });
+}
 function validateMigrationReplay(params) {
   const dialect = params.dialect ?? "postgres";
   assertProbeMode({ dialect, probe: params.probe });
@@ -6845,8 +7088,8 @@ function validateMigrationReplay(params) {
       assertSupportedSelfManagedScript({ sql: migration.sql, migration: migration.name, direction: "up" });
     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 } });
+      const state = migration.desiredState;
+      assertRemovalAuthorization({ steps: diffSchemas({ from: state.from.schema, to: state.to.schema, dialect }), previous: state.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 } });
   }
@@ -6858,11 +7101,11 @@ function assertMigrationMetadata(params) {
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   if (migration.desiredStatePending === true)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: `Migration ${migration.name} has unfinalized desired state; finalize its reviewed before/after declarations before applying`, meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError32({ 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 VibeError30({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch", migration: migration.name } });
+      throw new VibeError32({ 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 });
@@ -6871,23 +7114,19 @@ async function applyMigrations(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
   if (params.history !== undefined && params.history !== "complete" && params.history !== "subset")
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
   if (params.history === "complete")
     assertDistinctMigrationNames({ migrations });
   for (const migration of migrations)
     assertMigrationMetadata({ migration, dialect });
-  if (executor.withSession !== undefined) {
-    return executor.withSession({ run: (session) => applyMigrations({ ...params, executor: session }) });
-  }
-  await acquireLock({ executor, dialect });
-  try {
-    const moduleRecords = migrations.some((migration) => migration.moduleOrigin !== undefined) ? await readModuleJournal({ executor, dialect }) : undefined;
-    const recorded = moduleRecords === undefined ? await recordedRows({ executor, dialect }) : new Map([...moduleRecords].map(([name, record3]) => [name, record3.row]));
-    if (moduleRecords !== undefined) {
+  return withMigrationLock({ executor, dialect, run: async (executor) => {
+    let moduleRecords = await readModuleJournal({ executor, dialect });
+    const recorded = new Map([...moduleRecords].map(([name, record]) => [name, record.row]));
+    if (migrations.some((migration) => migration.moduleOrigin !== undefined) || [...moduleRecords.values()].some((record) => record.entry !== undefined)) {
       assertModuleUpgradeHistory({ migrations, records: moduleRecords });
       const namespace = await migrationNamespace({ executor, dialect });
       if (migrations.some((migration) => migration.moduleOrigin !== undefined && moduleNamespace({ origin: migration.moduleOrigin }) !== namespace))
-        throw new VibeError30({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
+        throw new VibeError32({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
     }
     if (params.history === "complete")
       assertCompleteHistory({ migrations, recorded, dialect });
@@ -6898,7 +7137,7 @@ async function applyMigrations(params) {
     });
     validateMigrationReplay({ ...params, migrations: pending, dialect });
     await ensureMigrationsTable({ executor, dialect });
-    if (moduleRecords !== undefined)
+    if (migrations.some((migration) => migration.moduleOrigin !== undefined))
       await ensureModuleJournal({ executor, dialect });
     const applied = [];
     const skipped = [];
@@ -6908,7 +7147,7 @@ async function applyMigrations(params) {
         await assertLiveModuleOwnership({ executor, origin: migration.moduleOrigin, resume: stored !== undefined });
       if (stored !== undefined) {
         if (stored.statementIndex < 0) {
-          throw new VibeError30({
+          throw new VibeError32({
             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 }
@@ -6929,11 +7168,14 @@ async function applyMigrations(params) {
             dialect,
             migration,
             start: stored.statementIndex,
+            moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }),
             ...params.probe === undefined ? {} : { probe: params.probe },
             insertRecord: false,
             ...stored.error === undefined ? {} : { storedError: stored.error }
           })
         });
+        if (migration.moduleOrigin !== undefined)
+          moduleRecords = await readModuleJournal({ executor, dialect });
         applied.push(migration.name);
         continue;
       }
@@ -6942,11 +7184,13 @@ async function applyMigrations(params) {
           executor,
           dialect,
           ...migration.execution === undefined ? {} : { execution: migration.execution },
-          run: () => runNonTransactional({ executor, dialect, migration, start: 0, insertRecord: true, ...params.probe === undefined ? {} : { probe: params.probe } })
+          run: () => runNonTransactional({ executor, dialect, migration, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), start: 0, insertRecord: true, ...params.probe === undefined ? {} : { probe: params.probe } })
         });
       } else {
-        await runTransactional({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
+        await runTransactional({ executor, dialect, migration, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), ...params.probe === undefined ? {} : { probe: params.probe } });
       }
+      if (migration.moduleOrigin !== undefined)
+        moduleRecords = await readModuleJournal({ executor, dialect });
       applied.push(migration.name);
     }
     const final = migrations.at(-1);
@@ -6961,9 +7205,7 @@ async function applyMigrations(params) {
       }
     }
     return { applied, skipped };
-  } finally {
-    await releaseLock({ executor, dialect });
-  }
+  } });
 }
 async function migrationStatus(params) {
   const { executor, migrations } = params;
@@ -7033,19 +7275,14 @@ function classifyJournal(params) {
   return journal;
 }
 async function resolveMigration(params) {
-  if (params.executor.withSession !== undefined) {
-    return params.executor.withSession({ run: (executor2) => resolveMigration({ ...params, executor: executor2 }) });
-  }
-  const { executor } = params;
   const dialect = params.dialect ?? "postgres";
-  await acquireLock({ executor, dialect });
-  await repairMigration({ ...params, executor, dialect }).finally(() => releaseLock({ executor, dialect }));
+  await withMigrationLock({ executor: params.executor, dialect, run: (executor) => repairMigration({ ...params, executor, dialect }) });
 }
 async function repairMigration(params) {
   const { executor, name, dialect } = params;
   const moduleRecord = (await readModuleJournal({ executor, dialect })).get(name);
   if (moduleRecord?.entry !== undefined)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
   await ensureMigrationsTable({ executor, dialect });
   if (params.as === "applied") {
     const insert = `INSERT INTO ${q5(dialect, MIGRATIONS_TABLE_NAME)} (${q5(dialect, "name")}, ${q5(dialect, "checksum")}, ${q5(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, ${RESOLVED_STATEMENT_INDEX})`;
@@ -7062,38 +7299,30 @@ async function rollbackMigration(params) {
   const { executor, migration } = params;
   const dialect = params.dialect ?? "postgres";
   const downSql = validateRollbackFile({ ...params, dialect });
-  if (executor.withSession !== undefined) {
-    return executor.withSession({ run: (session) => rollbackMigration({ ...params, executor: session }) });
-  }
-  await acquireLock({ executor, dialect });
-  await Promise.resolve().then(async () => {
-    const recorded = await recordedRows({ executor, dialect, modules: migration.moduleOrigin !== undefined });
+  await withMigrationLock({ executor, dialect, run: async (executor) => {
+    const recorded = await recordedRows({ executor, dialect, modules: true });
     const stored = assertRollbackRecord({ migration, stored: recorded.get(migration.name), dialect });
     const newest = [...recorded.keys()].at(-1);
     if (newest !== migration.name)
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
     await validateRollbackRecovery({ executor, migration, downSql, stored, dialect });
-    await executeRollback({ ...params, dialect, downSql, stored });
-  }).finally(() => releaseLock({ executor, dialect }));
+    await executeRollback({ ...params, executor, dialect, downSql, stored });
+  } });
 }
 async function rollbackMigrations(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
   assertDistinctMigrationNames({ migrations });
-  if (executor.withSession !== undefined) {
-    return executor.withSession({ run: (session) => rollbackMigrations({ ...params, executor: session }) });
-  }
-  await acquireLock({ executor, dialect });
-  return Promise.resolve().then(async () => {
-    const recorded = await recordedRows({ executor, dialect, modules: migrations.some((migration) => migration.moduleOrigin !== undefined) });
+  return withMigrationLock({ executor, dialect, run: async (executor) => {
+    const recorded = await recordedRows({ executor, dialect, modules: true });
     const journal = classifyJournal({ migrations, recorded, dialect });
     const byName = new Map(migrations.map((migration) => [migration.name, migration]));
     let start = Math.max(0, journal.length - 1);
     if (params.to !== undefined) {
-      const target = journal.findIndex((row2) => row2.name === params.to);
+      const target = journal.findIndex((row) => row.name === params.to);
       const row = journal[target];
       if (row?.state !== "applied")
-        throw new VibeError30({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
+        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
       assertMigrationMetadata({ migration: byName.get(row.name), dialect });
       start = target + 1;
     }
@@ -7101,7 +7330,7 @@ async function rollbackMigrations(params) {
     for (const row of journal.slice(start).reverse()) {
       const migration = byName.get(row.name);
       if (migration === undefined)
-        throw new VibeError30({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
+        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
       const stored = assertRollbackRecord({ migration, stored: recorded.get(row.name), dialect });
       const downSql = validateRollbackFile({ ...params, migration, dialect });
       plan.push({ migration, downSql, stored });
@@ -7110,28 +7339,28 @@ async function rollbackMigrations(params) {
       await validateRollbackRecovery({ executor, dialect, ...entry });
     const rolledBack = [];
     for (const entry of plan) {
-      await executeRollback({ ...params, dialect, ...entry });
+      await executeRollback({ ...params, executor, dialect, ...entry });
       rolledBack.push(entry.migration.name);
     }
     return { rolledBack };
-  }).finally(() => releaseLock({ executor, dialect }));
+  } });
 }
 function validateRollbackFile(params) {
   const { migration, dialect } = params;
   if (migration.desiredStatePending === true)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   if (migration.moduleOrigin !== undefined) {
     assertMaterializedModuleMigration({ migration });
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   const downSql = migration.downSql;
   if (downSql === undefined)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
   assertProbeMode({ dialect, probe: params.probe });
   if (migration.desiredState !== undefined) {
     assertDesiredState({ value: migration.desiredState, migration: migration.name });
     if (migration.desiredState.dialect !== dialect)
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch" } });
+      throw new VibeError32({ 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 });
@@ -7144,10 +7373,10 @@ function validateRollbackFile(params) {
 function assertRollbackRecord(params) {
   const { migration, stored, dialect } = params;
   if (stored === undefined)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
   assertChecksumMatches({ migration, stored: stored.checksum });
   if (stored.statementIndex >= 0 && (!isCompleteRecord({ dialect, migration, stored }) || stored.error !== undefined))
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
   return stored;
 }
 async function validateRollbackRecovery(params) {
@@ -7156,7 +7385,7 @@ async function validateRollbackRecovery(params) {
     return;
   const start = -stored.statementIndex - 1;
   if (start > downSql.length)
-    throw new VibeError30({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
+    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
   if (dialect === "sqlite" && usesSelfManagedTransactions({ sql: downSql }))
     assertSelfManagedResumeSafe({ sql: downSql, start, migration: migration.name, direction: "down" });
   if (!marksInflight({ dialect, execution: migration.downExecution }) || start >= downSql.length)
@@ -7169,16 +7398,17 @@ async function validateRollbackRecovery(params) {
 }
 async function executeRollback(params) {
   const { executor, dialect, migration, downSql, stored } = params;
+  const moduleOrigins = applicationModuleOrigins({ migration, records: await readModuleJournal({ executor, dialect }) });
   if (usesStatementBookkeeping({ dialect, sql: downSql, ...migration.downExecution === undefined ? {} : { execution: migration.downExecution } })) {
     const start = stored.statementIndex < 0 ? -stored.statementIndex - 1 : 0;
     await withSessionLimits({
       executor,
       dialect,
       execution: migration.downExecution,
-      run: () => runNonTransactionalDown({ executor, dialect, migration, downSql, start, probe: params.probe, storedError: stored.error })
+      run: () => runNonTransactionalDown({ executor, dialect, migration, moduleOrigins, downSql, start, probe: params.probe, storedError: stored.error })
     });
   } else
-    await runTransactionalDown({ executor, dialect, migration, downSql, probe: params.probe });
+    await runTransactionalDown({ executor, dialect, migration, moduleOrigins, downSql, probe: params.probe });
 }
 async function runTransactionalDown(params) {
   const { executor, dialect, migration, downSql } = params;
@@ -7190,14 +7420,15 @@ async function runTransactionalDown(params) {
     const limits = migration.downExecution;
     if (wrap && dialect === "postgres" && limits !== undefined) {
       if ((limits.lockTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect5({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
       if ((limits.statementTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect5({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
     }
     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 });
+    await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     for (const statement of downSql) {
       await executeStatement({ executor, statement, dialect });
     }
@@ -7205,6 +7436,7 @@ async function runTransactionalDown(params) {
       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 assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     await executor({
       text: `DELETE FROM ${q5(dialect, MIGRATIONS_TABLE_NAME)} WHERE ${q5(dialect, "name")} = ${ph(dialect, 1)}`,
       values: [migration.name]
@@ -7219,7 +7451,7 @@ async function runTransactionalDown(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError30({
+    throw new VibeError32({
       code: "VIBE_MIGRATION",
       message: `rollback of "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name, ...timeoutDiagnostic({ error }) },
@@ -7251,6 +7483,7 @@ async function runNonTransactionalDown(params) {
     throw uncertainStatement({ migration: migration.name, statements: downSql, index: start, dialect, direction: "down" });
   }
   const resumeState = resumeOperation === undefined ? undefined : await establishOperationState({ executor, dialect, operation: resumeOperation });
+  await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
   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 } }) });
@@ -7260,6 +7493,8 @@ async function runNonTransactionalDown(params) {
   if (resumeOperation !== undefined && resumeState === "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 } }) });
+    if (start + 1 === downSql.length)
+      await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     await recordProgress(start + 1);
     cursor = start + 1;
   }
@@ -7278,11 +7513,14 @@ async function runNonTransactionalDown(params) {
       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 verifySqliteTransitionBeforeRestore({ executor, dialect, from: migration.desiredState.to, to: migration.desiredState.down ?? migration.desiredState.from, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+        await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe, sqliteRestorePending: true });
         await recordProgress(index + 1);
       }
       await executeStatement({ executor, statement: downSql[index], dialect });
       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 (index === downSql.length - 1)
+        await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
       if (atomic) {
         await recordProgress(index + 1);
         await executor({ text: "COMMIT" });
@@ -7296,7 +7534,7 @@ async function runNonTransactionalDown(params) {
           values: [marks ? `${INFLIGHT_PREFIX}${index}` : error instanceof Error ? error.message : String(error), migration.name]
         });
       } catch {}
-      throw new VibeError30({
+      throw new VibeError32({
         code: "VIBE_MIGRATION",
         message: `rollback of "${migration.name}" failed at down statement ${index + 1} of ${downSql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running the rollback resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeoutDiagnostic({ error }) },
@@ -7323,11 +7561,12 @@ async function runTransactional(params) {
     const limits = migration.execution;
     if (wrap && dialect === "postgres" && limits !== undefined) {
       if ((limits.lockTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect5({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
       if ((limits.statementTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect5({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
     }
     await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
+    await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.from, inTransaction: true, requireInstalledRls: true });
     let statementIndex = 0;
@@ -7339,6 +7578,7 @@ async function runTransactional(params) {
       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 assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     if (migration.moduleOrigin !== undefined)
       await insertModuleJournal({ executor, dialect, migration, index: statementIndex, complete: true });
     else
@@ -7356,7 +7596,7 @@ async function runTransactional(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError30({
+    throw new VibeError32({
       code: "VIBE_MIGRATION",
       message: `migration "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name },
@@ -7376,6 +7616,7 @@ async function runNonTransactional(params) {
   const declared = execution?.transaction === "none";
   const marks = marksInflight({ dialect, ...execution === undefined ? {} : { execution } });
   const start = selfManaged ? selfManagedResumeStart({ sql: migration.sql, start: params.start }) : params.start;
+  await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
   if (insertRecord) {
     if (migration.desiredState !== undefined) {
       await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
@@ -7400,10 +7641,12 @@ 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 state2 = await establishOperationState({ executor, dialect, operation });
-      if (state2 === "satisfied") {
+      const state = await establishOperationState({ executor, dialect, operation });
+      if (state === "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 } }) });
+        if (start + 1 === migration.sql.length)
+          await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
         await checkpoint(start + 1);
         cursor = start + 1;
       }
@@ -7426,11 +7669,14 @@ async function runNonTransactional(params) {
       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 verifySqliteTransitionBeforeRestore({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+        await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe, sqliteRestorePending: true });
         await checkpoint(index + 1);
       }
       await executeStatement({ executor, statement: migration.sql[index], dialect });
       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 (index === migration.sql.length - 1)
+        await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
       if (atomic) {
         await checkpoint(index + 1);
         await executor({ text: "COMMIT" });
@@ -7446,7 +7692,7 @@ async function runNonTransactional(params) {
       } catch {}
       const sqlState = sqlStateOf(error);
       const timeout = sqlState === "55P03" ? "lock-timeout" : sqlState === "57014" ? "statement-timeout" : undefined;
-      throw new VibeError30({
+      throw new VibeError32({
         code: "VIBE_MIGRATION",
         message: timeout === "lock-timeout" ? `migration "${migration.name}" gave up waiting for a lock at statement ${index + 1} of ${migration.sql.length} (lock_timeout ${String(execution?.lockTimeoutMs ?? 0)}ms, SQLSTATE 55P03). Another session holds a conflicting lock; inspect the declared operation before retrying.` : timeout === "statement-timeout" ? `migration "${migration.name}" exceeded its statement_timeout at statement ${index + 1} of ${migration.sql.length} (${String(execution?.statementTimeoutMs ?? 0)}ms, SQLSTATE 57014). Inspect the declared operation before retrying.` : `migration "${migration.name}" failed at statement ${index + 1} of ${migration.sql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running applyMigrations resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeout === undefined ? {} : { reason: timeout, sqlState } },
@@ -7474,7 +7720,7 @@ async function acquireLock(params) {
     });
     const acquired = Number(rows[0]?.vibe_lock) === 1;
     if (!acquired) {
-      throw new VibeError30({
+      throw new VibeError32({
         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 }
@@ -7484,13 +7730,11 @@ async function acquireLock(params) {
 }
 async function releaseLock(params) {
   const { executor, dialect } = params;
-  try {
-    if (dialect === "postgres") {
-      await executor({ text: `SELECT pg_advisory_unlock(${PG_ADVISORY_LOCK_KEY})` });
-    } else if (dialect === "mysql") {
-      await executor({ text: `SELECT RELEASE_LOCK('${MYSQL_LOCK_NAME}')` });
-    }
-  } catch {}
+  if (dialect === "postgres") {
+    await executor({ text: `SELECT pg_advisory_unlock(${PG_ADVISORY_LOCK_KEY})` });
+  } else if (dialect === "mysql") {
+    await executor({ text: `SELECT RELEASE_LOCK('${MYSQL_LOCK_NAME}')` });
+  }
 }
 var INFLIGHT_PREFIX = "VIBE_INFLIGHT:";
 function inflightStatement(params) {
@@ -7511,7 +7755,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 VibeError30({
+  return new VibeError32({
     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: {
@@ -7529,7 +7773,7 @@ function assertExecutable(params) {
   if (execution === undefined || isDefaultExecution({ execution }))
     return;
   if (dialect !== "postgres") {
-    throw new VibeError30({
+    throw new VibeError32({
       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" }
@@ -7552,7 +7796,7 @@ async function withSessionLimits(params) {
   const statement = execution?.statementTimeoutMs ?? 0;
   if (dialect !== "postgres" || lock === 0 && statement === 0)
     return params.run();
-  const sqlDialect = getSqlDialect5({ dialect });
+  const sqlDialect = getSqlDialect7({ 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 });
@@ -7571,12 +7815,12 @@ async function withSessionLimits(params) {
   }
 }
 function usesStatementBookkeeping(params) {
-  const { dialect, sql: sql2 } = params;
+  const { dialect, sql } = params;
   if (params.execution?.transaction === "none")
     return true;
   if (!DIALECT_CAPABILITIES3[dialect].transactionalDdl)
     return true;
-  return dialect === "sqlite" && usesSelfManagedTransactions({ sql: sql2 });
+  return dialect === "sqlite" && usesSelfManagedTransactions({ sql });
 }
 function isCompleteRecord(params) {
   const { dialect, migration, stored } = params;
@@ -7591,7 +7835,7 @@ function isCompleteRecord(params) {
 async function recordedRows(params) {
   const { executor, dialect } = params;
   if (params.modules === true)
-    return new Map([...await readModuleJournal({ executor, dialect })].map(([name, record3]) => [name, record3.row]));
+    return new Map([...await readModuleJournal({ executor, dialect })].map(([name, record]) => [name, record.row]));
   const rows = await readJournalRows({ executor, dialect, query: {
     text: `SELECT ${q5(dialect, "name")}, ${q5(dialect, "checksum")}, ${q5(dialect, "statement_index")}, ${q5(dialect, "error")} FROM ${q5(dialect, MIGRATIONS_TABLE_NAME)} ORDER BY ${q5(dialect, "id")}`,
     values: []
@@ -7605,7 +7849,7 @@ function assertChecksumMatches(params) {
   const actual = checksumOf({ migration });
   if (stored === actual)
     return;
-  throw new VibeError30({
+  throw new VibeError32({
     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 }
@@ -7616,7 +7860,7 @@ function assertResumable(params) {
   const actual = checksumOf({ migration });
   if (stored.checksum === actual)
     return;
-  throw new VibeError30({
+  throw new VibeError32({
     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: {
@@ -7636,7 +7880,7 @@ function assertDistinctMigrationNames(params) {
   const names = new Set;
   for (const migration of params.migrations) {
     if (names.has(migration.name))
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
     names.add(migration.name);
   }
 }
@@ -7644,15 +7888,15 @@ function assertCompleteHistory(params) {
   const byName = new Map(params.migrations.map((migration) => [migration.name, migration]));
   for (const name of params.recorded.keys()) {
     if (!byName.has(name))
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
   }
   let index = 0;
   for (const [name, stored] of params.recorded) {
     const migration = params.migrations[index];
     if (migration?.name !== name)
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
     if (stored.statementIndex >= 0 && !isCompleteRecord({ dialect: params.dialect, migration, stored }) && index !== params.recorded.size - 1)
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
     index++;
   }
 }
@@ -7661,16 +7905,16 @@ async function assertApplyHistory(params) {
   const byName = new Map(migrations.map((migration) => [migration.name, migration]));
   for (const [name, stored] of recorded) {
     if (stored.statementIndex < 0) {
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
     }
     const migration = byName.get(name);
     if (migration === undefined) {
       if (stored.error !== undefined)
-        throw new VibeError30({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
+        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
       continue;
     }
     if (isCompleteRecord({ dialect, migration, stored }) && stored.error !== undefined)
-      throw new VibeError30({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
+      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
     if (isCompleteRecord({ dialect, migration, stored }))
       assertChecksumMatches({ migration, stored: stored.checksum });
     else
@@ -7695,10 +7939,10 @@ async function assertApplyHistory(params) {
   }
 }
 function q5(dialect, name) {
-  return getSqlDialect5({ dialect }).quoteIdent({ name });
+  return getSqlDialect7({ dialect }).quoteIdent({ name });
 }
 function ph(dialect, index) {
-  return getSqlDialect5({ dialect }).placeholder({ index });
+  return getSqlDialect7({ dialect }).placeholder({ index });
 }
 
 // packages/migrate/src/fs.ts
@@ -7706,7 +7950,7 @@ function absent(error) {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
 }
 function failure(params) {
-  return new VibeError31({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
+  return new VibeError33({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
 }
 async function optionalFile(params) {
   return readFile(params.path, "utf-8").catch((cause) => {
@@ -7718,15 +7962,15 @@ async function optionalFile(params) {
 function rlsMetadata(params) {
   return Promise.resolve().then(() => {
     const metadata = JSON.parse(params.text);
-    const strings2 = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
-    if (metadata?.version !== 1 || typeof metadata.destructive !== "boolean" || metadata.rls === undefined || !strings2(metadata.securityChanges) || !strings2(metadata.downSecurityChanges) || metadata.sqlChecksum !== migrationChecksum({ sql: params.migration.sql }) || metadata.downChecksum !== migrationChecksum({ sql: params.migration.downSql ?? [] })) {
-      throw new VibeError31({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
+    const strings = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+    if (metadata?.version !== 1 || typeof metadata.destructive !== "boolean" || metadata.rls === undefined || !strings(metadata.securityChanges) || !strings(metadata.downSecurityChanges) || metadata.sqlChecksum !== migrationChecksum({ sql: params.migration.sql }) || metadata.downChecksum !== migrationChecksum({ sql: params.migration.downSql ?? [] })) {
+      throw new VibeError33({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
     }
     assertValidSchemaIR4({ schema: metadata.rls.from });
     assertValidSchemaIR4({ schema: metadata.rls.to });
     return { ...params.migration, rls: metadata.rls, destructive: metadata.destructive, securityChanges: metadata.securityChanges, downSecurityChanges: metadata.downSecurityChanges };
   }).catch((cause) => {
-    throw new VibeError31({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
+    throw new VibeError33({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
   });
 }
 async function loadMigrationFiles(params) {
@@ -7759,7 +8003,7 @@ async function loadMigrationFiles(params) {
     const desired = await optionalFile({ path: join(directory, DESIRED_STATE_METADATA.filename) });
     if (desired !== undefined) {
       const pending = await Promise.resolve().then(() => isUnfinalizedDesiredState({ text: desired })).catch((cause) => {
-        throw new VibeError31({ code: "VIBE_MIGRATION", message: `Malformed desired state for ${name}`, meta: { reason: "desired-state-invalid", migration: name }, cause });
+        throw new VibeError33({ code: "VIBE_MIGRATION", message: `Malformed desired state for ${name}`, meta: { reason: "desired-state-invalid", migration: name }, cause });
       });
       migration = pending ? { ...migration, desiredStatePending: true } : { ...migration, desiredState: parseDesiredStateSidecar({ text: desired, migration: name }) };
     }
@@ -7771,9 +8015,9 @@ async function loadMigrationFiles(params) {
   return migrations;
 }
 export {
-  splitSqlStatements,
+  joinSqlStatements,
   loadMigrationFiles,
-  joinSqlStatements
+  splitSqlStatements
 };
 
-//# debugId=8DB0E0F7582B731664756E2164756E21
+//# debugId=F0D645556CA0676064756E2164756E21