@vibeorm/migrate 2.4.0 → 2.5.0

package/dist/index.js

@@ -6798,6 +6798,7 @@ function collectExtensionArtifacts(params) {
   const { schema, dialect, extensions } = params;
   const setup = [];
   const objects = [];
+  const groups = [];
   for (const extension of extensions) {
     const artifactsHook = extension.migrate?.artifacts;
     if (artifactsHook === undefined)
@@ -6805,6 +6806,7 @@ function collectExtensionArtifacts(params) {
     const declarations = extensionDeclarations({ schema, name: extension.name });
     if (Object.keys(declarations).length === 0 && extension.schema?.configOnly !== true)
       continue;
+    const contributed = [];
     for (const artifact of artifactsHook({
       schema,
       dialect,
@@ -6812,10 +6814,19 @@ function collectExtensionArtifacts(params) {
       options: extension.options,
       declarations
     })) {
-      (artifact.owns.kind === "postgresExtension" ? setup : objects).push(artifact);
+      if (artifact.owns.kind === "postgresExtension")
+        setup.push(artifact);
+      else {
+        objects.push(artifact);
+        contributed.push(artifact);
+      }
     }
+    groups.push({ extension: extension.name, objects: contributed });
   }
-  return { setup, objects };
+  return { setup, objects, groups };
+}
+function lastDeclaredSchema(params) {
+  return [...params.migrations].reverse().find((migration) => migration.desiredState !== undefined)?.desiredState?.to.schema;
 }
 function ownedTableNames(params) {
   const exact = new Set;
@@ -6917,6 +6928,36 @@ async function probeInstalledExtensionState(params) {
 function artifactCreateSql(params) {
   return params.artifacts.flatMap((artifact) => [...artifact.create]);
 }
+function planChangedArtifacts(params) {
+  const previousById = new Map((params.previous?.objects ?? []).map((artifact) => [artifact.id, artifact]));
+  const probedIds = new Set((params.probed ?? []).map((artifact) => artifact.id));
+  const missingIds = new Set(params.missing.map((artifact) => artifact.id));
+  const rebuilt = new Set;
+  for (const group of params.current.groups) {
+    const changed = group.objects.filter((artifact) => {
+      if (missingIds.has(artifact.id))
+        return false;
+      if (probedIds.has(artifact.id))
+        return true;
+      const before = previousById.get(artifact.id);
+      return before !== undefined && JSON.stringify(before.owns) === JSON.stringify(artifact.owns) && JSON.stringify(before.create) !== JSON.stringify(artifact.create);
+    });
+    if (changed.length === 0)
+      continue;
+    const rebuiltColumnTables = new Set(changed.flatMap((artifact) => artifact.owns.kind === "column" ? [artifact.owns.table] : []));
+    for (const artifact of group.objects) {
+      if (missingIds.has(artifact.id))
+        continue;
+      const dependent = (artifact.owns.kind === "index" || artifact.owns.kind === "trigger") && rebuiltColumnTables.has(artifact.owns.table);
+      if (changed.includes(artifact) || dependent)
+        rebuilt.add(artifact.id);
+    }
+  }
+  return params.current.objects.filter((artifact) => rebuilt.has(artifact.id));
+}
+function artifactDropSql(params) {
+  return [...params.artifacts].reverse().flatMap((artifact) => [...artifact.drop]);
+}
 // packages/migrate/src/runner.ts
 function migrationRlsSecurityChanges(params) {
   const source = params.migration.rls;
@@ -7067,6 +7108,7 @@ function generateMigration(params) {
     extensions: params.extensions ?? []
   });
   const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const rebuilt = planChangedArtifacts({ previous: collectExtensionArtifacts({ schema: from, dialect, extensions: params.extensions ?? [] }), current: artifacts, missing: [] });
   assertRetainedMigrationObjects({ from: from.migrationObjects ?? [], to: to.migrationObjects ?? [] });
   const strippedFrom = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: from, artifacts: allArtifacts }), to, objects: [...from.migrationObjects ?? [], ...to.migrationObjects ?? []] });
   const steps = diffSchemas({ from: strippedFrom, to, dialect, ...params.renames === undefined ? {} : { renames: params.renames } });
@@ -7077,6 +7119,7 @@ function generateMigration(params) {
       artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
     }),
     ...coreSql,
+    ...artifactDropSql({ artifacts: rebuilt }),
     ...artifactCreateSql({
       artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
     }),
@@ -8434,14 +8477,47 @@ async function compareReplayMigrationObjects(params) {
   return { ...params.schema, migrationObjects: objects.map((object) => ({ ...object, expected: definitions.get(sqlObjectKey11({ identity: object.identity })) })) };
 }
 // packages/migrate/src/replay-plan.ts
-import { VibeError as VibeError39, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
+import { VibeError as VibeError40, sqlObjectKey as sqlObjectKey13 } from "@vibeorm/schema";
 
 // packages/migrate/src/planner.ts
-import { VibeError as VibeError38, sqlObjectKey as sqlObjectKey12 } from "@vibeorm/schema";
+import { VibeError as VibeError39, sqlObjectKey as sqlObjectKey12 } from "@vibeorm/schema";
 import { renderSqliteRebuildObjects, sqliteDialect as sqliteDialect4 } from "@vibeorm/sql";
 
-// packages/migrate/src/index-predicates.ts
+// packages/migrate/src/artifact-probe.ts
 import { VibeError as VibeError37 } from "@vibeorm/schema";
+var SAVEPOINT = "vibeorm_artifact_probe";
+async function probeChangedArtifacts(params) {
+  const { executor, namespace } = params;
+  const changed = [];
+  for (const artifact of params.artifacts) {
+    if (artifact.owns.kind === "postgresExtension" || artifact.drop.length === 0)
+      continue;
+    const identity = legacyMigrationObjects({ artifacts: [artifact], dialect: "postgres", namespace })[0].identity;
+    const before = await inspectSqlObject({ executor, dialect: "postgres", identity });
+    if (before.state !== "present")
+      continue;
+    await executor({ text: `SAVEPOINT ${SAVEPOINT}` });
+    let after;
+    try {
+      for (const statement of [...artifact.drop, ...artifact.create])
+        await executor({ text: statement });
+      after = await inspectSqlObject({ executor, dialect: "postgres", identity });
+    } finally {
+      await executor({ text: `ROLLBACK TO SAVEPOINT ${SAVEPOINT}` });
+      await executor({ text: `RELEASE SAVEPOINT ${SAVEPOINT}` });
+    }
+    if (after.state !== "present")
+      throw new VibeError37({ code: "VIBE_MIGRATION", message: `Extension artifact ${artifact.id} did not produce its object when probed; its create SQL cannot be verified against the replayed history`, meta: { reason: "artifact-probe-unavailable", id: artifact.id, identity } });
+    if (canonicalMigrationJson({ value: before.definition.facts }) === canonicalMigrationJson({ value: after.definition.facts }))
+      continue;
+    const definition = before.definition.facts.definition;
+    changed.push({ artifact, ...identity.kind === "index" && typeof definition === "string" ? { restore: [`${definition};`] } : {} });
+  }
+  return changed;
+}
+
+// packages/migrate/src/index-predicates.ts
+import { VibeError as VibeError38 } from "@vibeorm/schema";
 import { defaultIndexName as defaultIndexName2 } from "@vibeorm/schema";
 function physicalIndexName(params) {
   return params.index.name ?? defaultIndexName2({ table: params.table, columns: params.columns, unique: params.index.kind === "unique", dialect: "postgres" });
@@ -8482,7 +8558,7 @@ async function deparseIndexPredicate(params) {
     const match = /^CHECK \((.*)\)$/s.exec(definition);
     return match === null ? undefined : match[1];
   } catch (error) {
-    if (error instanceof VibeError37 && error.code === "VIBE_MIGRATION")
+    if (error instanceof VibeError38 && error.code === "VIBE_MIGRATION")
       throw error;
     return;
   }
@@ -8501,7 +8577,7 @@ async function planSchemaMigration(params) {
   assertRetainedMigrationObjects({ from: params.previous?.schema.migrationObjects ?? [], to: objects });
   for (const object of objects)
     if (object.dialect !== dialect)
-      throw new VibeError38({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}`, meta: { feature: "migrationObject", dialect } });
+      throw new VibeError39({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}`, meta: { feature: "migrationObject", dialect } });
   const physical = params.physical ?? (dialect === "postgres" ? await introspectPhysicalPostgres({ executor }) : dialect === "mysql" ? await introspectMysql({ executor }) : await introspectSqlite({ executor }));
   if (params.previous !== undefined)
     assertMigrationState({ report: await verifyMigrationState({ executor, expected: params.previous, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
@@ -8510,7 +8586,7 @@ async function planSchemaMigration(params) {
     const identity = object.identity;
     if (identity.kind !== "table" || physical.models.some((model) => (model.dbName ?? model.name) === identity.name.name) || normalizeSchema({ schema: physical, dialect }).joinTables.has(identity.name.name))
       continue;
-    throw new VibeError38({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
+    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Catalog table is not visible to schema introspection; automatic planning cannot prove the complete physical state", meta: { reason: "inventory-unavailable", identity: object.identity } });
   }
   const states = resolved.unavailable.map((identity) => {
     const exists = identity.kind === "column" && [physical, params.previous?.schema].some((source) => source?.models.some((model) => (model.dbName ?? model.name) === identity.table.name && model.fields.some((field) => (field.dbName ?? field.name) === identity.column)));
@@ -8541,7 +8617,7 @@ async function planSchemaMigration(params) {
   }
   for (const object of legacyObjects) {
     if (objects.some((entry) => sqlObjectKey12({ identity: entry.identity }) === sqlObjectKey12({ identity: object.identity })))
-      throw new VibeError38({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
+      throw new VibeError39({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate combined and migration-only ownership", meta: { identity: object.identity } });
     const expected = object.expected ?? params.previous?.definitions.find((entry) => sqlObjectKey12({ identity: entry.identity }) === sqlObjectKey12({ identity: object.identity }));
     if (expected === undefined)
       states.push({ identity: object.identity, ownership: "migration", state: "unavailable", reason: "legacy-definition-required", differences: [] });
@@ -8584,7 +8660,7 @@ async function planSchemaMigration(params) {
     if (object.inspectionUnavailable !== undefined)
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: object.inspectionUnavailable, differences: [] });
     if (object.inspectionUnavailable !== undefined && invalid.rebuilt.has("table" in object.identity ? object.identity.table.name : object.identity.name.name))
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "SQLite rebuild cannot discard an unrepresented constraint; declare its independent definition or use a reviewed migration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "SQLite rebuild cannot discard an unrepresented constraint; declare its independent definition or use a reviewed migration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
     if (ownership === "unknown")
       states.push({ identity: object.identity, ownership, state: "unavailable", reason: "unmanaged", differences: [] });
     let collateral = "table" in object.identity && object.identity.table.namespace === namespace && droppedTables.has(object.identity.table.name);
@@ -8603,7 +8679,7 @@ async function planSchemaMigration(params) {
           for (const address of addresses) {
             const value = JSON.parse(String(address));
             if (!Array.isArray(value) || !Array.isArray(value[2]))
-              throw new VibeError38({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
+              throw new VibeError39({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency address" });
             const names = value[2];
             if (names[0] !== namespace || typeof names[1] !== "string")
               continue;
@@ -8613,10 +8689,10 @@ async function planSchemaMigration(params) {
       }
     }
     if (dialect === "sqlite" && ownership === "unknown" && object.identity.kind === "generatedColumn" && invalid.rebuilt.has(object.identity.table.name))
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "SQLite generated-column preservation requires an independent ownership declaration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "SQLite generated-column preservation requires an independent ownership declaration", meta: { reason: "sqlite-preservation-unavailable", identity: object.identity } });
     const removed = collateral || removals.some((identity) => sqlObjectKey12({ identity }) === key);
     if (removed && ownership === "migration")
-      throw new VibeError38({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
+      throw new VibeError39({ code: "VIBE_MIGRATION", message: "Automatic DDL would remove a migration-owned object", meta: { reason: "migration-owned-removal", identity: object.identity } });
     if (removed && ownership === "unknown" && object.backingConstraint === undefined)
       unmanagedRemovals.push(object.identity);
   }
@@ -8627,6 +8703,19 @@ async function planSchemaMigration(params) {
     if (artifact.owns.kind === "trigger" && invalidated.has(artifact.owns.table))
       triggers?.delete(artifact.owns.name);
   const missing = planMissingArtifacts({ introspected: physical, artifacts, installed: { ...installed, ...triggers === undefined ? {} : { triggers } } });
+  const previousDeclarations = params.previousDeclarations ?? params.previous?.schema;
+  const previousArtifacts = previousDeclarations === undefined ? undefined : collectExtensionArtifacts({ schema: previousDeclarations, dialect, extensions: params.extensions ?? [] });
+  const missingIds = new Set(missing.map((artifact) => artifact.id));
+  const probed = dialect === "postgres" && params.probe === "rollback" && params.probeArtifacts === true ? await probeChangedArtifacts({ executor, namespace, artifacts: collected.objects.filter((artifact) => !missingIds.has(artifact.id)) }) : [];
+  const rebuilt = params.rebuildArtifacts === true ? collected.objects.filter((artifact) => !missingIds.has(artifact.id)) : planChangedArtifacts({ ...previousArtifacts === undefined ? {} : { previous: previousArtifacts }, current: collected, missing, probed: probed.map((entry) => entry.artifact) });
+  const probedById = new Map(probed.map((entry) => [entry.artifact.id, entry]));
+  const rebuiltArtifacts = rebuilt.map((artifact) => {
+    const probe = probedById.get(artifact.id);
+    if (probe !== undefined)
+      return probe;
+    const declared = previousArtifacts?.objects.find((entry) => entry.id === artifact.id);
+    return { artifact, restore: [...(declared ?? artifact).create] };
+  });
   const restore = new Map;
   const preservedColumns = new Map;
   const preservedDefaults = new Map;
@@ -8650,11 +8739,11 @@ async function planSchemaMigration(params) {
         continue;
       const live = await inspectSqlObject({ executor, dialect, identity });
       if (live.state !== "present" || identity.kind !== "columnDefault" && typeof live.definition.facts.columnDefinition !== "string")
-        throw new VibeError38({ code: "VIBE_MIGRATION", message: "Cannot read the verified SQLite column definition for preservation", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError39({ code: "VIBE_MIGRATION", message: "Cannot read the verified SQLite column definition for preservation", meta: { reason: "sqlite-preservation-unavailable", identity } });
       if (identity.kind === "columnDefault") {
         const definition = live.definition.facts.definition;
         if (definition !== null && typeof definition !== "string")
-          throw new VibeError38({ code: "VIBE_MIGRATION", message: "Cannot preserve SQLite default", meta: { identity } });
+          throw new VibeError39({ code: "VIBE_MIGRATION", message: "Cannot preserve SQLite default", meta: { identity } });
         const defaults = preservedDefaults.get(identity.table.name) ?? new Map;
         defaults.set(identity.column, definition);
         preservedDefaults.set(identity.table.name, defaults);
@@ -8676,10 +8765,12 @@ async function planSchemaMigration(params) {
     return { ...rest, ...typeof expression === "string" ? { default: { kind: "dbgenerated", sql: expression } } : {} };
   }) })) };
   const core = renderSteps({ steps, dialect, from: dialect === "sqlite" ? physical : from, to: dialect === "mysql" ? { ...target, migrationObjects: protectedObjects } : target, sqliteRestore: restore, sqliteColumns: preservedColumns });
+  const planned = new Set([...missing, ...rebuilt].map((artifact) => artifact.id));
   const sql = [
     ...artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension") }),
     ...core,
-    ...artifactCreateSql({ artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension" && !(artifact.owns.kind === "trigger" && invalid.rebuilt.has(artifact.owns.table))) }),
+    ...artifactDropSql({ artifacts: rebuilt }),
+    ...artifactCreateSql({ artifacts: collected.objects.filter((artifact) => planned.has(artifact.id) && !(artifact.owns.kind === "trigger" && invalid.rebuilt.has(artifact.owns.table))) }),
     ...creates
   ];
   if (sql.length === 0) {
@@ -8691,7 +8782,7 @@ async function planSchemaMigration(params) {
     states.push(...report.objects);
   }
   const blocked = states.some((state) => state.reason === "dependency-inspection-unavailable" || state.ownership !== "unknown" && state.reason !== "legacy-definition-required" && (state.state === "unavailable" || state.state === "changed" || state.state === "missing" && sql.length === 0));
-  return { physical, from, to: schema, namespace, steps, objects: states, unmanagedRemovals, blocked, sql: blocked ? [] : sql };
+  return { physical, from, to: schema, namespace, steps, objects: states, unmanagedRemovals, blocked, sql: blocked ? [] : sql, rebuiltArtifacts };
 }
 
 // packages/migrate/src/replay-plan.ts
@@ -8718,7 +8809,8 @@ async function planReplayMigration(params) {
   const probe = reference.dialect === "postgres" ? "rollback" : reference.dialect === "mysql" ? "temporary" : "none";
   if (probe === "rollback")
     await executor({ text: "BEGIN" });
-  const plan = await Promise.resolve().then(() => planSchemaMigration({ executor, schema, physical: reference.state.schema, physicalInventory: reference.inventory, dialect: reference.dialect, namespace: reference.namespace, extensions: params.extensions, replaceChecks: params.replaceChecks, probe })).finally(async () => {
+  const previousDeclarations = lastDeclaredSchema({ migrations: params.migrations });
+  const plan = await Promise.resolve().then(() => planSchemaMigration({ executor, schema, physical: reference.state.schema, physicalInventory: reference.inventory, dialect: reference.dialect, namespace: reference.namespace, extensions: params.extensions, replaceChecks: params.replaceChecks, probe, probeArtifacts: probe === "rollback", ...previousDeclarations === undefined ? {} : { previousDeclarations } })).finally(async () => {
     if (probe === "rollback")
       await executor({ text: "ROLLBACK" });
   });
@@ -8737,24 +8829,24 @@ async function planReplayMigration(params) {
   const retainedObjects = reference.inventory.filter((object) => !declared.has(sqlObjectKey13({ identity: object.identity })) && !removals.has(sqlObjectKey13({ identity: object.identity })) && (object.identity.kind === "function" || object.identity.kind === "trigger" || historicalObjects.has(sqlObjectKey13({ identity: object.identity })))).map((object) => object.identity);
   const removedRegistrations = [...historicalObjects].filter(([key]) => present.has(key) && !declared.has(key)).map(([, identity]) => identity);
   if (removedRegistrations.length > 0)
-    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
+    throw new VibeError40({ code: "VIBE_MIGRATION", message: "Custom registrations removed from declarations still exist in replayed history. Restore the registration or supply reviewed SQL removing the exact named objects before generating again.", meta: { reason: "migration-object-removal-review-required", shadowReusable: true, objects: removedRegistrations } });
   return { ...plan, requiredRemovals: [...removals.values()], retainedObjects, securityChanges: securityChangesOf({ steps: plan.steps }), replayRemovals: params.migrations.flatMap((migration) => migration.desiredState?.unmanagedRemovals ?? []) };
 }
 function assertReplayRemovals(params) {
   const wanted = new Set([...params.plan.requiredRemovals, ...params.plan.replayRemovals].map((identity) => sqlObjectKey13({ identity })));
   const keys = params.approved.map((identity) => sqlObjectKey13({ identity }));
   if (new Set(keys).size !== keys.length)
-    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
+    throw new VibeError40({ code: "VIBE_MIGRATION", message: "Removal decisions contain duplicate identities", meta: { reason: "removal-decision-invalid", shadowReusable: true } });
   const unused = params.approved.filter((identity) => !wanted.has(sqlObjectKey13({ identity })));
   if (unused.length > 0)
-    throw new VibeError39({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
+    throw new VibeError40({ code: "VIBE_MIGRATION", message: "Removal decisions do not identify proposed removals. Custom objects without a generated removal require a reviewed hand-authored SQL migration.", meta: { reason: "removal-decision-unused", shadowReusable: true, objects: unused } });
   assertNamedRemovals({ removals: params.plan.requiredRemovals, approved: params.approved, acceptIntegrityLoss: params.acceptIntegrityLoss });
 }
 // packages/migrate/src/baseline.ts
-import { VibeError as VibeError44, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
+import { VibeError as VibeError45, sqlObjectKey as sqlObjectKey16 } from "@vibeorm/schema";
 
 // packages/migrate/src/reference-state.ts
-import { VibeError as VibeError40, sqlObjectKey as sqlObjectKey14 } from "@vibeorm/schema";
+import { VibeError as VibeError41, sqlObjectKey as sqlObjectKey14 } from "@vibeorm/schema";
 async function captureMigrationReference(params) {
   const namespace = await migrationNamespace({ executor: params.referenceExecutor, dialect: params.dialect });
   const identities = [...schemaObjectIdentities({ schema: params.schema, dialect: params.dialect, namespace }), ...(params.schema.migrationObjects ?? []).map((object) => object.identity)];
@@ -8764,14 +8856,14 @@ async function captureMigrationReference(params) {
       continue;
     const result = await inspectSqlObject({ executor: params.referenceExecutor, dialect: params.dialect, identity });
     if (result.state !== "present")
-      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
+      throw new VibeError41({ code: "VIBE_MIGRATION", message: "Independent reference object is missing or unavailable", meta: { reason: "reference-unavailable", identity, state: result.state } });
     definitions.push(result.definition);
   }
   let schema = params.schema;
   if (params.dialect === "postgres" && schema.models.some((model) => model.fields.some((field) => field.isUnsupported === true))) {
     const resolved = await resolvePostgresTypeIdentities({ executor: params.referenceExecutor, schema, mode: "reference" });
     if (resolved.unavailable.length > 0)
-      throw new VibeError40({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
+      throw new VibeError41({ code: "VIBE_MIGRATION", message: "Resolve unsupported types in the independent reference before capture", meta: { reason: "type-reference-required", columns: resolved.unavailable } });
     const physical = await introspectPhysicalPostgres({ executor: params.referenceExecutor });
     for (const model of resolved.schema.models)
       for (const field of model.fields) {
@@ -8779,7 +8871,7 @@ async function captureMigrationReference(params) {
           continue;
         const actual = physical.models.find((entry) => entry.name === (model.dbName ?? model.name))?.fields.find((entry) => entry.name === (field.dbName ?? field.name));
         if (actual === undefined || columnTypeKey({ field }) !== columnTypeKey({ field: actual }))
-          throw new VibeError40({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
+          throw new VibeError41({ code: "VIBE_MIGRATION", message: "Independent reference column does not match its declared PostgreSQL type", meta: { reason: "reference-type-mismatch", table: model.dbName ?? model.name, column: field.dbName ?? field.name } });
       }
     schema = resolved.schema;
   }
@@ -8787,13 +8879,13 @@ async function captureMigrationReference(params) {
 }
 
 // packages/migrate/src/compile-desired-state.ts
-import { VibeError as VibeError41 } from "@vibeorm/schema";
+import { VibeError as VibeError42 } from "@vibeorm/schema";
 import { renderExclusionSetup as renderExclusionSetup2, getSqlDialect as getSqlDialect12, renderMigrationServerVersion as renderMigrationServerVersion2 } from "@vibeorm/sql";
 async function compileDesiredState(params) {
   if (params.dialect !== "postgres")
-    throw new VibeError41({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Rollback declaration compilation requires PostgreSQL", meta: { feature: "desiredStateCompilation", dialect: params.dialect } });
+    throw new VibeError42({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Rollback declaration compilation requires PostgreSQL", meta: { feature: "desiredStateCompilation", dialect: params.dialect } });
   if (params.steps.some((step) => step.kind === "alterColumn" || step.kind === "addColumn" || step.kind === "addEnumValue"))
-    throw new VibeError41({ code: "VIBE_MIGRATION", message: "CHECK compilation after column or enum changes requires an independently built reference with the new type context", meta: { reason: "reference-required" } });
+    throw new VibeError42({ code: "VIBE_MIGRATION", message: "CHECK compilation after column or enum changes requires an independently built reference with the new type context", meta: { reason: "reference-required" } });
   const definitions = (params.schema.migrationObjects ?? []).flatMap((object) => object.expected === undefined ? [] : [object.expected]);
   await params.executor({ text: "SAVEPOINT vibeorm_desired_state" });
   try {
@@ -8816,7 +8908,7 @@ async function compileDesiredState(params) {
     const query = renderMigrationServerVersion2({ dialect: getSqlDialect12({ dialect: params.dialect }) });
     const version = (await params.executor({ text: query.text, values: [] }))[0]?.version;
     if (typeof version !== "string")
-      throw new VibeError41({ code: "VIBE_MIGRATION", message: "Cannot determine definition normalization version" });
+      throw new VibeError42({ code: "VIBE_MIGRATION", message: "Cannot determine definition normalization version" });
     return { ...createDesiredState({ schema: { ...params.schema, models }, dialect: params.dialect, definitions }), normalization: { format: "catalog-v1", dialect: params.dialect, serverVersion: version } };
   } finally {
     await params.executor({ text: "ROLLBACK TO SAVEPOINT vibeorm_desired_state" });
@@ -8825,7 +8917,7 @@ async function compileDesiredState(params) {
 }
 
 // packages/migrate/src/verify-history.ts
-import { VibeError as VibeError43, sqlObjectKey as sqlObjectKey15 } from "@vibeorm/schema";
+import { VibeError as VibeError44, sqlObjectKey as sqlObjectKey15 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect13, renderReplayCoverageGaps as renderReplayCoverageGaps2 } from "@vibeorm/sql";
 
 // packages/migrate/src/compare-sqlite-primary-key.ts
@@ -8898,7 +8990,7 @@ function compareSqlitePrimaryKeyRepresentations(params) {
 }
 
 // packages/migrate/src/compare-reference-rls.ts
-import { VibeError as VibeError42 } from "@vibeorm/schema";
+import { VibeError as VibeError43 } from "@vibeorm/schema";
 function securityFacts(params) {
   return new Map(params.tables.filter((table) => table.enabled || table.force || table.policies.length > 0).map((table) => [table.table, {
     table: table.table,
@@ -8909,7 +9001,7 @@ function securityFacts(params) {
 }
 async function comparePostgresReferenceRls(params) {
   if (params.schema.rls !== undefined && params.referenceExecutor === undefined)
-    throw new VibeError42({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
+    throw new VibeError43({ code: "VIBE_MIGRATION", message: "Native RLS verification requires the independently replayed reference connection; target policy probes are not permitted.", meta: { reason: "verification-rls-reference-required" } });
   const expected = securityFacts({ tables: params.schema.rls === undefined ? [] : await readPostgresRls({ executor: params.referenceExecutor }) });
   const actual = securityFacts({ tables: await readPostgresRls({ executor: params.executor }) });
   const objects = [...new Set([...expected.keys(), ...actual.keys()])].sort().map((table) => {
@@ -8933,14 +9025,14 @@ function selectMigrationVerificationPrefix(params) {
   for (const [index, file] of params.migrations.entries()) {
     const previous = params.migrations[index - 1];
     if (seen.has(file.name) || previous !== undefined && previous.name.localeCompare(file.name) > 0) {
-      throw new VibeError43({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
+      throw new VibeError44({ code: "VIBE_MIGRATION", message: "Verification requires a complete local migration chain in unique name order", meta: { reason: "verification-history-order", migration: file.name } });
     }
     seen.add(file.name);
   }
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.statementIndex < 0 || row.checksum === "" || file?.name !== row.name || file.desiredStatePending === true || migrationChecksum(file) !== row.checksum) {
-      throw new VibeError43({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError44({ code: "VIBE_MIGRATION", message: "Verification requires an exact, complete, checksum-verified applied prefix; inspect migrate status and resolve the history discrepancy first", meta: { reason: "verification-history-unverified", migration: row.name, state: row.state } });
     }
   }
   return params.migrations.slice(0, params.recorded.length);
@@ -8957,7 +9049,7 @@ async function verifyMigrationReference(params) {
   const coverage = renderReplayCoverageGaps2({ dialect: getSqlDialect13({ dialect }), namespace });
   const gaps = await executor({ text: coverage.text, values: [...coverage.values] });
   if (gaps.length > 0)
-    throw new VibeError43({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
+    throw new VibeError44({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Target contains objects whose full definitions are outside migration inspection coverage; verification is unavailable. No target changes were made.", meta: { feature: "targetInventoryCoverage", dialect, namespace, objects: gaps } });
   const security = dialect === "postgres" ? await comparePostgresReferenceRls({ executor, referenceExecutor: params.referenceExecutor, schema: reference.state.schema }) : { inSync: true, objects: [] };
   const inspected = await verifyMigrationState({ executor, dialect, expected: reference.state, probe: "none", batch: true });
   const structural = dialect === "sqlite" ? compareSqlitePrimaryKeyRepresentations({ report: inspected }) : inspected;
@@ -9104,7 +9196,7 @@ async function mysqlComparisonFacts(params) {
   return { ...facts, members };
 }
 function referenceContextError() {
-  return new VibeError43({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
+  return new VibeError44({ code: "VIBE_MIGRATION", message: "Replay and target dialect/namespace differ; safe reference translation is unavailable. Use a supported same-namespace reference setup", meta: { reason: "verification-reference-context" } });
 }
 
 // packages/migrate/src/baseline.ts
@@ -9112,19 +9204,19 @@ function generateBaselineMigration(params) {
   const objects = orderedMigrationObjects({ objects: params.schema.migrationObjects ?? [] });
   for (const object of objects)
     if (object.dialect !== params.dialect)
-      throw new VibeError44({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
+      throw new VibeError45({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Baseline object ${object.id} requires ${object.dialect}`, meta: { identity: object.identity, dialect: params.dialect } });
   const prerequisites = objects.filter((object) => object.identity.kind === "postgresExtension" || object.identity.kind === "enum" || object.identity.kind === "sequence");
   const prerequisiteKeys = new Set(prerequisites.map((object) => sqlObjectKey16({ identity: object.identity })));
   for (const object of prerequisites) {
     const unresolved = object.dependsOn.filter((identity) => !prerequisiteKeys.has(sqlObjectKey16({ identity })));
     if (unresolved.length > 0)
-      throw new VibeError44({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
+      throw new VibeError45({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Baseline prerequisite depends on objects created later. Supply reviewed initial SQL with an explicit dependency order.", meta: { reason: "baseline-prerequisite-order", identity: object.identity, dependencies: unresolved } });
   }
   const schema = { ...params.schema, migrationObjects: objects.filter((object) => !prerequisiteKeys.has(sqlObjectKey16({ identity: object.identity }))) };
   const generated = generateMigration({ from: { datasource: schema.datasource, models: [], enums: [], extensions: [] }, to: schema, name: params.name, dialect: params.dialect, extensions: params.extensions ?? [] });
   const sql = splitSqlStatements({ sql: joinSqlStatements({ sql: [...prerequisites.flatMap((object) => object.create), ...generated.sql] }), dialect: params.dialect });
   if (sql.length === 0)
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "A baseline must create declared database objects", meta: { reason: "baseline-empty" } });
   return {
     name: generated.name,
     sql,
@@ -9153,17 +9245,17 @@ async function verifyBaselineDeclarations(params) {
 async function verifyBaselineTarget(params) {
   const { reference } = params;
   if (reference.unavailable.length > 0 || reference.inventory.some((object) => object.inspectionUnavailable !== undefined))
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline reference contains objects that cannot be inspected. Supply supported reviewed declarations before adoption.", meta: { reason: "baseline-reference-unavailable", objects: reference.unavailable, inventory: reference.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
   const comparison = await verifyMigrationReference({ executor: params.executor, dialect: reference.dialect, reference, referenceExecutor: params.referenceExecutor }).catch((cause) => {
-    if (cause instanceof VibeError44 && cause.meta.reason === "verification-rls-reference-required")
-      throw new VibeError44({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
+    if (cause instanceof VibeError45 && cause.meta.reason === "verification-rls-reference-required")
+      throw new VibeError45({ code: cause.code, message: cause.message, meta: { reason: "baseline-rls-reference-required" }, cause });
     throw cause;
   });
   const security = comparison.objects.filter((object) => object.reason === "native-rls-mismatch");
   if (security.length > 0)
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Target native RLS policies or flags differ from the independent baseline. Restore the reviewed security declarations before recording; no target policies were changed.", meta: { reason: "baseline-rls-mismatch", shadowReusable: true, expected: security.flatMap((object) => object.differences.flatMap((difference) => difference.expected === undefined ? [] : [difference.expected])), actual: security.flatMap((object) => object.differences.flatMap((difference) => difference.actual === undefined ? [] : [difference.actual])) } });
   if (comparison.unavailable.length > 0)
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline comparison contains objects whose definitions cannot be verified in the target context; use a supported reference before adoption.", meta: { reason: "baseline-target-unavailable", shadowReusable: true, objects: comparison.unavailable } });
   const report = { inSync: comparison.objects.every((object) => object.state === "matching"), objects: comparison.objects };
   assertMigrationState({ report });
   const unmanaged = comparison.unmanaged.map((object) => object.identity);
@@ -9171,14 +9263,14 @@ async function verifyBaselineTarget(params) {
   const exclusions = params.excludeUnmanaged ?? [];
   const excluded = new Set(exclusions.map((identity) => sqlObjectKey16({ identity })));
   if (excluded.size !== exclusions.length || exclusions.some((identity) => !extras.has(sqlObjectKey16({ identity }))))
-    throw new VibeError44({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
+    throw new VibeError45({ code: "VIBE_CONFIG", message: "Baseline exclusions must uniquely name actual unmanaged target objects, never declared objects", meta: { reason: "baseline-exclusion-invalid", shadowReusable: true, exclusions } });
   const unreviewed = unmanaged.filter((identity) => !excluded.has(sqlObjectKey16({ identity })));
   if (unreviewed.length > 0)
-    throw new VibeError44({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
+    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Target has unmanaged objects. Register their SQL or explicitly exclude each identity with --exclude-unmanaged; no target objects were removed.", meta: { reason: "baseline-unmanaged-objects", shadowReusable: true, objects: unreviewed } });
   return { ...report, unmanaged };
 }
 // packages/migrate/src/baseline-record.ts
-import { VibeError as VibeError45 } from "@vibeorm/schema";
+import { VibeError as VibeError46 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect15, renderStatement } from "@vibeorm/sql";
 
 // packages/migrate/src/history.ts
@@ -9194,20 +9286,20 @@ async function readMigrationHistory(params) {
 
 // packages/migrate/src/baseline-record.ts
 function transactionFailure(params) {
-  if (params.cause instanceof VibeError45)
+  if (params.cause instanceof VibeError46)
     return params.cause;
-  return new VibeError45({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
+  return new VibeError46({ code: "VIBE_MIGRATION", message: "SQLite baseline recording failed; inspect the journal and transaction outcome before retrying.", meta: { reason: "baseline-record-transaction-failed" }, cause: params.cause });
 }
 async function recordBaselineMigration(params) {
   if (params.migration.moduleOrigin !== undefined)
-    throw new VibeError45({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
+    throw new VibeError46({ code: "VIBE_MIGRATION", message: "Package module migrations must use the immutable module installation workflow, not baseline adoption", meta: { reason: "baseline-module-unsupported" } });
   validateMigrationReplay({ dialect: params.dialect, migrations: [params.migration], acceptSecurityChanges: params.acceptSecurityChanges });
   await withMigrationLock({ executor: params.executor, dialect: params.dialect, run: async (executor) => {
     const record = async () => {
       const assertEmpty = async () => {
         const history = await readMigrationHistory({ executor, migrations: [params.migration], dialect: params.dialect });
         if (history.recorded.length > 0)
-          throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
+          throw new VibeError46({ code: "VIBE_MIGRATION", message: "Baseline recording requires an absent or empty migration journal. Use normal apply or explicit recovery for existing history.", meta: { reason: "baseline-journal-not-empty", shadowReusable: true, recorded: history.recorded.map((row) => ({ name: row.name, state: row.state })) } });
       };
       await assertEmpty();
       await params.verify({ executor });
@@ -9232,14 +9324,14 @@ async function recordBaselineMigration(params) {
       await executor({ text: "COMMIT" });
     }).then(undefined, async (cause) => {
       await executor({ text: "ROLLBACK" }).then(undefined, (rollback) => {
-        throw new VibeError45({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
+        throw new VibeError46({ code: "VIBE_MIGRATION", message: "Baseline recording failed and its SQLite transaction could not be rolled back. Inspect the journal and connection state before retrying; the outcome is uncertain.", meta: { reason: "baseline-record-rollback-failed" }, cause: new AggregateError([cause, rollback], "Baseline recording and rollback failed") });
       });
       throw transactionFailure({ cause });
     });
   } });
 }
 // packages/migrate/src/down.ts
-import { VibeError as VibeError46, sqlObjectKey as sqlObjectKey17 } from "@vibeorm/schema";
+import { VibeError as VibeError47, sqlObjectKey as sqlObjectKey17 } from "@vibeorm/schema";
 function buildRollbackTarget(params) {
   const { from, to, dialect } = params;
   const skipped = [];
@@ -9292,6 +9384,7 @@ function generateDownMigration(params) {
     extensions: params.extensions ?? []
   });
   const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const previous = collectExtensionArtifacts({ schema: params.previousDeclarations ?? from, dialect, extensions: params.extensions ?? [] });
   const owned = [...from.migrationObjects ?? [], ...to.migrationObjects ?? []];
   const strippedFrom = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: from, artifacts: allArtifacts }), to: from, objects: owned });
   const { target, skipped } = buildRollbackTarget({ from: strippedFrom, to, dialect });
@@ -9315,14 +9408,27 @@ function generateDownMigration(params) {
     return added?.kind === "addColumn" ? { ...field, isOptional: added.column.isOptional } : field;
   }) })) };
   const coreSql = renderSteps({ steps, dialect, from: to, to: dialect === "sqlite" ? sqlitePreservedSchema({ from, to: restored, objects: from.migrationObjects ?? [] }) : restored });
-  const created = planMissingArtifacts({ introspected: from, artifacts: allArtifacts });
-  const artifactDropSql = [];
+  const declaredBefore = new Set([...previous.setup, ...previous.objects].map((artifact) => JSON.stringify([artifact.id, artifact.owns])));
+  const created = params.physical === undefined ? allArtifacts.filter((artifact) => !declaredBefore.has(JSON.stringify([artifact.id, artifact.owns]))) : planMissingArtifacts({ introspected: params.physical, artifacts: allArtifacts, ...params.installed === undefined ? {} : { installed: params.installed } });
+  const createdDropSql = [];
   for (const artifact of [...created].reverse()) {
     if (artifact.owns.kind === "postgresExtension") {
       skipped.push(`extension "${artifact.owns.name}" stays installed \u2014 other objects may depend on it (drop it manually if intended)`);
       continue;
     }
-    artifactDropSql.push(...artifact.drop);
+    createdDropSql.push(...artifact.drop);
+  }
+  const rebuilt = params.rebuilt ?? planChangedArtifacts({ previous, current: artifacts, missing: created }).map((artifact) => {
+    const declared = previous.objects.find((entry) => entry.id === artifact.id);
+    return { artifact, ...declared === undefined ? {} : { restore: artifactCreateSql({ artifacts: [declared] }) } };
+  });
+  const restoreSql = [];
+  for (const entry of rebuilt) {
+    if (entry.restore === undefined) {
+      skipped.push(`rebuilt ${entry.artifact.id} cannot be restored automatically \u2014 its previous definition is not spelled by the catalog; write it into a reviewed down migration`);
+      continue;
+    }
+    restoreSql.push(...entry.restore);
   }
   const previousKeys = new Set((from.migrationObjects ?? []).map((object) => sqlObjectKey17({ identity: object.identity })));
   const ownedDropSql = [];
@@ -9334,24 +9440,26 @@ function generateDownMigration(params) {
       continue;
     }
     if (object.drop.length === 0)
-      throw new VibeError46({ code: "VIBE_MIGRATION", message: `Migration object ${object.id} needs reviewed reverse SQL`, meta: { reason: "migration-object-reverse-required", id: object.id } });
+      throw new VibeError47({ code: "VIBE_MIGRATION", message: `Migration object ${object.id} needs reviewed reverse SQL`, meta: { reason: "migration-object-reverse-required", id: object.id } });
     ownedDropSql.push(...object.drop);
   }
   return {
     name,
     target: restored,
-    sql: [...ownedDropSql, ...artifactDropSql, ...coreSql],
+    sql: [...ownedDropSql, ...createdDropSql, ...artifactDropSql({ artifacts: rebuilt.map((entry) => entry.artifact) }), ...coreSql, ...restoreSql],
     destructive: steps.some((step) => step.destructive),
     ...securityChangesOf({ steps }).length === 0 ? {} : { securityChanges: securityChangesOf({ steps }) },
     skipped
   };
 }
 // packages/migrate/src/push.ts
-import { VibeError as VibeError47, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect4, sqlObjectKey as sqlObjectKey18 } from "@vibeorm/schema";
+import { VibeError as VibeError48, assertValidSchemaIR as assertValidSchemaIR4, providerToDialect as providerToDialect4, sqlObjectKey as sqlObjectKey18, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES4 } from "@vibeorm/sql";
 async function push(params) {
   assertValidSchemaIR4({ schema: params.schema });
   const dialect = providerToDialect4({ provider: params.schema.datasource.provider });
+  if (params.rebuildArtifacts === true && dialect !== "postgres")
+    throw unsupportedCapability9({ dialect, feature: "rebuilding extension artifacts on push (rebuildArtifacts)", hint: "drop the extension's objects by hand and push again; the transactional rebuild exists on PostgreSQL only" });
   if (dialect !== "postgres")
     return pushChanges({ ...params, dialect });
   await params.executor({ text: "BEGIN" });
@@ -9379,6 +9487,7 @@ async function pushChanges(params) {
     ...params.previousState === undefined ? {} : { previous: params.previousState },
     ...params.extensions === undefined ? {} : { extensions: params.extensions },
     ...params.probe === undefined ? {} : { probe: params.probe },
+    ...params.rebuildArtifacts === undefined ? {} : { rebuildArtifacts: params.rebuildArtifacts },
     ...params.replaceChecks === undefined ? {} : { replaceChecks: params.replaceChecks }
   });
   const { steps, sql } = plan;
@@ -9386,11 +9495,11 @@ async function pushChanges(params) {
   if (params.dryRun === true)
     return { steps, applied: [], planned: sql, securityChanges, objects: plan.objects, blocked: plan.blocked, unmanagedRemovals: plan.unmanagedRemovals };
   if (plan.blocked)
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Schema push is blocked by unverified object definitions", meta: { reason: "migration-state-unverified", objects: plan.objects } });
   assertSecurityAcknowledgement({ securityChanges, ...params.acceptSecurityChanges === undefined ? {} : { acceptSecurityChanges: params.acceptSecurityChanges } });
   const destructive = steps.filter((step) => step.destructive);
   if (destructive.length > 0 && params.acceptDataLoss !== true)
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: `push refused: ${destructive.length} destructive step(s) would lose data; pass acceptDataLoss: true: ${destructive.map((step) => describeStep({ step })).join("; ")}`, meta: { destructive: destructive.map((step) => describeStep({ step })) } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: `push refused: ${destructive.length} destructive step(s) would lose data; pass acceptDataLoss: true: ${destructive.map((step) => describeStep({ step })).join("; ")}`, meta: { destructive: destructive.map((step) => describeStep({ step })) } });
   assertRemovalAuthorization({
     steps,
     dialect,
@@ -9402,7 +9511,7 @@ async function pushChanges(params) {
   const approved = new Set((params.removeUnmanaged ?? []).map((identity) => sqlObjectKey18({ identity })));
   const unapproved = plan.unmanagedRemovals.filter((identity) => !approved.has(sqlObjectKey18({ identity })));
   if (unapproved.length > 0)
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: "DDL would remove unmanaged dependent objects; approve their exact identities", meta: { reason: "unmanaged-removal-required", objects: unapproved } });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: "DDL would remove unmanaged dependent objects; approve their exact identities", meta: { reason: "unmanaged-removal-required", objects: unapproved } });
   const wrap = dialect !== "postgres" && DIALECT_CAPABILITIES4[dialect].transactionalDdl && !usesSelfManagedTransactions({ sql });
   if (wrap)
     await executor({ text: "BEGIN" });
@@ -9420,7 +9529,7 @@ async function pushChanges(params) {
       } catch {}
     } else if (dialect === "sqlite")
       await cleanupSelfManagedFailure({ executor });
-    throw new VibeError47({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
+    throw new VibeError48({ code: "VIBE_MIGRATION", message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`, meta: { statements: sql }, cause: error });
   }
   return { steps, applied: sql, securityChanges, objects: plan.objects, desiredState: createDesiredState({ schema: plan.to, dialect }) };
 }
@@ -9435,23 +9544,23 @@ async function pull(params) {
   }
 }
 // packages/migrate/src/module-export.ts
-import { VibeError as VibeError49 } from "@vibeorm/schema";
+import { VibeError as VibeError50 } from "@vibeorm/schema";
 
 // packages/migrate/src/module-bundle.ts
-import { VibeError as VibeError48 } from "@vibeorm/schema";
+import { VibeError as VibeError49 } from "@vibeorm/schema";
 function defineModuleMigrations(params) {
   if (!Array.isArray(params.steps) || params.steps.length === 0)
-    throw new VibeError48({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
+    throw new VibeError49({ code: "VIBE_MIGRATION", message: "A module upgrade bundle must contain its initial revision", meta: { reason: "module-chain-invalid", moduleId: params.moduleId } });
   const migrations = [];
   const revisions = new Set;
   let previous = null;
   for (const step of params.steps) {
     if (step.previousRevision !== previous || revisions.has(step.revision))
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
+      throw new VibeError49({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} has a duplicate revision or broken predecessor chain`, meta: { reason: "module-chain-invalid", moduleId: params.moduleId, revision: step.revision } });
     const origin = createModuleOrigin({ moduleId: params.moduleId, dialect: params.dialect, revision: step.revision, previousRevision: step.previousRevision, contracts: step.contracts, owned: step.owned, source: step.migration });
     const predecessor = migrations.at(-1)?.moduleOrigin;
     if (predecessor !== undefined && canonicalMigrationJson({ value: predecessor.source.desiredState.to }) !== canonicalMigrationJson({ value: origin.source.desiredState.from }))
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
+      throw new VibeError49({ code: "VIBE_MIGRATION", message: "Module source state differs from its predecessor", meta: { reason: "module-predecessor-state", moduleId: params.moduleId } });
     validateMigrationReplay({ migrations: [origin.source], dialect: params.dialect, acceptSecurityChanges: true, acceptIntegrityLoss: true, removeUnmanaged: origin.source.desiredState?.unmanagedRemovals ?? [] });
     migrations.push(Object.freeze({ ...origin.source, moduleOrigin: origin }));
     revisions.add(step.revision);
@@ -9461,13 +9570,13 @@ function defineModuleMigrations(params) {
 }
 function moduleMigrationFiles(params) {
   if (params.bundle === null || typeof params.bundle !== "object" || !Array.isArray(params.bundle.migrations))
-    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
+    throw new VibeError49({ code: "VIBE_MIGRATION", message: "Module bundle must contain an immutable migration chain", meta: { reason: "module-chain-invalid" } });
   if (!/^[A-Za-z0-9_-]+$/.test(params.prefix))
-    throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
+    throw new VibeError49({ code: "VIBE_MIGRATION", message: "Module migration prefix must be a safe local directory name", meta: { reason: "module-prefix-invalid" } });
   const bundle = defineModuleMigrations({ moduleId: params.bundle.moduleId, dialect: params.bundle.dialect, steps: params.bundle.migrations.map((migration) => {
     const origin = migration?.moduleOrigin;
     if (origin === undefined || origin.moduleId !== params.bundle.moduleId || origin.dialect !== params.bundle.dialect)
-      throw new VibeError48({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
+      throw new VibeError49({ code: "VIBE_MIGRATION", message: "Module bundle lacks matching immutable origin metadata", meta: { reason: "module-origin-invalid" } });
     assertModuleOrigin({ value: origin });
     restoreModuleMigration({ migration, origin });
     return { revision: origin.revision, previousRevision: origin.previousRevision, contracts: origin.contracts, owned: origin.owned, migration: origin.source };
@@ -9480,7 +9589,7 @@ function emitModuleMigrationExport(params) {
   moduleMigrationFiles({ bundle: params.bundle, prefix: "export" });
   const origin = params.bundle.migrations.at(-1).moduleOrigin;
   if (!origin.contracts.includes(params.contract))
-    throw new VibeError49({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
+    throw new VibeError50({ code: "VIBE_CONFIG", message: "The package runtime contract is not supported by its migration head", meta: { reason: "module-contract-mismatch", moduleId: origin.moduleId } });
   const expectation = { moduleId: origin.moduleId, revision: origin.revision, artifactChecksum: origin.artifactChecksum, contract: params.contract };
   return [
     { name: "migrations.js", content: `// Generated immutable migration data; no driver, filesystem or runner import.
@@ -9497,9 +9606,9 @@ export const moduleReadiness = Object.freeze(${JSON.stringify(expectation)});
   ];
 }
 // packages/migrate/src/module-pending.ts
-import { VibeError as VibeError50, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
+import { VibeError as VibeError51, sqlObjectKey as sqlObjectKey19 } from "@vibeorm/schema";
 function refusal3(params) {
-  return new VibeError50({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
+  return new VibeError51({ code: "VIBE_MIGRATION", message: "Module registration or immutable upgrade history conflicts with the application's declarations; review the registration and deployment sequence", meta: params });
 }
 function compose(params) {
   const { current, from, to } = params;
@@ -9607,16 +9716,16 @@ function pendingModuleMigrations(params) {
   return Object.freeze(result);
 }
 // packages/migrate/src/module-readiness.ts
-import { VibeError as VibeError51 } from "@vibeorm/schema";
+import { VibeError as VibeError52 } from "@vibeorm/schema";
 async function inspectModuleReadiness(params) {
   const ids = new Set;
   for (const expected of params.modules) {
     if (ids.has(expected.moduleId) || !expected.moduleId || !expected.revision || !expected.contract || !/^[a-f0-9]{64}$/.test(expected.artifactChecksum))
-      throw new VibeError51({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
+      throw new VibeError52({ code: "VIBE_CONFIG", message: "Module readiness needs a unique module id, revision, contract and immutable artifact checksum", meta: { reason: "module-readiness-expectation", moduleId: expected.moduleId } });
     ids.add(expected.moduleId);
   }
   if (params.compatibility !== undefined && params.compatibility !== "exact" && params.compatibility !== "contract")
-    throw new VibeError51({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
+    throw new VibeError52({ code: "VIBE_CONFIG", message: "Unknown module compatibility mode", meta: { reason: "module-readiness-expectation" } });
   const records = await readModuleJournal(params);
   const heads = moduleHistoryHeads({ records });
   const unresolved = [...records.values()].some(({ row, entry }) => row.error !== undefined || row.statementIndex < 0 || entry !== undefined && (!entry.complete || row.statementIndex !== entry.migration.sql.length));
@@ -9650,7 +9759,7 @@ async function inspectModuleReadiness(params) {
   return { ready: !unresolved && modules.every((module) => (module.revision === "matching" || module.revision === "compatible") && module.structural.status !== "drifted"), modules };
 }
 // packages/migrate/src/adoption.ts
-import { VibeError as VibeError52 } from "@vibeorm/schema";
+import { VibeError as VibeError53 } from "@vibeorm/schema";
 async function adoptMigration(params) {
   const report = await verifyMigrationState({ executor: params.executor, expected: params.reference, dialect: params.dialect });
   assertMigrationState({ report });
@@ -9666,11 +9775,11 @@ function deployedDesiredState(params) {
   for (const [index, row] of params.recorded.entries()) {
     const file = params.migrations[index];
     if (row.state !== "applied" || row.checksum === "" || file?.name !== row.name || migrationChecksum(file) !== row.checksum)
-      throw new VibeError52({ code: "VIBE_MIGRATION", message: "Desired state requires complete, checksum-verified migration history", meta: { reason: "desired-state-history-unverified", migration: row.name, state: row.state } });
+      throw new VibeError53({ code: "VIBE_MIGRATION", message: "Desired state requires complete, checksum-verified migration history", meta: { reason: "desired-state-history-unverified", migration: row.name, state: row.state } });
   }
   const applied = new Set(params.recorded.map((row) => row.name));
   if (params.migrations.some((migration) => applied.has(migration.name) && migration.desiredStatePending === true))
-    throw new VibeError52({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
+    throw new VibeError53({ code: "VIBE_MIGRATION", message: "Applied unfinalized metadata cannot establish desired state", meta: { reason: "desired-state-history-unverified" } });
   const last = [...params.migrations].reverse().find((migration) => applied.has(migration.name));
   return last?.desiredState?.to;
 }
@@ -9684,6 +9793,7 @@ export {
   adoptMigration,
   applyMigrations,
   artifactCreateSql,
+  artifactDropSql,
   assertMigrationState,
   assertProbeMode,
   assertRemovalAuthorization,
@@ -9720,6 +9830,7 @@ export {
   introspectPostgres,
   introspectSqlite,
   isDefaultExecution,
+  lastDeclaredSchema,
   legacyMigrationObjects,
   migrationChecksum,
   migrationNamespace,
@@ -9731,11 +9842,13 @@ export {
   parseExecutionSidecar,
   parseModuleOrigin,
   pendingModuleMigrations,
+  planChangedArtifacts,
   planMissingArtifacts,
   planRenames,
   planReplayMigration,
   planSchemaMigration,
   prepareCheckDiff,
+  probeChangedArtifacts,
   probeInstalledExtensionState,
   pull,
   push,
@@ -9762,4 +9875,4 @@ export {
   withMigrationReference
 };
 
-//# debugId=AA96882D3F595BC864756E2164756E21
+//# debugId=9F525A8FE96388CC64756E2164756E21