diff --git a/CLAUDE.md b/CLAUDE.md
index 03cfd36..b2739d6 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -25,9 +25,11 @@ apso generate          # Generate code from .apsorc schema
 apso dev               # Start local dev server via Docker Compose
 
 # Schema
-apso migrate           # Test schema migrations locally (PGlite sandbox)
-apso migrate generate  # Migration from a deployed .apsorc to this project's entities (TypeScript, PGlite)
-apso migrate verify    # Run a migration on the deployed schema, then check for drift
+apso migrate           # The guided flow: generate code, plan against the deployed schema, ask about anything ambiguous (or print questions as JSON and exit 2), write the migration, verify it
+apso migrate sandbox   # The older snapshot preview on an empty PGlite database (--sql prints DDL for an .apsorc)
+apso migrate plan      # Compare the deployed schema (found automatically) with .apsorc; ambiguous changes become questions in .apso/migration-plan.json; JSON when piped; exits 2 while any are open
+apso migrate generate  # Write the TypeORM migration from the answered plan: up() with renames, data moves and backfills, plus a reversing down(); --typeorm uses TypeORM's generator
+apso migrate verify    # Run the newest migration on a local PGlite copy of the schema it starts from (optionally --seed rows, --check assertions), then check data loss and drift
 apso test smoke        # Start the service; call /health, list, and create/read/delete each entity (TS on PGlite, Python/Go on DATABASE_URL)
 apso schema validate   # Validate local .apsorc (includes lint)
 apso schema lint       # Lint .apsorc with @apso/schema-tools (--fix, --json)
diff --git a/README.md b/README.md
index 7762c2d..d0df2f3 100644
--- a/README.md
+++ b/README.md
@@ -185,22 +185,18 @@ Requires Docker and Docker Compose. Looks for `docker-compose.yml` in the curren
 
 ### `apso migrate`
 
-Detect schema changes, generate migration SQL, and test against a local PGlite sandbox. No Docker or external database required.
+Write the migration for a schema change without losing data. `apso migrate` regenerates the code, compares `.apsorc` with the deployed schema, and asks about every change whose intent the schema can't show: was a missing field renamed or dropped, how does a field split, what replaces a removed enum value, what do existing rows get for a new required field. It then writes the migration from your answers (a TypeORM migration for TypeScript, an Alembic revision for Python, a goose file for Go), saves the answered plan beside it, and tests it on a local PGlite copy of the deployed schema.
 
 ```bash
-apso migrate              # Detect changes, generate and test SQL
-apso migrate --apply      # Update snapshot after successful test
-apso migrate --reset      # Clear sandbox and start fresh
-apso migrate --sql        # Output raw SQL only (for piping)
+apso migrate --baseline deployed.apsorc     # first time: the .apsorc that is deployed
+apso migrate                                # later runs find the baseline from the last migration
+apso migrate --answer field:Contact.phone=rename:mobilePhone
+apso migrate --seed seed.sql --check checks.sql
 ```
 
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--apply` | Update local schema snapshot after verified migration | `false` |
-| `--reset` | Reset the sandbox (clear snapshot and PGlite data) | `false` |
-| `--sql` | Output raw SQL statements only | `false` |
+In a terminal it asks each question. Without one (or with `--json`) it prints the open questions as JSON and exits 2, so a coding agent can answer them with `--answer` or in `.apso/migration-plan.json` and run it again. The same answers always produce the same SQL.
 
-The sandbox works by comparing your current `.apsorc` against the last-known snapshot, generating the migration SQL, and executing it against an in-process Postgres instance (PGlite). If the migration fails locally, you know before it reaches any real database.
+The steps are also separate commands: `apso migrate plan`, `apso migrate generate` and `apso migrate verify`. `apso migrate sandbox` is the older snapshot preview on an empty database (`--apply`, `--reset`, `--sql`).
 
 ### `apso deploy`
 
diff --git a/jest.config.js b/jest.config.js
index 017ad80..0383bb3 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -2,6 +2,8 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
+  // PGlite-backed suites (migration render, verify, generate) take seconds per test on CI runners.
+  testTimeout: 30000,
   testMatch: [
     "**/src/**/*.spec.ts",
     "**/src/**/*.test.ts",
diff --git a/src/commands/deploy.ts b/src/commands/deploy.ts
index 6510a2f..97fb7b1 100644
--- a/src/commands/deploy.ts
+++ b/src/commands/deploy.ts
@@ -95,7 +95,7 @@ export default class Deploy extends BaseCommand {
             this.log(`Error: ${result.error}`);
           }
           this.log("Fix the schema issue before deploying.");
-          this.log("Run 'apso migrate' for details.");
+          this.log("Run 'apso migrate sandbox' for details.");
           this.exit(1);
         }
 
diff --git a/src/commands/migrate.ts b/src/commands/migrate.ts
index 74f4bc7..5e2a01d 100644
--- a/src/commands/migrate.ts
+++ b/src/commands/migrate.ts
@@ -1,149 +1,218 @@
+import * as fs from "fs";
 import * as path from "path";
 import { Flags } from "@oclif/core";
+import * as inquirer from "inquirer";
 import BaseCommand from "../lib/base-command";
-import { parseApsorc } from "../lib/apsorc-parser";
+import { readApsorcFile } from "../lib/apsorc-parser";
+import { writePlannedMigration } from "../lib/ddl/migration-file";
+import { openQuestions, Plan, planWithAnswers, Question } from "../lib/plan";
+import { Baseline, baselineFile, resolveBaseline } from "../lib/plan/baseline";
+import { describeQuestion, optionLabel, splitDefaults, sqlHint } from "../lib/plan/prompts";
 import {
-  runMigrationSandbox,
-  applyMigration,
-  resetSandbox,
-} from "../lib/migrate/sandbox";
-import { createGenerator } from "../lib";
-import { TargetLanguage, GeneratorConfig } from "../lib/types";
-import { createFile } from "../lib/utils/file-system";
+  cliBinPath,
+  report,
+  run,
+  supportsPglite,
+  verifyMigration,
+} from "../lib/verify";
+
+const required = (v: string) => v.trim() !== "" || "Enter an expression";
 
 export default class Migrate extends BaseCommand {
   static description =
-    "Detect schema changes, generate migration SQL, and test against a local PGlite sandbox";
+    "Migrate the database to this .apsorc in one step: regenerate the code, compare with the deployed schema, ask about anything ambiguous (a rename or a drop, how a field splits, what replaces a removed value), write the migration, and test it on a local copy. In a terminal it asks; for an agent it prints the open questions as JSON and exits 2, and the agent reruns it with --answer. The steps are also separate commands: apso migrate plan, generate and verify.";
 
   static examples = [
-    `$ apso migrate`,
-    `$ apso migrate --apply`,
-    `$ apso migrate --reset`,
-    `$ apso migrate --sql`,
+    "$ apso migrate",
+    "$ apso migrate --answer field:Contact.phone=rename:mobilePhone",
+    "$ apso migrate --seed seed.sql --check checks.sql",
   ];
 
   static flags = {
-    apply: Flags.boolean({
+    baseline: Flags.string({
       description:
-        "Apply the migration: update the local snapshot after a successful test",
+        "The deployed .apsorc, the first time only. Later runs find it from the last migration",
+    }),
+    answer: Flags.string({
+      description: "Answer a question: <question id>=<option>. Repeatable.",
+      multiple: true,
+      default: [],
+    }),
+    seed: Flags.string({
+      description: "SQL file of rows to load first; the test then fails if the migration loses any",
+    }),
+    check: Flags.string({
+      description: "SQL file of SELECTs with a boolean ok column, run after the migration",
+    }),
+    "accept-loss": Flags.string({
+      description: "A table or table.column whose seeded data may be dropped on purpose (repeatable)",
+      multiple: true,
+      default: [],
+    }),
+    name: Flags.string({ description: "Migration name", default: "SchemaUpdate" }),
+    "skip-generate": Flags.boolean({
+      description: "Don't regenerate code from .apsorc first",
       default: false,
     }),
-    reset: Flags.boolean({
-      description: "Reset the sandbox (clear snapshot and PGlite data)",
+    "skip-verify": Flags.boolean({
+      description: "Write the migration without testing it",
       default: false,
     }),
-    sql: Flags.boolean({
-      description: "Output raw SQL only (for piping to files)",
+    json: Flags.boolean({
+      description: "Print the result as JSON (the default when output is not a terminal)",
       default: false,
     }),
   };
 
+  private json = false;
+
+  /** Progress for people; agents get only the final JSON. */
+  private say(s: string): void {
+    if (!this.json) this.log(s);
+  }
+
+  /** Print the outcome: one JSON object for agents, nothing extra for people. */
+  private out(status: string, extra: Record<string, unknown>): void {
+    if (this.json) this.log(JSON.stringify({ status, ...extra }, null, 2));
+  }
+
+  private fail(message: string, extra: Record<string, unknown> = {}): never {
+    if (this.json) {
+      this.out("failed", { error: message, ...extra });
+      this.exit(1);
+    }
+    this.error(message, { exit: 1 });
+  }
+
   async run(): Promise<void> {
     const { flags } = await this.parse(Migrate);
+    const cwd = process.cwd();
+    this.json = flags.json || !process.stdout.isTTY;
+    const interactive = !this.json && Boolean(process.stdin.isTTY);
+    // Keep stdout pure JSON for agents: parser notices go to stderr.
+    if (this.json) console.info = (...m: unknown[]) => process.stderr.write(m.join(" ") + "\n");
 
-    // Handle reset
-    if (flags.reset) {
-      resetSandbox();
-      this.log("Sandbox reset. Snapshot and PGlite data cleared.");
-      return;
+    const { apsorc } = readApsorcFile();
+    const cliBin = cliBinPath(this.config.root);
+
+    if (!flags["skip-generate"]) {
+      this.say("Generating code from .apsorc...");
+      // Agents run without a terminal, where generate needs the language spelled out.
+      const language = apsorc.language ?? "typescript";
+      const gen = await run(process.execPath, [cliBin, "generate", "--language", language], cwd);
+      if (!gen.ok) this.fail(`apso generate failed:\n${gen.output.trim().split("\n").slice(-15).join("\n")}`);
     }
 
-    // Parse .apsorc
-    let parsed;
+    const planPath = path.resolve(".apso/migration-plan.json");
+    let baseline: Baseline;
     try {
-      parsed = parseApsorc();
-    } catch (error: unknown) {
-      const msg = error instanceof Error ? error.message : String(error);
-      this.error(`Failed to parse .apsorc: ${msg}`);
+      baseline = resolveBaseline(cwd, apsorc, flags.baseline, planPath);
+    } catch (error) {
+      this.fail((error as Error).message);
     }
+    this.say(`Comparing with ${baseline.source}.`);
 
-    if (!flags.sql) {
-      this.log("Schema changes detected. Running migration sandbox...");
+    const previous: Plan | undefined = fs.existsSync(planPath)
+      ? JSON.parse(fs.readFileSync(planPath).toString())
+      : undefined;
+    let plan: Plan;
+    try {
+      plan = planWithAnswers(baseline.schema, apsorc, previous, flags.answer);
+    } catch (error) {
+      this.fail((error as Error).message);
     }
+    const save = () => {
+      fs.mkdirSync(path.dirname(planPath), { recursive: true });
+      fs.writeFileSync(planPath, JSON.stringify({ ...plan, before: baseline.schema }, null, 2) + "\n");
+    };
 
-    // Run the sandbox
-    const result = await runMigrationSandbox(
-      { entities: parsed.entities, relationshipMap: parsed.relationshipMap },
-    );
-
-    if (!result.needed) {
-      if (!flags.sql) {
-        this.log("No database-level changes detected.");
+    // Ask until nothing is open. Answers can raise new questions (dropping a
+    // field leaves a required one to backfill), so re-plan after each round.
+    for (let open = openQuestions(plan); open.length > 0; open = openQuestions(plan)) {
+      save();
+      if (!interactive) {
+        const next =
+          'Rerun apso migrate --answer <id>=<option> for each. For "sql" and "split:" answers, also set the question\'s "sql" in the plan file: a string, or one expression per split field.';
+        if (this.json) {
+          this.out("questions", { plan: path.relative(cwd, planPath), baseline: baseline.source, open: open.map((q) => describeQuestion(q)), next });
+        } else {
+          for (const q of open) this.log(`\n${q.id}\n  ${q.subject}\n  options: ${q.options.join(" | ")}`);
+          this.log(`\n${next}`);
+        }
+        this.exit(2);
       }
-      return;
+      for (const q of open) {
+        // eslint-disable-next-line no-await-in-loop
+        await this.ask(q);
+      }
+      plan = planWithAnswers(baseline.schema, apsorc, plan, []);
     }
+    save();
 
-    // Output results
-    if (flags.sql) {
-      // Raw SQL output mode
-      for (const sql of result.upSql) {
-        this.log(sql + ";");
-      }
+    const written = writePlannedMigration(cwd, baseline.schema, flags.name, planPath);
+    if (!written.ok) this.fail(written.steps.map((s) => s.output).filter(Boolean).join("\n"));
+    if (!written.needed) {
+      this.say("The database already matches .apsorc. Nothing to migrate.");
+      this.out("up-to-date", {});
       return;
     }
+    this.say(`Wrote ${written.file}`);
+    for (const f of written.findings ?? []) this.say(`  warning ${f.code}: ${f.message}`);
 
-    if (result.success) {
-      this.log("");
-      this.log("Migration SQL (up):");
-      this.log("---");
-      for (const sql of result.upSql) {
-        this.log(`  ${sql};`);
-      }
-      this.log("---");
-      this.log("");
-      this.log(`${result.upSql.length} statement(s) generated and tested.`);
-      this.log("Migration validated against local PGlite.");
-
-      // Generate language-native migration files for Python and Go
-      const language: TargetLanguage = parsed.language || "typescript";
-      if (language !== "typescript") {
-        const generatorConfig: GeneratorConfig = {
-          language,
-          rootFolder: parsed.rootFolder || "src",
-          apiType: parsed.apiType || "rest",
-          entities: parsed.entities,
-          relationshipMap: parsed.relationshipMap,
-        };
-
-        const generator = createGenerator(generatorConfig);
-        const migrationFiles = await generator.generateMigration({
-          entities: parsed.entities,
-          relationshipMap: parsed.relationshipMap,
-          upSql: result.upSql,
-          downSql: result.downSql,
-        });
-
-        for (const file of migrationFiles) {
-          const fullPath = path.join(process.cwd(), file.path);
-          // eslint-disable-next-line no-await-in-loop
-          await createFile(fullPath, file.content);
-          this.log(`Generated migration file: ${file.path}`);
-        }
-      }
+    let verified: boolean | "skipped" = "skipped";
+    // Python and Go verify without the project's own database driver.
+    const canVerify = (apsorc.language ?? "typescript") !== "typescript" || supportsPglite(cwd);
+    if (!flags["skip-verify"] && canVerify) {
+      this.say("Testing the migration on a local copy of the deployed schema...");
+      const result = await verifyMigration(cwd, baselineFile(baseline), written.file!, cliBin, {
+        seedFile: flags.seed,
+        checkFile: flags.check,
+        acceptLoss: flags["accept-loss"],
+      });
+      verified = result.ok;
+      if (!this.json) report((s) => this.log(s), { ...result, findings: [] }, false);
+      if (!result.ok)
+        this.fail(
+          `The migration in ${written.file} failed its test. Fix the answers in ${written.planFile} or the .apsorc, then run apso migrate again.`,
+          { file: written.file, planFile: written.planFile, steps: result.steps }
+        );
+    }
 
-      if (flags.apply) {
-        applyMigration({
-          entities: parsed.entities,
-          relationshipMap: parsed.relationshipMap,
-        });
-        this.log("Snapshot updated.");
-      } else {
-        this.log("Run with --apply to update the snapshot.");
-      }
-    } else {
-      this.log("");
-      this.log("Migration FAILED.");
-      if (result.error) {
-        this.log(`Error: ${result.error}`);
-      }
-      if (result.upSql.length > 0) {
-        this.log("");
-        this.log("Attempted SQL:");
-        for (const sql of result.upSql) {
-          this.log(`  ${sql};`);
-        }
+    this.say(`\nReview and commit ${written.file} and ${written.planFile}, then deploy.`);
+    if (verified === true && !flags.seed)
+      this.say("Tip: --seed <rows.sql> also checks that existing rows survive the migration.");
+    this.out("written", { file: written.file, planFile: written.planFile, verified });
+  }
+
+  private async ask(q: Question): Promise<void> {
+    const { choice } = await inquirer.prompt<{ choice: string }>([
+      {
+        type: "list",
+        name: "choice",
+        message: q.subject,
+        choices: q.options.map((o) => ({ name: optionLabel(q, o), value: o })),
+        default: q.suggested,
+      },
+    ]);
+    q.answer = choice;
+    if (choice === "sql") {
+      const { sql } = await inquirer.prompt<{ sql: string }>([
+        { type: "input", name: "sql", message: sqlHint(q), validate: required },
+      ]);
+      q.sql = sql;
+    }
+    if (choice.startsWith("split:")) {
+      const targets = choice.slice("split:".length).split(",");
+      const defaults = splitDefaults(q, targets);
+      const sql: Record<string, string> = {};
+      for (const t of targets) {
+        // eslint-disable-next-line no-await-in-loop
+        const { expr } = await inquirer.prompt<{ expr: string }>([
+          { type: "input", name: "expr", message: `SQL for ${t}`, default: defaults[t], validate: required },
+        ]);
+        sql[t] = expr;
       }
-      this.exit(1);
+      q.sql = sql;
     }
   }
 }
diff --git a/src/commands/migrate/generate.ts b/src/commands/migrate/generate.ts
index dcb0426..5f20036 100644
--- a/src/commands/migrate/generate.ts
+++ b/src/commands/migrate/generate.ts
@@ -1,29 +1,48 @@
 import * as path from "path";
 import { Flags } from "@oclif/core";
 import BaseCommand from "../../lib/base-command";
-import { parseApsorc } from "../../lib/apsorc-parser";
+import { readApsorcFile } from "../../lib/apsorc-parser";
+import { writePlannedMigration } from "../../lib/ddl/migration-file";
+import { Question } from "../../lib/plan";
+import {
+  Baseline,
+  baselineFile,
+  resolveBaseline,
+} from "../../lib/plan/baseline";
 import {
   cliBinPath,
-  migrateUnsupported,
   generateMigration,
   report,
 } from "../../lib/verify";
 
 export default class MigrateGenerate extends BaseCommand {
   static description =
-    "Generate a TypeORM migration from the deployed schema to this project's entities, using a local PGlite database (TypeScript services)";
+    "Write a migration from the deployed schema to this project's .apsorc. Apso renders the SQL from the answered migration plan (apso migrate plan), including data moves and a down() that reverses them. Exits 2 while plan questions are open. The migration is a TypeORM class, an Alembic revision or a goose SQL file, by the service's language. --typeorm uses TypeORM's generator on a local PGlite database instead (TypeScript services).";
 
-  static examples = [`$ apso migrate generate --baseline deployed.apsorc`];
+  static examples = [
+    `$ apso migrate plan --answer entity:Company=rename:Organization`,
+    `$ apso migrate generate`,
+    `$ apso migrate generate --typeorm`,
+  ];
 
   static flags = {
     baseline: Flags.string({
-      description: "The deployed .apsorc to migrate from",
-      required: true,
+      description:
+        "The deployed .apsorc to migrate from. Defaults to the schema after the newest planned migration, or the .apsorc from the last commit that changed the migrations folder",
     }),
     name: Flags.string({
       description: "Migration name",
       default: "SchemaUpdate",
     }),
+    plan: Flags.string({
+      description: "Migration plan with the answers",
+      default: ".apso/migration-plan.json",
+    }),
+    typeorm: Flags.boolean({
+      description:
+        "Use TypeORM's migration:generate instead of Apso's plan (no data moves)",
+      default: false,
+    }),
     json: Flags.boolean({
       description: "Print the result as JSON",
       default: false,
@@ -32,14 +51,47 @@ export default class MigrateGenerate extends BaseCommand {
 
   async run(): Promise<void> {
     const { flags } = await this.parse(MigrateGenerate);
-    const unsupported = migrateUnsupported(parseApsorc().language);
-    if (unsupported) this.error(unsupported);
-    const result = await generateMigration(
-      process.cwd(),
-      path.resolve(flags.baseline),
-      flags.name,
-      cliBinPath(this.config.root)
-    );
+    const { apsorc } = readApsorcFile();
+    if (flags.typeorm && (apsorc.language ?? "typescript") !== "typescript")
+      this.error("--typeorm works on TypeScript services only.");
+    let baseline: Baseline;
+    try {
+      baseline = resolveBaseline(
+        process.cwd(),
+        apsorc,
+        flags.baseline,
+        path.resolve(flags.plan)
+      );
+    } catch (error) {
+      this.error((error as Error).message, { exit: 1 });
+    }
+    const result = flags.typeorm
+      ? await generateMigration(
+          process.cwd(),
+          baselineFile(baseline),
+          flags.name,
+          cliBinPath(this.config.root)
+        )
+      : writePlannedMigration(
+          process.cwd(),
+          baseline.schema,
+          flags.name,
+          path.resolve(flags.plan)
+        );
+    const { open } = result as { open?: Question[] };
+    if (open && open.length > 0) {
+      if (flags.json) this.log(JSON.stringify(result));
+      else {
+        this.log(result.steps[0].output ?? "");
+        for (const q of open)
+          this.log(
+            `\n${q.id}\n  ${q.subject}\n  options: ${q.options.join(" | ")}${
+              q.suggested ? ` (suggested: ${q.suggested})` : ""
+            }`
+          );
+      }
+      this.exit(2);
+    }
     const summary = result.needed
       ? `Created ${result.file}`
       : "The database already matches; no migration needed.";
diff --git a/src/commands/migrate/plan.ts b/src/commands/migrate/plan.ts
new file mode 100644
index 0000000..08b2fea
--- /dev/null
+++ b/src/commands/migrate/plan.ts
@@ -0,0 +1,112 @@
+import * as fs from "fs";
+import * as path from "path";
+import { Flags } from "@oclif/core";
+import BaseCommand from "../../lib/base-command";
+import { readApsorcFile } from "../../lib/apsorc-parser";
+import { openQuestions, Plan, planWithAnswers } from "../../lib/plan";
+import { Baseline, resolveBaseline } from "../../lib/plan/baseline";
+import { describeQuestion } from "../../lib/plan/prompts";
+
+export default class MigratePlan extends BaseCommand {
+  static description =
+    "Compare the deployed .apsorc with this one and write a migration plan. Changes whose intent is ambiguous (rename or drop, how a field splits, which value replaces a removed enum value) become questions; answer them in the plan file or with --answer. Exits 2 while questions are open.";
+
+  static examples = [
+    "$ apso migrate plan",
+    "$ apso migrate plan --answer field:Contact.phone=rename:mobilePhone",
+    "$ apso migrate plan --baseline deployed.apsorc",
+  ];
+
+  static flags = {
+    baseline: Flags.string({
+      description:
+        "The deployed .apsorc to migrate from. Defaults to the schema after the newest planned migration, or the .apsorc from the last commit that changed the migrations folder",
+    }),
+    plan: Flags.string({
+      description: "Plan file to read answers from and write",
+      default: ".apso/migration-plan.json",
+    }),
+    answer: Flags.string({
+      description: "Answer a question: <question id>=<option>. Repeatable.",
+      multiple: true,
+      default: [],
+    }),
+    json: Flags.boolean({
+      description:
+        "Print the open questions as JSON (the default when output is not a terminal)",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(MigratePlan);
+    const planPath = path.resolve(flags.plan);
+    const { apsorc: after } = readApsorcFile();
+    let baseline: Baseline;
+    try {
+      baseline = resolveBaseline(
+        process.cwd(),
+        after,
+        flags.baseline,
+        planPath
+      );
+    } catch (error) {
+      this.error((error as Error).message, { exit: 1 });
+    }
+    const before = baseline.schema;
+    // Agents read the output from a pipe; people at a terminal get text.
+    const json = flags.json || !process.stdout.isTTY;
+    // Keep stdout pure JSON for agents: parser notices go to stderr.
+    if (json) console.info = (...m: unknown[]) => process.stderr.write(m.join(" ") + "\n");
+
+    const previous: Plan | undefined = fs.existsSync(planPath)
+      ? JSON.parse(fs.readFileSync(planPath).toString())
+      : undefined;
+    let plan: Plan;
+    try {
+      plan = planWithAnswers(before, after, previous, flags.answer);
+    } catch (error) {
+      this.error((error as Error).message, { exit: 1 });
+    }
+
+    fs.mkdirSync(path.dirname(planPath), { recursive: true });
+    fs.writeFileSync(
+      planPath,
+      JSON.stringify({ ...plan, before }, null, 2) + "\n"
+    );
+
+    const open = openQuestions(plan);
+    if (json) {
+      this.log(
+        JSON.stringify(
+          { plan: flags.plan, baseline: baseline.source, open: open.map((q) => describeQuestion(q)) },
+          null,
+          2
+        )
+      );
+    } else if (open.length === 0) {
+      this.log(`Compared with ${baseline.source}.`);
+      this.log(
+        `${flags.plan}: all ${plan.questions.length} question(s) answered.`
+      );
+    } else {
+      this.log(`Compared with ${baseline.source}.`);
+      this.log(
+        `${flags.plan}: ${open.length} of ${plan.questions.length} question(s) open.`
+      );
+      for (const q of open) {
+        const hint = q.suggested ? ` (suggested: ${q.suggested})` : "";
+        this.log(
+          `\n${q.id}\n  ${q.subject}\n  options: ${q.options.join(
+            " | "
+          )}${hint}`
+        );
+      }
+      this.log(
+        `\nAnswer with --answer <id>=<option>, or edit ${flags.plan}. ` +
+          `"sql" and "split:" answers also need a "sql" value in the file.`
+      );
+    }
+    if (open.length > 0) this.exit(2);
+  }
+}
diff --git a/src/commands/migrate/sandbox.ts b/src/commands/migrate/sandbox.ts
new file mode 100644
index 0000000..3b0ffaf
--- /dev/null
+++ b/src/commands/migrate/sandbox.ts
@@ -0,0 +1,149 @@
+import * as path from "path";
+import { Flags } from "@oclif/core";
+import BaseCommand from "../../lib/base-command";
+import { parseApsorc } from "../../lib/apsorc-parser";
+import {
+  runMigrationSandbox,
+  applyMigration,
+  resetSandbox,
+} from "../../lib/migrate/sandbox";
+import { createGenerator } from "../../lib";
+import { TargetLanguage, GeneratorConfig } from "../../lib/types";
+import { createFile } from "../../lib/utils/file-system";
+
+export default class MigrateSandbox extends BaseCommand {
+  static description =
+    "Test schema changes against a local PGlite sandbox that keeps its own snapshot of the last schema (the older flow; apso migrate is the guided one)";
+
+  static examples = [
+    `$ apso migrate sandbox`,
+    `$ apso migrate sandbox --apply`,
+    `$ apso migrate sandbox --reset`,
+    `$ apso migrate sandbox --sql`,
+  ];
+
+  static flags = {
+    apply: Flags.boolean({
+      description:
+        "Apply the migration: update the local snapshot after a successful test",
+      default: false,
+    }),
+    reset: Flags.boolean({
+      description: "Reset the sandbox (clear snapshot and PGlite data)",
+      default: false,
+    }),
+    sql: Flags.boolean({
+      description: "Output raw SQL only (for piping to files)",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(MigrateSandbox);
+
+    // Handle reset
+    if (flags.reset) {
+      resetSandbox();
+      this.log("Sandbox reset. Snapshot and PGlite data cleared.");
+      return;
+    }
+
+    // Parse .apsorc
+    let parsed;
+    try {
+      parsed = parseApsorc();
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.error(`Failed to parse .apsorc: ${msg}`);
+    }
+
+    if (!flags.sql) {
+      this.log("Schema changes detected. Running migration sandbox...");
+    }
+
+    // Run the sandbox
+    const result = await runMigrationSandbox(
+      { entities: parsed.entities, relationshipMap: parsed.relationshipMap },
+    );
+
+    if (!result.needed) {
+      if (!flags.sql) {
+        this.log("No database-level changes detected.");
+      }
+      return;
+    }
+
+    // Output results
+    if (flags.sql) {
+      // Raw SQL output mode
+      for (const sql of result.upSql) {
+        this.log(sql + ";");
+      }
+      return;
+    }
+
+    if (result.success) {
+      this.log("");
+      this.log("Migration SQL (up):");
+      this.log("---");
+      for (const sql of result.upSql) {
+        this.log(`  ${sql};`);
+      }
+      this.log("---");
+      this.log("");
+      this.log(`${result.upSql.length} statement(s) generated and tested.`);
+      this.log("Migration validated against local PGlite.");
+
+      // Generate language-native migration files for Python and Go
+      const language: TargetLanguage = parsed.language || "typescript";
+      if (language !== "typescript") {
+        const generatorConfig: GeneratorConfig = {
+          language,
+          rootFolder: parsed.rootFolder || "src",
+          apiType: parsed.apiType || "rest",
+          entities: parsed.entities,
+          relationshipMap: parsed.relationshipMap,
+        };
+
+        const generator = createGenerator(generatorConfig);
+        const migrationFiles = await generator.generateMigration({
+          entities: parsed.entities,
+          relationshipMap: parsed.relationshipMap,
+          upSql: result.upSql,
+          downSql: result.downSql,
+        });
+
+        for (const file of migrationFiles) {
+          const fullPath = path.join(process.cwd(), file.path);
+          // eslint-disable-next-line no-await-in-loop
+          await createFile(fullPath, file.content);
+          this.log(`Generated migration file: ${file.path}`);
+        }
+      }
+
+      if (flags.apply) {
+        applyMigration({
+          entities: parsed.entities,
+          relationshipMap: parsed.relationshipMap,
+        });
+        this.log("Snapshot updated.");
+      } else {
+        this.log("Run with --apply to update the snapshot.");
+      }
+    } else {
+      this.log("");
+      this.log("Migration FAILED.");
+      if (result.error) {
+        this.log(`Error: ${result.error}`);
+      }
+      if (result.upSql.length > 0) {
+        this.log("");
+        this.log("Attempted SQL:");
+        for (const sql of result.upSql) {
+          this.log(`  ${sql};`);
+        }
+      }
+      this.exit(1);
+    }
+  }
+}
diff --git a/src/commands/migrate/verify.ts b/src/commands/migrate/verify.ts
index 39a62b4..0e712fb 100644
--- a/src/commands/migrate/verify.ts
+++ b/src/commands/migrate/verify.ts
@@ -1,30 +1,47 @@
 import * as path from "path";
 import { Flags } from "@oclif/core";
 import BaseCommand from "../../lib/base-command";
-import { parseApsorc } from "../../lib/apsorc-parser";
+import { readApsorcFile } from "../../lib/apsorc-parser";
+import { baselineFile, latestPlannedMigration } from "../../lib/plan/baseline";
 import {
   cliBinPath,
-  migrateUnsupported,
   report,
   verifyMigration,
 } from "../../lib/verify";
 
 export default class MigrateVerify extends BaseCommand {
   static description =
-    "Run a migration on a local PGlite copy of the deployed schema, then check the database matches this project's entities (TypeScript services)";
+    "Run a migration on a local PGlite copy of the deployed schema, then check the database matches this project's entities (TypeScript), or a fresh build of its .apsorc (Python and Go, which also run down and check it gives back the deployed schema)";
 
   static examples = [
+    `$ apso migrate verify`,
+    `$ apso migrate verify --seed seed.sql --check checks.sql`,
+    `$ apso migrate verify --seed seed.sql --check checks.sql --accept-loss contact.fullName`,
     `$ apso migrate verify --baseline deployed.apsorc --migration src/migrations/1700000000000-SchemaUpdate-migration.ts`,
   ];
 
   static flags = {
     baseline: Flags.string({
-      description: "The deployed .apsorc the migration starts from",
-      required: true,
+      description:
+        "The deployed .apsorc the migration starts from. Defaults to the schema saved with the migration's plan",
     }),
     migration: Flags.string({
-      description: "The migration file to run",
-      required: true,
+      description:
+        "The migration file to run. Defaults to the newest planned migration",
+    }),
+    seed: Flags.string({
+      description:
+        "SQL file of rows to insert into the deployed schema before the migration runs; the check then fails if the migration loses any of them",
+    }),
+    check: Flags.string({
+      description:
+        "SQL file of SELECTs run after the migration; each row must have a boolean ok (and a label naming the check), e.g. SELECT bool_and(\"firstName\" <> '') AS ok, 'every contact has a first name' AS label FROM contact",
+    }),
+    "accept-loss": Flags.string({
+      description:
+        "A table or table.column whose seeded data the migration may drop on purpose (repeatable); pair it with --check to prove where the data went",
+      multiple: true,
+      default: [],
     }),
     "skip-build": Flags.boolean({
       description: "Use the existing dist/ build instead of building first",
@@ -38,14 +55,42 @@ export default class MigrateVerify extends BaseCommand {
 
   async run(): Promise<void> {
     const { flags } = await this.parse(MigrateVerify);
-    const unsupported = migrateUnsupported(parseApsorc().language);
-    if (unsupported) this.error(unsupported);
+    const { apsorc } = readApsorcFile();
+    const latest = latestPlannedMigration(process.cwd(), apsorc);
+    const migration = flags.migration ?? latest?.file;
+    if (!migration)
+      this.error(
+        "No planned migration found. Run apso migrate generate, or pass --migration.",
+        { exit: 1 }
+      );
+    // The migration's own plan says which schema it starts from.
+    const saved =
+      latest && path.resolve(latest.file) === path.resolve(migration)
+        ? latest.saved
+        : undefined;
+    let baseline: string;
+    if (flags.baseline) baseline = path.resolve(flags.baseline);
+    else if (saved)
+      baseline = baselineFile({
+        schema: saved.before,
+        source: latest!.planFile,
+      });
+    else
+      this.error(
+        `No saved plan for ${migration}; pass the deployed .apsorc with --baseline.`,
+        { exit: 1 }
+      );
     const result = await verifyMigration(
       process.cwd(),
-      path.resolve(flags.baseline),
-      flags.migration,
+      baseline,
+      migration,
       cliBinPath(this.config.root),
-      flags["skip-build"]
+      {
+        skipBuild: flags["skip-build"],
+        seedFile: flags.seed,
+        checkFile: flags.check,
+        acceptLoss: flags["accept-loss"],
+      }
     );
     report(
       (s) => this.log(s),
diff --git a/src/lib/ddl/catalog.ts b/src/lib/ddl/catalog.ts
new file mode 100644
index 0000000..dbfecee
--- /dev/null
+++ b/src/lib/ddl/catalog.ts
@@ -0,0 +1,67 @@
+/**
+ * Read a database's schema back out of Postgres's own catalog, in a form two
+ * databases can be compared by. Postgres normalizes what it stores (types,
+ * defaults, constraint definitions), so two databases built by different SQL
+ * compare equal when they ended up the same.
+ */
+
+export interface Catalog {
+  columns: string[];
+  constraints: string[];
+  indexes: string[];
+  enums: string[];
+}
+
+interface Queryable {
+  query<T>(sql: string): Promise<{ rows: T[] }>;
+}
+
+const COLUMNS = `
+SELECT table_name || '.' || column_name || ' ' || format_type(a.atttypid, a.atttypmod)
+       || CASE WHEN c.is_nullable = 'NO' THEN ' NOT NULL' ELSE '' END
+       || COALESCE(' DEFAULT ' || c.column_default, '') AS line
+FROM information_schema.columns c
+JOIN pg_attribute a ON a.attrelid = ('"' || c.table_name || '"')::regclass AND a.attname = c.column_name
+WHERE c.table_schema = 'public'`;
+
+const CONSTRAINTS = `
+SELECT conrelid::regclass::text || ' ' || conname || ' ' || pg_get_constraintdef(oid) AS line
+FROM pg_constraint
+WHERE connamespace = 'public'::regnamespace AND contype IN ('p', 'u', 'f', 'c')`;
+
+const INDEXES = `
+SELECT indexdef AS line FROM pg_indexes
+WHERE schemaname = 'public'
+  AND indexname NOT IN (SELECT conname FROM pg_constraint WHERE connamespace = 'public'::regnamespace)`;
+
+const ENUMS = `
+SELECT t.typname || ' ' || string_agg(e.enumlabel, ',' ORDER BY e.enumsortorder) AS line
+FROM pg_type t JOIN pg_enum e ON e.enumtypid = t.oid
+WHERE t.typnamespace = 'public'::regnamespace
+GROUP BY t.typname`;
+
+const lines = async (db: Queryable, sql: string) => {
+  const result = await db.query<{ line: string }>(sql);
+  return result.rows.map((r) => r.line).sort();
+};
+
+export async function readCatalog(db: Queryable): Promise<Catalog> {
+  return {
+    columns: await lines(db, COLUMNS),
+    constraints: await lines(db, CONSTRAINTS),
+    indexes: await lines(db, INDEXES),
+    enums: await lines(db, ENUMS),
+  };
+}
+
+/** Lines present in one catalog and not the other, prefixed - or +. */
+export function catalogDiff(a: Catalog, b: Catalog): string[] {
+  const out: string[] = [];
+  for (const key of Object.keys(a) as (keyof Catalog)[]) {
+    const left = new Set(a[key]);
+    const right = new Set(b[key]);
+    for (const l of a[key]) if (!right.has(l)) out.push(`- ${key}: ${l}`);
+    for (const l of b[key]) if (!left.has(l)) out.push(`+ ${key}: ${l}`);
+  }
+  return out;
+}
diff --git a/src/lib/ddl/change.ts b/src/lib/ddl/change.ts
new file mode 100644
index 0000000..1400829
--- /dev/null
+++ b/src/lib/ddl/change.ts
@@ -0,0 +1,497 @@
+/**
+ * Render an answered migration plan as the SQL that moves a database from
+ * the deployed .apsorc to the new one.
+ *
+ * Renames come first: the answered renames are applied to the deployed
+ * schema and its model rebuilt. Both models are built the same way, so their
+ * objects pair up by position and every name that differs becomes a RENAME
+ * (tables, columns, sequences, constraints, indexes, enum types). The renamed
+ * model is then diffed against the new one by identity, and the plan's
+ * answers supply the data steps. Statements run in a fixed order so data is
+ * moved before anything it lives in is dropped.
+ */
+import { parseApsorcV2 } from "../apsorc-parser";
+import { ApsorcType } from "../apsorc-parser";
+import { openQuestions, Plan, planMigration, Question } from "../plan";
+import {
+  Model,
+  ModelColumn,
+  ModelConstraint,
+  addConstraintSql,
+  createIndexSql,
+  createTableSql,
+  createTypeSql,
+  literal,
+  q,
+  schemaModel,
+  tableName,
+} from ".";
+
+const answered = (plan: Plan, kind: Question["kind"]) =>
+  plan.questions.filter((x) => x.kind === kind && x.answer);
+/** "field:Contact.phone" -> ["Contact", "phone"]; "enum:Contact.status:archived" -> [..., "archived"]. */
+const subject = (id: string) => {
+  const [entity, rest = ""] = id.slice(id.indexOf(":") + 1).split(".");
+  const [field, value] = rest.split(":");
+  return { entity, field, value };
+};
+
+/** The deployed .apsorc with every answered rename applied. */
+function applyRenames(
+  before: ApsorcType,
+  after: ApsorcType,
+  plan: Plan
+): ApsorcType {
+  const copy: ApsorcType = JSON.parse(JSON.stringify(before));
+  for (const x of answered(plan, "removedField")) {
+    if (!x.answer!.startsWith("rename:")) continue;
+    const { entity, field } = subject(x.id);
+    const f = copy.entities
+      .find((e) => e.name === entity)
+      ?.fields?.find((g) => g.name === field);
+    if (f) f.name = x.answer!.slice("rename:".length);
+  }
+  for (const x of answered(plan, "removedEntity")) {
+    if (!x.answer!.startsWith("rename:")) continue;
+    const from = subject(x.id).entity;
+    const to = x.answer!.slice("rename:".length);
+    const e = copy.entities.find((y) => y.name === from);
+    if (!e) continue;
+    e.name = to;
+    const target = after.entities.find((y) => y.name === to);
+    if (target?.table) e.table = target.table;
+    else delete e.table;
+    for (const r of copy.relationships ?? []) {
+      if (r.from === from) r.from = to;
+      if (r.to === from) r.to = to;
+    }
+  }
+  return copy;
+}
+
+function renames(was: Model, now: Model): string[] {
+  const same = (k: keyof Model) => was[k].length === now[k].length;
+  if (
+    !same("tables") ||
+    !same("constraints") ||
+    !same("indexes") ||
+    !same("enums")
+  )
+    throw new Error(
+      "Renaming changed the schema's shape; this rename can't be rendered."
+    );
+  const out: string[] = [];
+  was.tables.forEach((t, i) => {
+    const n = now.tables[i];
+    if (t.name !== n.name)
+      out.push(`ALTER TABLE ${q(t.name)} RENAME TO ${q(n.name)}`);
+    t.columns.forEach((c, j) => {
+      const nc = n.columns[j];
+      if (c.name !== nc.name)
+        out.push(
+          `ALTER TABLE ${q(n.name)} RENAME COLUMN ${q(c.name)} TO ${q(nc.name)}`
+        );
+      if (c.serial && t.name !== n.name)
+        out.push(
+          `ALTER SEQUENCE ${q(`${t.name}_${c.name}_seq`)} RENAME TO ${q(
+            `${n.name}_${nc.name}_seq`
+          )}`
+        );
+    });
+  });
+  was.constraints.forEach((c, i) => {
+    const n = now.constraints[i];
+    if (c.name !== n.name)
+      out.push(
+        `ALTER TABLE ${q(n.table)} RENAME CONSTRAINT ${q(c.name)} TO ${q(
+          n.name
+        )}`
+      );
+  });
+  was.indexes.forEach((x, i) => {
+    if (x.name !== now.indexes[i].name)
+      out.push(
+        `ALTER INDEX "public".${q(x.name)} RENAME TO ${q(now.indexes[i].name)}`
+      );
+  });
+  was.enums.forEach((e, i) => {
+    if (e.name !== now.enums[i].name)
+      out.push(
+        `ALTER TYPE "public".${q(e.name)} RENAME TO ${q(now.enums[i].name)}`
+      );
+  });
+  return out;
+}
+
+const nullableSql = (c: ModelColumn) =>
+  `${q(c.name)} ${c.type}${
+    c.default === undefined ? "" : ` DEFAULT ${c.default}`
+  }`;
+
+type Named = { name: string; body?: string; unique?: boolean };
+/** Missing from the other model, or present under another name or definition. */
+const changed = (x: Named, y?: Named) =>
+  !y || x.name !== y.name || x.body !== y.body || x.unique !== y.unique;
+/** The enum type name in a column type like "public"."contact_status_enum". */
+const typeOf = (t: string) => (t.match(/^"public"\."(.+)"$/) ?? [])[1];
+
+export interface ChangeDdl {
+  up: string[];
+}
+
+export function changeDdl(
+  before: ApsorcType,
+  after: ApsorcType,
+  plan: Plan
+): ChangeDdl {
+  const renamed = applyRenames(before, after, plan);
+  const was = schemaModel(parseApsorcV2(before));
+  const R = schemaModel(parseApsorcV2(renamed));
+  const A = schemaModel(parseApsorcV2(after));
+  const table = (entity: string, schema: ApsorcType = after) => {
+    const e = schema.entities.find((x) => x.name === entity);
+    if (!e) throw new Error(`No entity ${entity}`);
+    return tableName(e);
+  };
+
+  const up: string[] = renames(was, R);
+  const later: string[] = [];
+
+  const rTables = new Map(R.tables.map((t) => [t.name, t]));
+  const aTables = new Map(A.tables.map((t) => [t.name, t]));
+  const rCons = new Map(R.constraints.map((c) => [c.key, c]));
+  const aCons = new Map(A.constraints.map((c) => [c.key, c]));
+  const rIdx = new Map(R.indexes.map((i) => [i.key, i]));
+  const aIdx = new Map(A.indexes.map((i) => [i.key, i]));
+  // Drop keys and indexes that go away or change. Foreign keys first.
+  for (const c of [...R.constraints].sort(
+    (a, b) => (a.kind === "fk" ? -1 : 0) - (b.kind === "fk" ? -1 : 0)
+  ))
+    if (
+      changed(c, aCons.get(c.key)) &&
+      (c.kind === "fk" || aTables.has(c.table))
+    )
+      up.push(`ALTER TABLE ${q(c.table)} DROP CONSTRAINT ${q(c.name)}`);
+  for (const i of R.indexes)
+    if (changed(i, aIdx.get(i.key)) && aTables.has(i.table))
+      up.push(`DROP INDEX "public".${q(i.name)}`);
+
+  // Enum types: create new ones; swap changed ones through <name>_old.
+  const rEnums = new Map(R.enums.map((e) => [e.name, e]));
+  const swapped = new Set<string>();
+  for (const e of A.enums) {
+    const old = rEnums.get(e.name);
+    if (!old) up.push(createTypeSql(e));
+    else if (old.values.join(",") !== e.values.join(",")) {
+      up.push(
+        `ALTER TYPE "public".${q(e.name)} RENAME TO ${q(`${e.name}_old`)}`,
+        createTypeSql(e)
+      );
+      swapped.add(e.name);
+      later.push(`DROP TYPE "public".${q(`${e.name}_old`)}`);
+    }
+  }
+
+  // New tables, with their own primary and unique keys inline.
+  const createdInline = new Set<string>();
+  for (const t of A.tables)
+    if (!rTables.has(t.name)) {
+      up.push(createTableSql(t, A.constraints));
+      for (const c of A.constraints)
+        if (c.table === t.name && c.kind !== "fk") createdInline.add(c.key);
+    }
+
+  // Columns on tables that stay.
+  const setNotNull: string[] = [];
+  const enumMap = new Map<string, Map<string, string>>();
+  for (const x of answered(plan, "enumValue")) {
+    const { entity, field, value } = subject(x.id);
+    const key = `${table(entity)}.${field}`;
+    if (!enumMap.has(key)) enumMap.set(key, new Map());
+    enumMap.get(key)!.set(value!, x.answer!);
+  }
+  const casts = new Map(
+    answered(plan, "cast").map((x) => {
+      const { entity, field } = subject(x.id);
+      return [`${table(entity)}.${field}`, x] as const;
+    })
+  );
+  for (const t of A.tables) {
+    const old = rTables.get(t.name);
+    if (!old) continue;
+    for (const c of t.columns) {
+      const o = old.columns.find((x) => x.name === c.name);
+      const at = `ALTER TABLE ${q(t.name)} ALTER COLUMN ${q(c.name)}`;
+      if (!o) {
+        const needsData = c.notNull && c.default === undefined && !c.serial;
+        up.push(
+          `ALTER TABLE ${q(t.name)} ADD ${needsData ? nullableSql(c) : c.sql}`
+        );
+        if (needsData) setNotNull.push(`${at} SET NOT NULL`);
+        continue;
+      }
+      const enumName = typeOf(c.type);
+      const retype = o.type !== c.type || (enumName && swapped.has(enumName));
+      if (retype) {
+        let using = `${q(c.name)}::${c.type}`;
+        const map = enumMap.get(`${t.name}.${c.name}`);
+        const cast = casts.get(`${t.name}.${c.name}`);
+        if (enumName && map?.size)
+          using = `(CASE ${q(c.name)}::text ${[...map]
+            .map(([v, to]) => `WHEN ${literal(v)} THEN ${literal(to)}`)
+            .join(" ")} ELSE ${q(c.name)}::text END)::${c.type}`;
+        else if (enumName) using = `${q(c.name)}::text::${c.type}`;
+        else if (cast?.answer === "sql") using = `(${cast.sql})`;
+        if (o.default !== undefined) up.push(`${at} DROP DEFAULT`);
+        up.push(`${at} TYPE ${c.type} USING ${using}`);
+        if (c.default !== undefined)
+          setNotNull.push(`${at} SET DEFAULT ${c.default}`);
+      } else if (o.default !== c.default) {
+        setNotNull.push(
+          c.default === undefined
+            ? `${at} DROP DEFAULT`
+            : `${at} SET DEFAULT ${c.default}`
+        );
+      }
+      if (!o.notNull && c.notNull) setNotNull.push(`${at} SET NOT NULL`);
+      if (o.notNull && !c.notNull) up.push(`${at} DROP NOT NULL`);
+    }
+  }
+
+  // Data: split, move, copied links, backfills.
+  for (const x of answered(plan, "removedField")) {
+    const { entity, field } = subject(x.id);
+    const t = table(entity);
+    if (x.answer!.startsWith("split:") && typeof x.sql === "object") {
+      const sets = x
+        .answer!.slice("split:".length)
+        .split(",")
+        .map((f) => `${q(f)} = (${(x.sql as Record<string, string>)[f]})`);
+      up.push(`UPDATE ${q(t)} SET ${sets.join(", ")}`);
+    }
+    if (x.answer!.startsWith("move:")) {
+      const [toEntity, toField] = x.answer!.slice("move:".length).split(".");
+      const target = table(toEntity);
+      const fk = A.constraints.find(
+        (c) => c.kind === "fk" && c.table === target && c.references === t
+      );
+      if (!fk)
+        throw new Error(
+          `${toEntity} has no foreign key to ${entity}, so ${field} can't move there.`
+        );
+      up.push(
+        `INSERT INTO ${q(target)} (${q(toField)}, ${q(
+          fk.columns[0]
+        )}) SELECT ${q(field)}, "id" FROM ${q(t)} WHERE ${q(field)} IS NOT NULL`
+      );
+    }
+  }
+  for (const x of answered(plan, "relation")) {
+    if (x.answer !== "copy-links") continue;
+    const { entity, field: target } = subject(x.id);
+    const from = table(entity);
+    const to = table(target);
+    const fk = R.constraints.find(
+      (c) => c.kind === "fk" && c.table === from && c.references === to
+    );
+    const joinFks = A.constraints.filter(
+      (c) => c.kind === "fk" && !rTables.has(c.table)
+    );
+    const join = joinFks.find(
+      (c) =>
+        c.references === from &&
+        joinFks.some((d) => d.table === c.table && d.references === to)
+    );
+    const other =
+      join &&
+      joinFks.find((d) => d.table === join.table && d.references === to);
+    if (!fk || !join || !other)
+      throw new Error(`Can't find where ${entity}'s links to ${target} go.`);
+    up.push(
+      `INSERT INTO ${q(join.table)} (${q(join.columns[0])}, ${q(
+        other.columns[0]
+      )}) SELECT "id", ${q(fk.columns[0])} FROM ${q(from)} WHERE ${q(
+        fk.columns[0]
+      )} IS NOT NULL`
+    );
+  }
+  for (const x of answered(plan, "backfill")) {
+    const { entity, field } = subject(x.id);
+    const value = x.answer === "sql" ? `(${x.sql})` : literal(x.answer!);
+    up.push(
+      `UPDATE ${q(table(entity))} SET ${q(field)} = ${value} WHERE ${q(
+        field
+      )} IS NULL`
+    );
+  }
+  up.push(...setNotNull);
+
+  // Drop what is gone: columns, tables, enum types.
+  for (const t of R.tables) {
+    const now = aTables.get(t.name);
+    if (!now) continue;
+    for (const c of t.columns)
+      if (!now.columns.some((x) => x.name === c.name))
+        up.push(`ALTER TABLE ${q(t.name)} DROP COLUMN ${q(c.name)}`);
+  }
+  for (const t of R.tables)
+    if (!aTables.has(t.name)) up.push(`DROP TABLE ${q(t.name)}`);
+  up.push(...later);
+  for (const e of R.enums)
+    if (!A.enums.some((x) => x.name === e.name))
+      up.push(`DROP TYPE "public".${q(e.name)}`);
+
+  // New keys and indexes, foreign keys last.
+  const add = (c: ModelConstraint) =>
+    changed(c, rCons.get(c.key)) && !createdInline.has(c.key);
+  for (const c of A.constraints)
+    if (c.kind !== "fk" && add(c)) up.push(addConstraintSql(c));
+  for (const i of A.indexes)
+    if (changed(i, rIdx.get(i.key))) up.push(createIndexSql(i));
+  for (const c of A.constraints)
+    if (c.kind === "fk" && add(c)) up.push(addConstraintSql(c));
+
+  return { up };
+}
+
+export type DownDdl = { down: string[] } | { irreversible: string[] };
+
+/**
+ * The reverse migration: the plan from the new schema back to the deployed
+ * one, answered from the forward answers. Renames invert, added fields drop,
+ * removed enum values map back, a split rejoins, and data that moved (to a
+ * new table, or into many-to-many links) is copied back. Anything left
+ * unanswered is reported instead of guessed.
+ */
+export function downDdl(
+  before: ApsorcType,
+  after: ApsorcType,
+  plan: Plan
+): DownDdl {
+  const fwd = new Map(
+    plan.questions.filter((x) => x.answer).map((x) => [x.id, x])
+  );
+  const entityRenamedFrom = new Map(
+    answered(plan, "removedEntity")
+      .filter((x) => x.answer!.startsWith("rename:"))
+      .map((x) => [x.answer!.slice("rename:".length), subject(x.id).entity])
+  );
+  const forwardEntity = (name: string) =>
+    [...entityRenamedFrom].find(([, old]) => old === name)?.[0] ?? name;
+  const nowTable = (entity: string) =>
+    tableName(after.entities.find((e) => e.name === entity)!);
+  const A = schemaModel(parseApsorcV2(after));
+  const B = schemaModel(parseApsorcV2(before));
+
+  const answer = (x: Question): Partial<Question> | undefined => {
+    const { entity, field, value } = subject(x.id);
+    if (x.kind === "removedEntity") {
+      const old = entityRenamedFrom.get(entity);
+      return { answer: old ? `rename:${old}` : "drop" };
+    }
+    if (x.kind === "removedField") {
+      const renamedFrom = [...fwd.values()].find(
+        (f) =>
+          f.kind === "removedField" &&
+          f.answer === `rename:${field}` &&
+          forwardEntity(subject(f.id).entity) === entity
+      );
+      return {
+        answer: renamedFrom
+          ? `rename:${subject(renamedFrom.id).field}`
+          : "drop",
+      };
+    }
+    if (x.kind === "enumValue") {
+      const from = [...fwd.values()].find(
+        (f) =>
+          f.kind === "enumValue" &&
+          f.answer === value &&
+          subject(f.id).field === field
+      );
+      return from && { answer: subject(from.id).value };
+    }
+    if (x.kind === "cast") return { answer: "cast" };
+    if (x.kind === "relation") return { answer: "drop-links" };
+    if (x.kind === "backfill") {
+      const split = fwd.get(`field:${forwardEntity(entity)}.${field}`);
+      if (split?.answer?.startsWith("split:")) {
+        const parts = split.answer
+          .slice("split:".length)
+          .split(",")
+          .map((p) => q(p));
+        return { answer: "sql", sql: `concat_ws(' ', ${parts.join(", ")})` };
+      }
+    }
+    return undefined;
+  };
+
+  let rev = planMigration(after, before);
+  for (let round = 0; round < 3; round++) {
+    for (const x of rev.questions) if (!x.answer) Object.assign(x, answer(x));
+    rev = planMigration(after, before, rev);
+  }
+
+  // Data the forward migration moved out of a column comes back from where it went.
+  const extra: Question[] = [];
+  for (const x of answered(plan, "removedField")) {
+    if (!x.answer!.startsWith("move:")) continue;
+    const { entity, field } = subject(x.id);
+    const [toEntity, toField] = x.answer!.slice("move:".length).split(".");
+    const from = nowTable(entity);
+    const to = nowTable(toEntity);
+    const fk = A.constraints.find(
+      (c) => c.kind === "fk" && c.table === to && c.references === from
+    )!;
+    extra.push({
+      id: `backfill:${entity}.${field}`,
+      kind: "backfill",
+      subject: `restore ${field} from ${toEntity}`,
+      options: ["sql"],
+      answer: "sql",
+      sql: `SELECT ${q(toField)} FROM ${q(to)} x WHERE x.${q(
+        fk.columns[0]
+      )} = ${q(from)}."id" ORDER BY x."id" LIMIT 1`,
+    });
+  }
+  for (const x of answered(plan, "relation")) {
+    if (x.answer !== "copy-links") continue;
+    const { entity, field: target } = subject(x.id);
+    const from = nowTable(entity);
+    const to = nowTable(target);
+    const fk = B.constraints.find(
+      (c) => c.kind === "fk" && c.table === from && c.references === to
+    )!;
+    const joinFks = A.constraints.filter(
+      (c) => c.kind === "fk" && !B.tables.some((t) => t.name === c.table)
+    );
+    const own = joinFks.find(
+      (c) =>
+        c.references === from &&
+        joinFks.some((d) => d.table === c.table && d.references === to)
+    )!;
+    const other = joinFks.find(
+      (d) => d.table === own.table && d.references === to
+    )!;
+    extra.push({
+      id: `backfill:${entity}.${fk.columns[0]}`,
+      kind: "backfill",
+      subject: `restore ${fk.columns[0]} from ${own.table}`,
+      options: ["sql"],
+      answer: "sql",
+      sql: `SELECT j.${q(other.columns[0])} FROM ${q(own.table)} j WHERE j.${q(
+        own.columns[0]
+      )} = ${q(from)}."id" LIMIT 1`,
+    });
+  }
+
+  const open = openQuestions(rev);
+  if (open.length > 0)
+    return { irreversible: open.map((x) => `${x.id}: ${x.subject}`) };
+  return {
+    down: changeDdl(after, before, {
+      ...rev,
+      questions: [...rev.questions, ...extra],
+    }).up,
+  };
+}
diff --git a/src/lib/ddl/index.ts b/src/lib/ddl/index.ts
new file mode 100644
index 0000000..64996b2
--- /dev/null
+++ b/src/lib/ddl/index.ts
@@ -0,0 +1,456 @@
+/**
+ * Apso's own DDL writer: the CREATE statements for a whole .apsorc schema.
+ *
+ * Column rules mirror the TypeScript entity templates (templates/entities),
+ * and names follow TypeORM's DefaultNamingStrategy (a prefix plus a sha1 of
+ * "table_columns"). A database built from this SQL therefore matches the one
+ * TypeORM builds for the generated entities, and services already deployed
+ * see no drift. test/lib/ddl/project-parity.test.ts checks that against a
+ * real scaffolded service.
+ */
+import { createHash } from "crypto";
+import { Entity } from "../types/entity";
+import { ComputedField } from "../types/field";
+import { RelationshipMap } from "../types/relationship";
+import { getFieldForTemplate } from "../utils/field";
+import { snakeCase } from "../utils/casing";
+import { getRelationshipForTemplate } from "../utils/relationships";
+
+// TypeORM's own casing, used for join table and join column names.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const typeormCase = require("typeorm/util/StringUtils");
+
+const sha1 = (s: string) => createHash("sha1").update(s).digest("hex");
+const key = (table: string, columns: string[]) =>
+  `${table.replace(".", "_")}_${[...columns].sort().join("_")}`;
+
+export const constraintName = {
+  primaryKey: (t: string, cols: string[]) =>
+    "PK_" + sha1(key(t, cols)).slice(0, 27),
+  unique: (t: string, cols: string[]) =>
+    "UQ_" + sha1(key(t, cols)).slice(0, 27),
+  relation: (t: string, cols: string[]) =>
+    "REL_" + sha1(key(t, cols)).slice(0, 26),
+  foreignKey: (t: string, cols: string[]) =>
+    "FK_" + sha1(key(t, cols)).slice(0, 27),
+  index: (t: string, cols: string[]) =>
+    "IDX_" + sha1(key(t, cols)).slice(0, 26),
+};
+
+export const q = (name: string) => `"${name.replace(/"/g, '""')}"`;
+export const literal = (v: string) => `'${v.replace(/'/g, "''")}'`;
+
+export const tableName = (e: Entity) => e.table || snakeCase(e.name);
+export const enumTypeName = (table: string, column: string) =>
+  `${table}_${column}_enum`;
+
+export interface ColumnSpec {
+  /** Column SQL without constraints: name, type, NOT NULL, DEFAULT. */
+  sql: string;
+  type: string;
+  notNull: boolean;
+  default?: string;
+  unique: boolean;
+  index: boolean;
+}
+
+const hasDefault = (f: ComputedField) =>
+  f.default !== null && f.default !== undefined;
+// TypeORM quotes every default it is given except booleans.
+const quoted = (f: ComputedField) =>
+  hasDefault(f) ? literal(String(f.default)) : undefined;
+
+/** One column as its entity template declares it. */
+export function columnSpec(table: string, f: ComputedField): ColumnSpec {
+  const textLike = (type: string): [string, string | undefined, boolean] => [
+    type,
+    quoted(f),
+    Boolean(f.unique),
+  ];
+  const { length: size } = f;
+  let type: string;
+  let def: string | undefined;
+  let unique = false;
+  switch (f.type as string) {
+    case "text":
+    case "string":
+      [type, def, unique] = textLike("text");
+      break;
+    case "varchar":
+      [type, def, unique] = textLike(`character varying(${size || 255})`);
+      break;
+    case "char":
+      [type, def, unique] = textLike(`character(${size || 1})`);
+      break;
+    case "enum":
+      type = `"public".${q(enumTypeName(table, f.name))}`;
+      def = quoted(f);
+      break;
+    case "integer":
+    case "bigint":
+    case "smallint":
+      type = f.type;
+      def = quoted(f);
+      break;
+    case "decimal":
+    case "numeric":
+      type = `numeric(${f.precision || 10},${f.scale || 2})`;
+      def = quoted(f);
+      break;
+    case "float":
+      type = "numeric";
+      def = quoted(f);
+      break;
+    case "double":
+      type = "double precision";
+      def = quoted(f);
+      break;
+    case "boolean":
+      type = "boolean";
+      def = String(String(f.default).toLowerCase() === "true");
+      break;
+    case "uuid":
+      type = "uuid";
+      def = hasDefault(f) ? String(f.default) : undefined;
+      break;
+    case "date":
+      type = "date";
+      break;
+    case "timestamp":
+      type = "TIMESTAMP";
+      break;
+    case "timestamptz":
+      type = "TIMESTAMP WITH TIME ZONE";
+      break;
+    case "json":
+    case "jsonb":
+      type = "jsonb";
+      break;
+    case "json-plain":
+      type = "json";
+      break;
+    default:
+      // ponytail: spatial, range and other special templates; add each with a parity case.
+      throw new Error(
+        `The DDL writer does not support field type "${f.type}" yet (${table}.${f.name}).`
+      );
+  }
+  let sql = `${q(f.name)} ${type}`;
+  if (!f.nullable) sql += " NOT NULL";
+  if (def !== undefined) sql += ` DEFAULT ${def}`;
+  return {
+    sql,
+    type,
+    notNull: !f.nullable,
+    default: def,
+    unique,
+    index: Boolean(f.index),
+  };
+}
+
+export interface SchemaInput {
+  entities: Entity[];
+  relationshipMap: RelationshipMap;
+}
+
+export interface ModelColumn {
+  name: string;
+  /** The column as CREATE TABLE writes it. */
+  sql: string;
+  type: string;
+  notNull: boolean;
+  default?: string;
+  /** A SERIAL id, whose default is the table's id sequence. */
+  serial?: boolean;
+}
+
+export interface ModelTable {
+  name: string;
+  columns: ModelColumn[];
+}
+
+export interface ModelConstraint {
+  /** Identity independent of the name: kind, table, columns (and target). */
+  key: string;
+  name: string;
+  table: string;
+  kind: "pk" | "unique" | "fk";
+  columns: string[];
+  /** Everything after CONSTRAINT "name". */
+  body: string;
+  references?: string;
+}
+
+export interface ModelIndex {
+  key: string;
+  name: string;
+  table: string;
+  columns: string[];
+  unique: boolean;
+}
+
+export interface ModelEnum {
+  name: string;
+  values: string[];
+}
+
+/** Every object a schema creates, in creation order. */
+export interface Model {
+  extensions: string[];
+  enums: ModelEnum[];
+  tables: ModelTable[];
+  constraints: ModelConstraint[];
+  indexes: ModelIndex[];
+}
+
+const cols = (c: string[]) => c.map((x) => q(x)).join(", ");
+const column = (
+  name: string,
+  type: string,
+  notNull: boolean,
+  def?: string,
+  serial?: boolean
+): ModelColumn => ({
+  name,
+  sql: `${q(name)} ${serial ? "SERIAL" : type}${notNull ? " NOT NULL" : ""}${
+    def && !serial ? ` DEFAULT ${def}` : ""
+  }`,
+  type,
+  notNull,
+  default: def,
+  serial,
+});
+
+const pkColumn = (e: Entity) =>
+  (e.fields ?? []).find((f) => f.primary)?.name ?? "id";
+const fkType = (target?: Entity) =>
+  target?.primaryKeyType === "uuid" ? "uuid" : "integer";
+
+export function schemaModel(input: SchemaInput): Model {
+  const { entities, relationshipMap } = input;
+  const byName = new Map(entities.map((e) => [e.name, e]));
+  const model: Model = {
+    extensions: [],
+    enums: [],
+    tables: [],
+    constraints: [],
+    indexes: [],
+  };
+  const entityTables: ModelTable[] = [];
+  const joinTables: ModelTable[] = [];
+  const inline: ModelConstraint[] = [];
+  const foreignKeys: ModelConstraint[] = [];
+
+  const index = (table: string, columns: string[], unique = false) =>
+    model.indexes.push({
+      key: `index:${table}(${columns.join(",")})`,
+      name: constraintName.index(table, columns),
+      table,
+      columns,
+      unique,
+    });
+  const unique = (
+    table: string,
+    columns: string[],
+    name: string,
+    list = inline
+  ) =>
+    list.push({
+      key: `unique:${table}(${columns.join(",")})`,
+      name,
+      table,
+      kind: "unique",
+      columns,
+      body: `UNIQUE (${cols(columns)})`,
+    });
+  const primaryKey = (table: string, columns: string[], list = inline) =>
+    list.push({
+      key: `pk:${table}`,
+      name: constraintName.primaryKey(table, columns),
+      table,
+      kind: "pk",
+      columns,
+      body: `PRIMARY KEY (${cols(columns)})`,
+    });
+  const foreignKey = (
+    table: string,
+    col: string,
+    target: string,
+    targetCol: string,
+    actions: string
+  ) =>
+    foreignKeys.push({
+      key: `fk:${table}(${col})->${target}`,
+      name: constraintName.foreignKey(table, [col]),
+      table,
+      kind: "fk",
+      columns: [col],
+      references: target,
+      body: `FOREIGN KEY (${q(col)}) REFERENCES ${q(target)}(${q(
+        targetCol
+      )}) ${actions}`,
+    });
+
+  for (const e of entities) {
+    const table = tableName(e);
+    const t: ModelTable = { name: table, columns: [] };
+    const customPk = (e.fields ?? []).some((f) => f.primary);
+
+    if (!customPk) {
+      const pkType: string = e.primaryKeyType || "serial";
+      if (pkType === "uuid") {
+        model.extensions.push(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
+        t.columns.push(column("id", "uuid", true, "uuid_generate_v4()"));
+      } else if (pkType === "text") t.columns.push(column("id", "text", true));
+      else
+        t.columns.push(
+          column(
+            "id",
+            "integer",
+            true,
+            `nextval('${table}_id_seq'::regclass)`,
+            true
+          )
+        );
+    }
+    if (e.created_at)
+      t.columns.push(column("created_at", "TIMESTAMP", true, "now()"));
+    if (e.updated_at)
+      t.columns.push(column("updated_at", "TIMESTAMP", true, "now()"));
+
+    for (const f of getFieldForTemplate(e.fields ?? [], e.name)) {
+      if (!customPk && f.name === "id") continue;
+      if (e.created_at && f.name === "created_at") continue;
+      if (e.updated_at && f.name === "updated_at") continue;
+      if (f.type === "enum" && f.values)
+        model.enums.push({
+          name: enumTypeName(table, f.name),
+          values: [...f.values],
+        });
+      const spec = columnSpec(table, f);
+      t.columns.push(column(f.name, spec.type, spec.notNull, spec.default));
+      if (spec.unique)
+        unique(table, [f.name], constraintName.unique(table, [f.name]));
+      if (spec.index) index(table, [f.name]);
+    }
+
+    for (const i of e.indexes ?? []) index(table, i.fields, i.unique);
+    for (const u of e.uniques ?? [])
+      unique(table, u.fields, u.name || constraintName.unique(table, u.fields));
+
+    for (const r of getRelationshipForTemplate(
+      e.name,
+      relationshipMap[e.name] || [],
+      entities
+    )) {
+      const target = byName.get(r.name);
+      if (!target) continue;
+      const targetTable = tableName(target);
+      // The template gives OneToOne onDelete CASCADE and a nullable join column.
+      const oneToOne = r.type === "OneToOne";
+      const onDelete = r.cascadeDelete || oneToOne ? "CASCADE" : "NO ACTION";
+
+      if (r.type === "ManyToOne" || (oneToOne && r.joinTable)) {
+        const col =
+          r.type === "ManyToOne"
+            ? r.camelCasedId
+            : typeormCase.camelCase(`${r.relationshipName}_id`);
+        t.columns.push(column(col, fkType(target), !(r.nullable || oneToOne)));
+        if (oneToOne)
+          unique(table, [col], constraintName.relation(table, [col]));
+        if (r.type === "ManyToOne" && r.index) index(table, [col]);
+        foreignKey(
+          table,
+          col,
+          targetTable,
+          pkColumn(target),
+          `ON DELETE ${onDelete} ON UPDATE NO ACTION`
+        );
+      }
+
+      if (r.type === "ManyToMany" && r.joinTable) {
+        const join =
+          r.joinTableName ||
+          typeormCase.snakeCase(
+            `${table}_${r.pluralizedRelationshipName}_${targetTable}`
+          );
+        const ownCol =
+          r.joinColumnName || typeormCase.camelCase(`${table}_${pkColumn(e)}`);
+        const otherCol =
+          r.inverseJoinColumnName ||
+          typeormCase.camelCase(`${targetTable}_${pkColumn(target)}`);
+        joinTables.push({
+          name: join,
+          columns: [
+            column(ownCol, fkType(e), true),
+            column(otherCol, fkType(target), true),
+          ],
+        });
+        primaryKey(join, [ownCol, otherCol]);
+        index(join, [ownCol]);
+        index(join, [otherCol]);
+        // TypeORM cascades the inverse key only when no inverse relation exists.
+        const inverse = r.biDirectional ? "NO ACTION" : "CASCADE";
+        foreignKey(
+          join,
+          ownCol,
+          table,
+          pkColumn(e),
+          "ON DELETE CASCADE ON UPDATE CASCADE"
+        );
+        foreignKey(
+          join,
+          otherCol,
+          targetTable,
+          pkColumn(target),
+          `ON DELETE ${inverse} ON UPDATE ${inverse}`
+        );
+      }
+    }
+
+    primaryKey(
+      table,
+      customPk
+        ? (e.fields ?? []).filter((f) => f.primary).map((f) => f.name)
+        : ["id"]
+    );
+    entityTables.unshift(t);
+  }
+
+  model.extensions = [...new Set(model.extensions)];
+  model.tables = [...entityTables, ...joinTables];
+  model.constraints = [...inline, ...foreignKeys];
+  return model;
+}
+
+export const createTypeSql = (e: ModelEnum) =>
+  `CREATE TYPE "public".${q(e.name)} AS ENUM(${e.values
+    .map((v) => literal(v))
+    .join(", ")})`;
+export const createIndexSql = (i: ModelIndex) =>
+  `CREATE ${i.unique ? "UNIQUE " : ""}INDEX ${q(i.name)} ON ${q(
+    i.table
+  )} (${cols(i.columns)})`;
+export const addConstraintSql = (c: ModelConstraint) =>
+  `ALTER TABLE ${q(c.table)} ADD CONSTRAINT ${q(c.name)} ${c.body}`;
+export const createTableSql = (t: ModelTable, constraints: ModelConstraint[]) =>
+  `CREATE TABLE ${q(t.name)} (${[
+    ...t.columns.map((c) => c.sql),
+    ...constraints
+      .filter((c) => c.table === t.name && c.kind !== "fk")
+      .map((c) => `CONSTRAINT ${q(c.name)} ${c.body}`),
+  ].join(", ")})`;
+
+/** CREATE statements for every enum type, table, index and foreign key. */
+export function schemaDdl(input: SchemaInput): string[] {
+  const m = schemaModel(input);
+  return [
+    ...m.extensions,
+    ...m.enums.map((e) => createTypeSql(e)),
+    ...m.tables.map((t) => createTableSql(t, m.constraints)),
+    ...m.indexes.map((i) => createIndexSql(i)),
+    ...m.constraints
+      .filter((c) => c.kind === "fk")
+      .map((c) => addConstraintSql(c)),
+  ];
+}
diff --git a/src/lib/ddl/migration-file.ts b/src/lib/ddl/migration-file.ts
new file mode 100644
index 0000000..015fcc8
--- /dev/null
+++ b/src/lib/ddl/migration-file.ts
@@ -0,0 +1,278 @@
+/**
+ * Write a migration from an answered plan: up is Apso's change DDL, down the
+ * reverse, and the plan is saved beside the migration so the answers that
+ * produced it stay with it. The SQL is the same for every language; only the
+ * wrapper differs: a TypeORM class, an Alembic revision, or a goose SQL file.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { ApsorcType } from "../apsorc-parser";
+import { openQuestions, Plan, planMigration, Question } from "../plan";
+import { migrationExtension, migrationsDir } from "../plan/baseline";
+import { pascalCase, snakeCase } from "../utils/casing";
+import { reviewMigration, Finding } from "../verify/review";
+import { changeDdl, DownDdl, downDdl } from "./change";
+import { literal } from ".";
+
+const template = (sql: string) =>
+  "`" +
+  sql.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${") +
+  "`";
+const queries = (statements: string[]) =>
+  statements
+    .map((s) => `        await queryRunner.query(${template(s)});`)
+    .join("\n");
+
+export function typeormMigration(
+  className: string,
+  up: string[],
+  down: DownDdl
+): string {
+  const downBody =
+    "down" in down
+      ? queries(down.down)
+      : `        throw new Error(${JSON.stringify(irreversible(down))});`;
+  return `import { MigrationInterface, QueryRunner } from "typeorm";
+
+// Generated by apso migrate generate from the answered migration plan saved beside this file.
+export class ${className} implements MigrationInterface {
+    name = '${className}'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+${queries(up)}
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+${downBody}
+    }
+
+}
+`;
+}
+
+const irreversible = (down: { irreversible: string[] }) =>
+  `This migration can't be reversed automatically: ${down.irreversible.join(
+    "; "
+  )}`;
+
+/**
+ * A Python string literal for any SQL. A JSON string is one (same escapes),
+ * where """...""" breaks on SQL that ends in a quoted identifier (#148).
+ */
+export const pyString = (s: string): string => JSON.stringify(s);
+
+const executes = (statements: string[]) =>
+  statements.map((s) => `    op.execute(${pyString(s)})`).join("\n");
+
+export function alembicMigration(
+  revision: string,
+  downRevision: string | undefined,
+  up: string[],
+  down: DownDdl
+): string {
+  const downBody =
+    "down" in down
+      ? executes(down.down) || "    pass"
+      : `    raise NotImplementedError(${pyString(irreversible(down))})`;
+  return `"""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = ${pyString(revision)}
+down_revision = ${downRevision === undefined ? "None" : pyString(downRevision)}
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+${executes(up)}
+
+
+def downgrade() -> None:
+${downBody}
+`;
+}
+
+/**
+ * Statements for a goose SQL file. goose splits on lines ending in ";", so a
+ * statement with a ";" of its own is fenced with StatementBegin/End.
+ */
+export const gooseStatements = (statements: string[]): string =>
+  statements
+    .map((s) =>
+      s.includes(";")
+        ? `-- +goose StatementBegin\n${s};\n-- +goose StatementEnd`
+        : `${s};`
+    )
+    .join("\n");
+
+export function gooseMigration(up: string[], down: DownDdl): string {
+  // goose has no way to refuse a down, so the SQL refuses it instead.
+  const downBody =
+    "down" in down
+      ? gooseStatements(down.down)
+      : gooseStatements([
+          `DO $$ BEGIN RAISE EXCEPTION ${literal(
+            irreversible(down).replace(/%/g, "%%")
+          )}; END $$`,
+        ]);
+  return `-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+${gooseStatements(up)}
+
+-- +goose Down
+${downBody}
+`;
+}
+
+/** The newest Alembic revision: the one no other revision names as its down_revision. */
+export function alembicHead(dir: string): string | undefined {
+  if (!fs.existsSync(dir)) return undefined;
+  const revisions: string[] = [];
+  const downs = new Set<string>();
+  for (const f of fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith(".py"))
+    .sort()) {
+    const source = fs.readFileSync(path.join(dir, f)).toString();
+    const rev = source.match(/^revision\b[^\n=]*=\s*["']([^"']+)["']/m);
+    if (rev) revisions.push(rev[1]);
+    const down = source.match(/^down_revision\b[^\n=]*=(.*)$/m);
+    for (const d of down?.[1].matchAll(/["']([^"']+)["']/g) ?? [])
+      downs.add(d[1]);
+  }
+  return revisions.filter((r) => !downs.has(r)).pop();
+}
+
+const calls = (body: string) =>
+  [...body.matchAll(/^\s*op\.execute\((".*")\)\s*$/gm)]
+    .map((m) => JSON.parse(m[1]) as string)
+    .join(";\n");
+
+/**
+ * The up and down SQL of an Alembic or goose migration, for running it on a
+ * database without the framework. down is undefined when it refuses to run.
+ */
+export function migrationSql(
+  file: string,
+  source: string
+): { up: string; down?: string } {
+  if (file.endsWith(".sql")) {
+    const [up, down = ""] = source
+      .split(/^-- \+goose Down\b.*$/m)
+      .map((s) => s.replace(/^[\S\s]*?^-- \+goose Up\b.*$/m, ""));
+    return { up, down: /RAISE EXCEPTION/.test(down) ? undefined : down };
+  }
+  const [upBody, downBody = ""] = source.split(/^def downgrade\b/m);
+  return {
+    up: calls(upBody),
+    down: /raise NotImplementedError/.test(downBody) ? undefined : calls(downBody),
+  };
+}
+
+export interface PlannedMigration {
+  ok: boolean;
+  needed: boolean;
+  /** Questions still open in the plan; nothing is written while any are. */
+  open?: Question[];
+  file?: string;
+  planFile?: string;
+  findings?: Finding[];
+  steps: { name: string; ok: boolean; output?: string }[];
+}
+
+export function writePlannedMigration(
+  projectDir: string,
+  before: ApsorcType,
+  name: string,
+  planPath: string,
+  now = Date.now()
+): PlannedMigration {
+  const after: ApsorcType = JSON.parse(
+    fs.readFileSync(path.join(projectDir, ".apsorc")).toString()
+  );
+  const previous: Plan | undefined = fs.existsSync(planPath)
+    ? JSON.parse(fs.readFileSync(planPath).toString())
+    : undefined;
+  const plan = planMigration(before, after, previous);
+  fs.mkdirSync(path.dirname(planPath), { recursive: true });
+  fs.writeFileSync(
+    planPath,
+    JSON.stringify({ ...plan, before }, null, 2) + "\n"
+  );
+
+  const open = openQuestions(plan);
+  if (open.length > 0)
+    return {
+      ok: false,
+      needed: true,
+      open,
+      steps: [
+        {
+          name: "plan",
+          ok: false,
+          output: `${open.length} question(s) in ${path.relative(
+            projectDir,
+            planPath
+          )} are open. Answer them with apso migrate plan --answer, then generate again.`,
+        },
+      ],
+    };
+
+  let up: string[];
+  let down: DownDdl;
+  try {
+    up = changeDdl(before, after, plan).up;
+    down = downDdl(before, after, plan);
+  } catch (error) {
+    const output = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      needed: true,
+      steps: [
+        {
+          name: "render",
+          ok: false,
+          output: `${output}\nTo use TypeORM's generator instead, rerun with --typeorm.`,
+        },
+      ],
+    };
+  }
+  if (up.length === 0)
+    return { ok: true, needed: false, steps: [{ name: "render", ok: true }] };
+
+  const className = `${pascalCase(name)}Migration${now}`;
+  const dir = migrationsDir(projectDir, after);
+  fs.mkdirSync(dir, { recursive: true });
+  // goose orders by the number before "_", and its own files use
+  // YYYYMMDDHHMMSS, so Python and Go use that too.
+  const stamp = new Date(now).toISOString().replace(/\D/g, "").slice(0, 14);
+  const base =
+    after.language === "python" || after.language === "go"
+      ? `${stamp}_${snakeCase(name)}`
+      : `${now}-${name}-migration`;
+  const file = base + migrationExtension(after);
+  const source =
+    after.language === "python"
+      ? alembicMigration(stamp, alembicHead(dir), up, down)
+      : after.language === "go"
+      ? gooseMigration(up, down)
+      : typeormMigration(className, up, down);
+  fs.writeFileSync(path.join(dir, file), source);
+  fs.writeFileSync(
+    path.join(dir, `${base}.plan.json`),
+    // The schemas let later runs find the baseline without being told.
+    JSON.stringify({ ...plan, before, after }, null, 2) + "\n"
+  );
+  // The answers now live beside the migration; the next change starts fresh.
+  fs.rmSync(planPath, { force: true });
+  const rel = (f: string) => path.relative(projectDir, path.join(dir, f));
+  return {
+    ok: true,
+    needed: true,
+    file: rel(file),
+    planFile: rel(`${base}.plan.json`),
+    // The review reads TypeORM's wrapper; the SQL is the same in all three.
+    findings: reviewMigration(typeormMigration(className, up, down)),
+    steps: [{ name: "render", ok: true }],
+  };
+}
diff --git a/src/lib/generators/go.ts b/src/lib/generators/go.ts
index 20d32f4..b2c556e 100644
--- a/src/lib/generators/go.ts
+++ b/src/lib/generators/go.ts
@@ -22,6 +22,7 @@ import {
 } from "../utils/relationships";
 import { snakeCase, camelCase, pascalCase, kebabCase } from "../utils/casing";
 import { getEventEmittingEntities } from "../events";
+import { gooseStatements } from "../ddl/migration-file";
 import pluralize from "pluralize";
 
 /**
@@ -392,8 +393,8 @@ export class GoGenerator extends BaseGenerator {
     const name = migrationName || "auto";
     const filename = `${timestamp}_${name}.sql`;
 
-    const upStatements = upSql.map((sql) => `${sql};`).join("\n");
-    const downStatements = (downSql || []).map((sql) => `${sql};`).join("\n");
+    const upStatements = gooseStatements(upSql);
+    const downStatements = gooseStatements(downSql || []);
 
     const content = `-- +goose Up
 ${upStatements}
diff --git a/src/lib/generators/python.ts b/src/lib/generators/python.ts
index 2f92a9e..192f585 100644
--- a/src/lib/generators/python.ts
+++ b/src/lib/generators/python.ts
@@ -22,6 +22,7 @@ import {
 } from "../utils/relationships";
 import { snakeCase, camelCase } from "../utils/casing";
 import { getEventEmittingEntities } from "../events";
+import { pyString } from "../ddl/migration-file";
 import pluralize from "pluralize";
 
 /**
@@ -319,10 +320,10 @@ export class PythonGenerator extends BaseGenerator {
     const filename = `${timestamp}_${name}.py`;
 
     const upStatements = upSql
-      .map((sql) => `    op.execute("""${sql}""")`)
+      .map((sql) => `    op.execute(${pyString(sql)})`)
       .join("\n");
     const downStatements = (downSql || [])
-      .map((sql) => `    op.execute("""${sql}""")`)
+      .map((sql) => `    op.execute(${pyString(sql)})`)
       .join("\n");
 
     const content = `"""${name}"""
diff --git a/src/lib/plan/baseline.ts b/src/lib/plan/baseline.ts
new file mode 100644
index 0000000..d3319b7
--- /dev/null
+++ b/src/lib/plan/baseline.ts
@@ -0,0 +1,128 @@
+/**
+ * Find the deployed schema without being told. Every migration
+ * `apso migrate generate` writes is committed with its plan, and the plan
+ * records the schema before and after it, so the newest one says what the
+ * database looks like once the migrations run. A service whose migrations
+ * predate this falls back to the .apsorc from the last commit that touched
+ * its migrations.
+ */
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { ApsorcType } from "../apsorc-parser";
+
+export interface SavedPlan {
+  before: ApsorcType;
+  after: ApsorcType;
+}
+
+export interface Baseline {
+  schema: ApsorcType;
+  /** Where the schema came from, for messages. */
+  source: string;
+}
+
+/** Where each language's migrations live, and the extension of one. */
+export const migrationsDir = (projectDir: string, apsorc?: ApsorcType) =>
+  apsorc?.language === "python"
+    ? path.join(projectDir, "alembic", "versions")
+    : apsorc?.language === "go"
+    ? path.join(projectDir, "migrations")
+    : path.join(projectDir, apsorc?.rootFolder || "src", "migrations");
+export const migrationExtension = (apsorc?: ApsorcType) =>
+  apsorc?.language === "python"
+    ? ".py"
+    : apsorc?.language === "go"
+    ? ".sql"
+    : ".ts";
+
+/** The newest migration with a saved plan, by its timestamp prefix. */
+export function latestPlannedMigration(
+  projectDir: string,
+  apsorc?: ApsorcType
+): { file: string; planFile: string; saved: SavedPlan } | undefined {
+  const dir = migrationsDir(projectDir, apsorc);
+  if (!fs.existsSync(dir)) return undefined;
+  const plans = fs
+    .readdirSync(dir)
+    .filter((f) => /^\d+[_-].+\.plan\.json$/.test(f))
+    .sort((a, b) => Number(b.split(/[_-]/)[0]) - Number(a.split(/[_-]/)[0]));
+  for (const planFile of plans) {
+    const saved = JSON.parse(
+      fs.readFileSync(path.join(dir, planFile)).toString()
+    );
+    if (!saved.before || !saved.after) continue;
+    const file = planFile.replace(/\.plan\.json$/, migrationExtension(apsorc));
+    return {
+      file: path.relative(projectDir, path.join(dir, file)),
+      planFile: path.relative(projectDir, path.join(dir, planFile)),
+      saved,
+    };
+  }
+  return undefined;
+}
+
+const git = (cwd: string, args: string[]) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+export function resolveBaseline(
+  projectDir: string,
+  apsorc: ApsorcType,
+  explicit?: string,
+  planPath?: string
+): Baseline {
+  if (explicit)
+    return {
+      schema: JSON.parse(fs.readFileSync(path.resolve(explicit)).toString()),
+      source: explicit,
+    };
+
+  // A plan in progress remembers the baseline it was started from.
+  if (planPath && fs.existsSync(planPath)) {
+    const working = JSON.parse(fs.readFileSync(planPath).toString());
+    if (working.before)
+      return {
+        schema: working.before,
+        source: path.relative(projectDir, planPath),
+      };
+  }
+
+  const latest = latestPlannedMigration(projectDir, apsorc);
+  if (latest) return { schema: latest.saved.after, source: latest.planFile };
+
+  try {
+    const dir = path.relative(projectDir, migrationsDir(projectDir, apsorc));
+    const sha = git(projectDir, ["log", "-1", "--format=%H", "--", dir]).trim();
+    if (sha) {
+      // "<sha>:./.apsorc" is relative to cwd, so symlinked paths don't matter.
+      const schema = JSON.parse(git(projectDir, ["show", `${sha}:./.apsorc`]));
+      return {
+        schema,
+        source: `.apsorc at ${sha.slice(
+          0,
+          7
+        )}, the last commit that changed ${dir}`,
+      };
+    }
+  } catch {
+    // No git, no history for the migrations, or no .apsorc in that commit.
+  }
+  throw new Error(
+    "Can't tell which schema is deployed: no migration from apso migrate generate yet, and no git history for the migrations folder. Pass the deployed .apsorc once with --baseline; later runs find it on their own."
+  );
+}
+
+/** A baseline as a file, for steps that scaffold it into a project copy. */
+export function baselineFile(baseline: Baseline): string {
+  const file = path.join(
+    fs.mkdtempSync(path.join(os.tmpdir(), "apso-baseline-")),
+    ".apsorc"
+  );
+  fs.writeFileSync(file, JSON.stringify(baseline.schema, null, 2));
+  return file;
+}
diff --git a/src/lib/plan/index.ts b/src/lib/plan/index.ts
new file mode 100644
index 0000000..799c41d
--- /dev/null
+++ b/src/lib/plan/index.ts
@@ -0,0 +1,349 @@
+/**
+ * The migration plan: compare the deployed .apsorc with the new one and list
+ * every change whose intent the schema alone can't settle (a removed field
+ * might be renamed, split, moved or dropped). Each becomes a question; the
+ * user's own agent answers it, and the answers are kept in the plan file so
+ * the same plan always renders the same migration.
+ *
+ * Question ids come from the change itself, so re-planning after another
+ * .apsorc edit keeps every answer whose question still exists.
+ */
+import { createHash } from "crypto";
+import { normalizeFieldType } from "../utils/field";
+
+interface PlanField {
+  name: string;
+  type: string;
+  values?: string[];
+  nullable?: boolean;
+  default?: string | null;
+}
+
+interface PlanEntity {
+  name: string;
+  fields?: PlanField[];
+}
+
+interface PlanRelationship {
+  from: string;
+  to: string;
+  type: string;
+}
+
+export interface PlanSchema {
+  entities: PlanEntity[];
+  relationships?: PlanRelationship[];
+}
+
+export type QuestionKind =
+  | "removedField"
+  | "removedEntity"
+  | "enumValue"
+  | "backfill"
+  | "cast"
+  | "relation";
+
+export interface Question {
+  id: string;
+  kind: QuestionKind;
+  /** What changed, in words, for the agent and the person reading the plan. */
+  subject: string;
+  /** Allowed answers. "sql" and "split:..." also need `sql`. */
+  options: string[];
+  /** Set only when exactly one reading fits; still needs an answer. */
+  suggested?: string;
+  answer?: string;
+  /** A SQL expression, or one per target field for a split. */
+  sql?: string | Record<string, string>;
+}
+
+export interface Plan {
+  version: 1;
+  from: string;
+  to: string;
+  questions: Question[];
+}
+
+export const hashSchema = (s: PlanSchema): string =>
+  "sha256:" +
+  createHash("sha256")
+    .update(
+      JSON.stringify({
+        entities: s.entities,
+        relationships: s.relationships ?? [],
+      })
+    )
+    .digest("hex");
+
+const STRING_TYPES = new Set(["text", "varchar", "char", "string"]);
+const sameType = (a: PlanField, b: PlanField) => {
+  const ta = normalizeFieldType(a.type);
+  const tb = normalizeFieldType(b.type);
+  return ta === tb || (STRING_TYPES.has(ta) && STRING_TYPES.has(tb));
+};
+
+const fieldsOf = (e?: PlanEntity) => e?.fields ?? [];
+const byName = <T extends { name: string }>(list: T[], name: string) =>
+  list.find((x) => x.name === name);
+const fieldSignature = (e: PlanEntity) =>
+  fieldsOf(e)
+    .map((f) => `${f.name}:${normalizeFieldType(f.type)}`)
+    .sort()
+    .join(",");
+const relates = (rels: PlanRelationship[], a: string, b: string) =>
+  rels.some(
+    (r) => (r.from === a && r.to === b) || (r.from === b && r.to === a)
+  );
+
+/** Every answer this question will accept is valid; anything else stays open. */
+export function isAnswered(q: Question): boolean {
+  if (!q.answer || !q.options.includes(q.answer)) return false;
+  if (q.answer === "sql")
+    return typeof q.sql === "string" && q.sql.trim() !== "";
+  if (q.answer.startsWith("split:")) {
+    const targets = q.answer.slice("split:".length).split(",");
+    const sql = q.sql;
+    return (
+      typeof sql === "object" &&
+      sql !== null &&
+      targets.every((t) => typeof sql[t] === "string" && sql[t].trim() !== "")
+    );
+  }
+  return true;
+}
+
+export const openQuestions = (plan: Plan): Question[] =>
+  plan.questions.filter((q) => !isAnswered(q));
+
+/** Added fields an answer already accounts for (a rename, split or move target). */
+function claimedTargets(questions: Question[]): Set<string> {
+  const claimed = new Set<string>();
+  for (const q of questions) {
+    if (!q.answer) continue;
+    const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+    if (q.answer.startsWith("rename:"))
+      claimed.add(`${entity}.${q.answer.slice(7)}`);
+    if (q.answer.startsWith("split:"))
+      for (const t of q.answer.slice(6).split(","))
+        claimed.add(`${entity}.${t}`);
+    if (q.answer.startsWith("move:")) claimed.add(q.answer.slice(5));
+  }
+  return claimed;
+}
+
+/** Added fields some still-open question may yet claim. */
+function pendingTargets(questions: Question[]): Set<string> {
+  const pending = new Set<string>();
+  for (const q of questions) {
+    if (q.answer || q.kind !== "removedField") continue;
+    const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+    for (const o of q.options) {
+      if (o.startsWith("rename:")) pending.add(`${entity}.${o.slice(7)}`);
+      if (o.startsWith("split:"))
+        for (const t of o.slice(6).split(",")) pending.add(`${entity}.${t}`);
+      if (o.startsWith("move:")) pending.add(o.slice(5));
+    }
+  }
+  return pending;
+}
+
+export function planMigration(
+  before: PlanSchema,
+  after: PlanSchema,
+  previous?: Plan
+): Plan {
+  const questions: Question[] = [];
+  const beforeRels = before.relationships ?? [];
+  const afterRels = after.relationships ?? [];
+  const added = after.entities.filter((e) => !byName(before.entities, e.name));
+
+  // Removed entities: rename to an added entity with the same fields, or drop.
+  for (const old of before.entities.filter(
+    (e) => !byName(after.entities, e.name)
+  )) {
+    const matches = added.filter(
+      (e) => fieldSignature(e) === fieldSignature(old)
+    );
+    questions.push({
+      id: `entity:${old.name}`,
+      kind: "removedEntity",
+      subject: `Entity ${old.name} is gone`,
+      options: [...matches.map((e) => `rename:${e.name}`), "drop"],
+      ...(matches.length === 1
+        ? { suggested: `rename:${matches[0].name}` }
+        : {}),
+    });
+  }
+
+  for (const now of after.entities) {
+    const was = byName(before.entities, now.name);
+    if (!was) continue;
+    const addedFields = fieldsOf(now).filter(
+      (f) => !byName(fieldsOf(was), f.name)
+    );
+
+    for (const old of fieldsOf(was)) {
+      const cur = byName(fieldsOf(now), old.name);
+      if (!cur) {
+        // Removed field: rename, split, move to a new related entity, or drop.
+        const same = addedFields.filter((f) => sameType(f, old));
+        const moves = added
+          .filter((e) => relates(afterRels, e.name, now.name))
+          .flatMap((e) =>
+            fieldsOf(e)
+              .filter((f) => sameType(f, old))
+              .map((f) => `move:${e.name}.${f.name}`)
+          );
+        const options = [
+          ...same.map((f) => `rename:${f.name}`),
+          ...(same.length > 1
+            ? [`split:${same.map((f) => f.name).join(",")}`]
+            : []),
+          ...moves,
+          "drop",
+        ];
+        const readings = options.length - 1;
+        questions.push({
+          id: `field:${now.name}.${old.name}`,
+          kind: "removedField",
+          subject: `Field ${now.name}.${old.name} (${old.type}) is gone`,
+          options,
+          ...(readings === 1 && same.length === 1
+            ? { suggested: options[0] }
+            : {}),
+        });
+        continue;
+      }
+      if (!sameType(cur, old)) {
+        questions.push({
+          id: `cast:${now.name}.${old.name}`,
+          kind: "cast",
+          subject: `Field ${now.name}.${old.name} changes type from ${old.type} to ${cur.type}`,
+          options: ["cast", "sql"],
+        });
+      } else if (old.values && cur.values) {
+        for (const v of old.values.filter((v) => !cur.values!.includes(v))) {
+          questions.push({
+            id: `enum:${now.name}.${old.name}:${v}`,
+            kind: "enumValue",
+            subject: `Enum value '${v}' is removed from ${now.name}.${old.name}`,
+            options: [...cur.values],
+          });
+        }
+      }
+      if (old.nullable && !cur.nullable && cur.default === undefined) {
+        questions.push({
+          id: `backfill:${now.name}.${old.name}`,
+          kind: "backfill",
+          subject: `Field ${now.name}.${old.name} becomes required; rows where it is null need a value`,
+          options: cur.values ? [...cur.values, "sql"] : ["sql"],
+        });
+      }
+    }
+  }
+
+  // Relationships between the same two entities that change kind or vanish.
+  for (const r of beforeRels.filter((r) => r.type === "ManyToOne")) {
+    if (!byName(after.entities, r.from) || !byName(after.entities, r.to))
+      continue;
+    const kept = afterRels.some(
+      (x) => x.type === "ManyToOne" && x.from === r.from && x.to === r.to
+    );
+    if (kept) continue;
+    const toMany = afterRels.some(
+      (x) =>
+        x.type === "ManyToMany" &&
+        ((x.from === r.from && x.to === r.to) ||
+          (x.from === r.to && x.to === r.from))
+    );
+    questions.push({
+      id: `relation:${r.from}.${r.to}`,
+      kind: "relation",
+      subject: toMany
+        ? `${r.from} ManyToOne ${r.to} becomes ManyToMany`
+        : `${r.from} ManyToOne ${r.to} is removed`,
+      options: toMany ? ["copy-links", "drop-links"] : ["drop-links"],
+    });
+  }
+
+  // Carry answers over from the previous plan before deciding on backfills,
+  // which depend on what the removed-field answers claimed.
+  const prev = new Map((previous?.questions ?? []).map((q) => [q.id, q]));
+  const carry = (q: Question): Question => {
+    const p = prev.get(q.id);
+    if (!p?.answer || !q.options.includes(p.answer)) return q;
+    return {
+      ...q,
+      answer: p.answer,
+      ...(p.sql === undefined ? {} : { sql: p.sql }),
+    };
+  };
+  const answeredSoFar = questions.map((q) => carry(q));
+
+  // New required fields on existing tables need a value for existing rows,
+  // unless a rename, split or move fills them, or an open question still might.
+  const claimed = claimedTargets(answeredSoFar);
+  const pending = pendingTargets(answeredSoFar);
+  for (const now of after.entities) {
+    const was = byName(before.entities, now.name);
+    if (!was) continue;
+    for (const f of fieldsOf(now)) {
+      if (
+        byName(fieldsOf(was), f.name) ||
+        f.nullable ||
+        f.default !== undefined
+      )
+        continue;
+      const key = `${now.name}.${f.name}`;
+      if (claimed.has(key) || pending.has(key)) continue;
+      answeredSoFar.push(
+        carry({
+          id: `backfill:${key}`,
+          kind: "backfill",
+          subject: `New required field ${key} needs a value for existing rows`,
+          options: f.values ? [...f.values, "sql"] : ["sql"],
+        })
+      );
+    }
+  }
+
+  return {
+    version: 1,
+    from: hashSchema(before),
+    to: hashSchema(after),
+    questions: answeredSoFar,
+  };
+}
+
+/**
+ * Plan with --answer values (<question id>=<option>) applied on top of the
+ * plan in progress. Throws a message for the user when an answer is malformed,
+ * names no question, or is not one of its options.
+ */
+export function planWithAnswers(
+  before: PlanSchema,
+  after: PlanSchema,
+  previous: Plan | undefined,
+  answers: string[]
+): Plan {
+  const given = new Map<string, string>();
+  for (const a of answers) {
+    const eq = a.indexOf("=");
+    if (eq < 1) throw new Error(`--answer must be <question id>=<option>, got "${a}"`);
+    given.set(a.slice(0, eq), a.slice(eq + 1));
+  }
+  const seed: Plan = previous ?? { version: 1, from: "", to: "", questions: [] };
+  for (const [id, answer] of given) {
+    const q = seed.questions.find((x) => x.id === id);
+    if (q) q.answer = answer;
+    else seed.questions.push({ id, kind: "removedField", subject: "", options: [], answer });
+  }
+  const plan = planMigration(before, after, seed);
+  for (const [id, answer] of given) {
+    const q = plan.questions.find((x) => x.id === id);
+    if (!q) throw new Error(`No question "${id}" in this plan.`);
+    if (!q.options.includes(answer))
+      throw new Error(`"${answer}" is not an option for ${id}. Options: ${q.options.join(", ")}`);
+  }
+  return plan;
+}
diff --git a/src/lib/plan/prompts.ts b/src/lib/plan/prompts.ts
new file mode 100644
index 0000000..f324528
--- /dev/null
+++ b/src/lib/plan/prompts.ts
@@ -0,0 +1,81 @@
+/**
+ * Words for asking a plan question in a terminal: what each option does to
+ * the data, a hint for SQL answers, and a starting rule for a two-way split.
+ */
+import { Question } from ".";
+
+const after = (o: string, prefix: string) => o.slice(prefix.length);
+
+export function optionLabel(q: Question, o: string): string {
+  let label = o;
+  switch (q.kind) {
+    case "removedField":
+      if (o.startsWith("rename:")) label = `Renamed to ${after(o, "rename:")} (keeps the data)`;
+      else if (o.startsWith("split:"))
+        label = `Split into ${after(o, "split:").split(",").join(" and ")} (you give the rule)`;
+      else if (o.startsWith("move:")) label = `Moved to ${after(o, "move:")} (copies the existing values)`;
+      else if (o === "drop") label = "Dropped (deletes its data)";
+      break;
+    case "removedEntity":
+      if (o.startsWith("rename:")) label = `Renamed to ${after(o, "rename:")} (keeps its rows)`;
+      else if (o === "drop") label = "Dropped (deletes its rows)";
+      break;
+    case "enumValue":
+      label = `Change those rows to '${o}'`;
+      break;
+    case "backfill":
+      label = o === "sql" ? "Use a SQL expression" : `Set existing rows to '${o}'`;
+      break;
+    case "cast":
+      label = o === "sql" ? "Use a SQL expression to convert" : "Convert each value as it is (fails on values that don't convert)";
+      break;
+    case "relation":
+      label = o === "copy-links" ? "Copy each existing link into the new join table" : "Start with no links (deletes them)";
+      break;
+    default:
+      break;
+  }
+  return o === q.suggested ? `${label} (suggested)` : label;
+}
+
+const fieldOf = (q: Question) => q.id.slice(q.id.indexOf(":") + 1).split(".")[1]?.split(":")[0] ?? "";
+
+export function sqlHint(q: Question): string {
+  const f = fieldOf(q);
+  return q.kind === "cast"
+    ? `SQL that converts "${f}", e.g. NULLIF("${f}", '')::integer`
+    : `SQL for "${f}" on existing rows, e.g. 'unknown' or another column`;
+}
+
+/** A two-way split on the first space: "Ada Lovelace" -> Ada / Lovelace, "Cher" -> Cher / null. */
+export function splitDefaults(q: Question, targets: string[]): Record<string, string> {
+  if (targets.length !== 2) return {};
+  const src = `"${fieldOf(q)}"`;
+  const first = `split_part(btrim(${src}), ' ', 1)`;
+  return {
+    [targets[0]]: first,
+    [targets[1]]: `NULLIF(btrim(substr(btrim(${src}), length(${first}) + 1)), '')`,
+  };
+}
+
+/**
+ * A question as an app or agent shows it: each option's words, a hint when an
+ * option needs SQL, and a starting rule for each two-way split option.
+ */
+export function describeQuestion(q: Question): Question & {
+  labels: Record<string, string>;
+  sqlHint?: string;
+  splitDefaults?: Record<string, Record<string, string>>;
+} {
+  const splits = q.options.filter((o) => o.startsWith("split:"));
+  return {
+    ...q,
+    labels: Object.fromEntries(q.options.map((o) => [o, optionLabel(q, o)])),
+    ...(q.options.includes("sql") && { sqlHint: sqlHint(q) }),
+    ...(splits.length > 0 && {
+      splitDefaults: Object.fromEntries(
+        splits.map((o) => [o, splitDefaults(q, after(o, "split:").split(","))])
+      ),
+    }),
+  };
+}
diff --git a/src/lib/verify/index.ts b/src/lib/verify/index.ts
index 7da48cd..2b9ebaf 100644
--- a/src/lib/verify/index.ts
+++ b/src/lib/verify/index.ts
@@ -1,7 +1,7 @@
 /**
  * Pre-deploy checks for a generated service: generate the migration from the
- * deployed schema, run it and check for drift (TypeScript only, on PGlite),
- * and smoke test the endpoints. The CLI and the in-browser editor (which runs
+ * deployed schema, run it and check for drift (on PGlite), and smoke test the
+ * endpoints. The CLI and the in-browser editor (which runs
  * the CLI in a WebContainer) share these steps.
  */
 
@@ -12,11 +12,16 @@ import * as net from "net";
 import * as os from "os";
 import * as path from "path";
 import pluralize from "pluralize";
+import { parseApsorcV2 } from "../apsorc-parser";
+import { schemaDdl } from "../ddl";
+import { catalogDiff, readCatalog } from "../ddl/catalog";
+import { migrationSql, typeormMigration } from "../ddl/migration-file";
 import { Entity } from "../types/entity";
 import { TargetLanguage } from "../types/generator";
 import { RelationshipMap } from "../types/relationship";
 import { kebabCase } from "../utils/casing";
 import { planCrud } from "./crud-plan";
+import { Finding, reviewMigration } from "./review";
 
 export interface Step {
   name: string;
@@ -124,26 +129,13 @@ export async function buildBaseline(
   }
 }
 
-/**
- * Why `apso migrate` can't run for this project's language, or undefined.
- * ponytail: Python (Alembic) and Go (goose) have no local scratch database to
- * build the baseline on; add when they get one like PGlite for TypeScript.
- */
-export const migrateUnsupported = (
-  language: TargetLanguage = "typescript"
-): string | undefined => {
-  if (language === "python")
-    return "apso migrate supports TypeScript services only for now. This is a Python service: use Alembic directly (alembic revision --autogenerate, alembic upgrade head, alembic check).";
-  if (language === "go")
-    return "apso migrate supports TypeScript services only for now. This is a Go service: write goose migrations in migrations/ and run them with `go run cmd/migrate/main.go up`.";
-  return undefined;
-};
-
 export interface GenerateResult {
   ok: boolean;
   needed: boolean;
   file?: string;
   steps: Step[];
+  /** Statements in the generated migration that lose data or fail on rows. */
+  findings?: Finding[];
 }
 
 /** Generate a migration from the deployed schema (baselineApsorc) to the project's entities. */
@@ -190,6 +182,9 @@ export async function generateMigration(
       needed: true,
       file: file && path.join("src", "migrations", file),
       steps,
+      findings: file
+        ? reviewMigration(fs.readFileSync(path.join(migrationsDir, file), "utf8"))
+        : undefined,
     };
   } finally {
     fs.rmSync(dataDir, { recursive: true, force: true });
@@ -212,8 +207,110 @@ ds.initialize()
 export interface CheckResult {
   ok: boolean;
   steps: Step[];
+  findings?: Finding[];
 }
 
+// Row and non-null value counts per table and column of the PGlite database
+// at PGLITE_DATA_DIR, after running the SQL file in argv[1] if given, plus each
+// column's distinct values (as text) so data moved to another table is found.
+const COUNT_ROWS = `
+const fs = require("fs");
+const { PGlite } = require("@electric-sql/pglite");
+(async () => {
+  const db = new PGlite(process.env.PGLITE_DATA_DIR);
+  if (process.argv[1]) await db.exec(fs.readFileSync(process.argv[1], "utf8"));
+  const cols = (await db.query("SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name <> 'migrations'")).rows;
+  const out = {};
+  for (const { table_name: t, column_name: c } of cols) {
+    const q = '"' + c + '"';
+    const r = (await db.query("SELECT count(*)::int AS rows, count(" + q + ")::int AS vals, (SELECT array_agg(v) FROM (SELECT DISTINCT " + q + "::text AS v FROM \\"" + t + "\\" WHERE " + q + " IS NOT NULL LIMIT 1000) d) AS dv FROM \\"" + t + "\\"")).rows[0];
+    out[t] = out[t] || { rows: r.rows, values: {}, distinct: {} };
+    out[t].values[c] = r.vals;
+    out[t].distinct[c] = r.dv || [];
+  }
+  console.log(JSON.stringify(out));
+  await db.close();
+})().catch((e) => { console.error(e.message); process.exit(1); });
+`;
+
+// Assertions the user wrote for this migration: each SELECT returns rows with a
+// boolean "ok" and a "label", the same format as the eval checks.
+const RUN_CHECKS = `
+const fs = require("fs");
+const { PGlite } = require("@electric-sql/pglite");
+(async () => {
+  const db = new PGlite(process.env.PGLITE_DATA_DIR);
+  const failed = [];
+  for (const r of await db.exec(fs.readFileSync(process.argv[1], "utf8")))
+    for (const row of r.rows) if ("ok" in row && row.ok !== true) failed.push(row.label || JSON.stringify(row));
+  await db.close();
+  if (failed.length) { console.error("Failed checks:\\n" + failed.join("\\n")); process.exit(1); }
+})().catch((e) => { console.error(e.message); process.exit(1); });
+`;
+
+type Counts = Record<
+  string,
+  { rows: number; values: Record<string, number>; distinct?: Record<string, string[]> }
+>;
+
+// Filled in by the database on insert, so a moved row gets new ones.
+const GENERATED = new Set(["created_at", "updated_at"]);
+
+/**
+ * Rows and values present before the migration and missing after it,
+ * following the tables and columns the migration renames. A column or table
+ * whose values all turn up in another column after the migration was moved,
+ * not lost (a field moved to a new table, a foreign key moved to a join table).
+ */
+export function dataLoss(before: Counts, after: Counts, source: string): string[] {
+  const tables = new Map(
+    [...source.matchAll(/ALTER TABLE "([^"]+)" RENAME TO "([^"]+)"/g)].map((m) => [m[1], m[2]])
+  );
+  const columns = new Map(
+    [...source.matchAll(/ALTER TABLE "([^"]+)" RENAME COLUMN "([^"]+)" TO "([^"]+)"/g)].map(
+      (m) => [`${m[1]}.${m[2]}`, m[3]]
+    )
+  );
+  // Only tables the migration creates count, and not their ids: small integer
+  // values (foreign keys) would otherwise match any existing id column.
+  const afterValues = Object.entries(after)
+    .filter(([t]) => !before[t] && ![...tables.values()].includes(t))
+    .flatMap(([, a]) =>
+      Object.entries(a.distinct ?? {})
+        .filter(([c]) => c !== "id")
+        .map(([, v]) => new Set(v))
+    );
+  const moved = (t: string, c: string) => {
+    const vals = before[t].distinct?.[c] ?? [];
+    return vals.length > 0 && afterValues.some((s) => vals.every((v) => s.has(v)));
+  };
+  const lost: string[] = [];
+  for (const [t, { rows, values }] of Object.entries(before)) {
+    if (!rows) continue;
+    const t2 = tables.get(t) ?? t;
+    const now = after[t2];
+    if (!now) {
+      const gone = Object.keys(values).filter(
+        (c) => values[c] > 0 && !GENERATED.has(c) && !moved(t, c)
+      );
+      if (gone.length > 0) lost.push(`table ${t}: all ${rows} rows`);
+      continue;
+    }
+    if (now.rows < rows) lost.push(`table ${t}: ${rows - now.rows} of ${rows} rows`);
+    for (const [c, n] of Object.entries(values)) {
+      const c2 = columns.get(`${t}.${c}`) ?? columns.get(`${t2}.${c}`) ?? c;
+      const kept = now.values[c2] ?? 0;
+      if (n > kept && !(kept === 0 && moved(t, c)))
+        lost.push(`${t}.${c}: ${n - kept} of ${n} values`);
+    }
+  }
+  return lost;
+}
+
+/** Losses the user accepted by name: a table, or table.column. */
+export const unaccepted = (lost: string[], accept: string[]) =>
+  lost.filter((l) => !accept.some((a) => l.startsWith(`${a}:`) || l.startsWith(`table ${a}:`)));
+
 /**
  * Projects from the v1 template have no PGlite support in src/orm.config.ts,
  * so the checks cannot run locally. They pass as skipped rather than block a
@@ -250,9 +347,22 @@ export async function verifyMigration(
   baselineApsorc: string,
   migrationFile: string,
   cliBin: string,
-  skipBuild = false
+  {
+    skipBuild = false,
+    seedFile,
+    checkFile,
+    acceptLoss = [],
+  }: { skipBuild?: boolean; seedFile?: string; checkFile?: string; acceptLoss?: string[] } = {}
 ): Promise<CheckResult> {
+  if (/\.(py|sql)$/.test(migrationFile))
+    return verifySqlMigration(projectDir, baselineApsorc, migrationFile, cliBin, {
+      seedFile,
+      checkFile,
+      acceptLoss,
+    });
   if (!supportsPglite(projectDir)) return NO_PGLITE;
+  const source = fs.readFileSync(path.resolve(projectDir, migrationFile), "utf8");
+  const findings = reviewMigration(source);
   const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
   const steps: Step[] = [];
   const done = (s: Step) => {
@@ -261,7 +371,15 @@ export async function verifyMigration(
   };
   try {
     if (!done(await buildBaseline(projectDir, baselineApsorc, dataDir, cliBin)))
-      return { ok: false, steps };
+      return { ok: false, steps, findings };
+    const count = async (name: string, sql?: string) => {
+      const r = await run(process.execPath, ["-e", COUNT_ROWS, ...(sql ? [sql] : [])], projectDir, pgliteEnv(dataDir));
+      done(step(name, r));
+      return r.ok ? (JSON.parse(r.output.trim().split("\n").pop()!) as Counts) : undefined;
+    };
+    // Seed rows make the migration face the data it will meet in production.
+    const before = seedFile ? await count("seed", path.resolve(seedFile)) : undefined;
+    if (seedFile && !before) return { ok: false, steps, findings };
     const compiled = path
       .join("dist", path.relative("src", migrationFile))
       .replace(/\.ts$/, ".js");
@@ -269,7 +387,7 @@ export async function verifyMigration(
     const needsBuild =
       !skipBuild || !fs.existsSync(path.join(projectDir, compiled));
     if (needsBuild && !done(step("build", await build(projectDir))))
-      return { ok: false, steps };
+      return { ok: false, steps, findings };
     const migrate = await run(
       process.execPath,
       ["-e", RUN_ONE_MIGRATION, compiled],
@@ -277,14 +395,136 @@ export async function verifyMigration(
       pgliteEnv(dataDir)
     );
     if (!done({ ...step("migrate", migrate), output: tail(migrate.output) }))
-      return { ok: false, steps };
+      return { ok: false, steps, findings };
+    if (before) {
+      const after = await count("count");
+      if (!after) return { ok: false, steps, findings };
+      const lost = dataLoss(before, after, source);
+      const ok = unaccepted(lost, acceptLoss).length === 0;
+      done({
+        name: "data",
+        ok,
+        output: lost.length > 0
+          ? `The migration lost seeded data:\n${lost.join("\n")}${ok ? "" : "\nFix the migration. If data moved somewhere the check can't follow (e.g. a field split in two), prove it with --check and rerun with --accept-loss <table.column>."}`
+          : undefined,
+      });
+      if (!ok) return { ok: false, steps, findings };
+    }
+    if (
+      checkFile &&
+      !done(step("check", await run(process.execPath, ["-e", RUN_CHECKS, path.resolve(checkFile)], projectDir, pgliteEnv(dataDir))))
+    )
+      return { ok: false, steps, findings };
 
     const drift = await typeorm(
       projectDir,
       ["migration:generate", "./src/migrations/drift", "--check"],
       pgliteEnv(dataDir)
     );
-    return { ok: done(step("drift", drift)), steps };
+    return { ok: done(step("drift", drift)), steps, findings };
+  } finally {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  }
+}
+
+const ddlOf = (apsorcFile: string) =>
+  schemaDdl(parseApsorcV2(JSON.parse(fs.readFileSync(apsorcFile).toString()))).join(";\n");
+
+/**
+ * verifyMigration for an Alembic or goose migration. Python and Go services
+ * have no TypeORM, so Apso's DDL writer builds the deployed schema, the
+ * migration's SQL runs as written, and drift is a catalog diff against a
+ * fresh build of the new .apsorc. down then runs and must give back the
+ * deployed schema.
+ */
+async function verifySqlMigration(
+  projectDir: string,
+  baselineApsorc: string,
+  migrationFile: string,
+  cliBin: string,
+  { seedFile, checkFile, acceptLoss = [] }: { seedFile?: string; checkFile?: string; acceptLoss?: string[] }
+): Promise<CheckResult> {
+  const { PGlite } = await import("@electric-sql/pglite");
+  const steps: Step[] = [];
+  const done = (s: Step) => {
+    steps.push(s);
+    return s.ok;
+  };
+  let sql: { up: string; down?: string };
+  try {
+    sql = migrationSql(migrationFile, fs.readFileSync(path.resolve(projectDir, migrationFile), "utf8"));
+  } catch (error) {
+    done({ name: "read", ok: false, output: (error as Error).message });
+    return { ok: false, steps };
+  }
+  const findings = reviewMigration(typeormMigration("Migration", [sql.up], { down: [] }));
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+  // The CLI's own PGlite: the project has no node_modules to load one from.
+  const cliRoot = path.dirname(path.dirname(cliBin));
+  const script = (name: string, code: string, arg?: string) =>
+    run(process.execPath, ["-e", code, ...(arg ? [path.resolve(arg)] : [])], cliRoot, pgliteEnv(dataDir)).then(
+      (r) => {
+        done(step(name, r));
+        return r;
+      }
+    );
+  const exec = async (name: string, statements: string) => {
+    const db = new PGlite(dataDir);
+    try {
+      await db.exec(statements);
+      return done({ name, ok: true });
+    } catch (error) {
+      return done({ name, ok: false, output: (error as Error).message });
+    } finally {
+      await db.close();
+    }
+  };
+  const drift = async (name: string, apsorcFile: string) => {
+    const db = new PGlite(dataDir);
+    const fresh = new PGlite();
+    try {
+      await fresh.exec(ddlOf(apsorcFile));
+      const diff = catalogDiff(await readCatalog(fresh), await readCatalog(db));
+      return done({
+        name,
+        ok: diff.length === 0,
+        output: diff.length > 0 ? `The database differs from ${path.basename(apsorcFile)} (- missing, + extra):\n${diff.join("\n")}` : undefined,
+      });
+    } finally {
+      await db.close();
+      await fresh.close();
+    }
+  };
+  try {
+    if (!(await exec("baseline", ddlOf(baselineApsorc)))) return { ok: false, steps, findings };
+    const count = async (name: string, file?: string) => {
+      const r = await script(name, COUNT_ROWS, file);
+      return r.ok ? (JSON.parse(r.output.trim().split("\n").pop()!) as Counts) : undefined;
+    };
+    const before = seedFile ? await count("seed", seedFile) : undefined;
+    if (seedFile && !before) return { ok: false, steps, findings };
+    if (!(await exec("migrate", sql.up))) return { ok: false, steps, findings };
+    if (before) {
+      const after = await count("count");
+      if (!after) return { ok: false, steps, findings };
+      const lost = dataLoss(before, after, sql.up);
+      const ok = unaccepted(lost, acceptLoss).length === 0;
+      done({
+        name: "data",
+        ok,
+        output: lost.length > 0
+          ? `The migration lost seeded data:\n${lost.join("\n")}${ok ? "" : "\nFix the migration. If data moved somewhere the check can't follow (e.g. a field split in two), prove it with --check and rerun with --accept-loss <table.column>."}`
+          : undefined,
+      });
+      if (!ok) return { ok: false, steps, findings };
+    }
+    const checked = checkFile ? await script("check", RUN_CHECKS, checkFile) : undefined;
+    if (checked && !checked.ok) return { ok: false, steps, findings };
+    if (!(await drift("drift", path.join(projectDir, ".apsorc")))) return { ok: false, steps, findings };
+    if (sql.down === undefined) done({ name: "down", ok: true, output: "down refuses to run (irreversible), so it was not tested." });
+    else if (!(await exec("down", sql.down)) || !(await drift("down drift", baselineApsorc)))
+      return { ok: false, steps, findings };
+    return { ok: true, steps, findings };
   } finally {
     fs.rmSync(dataDir, { recursive: true, force: true });
   }
@@ -669,5 +909,6 @@ export function report(
     log(`${s.ok ? "ok  " : "FAIL"} ${s.name}`);
     if (s.output) log(s.output.replace(/^/gm, "     "));
   }
+  for (const f of result.findings ?? []) log(`WARN ${f.code}: ${f.message}`);
   if (summary) log(summary);
 }
diff --git a/src/lib/verify/review.ts b/src/lib/verify/review.ts
new file mode 100644
index 0000000..27c9cb2
--- /dev/null
+++ b/src/lib/verify/review.ts
@@ -0,0 +1,135 @@
+/**
+ * Review a TypeORM-generated migration for statements that lose data or fail
+ * on a populated database. TypeORM changes a column type by DROP + ADD, casts
+ * enums without remapping removed values, and adds NOT NULL columns as if the
+ * table were empty. The generated file is kept; each finding names a
+ * statement to rewrite.
+ */
+
+export interface Finding {
+  code: string;
+  table: string;
+  column?: string;
+  message: string;
+}
+
+/** The SQL of each queryRunner.query call in a method body. */
+const queries = (body: string) =>
+  [...body.matchAll(/queryRunner\.query\(\s*`([\S\s]*?)`/g)].map((m) => m[1]);
+
+const enumValues = (sql?: string) =>
+  new Set(
+    [...(sql?.match(/ENUM\(([^)]*)\)/)?.[1] ?? "").matchAll(/'([^']*)'/g)].map(
+      (v) => v[1]
+    )
+  );
+
+const typeSql = (sqls: string[], type: string) =>
+  sqls.find((s) => s.startsWith(`CREATE TYPE "public"."${type}" AS ENUM`));
+
+const list = (values: string[]) => values.map((v) => `"${v}"`).join(", ");
+
+export function reviewMigration(source: string): Finding[] {
+  const [upBody, downBody = ""] = source.split(/public\s+async\s+down\s*\(/);
+  const up = queries(upBody);
+  const down = queries(downBody);
+  const findings: Finding[] = [];
+  const add = (code: string, table: string, column: string | undefined, message: string) =>
+    findings.push({ code, table, column, message });
+
+  // Statements on tables this migration creates touch no existing rows.
+  const created = new Set(
+    up.map((q) => q.match(/^CREATE TABLE "([^"]+)"/)?.[1]).filter(Boolean)
+  );
+  const existing = (table: string) => !created.has(table);
+
+  // An UPDATE or INSERT before a statement that names the column means the
+  // migration already moves or backfills its data.
+  const handled = (i: number, col: string) =>
+    up.slice(0, i).some((q) => /^(UPDATE|INSERT)\b/.test(q) && q.includes(`"${col}"`));
+
+  const dropped = new Map<string, string[]>();
+  const added = new Map<string, string[]>();
+  for (const [i, q] of up.entries()) {
+    const d = q.match(/^ALTER TABLE "([^"]+)" DROP COLUMN "([^"]+)"/);
+    if (d && !handled(i, d[2])) dropped.set(d[1], [...(dropped.get(d[1]) ?? []), d[2]]);
+    const a = q.match(/^ALTER TABLE "([^"]+)" ADD "([^"]+)"/);
+    if (a) added.set(a[1], [...(added.get(a[1]) ?? []), a[2]]);
+  }
+  for (const [table, cols] of dropped) {
+    const adds = added.get(table) ?? [];
+    const newCols = adds.filter((a) => !cols.includes(a));
+    for (const col of cols) {
+      if (adds.includes(col))
+        add("TYPE_CHANGE_DROPS_DATA", table, col,
+          `${table}.${col}: TypeORM drops and re-adds the column to change its type, deleting every value. Replace the DROP and ADD with ALTER COLUMN "${col}" TYPE ... USING a cast that converts the existing values.`);
+      else if (newCols.length > 0)
+        add("POSSIBLE_RENAME", table, col,
+          `${table}.${col} is dropped while ${list(newCols)} is added. If that is a rename, replace the DROP and ADD with RENAME COLUMN to keep the data; otherwise every value in "${col}" is deleted.`);
+      else
+        add("DROPS_COLUMN", table, col,
+          created.size > 0
+            ? `${table}.${col} is dropped with all its values while this migration creates ${list([...created] as string[])}. If the data moves there, copy it with INSERT ... SELECT before the DROP; otherwise confirm the loss.`
+            : `${table}.${col} is dropped with all its values. Confirm the loss, or copy the data first.`);
+    }
+  }
+
+  for (const [i, q] of up.entries()) {
+    let m = q.match(/^DROP TABLE "([^"]+)"/);
+    if (m)
+      add("DROPS_TABLE", m[1], undefined,
+        `Table ${m[1]} is dropped with all its rows. Confirm the loss, or rename the table if an entity was renamed.`);
+
+    m = q.match(/^ALTER TABLE "([^"]+)" ADD "([^"]+)" [^,]*\bNOT NULL\b(.*)$/);
+    if (m && existing(m[1])) {
+      const def = m[3].match(/DEFAULT (.+)$/)?.[1].trim();
+      if (def)
+        add("DEFAULT_BACKFILLS_ROWS", m[1], m[2],
+          `${m[1]}.${m[2]} is added NOT NULL DEFAULT ${def}, so every existing row gets ${def}. Confirm that is right for existing rows, or add the column nullable, backfill it, then SET NOT NULL.`);
+      else
+        add("NOT_NULL_WITHOUT_BACKFILL", m[1], m[2],
+          `${m[1]}.${m[2]} is added NOT NULL with no default, which fails if ${m[1]} has any rows. Add it nullable, backfill it, then SET NOT NULL.`);
+    }
+
+    m = q.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)" SET NOT NULL/);
+    if (m && existing(m[1]) && !handled(i, m[2]))
+      add("SET_NOT_NULL", m[1], m[2],
+        `${m[1]}.${m[2]} becomes NOT NULL, which fails on any row where it is null. Backfill those rows first.`);
+
+    m = q.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)" TYPE (?!"public"\."[^"]+_enum")/);
+    if (m && existing(m[1]))
+      add("TYPE_CAST", m[1], m[2],
+        `${m[1]}.${m[2]} changes type in place; a value the cast cannot convert fails the migration. Check the USING clause handles every existing value.`);
+
+    m =
+      q.match(/^CREATE UNIQUE INDEX "[^"]+" ON "([^"]+)" \(([^)]+)\)/) ??
+      q.match(/^ALTER TABLE "([^"]+)" ADD CONSTRAINT "[^"]+" UNIQUE \(([^)]+)\)/);
+    if (m && existing(m[1]))
+      add("UNIQUE_ON_EXISTING_ROWS", m[1], m[2].replace(/"/g, ""),
+        `A unique constraint on ${m[1]} (${m[2].replace(/"/g, "")}) fails if existing rows hold duplicates. Check for duplicates first and decide which row wins.`);
+
+    m = q.match(/^ALTER TABLE "([^"]+)" ADD CONSTRAINT "[^"]+" FOREIGN KEY \("([^"]+)"\) REFERENCES "([^"]+)"/);
+    if (m && existing(m[1]) && created.has(m[3]))
+      add("FOREIGN_KEY_TO_NEW_TABLE", m[1], m[2],
+        `Existing ${m[1]} rows must point at ${m[3]}, which this migration creates empty, so the foreign key fails on any row with ${m[2]} set. If ${m[3]} replaces an existing entity, replace the CREATE TABLE with ALTER TABLE "<old table>" RENAME TO "${m[3]}" and ALTER SEQUENCE "<old table>_id_seq" RENAME TO "${m[3]}_id_seq"; TypeORM leaves the old table in place.`);
+  }
+
+  // TypeORM swaps an enum by renaming the old type to *_old, creating the new
+  // one and casting through text; down() recreates *_old with the old values.
+  for (const q of up) {
+    const m = q.match(/^ALTER TYPE "public"\."([^"]+)" RENAME TO "([^"]+_old)"/);
+    if (!m) continue;
+    const now = enumValues(typeSql(up, m[1]));
+    const cast = up.find((s) => s.includes(`TYPE "public"."${m[1]}" USING`));
+    // A USING clause that names a removed value maps it; the rest still fail.
+    const removed = [...enumValues(typeSql(down, m[2]))].filter(
+      (v) => !now.has(v) && !cast?.includes(`'${v}'`)
+    );
+    const col = cast?.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)"/);
+    if (removed.length > 0 && col)
+      add("ENUM_VALUES_REMOVED", col[1], col[2],
+        `${col[1]}.${col[2]} drops enum value ${removed.map((v) => `'${v}'`).join(", ")}; the cast fails on any row that still holds it. Map those rows to a remaining value in the USING clause, e.g. CASE "${col[2]}"::text WHEN '${removed[0]}' THEN '...' ELSE "${col[2]}"::text END.`);
+  }
+
+  return findings;
+}
diff --git a/test/commands/generate.test.ts b/test/commands/generate.test.ts
index f757919..5c3df13 100644
--- a/test/commands/generate.test.ts
+++ b/test/commands/generate.test.ts
@@ -73,5 +73,6 @@ describe("apso generate removes stale autogen files", () => {
     );
     expect(after).toContain(".gitkeep");
     expect(fs.readFileSync(extension, "utf8")).toBe("hand-written");
-  });
+    // Two full generates, plus Biome formatting for TypeScript: slow on CI runners.
+  }, 30_000);
 });
diff --git a/test/fixtures/ddl/coverage.apsorc b/test/fixtures/ddl/coverage.apsorc
new file mode 100644
index 0000000..6a50cde
--- /dev/null
+++ b/test/fixtures/ddl/coverage.apsorc
@@ -0,0 +1,48 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Account",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        { "name": "handle", "type": "text", "unique": true, "index": true },
+        { "name": "code", "type": "char", "length": 3, "nullable": true },
+        { "name": "active", "type": "boolean" },
+        { "name": "verified", "type": "boolean", "default": "false" },
+        { "name": "visits", "type": "bigint", "default": "0" },
+        { "name": "balance", "type": "decimal", "precision": 12, "scale": 4, "nullable": true },
+        { "name": "ratio", "type": "float", "nullable": true },
+        { "name": "score", "type": "double", "nullable": true },
+        { "name": "born", "type": "date", "nullable": true },
+        { "name": "seenAt", "type": "timestamptz", "nullable": true },
+        { "name": "prefs", "type": "json", "nullable": true },
+        { "name": "raw", "type": "json-plain", "nullable": true },
+        { "name": "tier", "type": "enum", "values": ["free", "pro"], "index": true }
+      ],
+      "indexes": [{ "fields": ["code", "tier"] }, { "fields": ["visits"], "unique": true }],
+      "uniques": [{ "name": "unique_account_code_born", "fields": ["code", "born"] }, { "fields": ["ratio", "score"] }]
+    },
+    {
+      "name": "Profile",
+      "table": "account_profile",
+      "fields": [{ "name": "bio", "type": "varchar", "length": 500, "nullable": true }]
+    },
+    {
+      "name": "Tag",
+      "fields": [{ "name": "label", "type": "varchar", "unique": true }]
+    },
+    {
+      "name": "Post",
+      "fields": [{ "name": "title", "type": "string" }]
+    }
+  ],
+  "relationships": [
+    { "from": "Post", "to": "Account", "type": "ManyToOne", "cascadeDelete": true, "index": true },
+    { "from": "Post", "to": "Profile", "type": "ManyToOne", "nullable": true },
+    { "from": "Post", "to": "Tag", "type": "ManyToMany" },
+    { "from": "Account", "to": "Profile", "type": "OneToOne" }
+  ]
+}
diff --git a/test/fixtures/plan/enum-replace/after.apsorc b/test/fixtures/plan/enum-replace/after.apsorc
new file mode 100644
index 0000000..e9ad81d
--- /dev/null
+++ b/test/fixtures/plan/enum-replace/after.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "closed"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/enum-replace/before.apsorc b/test/fixtures/plan/enum-replace/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/enum-replace/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/enum-replace/checks.sql b/test/fixtures/plan/enum-replace/checks.sql
new file mode 100644
index 0000000..434d97f
--- /dev/null
+++ b/test/fixtures/plan/enum-replace/checks.sql
@@ -0,0 +1,2 @@
+SELECT (SELECT count(*) FROM "contact" WHERE "status" = 'closed' AND "id" IN (2, 4)) = 2 AS ok, 'archived contacts are now closed' AS label;
+SELECT (SELECT count(*) FROM "contact" WHERE ("id", "status"::text) IN ((1, 'active'), (3, 'lead'))) = 2 AS ok, 'other statuses are unchanged' AS label;
diff --git a/test/fixtures/plan/enum-replace/seed.sql b/test/fixtures/plan/enum-replace/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/enum-replace/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/extract-entity/after.apsorc b/test/fixtures/plan/extract-entity/after.apsorc
new file mode 100644
index 0000000..50d43d9
--- /dev/null
+++ b/test/fixtures/plan/extract-entity/after.apsorc
@@ -0,0 +1,81 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    },
+    {
+      "name": "PhoneNumber",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "number",
+          "type": "varchar",
+          "length": 40
+        },
+        {
+          "name": "label",
+          "type": "enum",
+          "values": [
+            "mobile",
+            "work",
+            "home"
+          ],
+          "default": "mobile"
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    },
+    {
+      "from": "PhoneNumber",
+      "to": "Contact",
+      "type": "ManyToOne",
+      "index": true,
+      "cascadeDelete": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/extract-entity/before.apsorc b/test/fixtures/plan/extract-entity/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/extract-entity/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/extract-entity/checks.sql b/test/fixtures/plan/extract-entity/checks.sql
new file mode 100644
index 0000000..3bfe7fc
--- /dev/null
+++ b/test/fixtures/plan/extract-entity/checks.sql
@@ -0,0 +1,2 @@
+SELECT (SELECT count(*) FROM "phone_number") = 3 AS ok, 'one phone_number row per contact that had a phone' AS label;
+SELECT (SELECT count(*) FROM "phone_number" p JOIN "contact" c ON c."id" = p."contactId" WHERE (c."id", p."number") IN ((1, '555-0101'), (2, '555-0102'), (4, '555-0104'))) = 3 AS ok, 'each number belongs to its original contact' AS label;
diff --git a/test/fixtures/plan/extract-entity/seed.sql b/test/fixtures/plan/extract-entity/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/extract-entity/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/many-to-many/after.apsorc b/test/fixtures/plan/many-to-many/after.apsorc
new file mode 100644
index 0000000..b51dcb9
--- /dev/null
+++ b/test/fixtures/plan/many-to-many/after.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToMany",
+      "bi_directional": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/many-to-many/before.apsorc b/test/fixtures/plan/many-to-many/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/many-to-many/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/many-to-many/checks.sql b/test/fixtures/plan/many-to-many/checks.sql
new file mode 100644
index 0000000..c232c7e
--- /dev/null
+++ b/test/fixtures/plan/many-to-many/checks.sql
@@ -0,0 +1,2 @@
+SELECT (SELECT count(*) FROM "contact_companies_company") = 4 AS ok, 'one link per existing contact' AS label;
+SELECT (SELECT count(*) FROM "contact_companies_company" WHERE ("contactId", "companyId") IN ((1, 1), (2, 1), (3, 2), (4, 2))) = 4 AS ok, 'each contact keeps its original company' AS label;
diff --git a/test/fixtures/plan/many-to-many/seed.sql b/test/fixtures/plan/many-to-many/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/many-to-many/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/rename-entity/after.apsorc b/test/fixtures/plan/rename-entity/after.apsorc
new file mode 100644
index 0000000..2b67efd
--- /dev/null
+++ b/test/fixtures/plan/rename-entity/after.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Organization",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Organization",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/rename-entity/before.apsorc b/test/fixtures/plan/rename-entity/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/rename-entity/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/rename-entity/checks.sql b/test/fixtures/plan/rename-entity/checks.sql
new file mode 100644
index 0000000..cfe091c
--- /dev/null
+++ b/test/fixtures/plan/rename-entity/checks.sql
@@ -0,0 +1,3 @@
+SELECT (SELECT count(*) FROM "organization") = 2 AS ok, 'both companies are now organizations' AS label;
+SELECT (SELECT count(*) FROM "contact" WHERE ("id", "organizationId") IN ((1, 1), (2, 1), (3, 2), (4, 2))) = 4 AS ok, 'each contact keeps its organization' AS label;
+SELECT nextval('organization_id_seq') = 3 AS ok, 'new organizations continue the old id sequence' AS label;
diff --git a/test/fixtures/plan/rename-entity/seed.sql b/test/fixtures/plan/rename-entity/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/rename-entity/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/rename-field/after.apsorc b/test/fixtures/plan/rename-field/after.apsorc
new file mode 100644
index 0000000..2630538
--- /dev/null
+++ b/test/fixtures/plan/rename-field/after.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "mobilePhone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/rename-field/before.apsorc b/test/fixtures/plan/rename-field/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/rename-field/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/rename-field/checks.sql b/test/fixtures/plan/rename-field/checks.sql
new file mode 100644
index 0000000..bbe05ce
--- /dev/null
+++ b/test/fixtures/plan/rename-field/checks.sql
@@ -0,0 +1,2 @@
+SELECT (SELECT count(*) FROM "contact" WHERE ("id", "mobilePhone") IN ((1, '555-0101'), (2, '555-0102'), (4, '555-0104'))) = 3 AS ok, 'phone numbers moved to mobilePhone' AS label;
+SELECT (SELECT "mobilePhone" FROM "contact" WHERE "id" = 3) IS NULL AS ok, 'a missing phone stays missing' AS label;
diff --git a/test/fixtures/plan/rename-field/seed.sql b/test/fixtures/plan/rename-field/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/rename-field/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/required-field/after.apsorc b/test/fixtures/plan/required-field/after.apsorc
new file mode 100644
index 0000000..0503c59
--- /dev/null
+++ b/test/fixtures/plan/required-field/after.apsorc
@@ -0,0 +1,67 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        },
+        {
+          "name": "region",
+          "type": "enum",
+          "values": [
+            "us",
+            "eu",
+            "apac"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/required-field/before.apsorc b/test/fixtures/plan/required-field/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/required-field/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/required-field/checks.sql b/test/fixtures/plan/required-field/checks.sql
new file mode 100644
index 0000000..8bc11f1
--- /dev/null
+++ b/test/fixtures/plan/required-field/checks.sql
@@ -0,0 +1 @@
+SELECT bool_and("region" = 'us') AS ok, 'existing companies get the chosen region' AS label FROM "company";
diff --git a/test/fixtures/plan/required-field/seed.sql b/test/fixtures/plan/required-field/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/required-field/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/split-field/after.apsorc b/test/fixtures/plan/split-field/after.apsorc
new file mode 100644
index 0000000..1d472af
--- /dev/null
+++ b/test/fixtures/plan/split-field/after.apsorc
@@ -0,0 +1,63 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "firstName",
+          "type": "text"
+        },
+        {
+          "name": "lastName",
+          "type": "text",
+          "nullable": true
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/split-field/before.apsorc b/test/fixtures/plan/split-field/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/split-field/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/split-field/checks.sql b/test/fixtures/plan/split-field/checks.sql
new file mode 100644
index 0000000..529c32c
--- /dev/null
+++ b/test/fixtures/plan/split-field/checks.sql
@@ -0,0 +1,2 @@
+SELECT bool_and("firstName" <> '') AS ok, 'every contact has a first name' AS label FROM "contact";
+SELECT bool_and(btrim(concat_ws(' ', "firstName", "lastName")) = CASE "id" WHEN 1 THEN 'Ada Lovelace' WHEN 2 THEN 'Cher' WHEN 3 THEN 'Ludwig van Beethoven' WHEN 4 THEN 'Grace Hopper' END) AS ok, 'firstName and lastName together give back the original name' AS label FROM "contact";
diff --git a/test/fixtures/plan/split-field/seed.sql b/test/fixtures/plan/split-field/seed.sql
new file mode 100644
index 0000000..41028cb
--- /dev/null
+++ b/test/fixtures/plan/split-field/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Cher', '555-0102', 'archived', '7', 1),
+  (3, 'Ludwig van Beethoven', NULL, 'lead', ' 42', 2),
+  (4, '  Grace Hopper ', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/plan/type-change/after.apsorc b/test/fixtures/plan/type-change/after.apsorc
new file mode 100644
index 0000000..2fc5742
--- /dev/null
+++ b/test/fixtures/plan/type-change/after.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "integer",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/type-change/before.apsorc b/test/fixtures/plan/type-change/before.apsorc
new file mode 100644
index 0000000..0d87548
--- /dev/null
+++ b/test/fixtures/plan/type-change/before.apsorc
@@ -0,0 +1,58 @@
+{
+  "version": 2,
+  "rootFolder": "src",
+  "apiType": "Rest",
+  "entities": [
+    {
+      "name": "Company",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "name",
+          "type": "text"
+        }
+      ]
+    },
+    {
+      "name": "Contact",
+      "created_at": true,
+      "updated_at": true,
+      "fields": [
+        {
+          "name": "fullName",
+          "type": "text"
+        },
+        {
+          "name": "phone",
+          "type": "varchar",
+          "length": 40,
+          "nullable": true
+        },
+        {
+          "name": "status",
+          "type": "enum",
+          "values": [
+            "lead",
+            "active",
+            "archived"
+          ],
+          "default": "lead"
+        },
+        {
+          "name": "score",
+          "type": "text",
+          "nullable": true
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "from": "Contact",
+      "to": "Company",
+      "type": "ManyToOne",
+      "index": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/plan/type-change/checks.sql b/test/fixtures/plan/type-change/checks.sql
new file mode 100644
index 0000000..29696ba
--- /dev/null
+++ b/test/fixtures/plan/type-change/checks.sql
@@ -0,0 +1,2 @@
+SELECT (SELECT count(*) FROM "contact" WHERE ("id", "score") IN ((1, 12), (2, 7), (3, 42))) = 3 AS ok, 'numeric scores survive the cast' AS label;
+SELECT (SELECT "score" FROM "contact" WHERE "id" = 4) IS NULL AS ok, 'a score that is not a number becomes null' AS label;
diff --git a/test/fixtures/plan/type-change/seed.sql b/test/fixtures/plan/type-change/seed.sql
new file mode 100644
index 0000000..b66dbad
--- /dev/null
+++ b/test/fixtures/plan/type-change/seed.sql
@@ -0,0 +1,8 @@
+INSERT INTO "company" ("id", "name") VALUES (1, 'Acme'), (2, 'Globex');
+SELECT setval('company_id_seq', 2);
+INSERT INTO "contact" ("id", "fullName", "phone", "status", "score", "companyId") VALUES
+  (1, 'Ada Lovelace', '555-0101', 'active', '12', 1),
+  (2, 'Alan Turing', '555-0102', 'archived', '7', 1),
+  (3, 'Grace Hopper', NULL, 'lead', ' 42', 2),
+  (4, 'Edsger Dijkstra', '555-0104', 'archived', 'n/a', 2);
+SELECT setval('contact_id_seq', 4);
diff --git a/test/fixtures/typeorm-migrations/enum-replace.ts b/test/fixtures/typeorm-migrations/enum-replace.ts
new file mode 100644
index 0000000..a13558c
--- /dev/null
+++ b/test/fixtures/typeorm-migrations/enum-replace.ts
@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class SchemaUpdateMigration1793049700161 implements MigrationInterface {
+    name = 'SchemaUpdateMigration1793049700161'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TYPE "public"."contact_status_enum" RENAME TO "contact_status_enum_old"`);
+        await queryRunner.query(`CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'closed')`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" DROP DEFAULT`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" TYPE "public"."contact_status_enum" USING "status"::"text"::"public"."contact_status_enum"`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" SET DEFAULT 'lead'`);
+        await queryRunner.query(`DROP TYPE "public"."contact_status_enum_old"`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TYPE "public"."contact_status_enum_old" AS ENUM('lead', 'active', 'archived')`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" DROP DEFAULT`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" TYPE "public"."contact_status_enum_old" USING "status"::"text"::"public"."contact_status_enum_old"`);
+        await queryRunner.query(`ALTER TABLE "contact" ALTER COLUMN "status" SET DEFAULT 'lead'`);
+        await queryRunner.query(`DROP TYPE "public"."contact_status_enum"`);
+        await queryRunner.query(`ALTER TYPE "public"."contact_status_enum_old" RENAME TO "contact_status_enum"`);
+    }
+
+}
diff --git a/test/fixtures/typeorm-migrations/rename-entity.ts b/test/fixtures/typeorm-migrations/rename-entity.ts
new file mode 100644
index 0000000..55eb007
--- /dev/null
+++ b/test/fixtures/typeorm-migrations/rename-entity.ts
@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class SchemaUpdateMigration1793049700178 implements MigrationInterface {
+    name = 'SchemaUpdateMigration1793049700178'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" DROP CONSTRAINT "FK_196374b312744cf2c400c962383"`);
+        await queryRunner.query(`DROP INDEX "public"."IDX_196374b312744cf2c400c96238"`);
+        await queryRunner.query(`ALTER TABLE "contact" RENAME COLUMN "companyId" TO "organizationId"`);
+        await queryRunner.query(`CREATE TABLE "organization" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_472c1f99a32def1b0abb219cd67" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE INDEX "IDX_7719d73cd16a9f57ecc6ac24b3" ON "contact" ("organizationId") `);
+        await queryRunner.query(`ALTER TABLE "contact" ADD CONSTRAINT "FK_7719d73cd16a9f57ecc6ac24b3d" FOREIGN KEY ("organizationId") REFERENCES "organization"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" DROP CONSTRAINT "FK_7719d73cd16a9f57ecc6ac24b3d"`);
+        await queryRunner.query(`DROP INDEX "public"."IDX_7719d73cd16a9f57ecc6ac24b3"`);
+        await queryRunner.query(`DROP TABLE "organization"`);
+        await queryRunner.query(`ALTER TABLE "contact" RENAME COLUMN "organizationId" TO "companyId"`);
+        await queryRunner.query(`CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId") `);
+        await queryRunner.query(`ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+}
diff --git a/test/fixtures/typeorm-migrations/rename-field.ts b/test/fixtures/typeorm-migrations/rename-field.ts
new file mode 100644
index 0000000..65070b8
--- /dev/null
+++ b/test/fixtures/typeorm-migrations/rename-field.ts
@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class SchemaUpdateMigration1793049717243 implements MigrationInterface {
+    name = 'SchemaUpdateMigration1793049717243'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" RENAME COLUMN "phone" TO "mobilePhone"`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" RENAME COLUMN "mobilePhone" TO "phone"`);
+    }
+
+}
diff --git a/test/fixtures/typeorm-migrations/required-field.ts b/test/fixtures/typeorm-migrations/required-field.ts
new file mode 100644
index 0000000..2fe54f6
--- /dev/null
+++ b/test/fixtures/typeorm-migrations/required-field.ts
@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class SchemaUpdateMigration1793049726507 implements MigrationInterface {
+    name = 'SchemaUpdateMigration1793049726507'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TYPE "public"."company_region_enum" AS ENUM('us', 'eu', 'apac')`);
+        await queryRunner.query(`ALTER TABLE "company" ADD "region" "public"."company_region_enum" NOT NULL DEFAULT 'us'`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "company" DROP COLUMN "region"`);
+        await queryRunner.query(`DROP TYPE "public"."company_region_enum"`);
+    }
+
+}
diff --git a/test/fixtures/typeorm-migrations/type-change.ts b/test/fixtures/typeorm-migrations/type-change.ts
new file mode 100644
index 0000000..b3ed039
--- /dev/null
+++ b/test/fixtures/typeorm-migrations/type-change.ts
@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class SchemaUpdateMigration1793049700136 implements MigrationInterface {
+    name = 'SchemaUpdateMigration1793049700136'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" DROP COLUMN "score"`);
+        await queryRunner.query(`ALTER TABLE "contact" ADD "score" integer`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "contact" DROP COLUMN "score"`);
+        await queryRunner.query(`ALTER TABLE "contact" ADD "score" text`);
+    }
+
+}
diff --git a/test/lib/ddl/__snapshots__/ddl.test.ts.snap b/test/lib/ddl/__snapshots__/ddl.test.ts.snap
new file mode 100644
index 0000000..4df9725
--- /dev/null
+++ b/test/lib/ddl/__snapshots__/ddl.test.ts.snap
@@ -0,0 +1,180 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`schemaDdl coverage runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."account_tier_enum" AS ENUM('free', 'pro')",
+  "CREATE TABLE "post" ("id" SERIAL NOT NULL, "title" text NOT NULL, "accountId" integer NOT NULL, "profileId" integer, CONSTRAINT "PK_be5fda3aac270b134ff9c21cdee" PRIMARY KEY ("id"))",
+  "CREATE TABLE "tag" ("id" SERIAL NOT NULL, "label" character varying(255) NOT NULL, CONSTRAINT "UQ_647c189a51deb35bc452751bc4a" UNIQUE ("label"), CONSTRAINT "PK_8e4052373c579afc1471f526760" PRIMARY KEY ("id"))",
+  "CREATE TABLE "account_profile" ("id" SERIAL NOT NULL, "bio" character varying(500), CONSTRAINT "PK_928b8a91ee2e4bceee8c0ddf0cd" PRIMARY KEY ("id"))",
+  "CREATE TABLE "account" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "handle" text NOT NULL, "code" character(3), "active" boolean NOT NULL DEFAULT false, "verified" boolean NOT NULL DEFAULT false, "visits" bigint NOT NULL DEFAULT '0', "balance" numeric(12,4), "ratio" numeric, "score" double precision, "born" date, "seenAt" TIMESTAMP WITH TIME ZONE, "prefs" jsonb, "raw" json, "tier" "public"."account_tier_enum" NOT NULL DEFAULT 'free', "profileId" integer, CONSTRAINT "UQ_734bbcf136a53616581ed7489c1" UNIQUE ("handle"), CONSTRAINT "unique_account_code_born" UNIQUE ("code", "born"), CONSTRAINT "UQ_0faf7d6efef933e4b40996ad023" UNIQUE ("ratio", "score"), CONSTRAINT "REL_ff102ecfd2f4b5a7edf239dd02" UNIQUE ("profileId"), CONSTRAINT "PK_54115ee388cdb6d86bb4bf5b2ea" PRIMARY KEY ("id"))",
+  "CREATE TABLE "post_tags_tag" ("postId" integer NOT NULL, "tagId" integer NOT NULL, CONSTRAINT "PK_e9b7b8e6a07bdccb6a954171676" PRIMARY KEY ("postId", "tagId"))",
+  "CREATE INDEX "IDX_734bbcf136a53616581ed7489c" ON "account" ("handle")",
+  "CREATE INDEX "IDX_a924efb2a1b358e0fcf9b80931" ON "account" ("tier")",
+  "CREATE INDEX "IDX_8a4bcb70c6769e9a951b5448cc" ON "account" ("code", "tier")",
+  "CREATE UNIQUE INDEX "IDX_77f186f325459ffba1c72fd405" ON "account" ("visits")",
+  "CREATE INDEX "IDX_f219a87fd8c020d3bb6527c942" ON "post" ("accountId")",
+  "CREATE INDEX "IDX_b651178cc41334544a7a9601c4" ON "post_tags_tag" ("postId")",
+  "CREATE INDEX "IDX_41e7626b9cc03c5c65812ae55e" ON "post_tags_tag" ("tagId")",
+  "ALTER TABLE "account" ADD CONSTRAINT "FK_ff102ecfd2f4b5a7edf239dd025" FOREIGN KEY ("profileId") REFERENCES "account_profile"("id") ON DELETE CASCADE ON UPDATE NO ACTION",
+  "ALTER TABLE "post" ADD CONSTRAINT "FK_f219a87fd8c020d3bb6527c9420" FOREIGN KEY ("accountId") REFERENCES "account"("id") ON DELETE CASCADE ON UPDATE NO ACTION",
+  "ALTER TABLE "post" ADD CONSTRAINT "FK_970844fcd10c2b6df7c1b49eacf" FOREIGN KEY ("profileId") REFERENCES "account_profile"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "post_tags_tag" ADD CONSTRAINT "FK_b651178cc41334544a7a9601c45" FOREIGN KEY ("postId") REFERENCES "post"("id") ON DELETE CASCADE ON UPDATE CASCADE",
+  "ALTER TABLE "post_tags_tag" ADD CONSTRAINT "FK_41e7626b9cc03c5c65812ae55e8" FOREIGN KEY ("tagId") REFERENCES "tag"("id") ON DELETE CASCADE ON UPDATE CASCADE",
+]
+`;
+
+exports[`schemaDdl enum-replace runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'closed')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl extract-entity runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TYPE "public"."phone_number_label_enum" AS ENUM('mobile', 'work', 'home')",
+  "CREATE TABLE "phone_number" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "number" character varying(40) NOT NULL, "label" "public"."phone_number_label_enum" NOT NULL DEFAULT 'mobile', "contactId" integer NOT NULL, CONSTRAINT "PK_c16f58426537a660b3f2a26e983" PRIMARY KEY ("id"))",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "CREATE INDEX "IDX_069067410ee19d423487a189e4" ON "phone_number" ("contactId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "phone_number" ADD CONSTRAINT "FK_069067410ee19d423487a189e4d" FOREIGN KEY ("contactId") REFERENCES "contact"("id") ON DELETE CASCADE ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl inventory-multi-fk runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."purchase_order_status_enum" AS ENUM('draft', 'sent', 'partial', 'received', 'cancelled')",
+  "CREATE TYPE "public"."stock_movement_movement_type_enum" AS ENUM('received', 'sold', 'transferred', 'adjusted', 'damaged')",
+  "CREATE TYPE "public"."stock_movement_reference_document_type_enum" AS ENUM('purchase_order', 'stock_transfer', 'inventory_count', 'manual')",
+  "CREATE TYPE "public"."stock_transfer_status_enum" AS ENUM('pending', 'in_transit', 'received', 'cancelled')",
+  "CREATE TYPE "public"."inventory_count_count_status_enum" AS ENUM('pending', 'in_progress', 'completed', 'approved')",
+  "CREATE TYPE "public"."alert_alert_type_enum" AS ENUM('low_stock', 'reorder_trigger', 'overstock', 'expiration')",
+  "CREATE TYPE "public"."alert_severity_enum" AS ENUM('info', 'warning', 'critical')",
+  "CREATE TABLE "alert" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "alert_type" "public"."alert_alert_type_enum" NOT NULL DEFAULT 'low_stock', "severity" "public"."alert_severity_enum" NOT NULL DEFAULT 'info', "triggered_date" TIMESTAMP WITH TIME ZONE NOT NULL, "resolved_date" TIMESTAMP WITH TIME ZONE, "is_resolved" boolean NOT NULL DEFAULT false, "message" text NOT NULL, "productId" integer NOT NULL, "warehouseId" integer NOT NULL, CONSTRAINT "PK_ad91cad659a3536465d564a4b2f" PRIMARY KEY ("id"))",
+  "CREATE TABLE "inventory_count" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "count_date" TIMESTAMP WITH TIME ZONE NOT NULL, "count_status" "public"."inventory_count_count_status_enum" NOT NULL DEFAULT 'pending', "discrepancy_count" integer NOT NULL DEFAULT '0', "adjustment_approved" boolean NOT NULL DEFAULT false, "approval_date" TIMESTAMP WITH TIME ZONE, "approved_by" character varying(255), "warehouseId" integer NOT NULL, CONSTRAINT "PK_2706c2f462af54d29b7f3f950b0" PRIMARY KEY ("id"))",
+  "CREATE TABLE "stock_transfer" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "transfer_number" character varying(255) NOT NULL, "transfer_date" TIMESTAMP WITH TIME ZONE NOT NULL, "expected_arrival_date" TIMESTAMP WITH TIME ZONE NOT NULL, "status" "public"."stock_transfer_status_enum" NOT NULL DEFAULT 'pending', "shipping_method" character varying(255) NOT NULL, "tracking_number" character varying(255), "notes" text, "warehouseId" integer NOT NULL, "productId" integer NOT NULL, CONSTRAINT "unique_stock_transfer_number" UNIQUE ("transfer_number"), CONSTRAINT "PK_b6165ea3cc5b8062e7eaa1bd44d" PRIMARY KEY ("id"))",
+  "CREATE TABLE "stock_movement" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "movement_type" "public"."stock_movement_movement_type_enum" NOT NULL DEFAULT 'received', "quantity" integer NOT NULL, "movement_date" TIMESTAMP WITH TIME ZONE NOT NULL, "reference_document_id" character varying(255), "reference_document_type" "public"."stock_movement_reference_document_type_enum" NOT NULL DEFAULT 'purchase_order', "notes" text, "productId" integer NOT NULL, "warehouseId" integer NOT NULL, "purchaseOrderId" integer NOT NULL, "stockTransferId" integer NOT NULL, "inventoryCountId" integer NOT NULL, CONSTRAINT "PK_9fe1232f916686ae8cf00294749" PRIMARY KEY ("id"))",
+  "CREATE TABLE "purchase_order" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "order_number" character varying(255) NOT NULL, "order_date" TIMESTAMP WITH TIME ZONE NOT NULL, "expected_delivery_date" TIMESTAMP WITH TIME ZONE NOT NULL, "status" "public"."purchase_order_status_enum" NOT NULL DEFAULT 'draft', "total_amount" numeric(10,2) NOT NULL, "notes" text, "supplierId" integer NOT NULL, CONSTRAINT "unique_purchase_order_number" UNIQUE ("order_number"), CONSTRAINT "PK_ad3e1c7b862f4043b103a6c8c60" PRIMARY KEY ("id"))",
+  "CREATE TABLE "inventory_level" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "quantity_on_hand" integer NOT NULL DEFAULT '0', "quantity_reserved" integer NOT NULL DEFAULT '0', "quantity_available" integer NOT NULL DEFAULT '0', "last_counted_date" TIMESTAMP WITH TIME ZONE, "recount_required" boolean NOT NULL DEFAULT false, "productId" integer NOT NULL, "warehouseId" integer NOT NULL, CONSTRAINT "PK_e9d89cce26e51fd2e52104308cf" PRIMARY KEY ("id"))",
+  "CREATE TABLE "supplier" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "company_name" character varying(255) NOT NULL, "contact_person" character varying(255) NOT NULL, "email" character varying(255) NOT NULL, "phone" character varying(255), "payment_terms" character varying(255) NOT NULL, "lead_time_days" integer NOT NULL DEFAULT '0', CONSTRAINT "unique_supplier_email" UNIQUE ("email"), CONSTRAINT "PK_2bc0d2cab6276144d2ff98a2828" PRIMARY KEY ("id"))",
+  "CREATE TABLE "warehouse" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" character varying(255) NOT NULL, "address" character varying(255) NOT NULL, "city" character varying(255) NOT NULL, "state" character varying(255) NOT NULL, "postal_code" character varying(255) NOT NULL, "country" character varying(255) NOT NULL, "capacity" bigint NOT NULL, "manager_name" character varying(255), "manager_email" character varying(255), CONSTRAINT "unique_warehouse_manager_email" UNIQUE ("manager_email"), CONSTRAINT "PK_965abf9f99ae8c5983ae74ebde8" PRIMARY KEY ("id"))",
+  "CREATE TABLE "product" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" character varying(255) NOT NULL, "sku" character varying(255) NOT NULL, "barcode" character varying(255), "description" text, "category" character varying(255), "unit_of_measure" character varying(255) NOT NULL, "reorder_point" integer NOT NULL DEFAULT '0', "reorder_quantity" integer NOT NULL DEFAULT '0', CONSTRAINT "unique_product_sku" UNIQUE ("sku"), CONSTRAINT "unique_product_barcode" UNIQUE ("barcode"), CONSTRAINT "PK_bebc9158e480b949565b4dc7a82" PRIMARY KEY ("id"))",
+  "CREATE UNIQUE INDEX "IDX_34f6ca1cd897cc926bdcca1ca3" ON "product" ("sku")",
+  "CREATE UNIQUE INDEX "IDX_7ac18742b02b8af41afdaa3b9a" ON "product" ("barcode")",
+  "CREATE INDEX "IDX_d71ac3a30622a475df871b5513" ON "product" ("category")",
+  "CREATE INDEX "IDX_22cc43e9a74d7498546e9a63e7" ON "product" ("name")",
+  "CREATE INDEX "IDX_d5d5470e55d4238b1239e9f154" ON "warehouse" ("name")",
+  "CREATE INDEX "IDX_170fc4b91d85bd5529cc3d9b07" ON "warehouse" ("city")",
+  "CREATE UNIQUE INDEX "IDX_2fab7864ff7c3c8443bd60fe1a" ON "warehouse" ("manager_email")",
+  "CREATE INDEX "IDX_2919d31557c892df61c6666c5c" ON "supplier" ("company_name")",
+  "CREATE UNIQUE INDEX "IDX_c40cbff7400f06ae1c8d9f4233" ON "supplier" ("email")",
+  "CREATE INDEX "IDX_e00461bccae94468b802eb0528" ON "inventory_level" ("quantity_available")",
+  "CREATE INDEX "IDX_5830be5baf34b0316c965b0e55" ON "inventory_level" ("last_counted_date")",
+  "CREATE UNIQUE INDEX "IDX_a932de191f1a55173e4b985c6e" ON "purchase_order" ("order_number")",
+  "CREATE INDEX "IDX_9d78349144d7e60ceaba65daac" ON "purchase_order" ("order_date")",
+  "CREATE INDEX "IDX_74cdefa69dd3fa109518094424" ON "purchase_order" ("expected_delivery_date")",
+  "CREATE INDEX "IDX_c9cdb0a71bfc9c896a32e86de1" ON "purchase_order" ("status")",
+  "CREATE INDEX "IDX_6abab23462824d24a68779f877" ON "stock_movement" ("movement_type")",
+  "CREATE INDEX "IDX_36a47cba62434621b3050a11de" ON "stock_movement" ("movement_date")",
+  "CREATE INDEX "IDX_b23f39ee962952607901553663" ON "stock_movement" ("reference_document_id")",
+  "CREATE INDEX "IDX_4cdd5089d5aefc5c3c11c7cf6e" ON "stock_movement" ("reference_document_type")",
+  "CREATE INDEX "IDX_cb4500178121ca86f25db1f930" ON "stock_movement" ("movement_type", "movement_date")",
+  "CREATE UNIQUE INDEX "IDX_c3b6f1959fccaffa96e8e0e349" ON "stock_transfer" ("transfer_number")",
+  "CREATE INDEX "IDX_fc70e3e73fb5cc1a0076cface8" ON "stock_transfer" ("transfer_date")",
+  "CREATE INDEX "IDX_59a46f9dcda16a0e4839c4dd27" ON "stock_transfer" ("expected_arrival_date")",
+  "CREATE INDEX "IDX_70f17fc214ab5e82cc2eb9245a" ON "stock_transfer" ("status")",
+  "CREATE INDEX "IDX_f553e952f5b090ecec800fb298" ON "stock_transfer" ("tracking_number")",
+  "CREATE INDEX "IDX_916246e43c74e9b81a296c0730" ON "inventory_count" ("count_date")",
+  "CREATE INDEX "IDX_c10d235fd817625d237b493b23" ON "inventory_count" ("count_status")",
+  "CREATE INDEX "IDX_179793785adedfb8b6c7de63d2" ON "inventory_count" ("approval_date")",
+  "CREATE INDEX "IDX_417891fd39353a6a32697492df" ON "alert" ("alert_type")",
+  "CREATE INDEX "IDX_b52a542544bc2b02efed8a008d" ON "alert" ("severity")",
+  "CREATE INDEX "IDX_b6c2a21a2b10731dee4ac52baa" ON "alert" ("triggered_date")",
+  "CREATE INDEX "IDX_30b74940624c030a6b45df38a8" ON "alert" ("resolved_date")",
+  "CREATE INDEX "IDX_7ea45df55178498062ff1ec1e9" ON "alert" ("is_resolved")",
+  "CREATE INDEX "IDX_9c65227d50d4fb082071566328" ON "alert" ("alert_type", "severity")",
+  "ALTER TABLE "inventory_level" ADD CONSTRAINT "FK_b800cfb30def1fe9adcdd87f2d6" FOREIGN KEY ("productId") REFERENCES "product"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "inventory_level" ADD CONSTRAINT "FK_ce9364f1f524e53ee0493e760fb" FOREIGN KEY ("warehouseId") REFERENCES "warehouse"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "purchase_order" ADD CONSTRAINT "FK_e4ea5841622429c12889a487f31" FOREIGN KEY ("supplierId") REFERENCES "supplier"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_movement" ADD CONSTRAINT "FK_9e1078f3037faf8730f384bb422" FOREIGN KEY ("productId") REFERENCES "product"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_movement" ADD CONSTRAINT "FK_4118b88709dd431c6185b89953f" FOREIGN KEY ("warehouseId") REFERENCES "warehouse"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_movement" ADD CONSTRAINT "FK_4074c87e32df6379a2fab412768" FOREIGN KEY ("purchaseOrderId") REFERENCES "purchase_order"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_movement" ADD CONSTRAINT "FK_cc0121a69f371a62ec490e3def0" FOREIGN KEY ("stockTransferId") REFERENCES "stock_transfer"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_movement" ADD CONSTRAINT "FK_e4c814076de7af958d41ce3bc49" FOREIGN KEY ("inventoryCountId") REFERENCES "inventory_count"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_transfer" ADD CONSTRAINT "FK_4e7a74115f69f38af54297909f6" FOREIGN KEY ("warehouseId") REFERENCES "warehouse"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "stock_transfer" ADD CONSTRAINT "FK_5b650ac5cc3387ac9ac7ad7eb0c" FOREIGN KEY ("productId") REFERENCES "product"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "inventory_count" ADD CONSTRAINT "FK_9d9a2491e8963a389cc87249b27" FOREIGN KEY ("warehouseId") REFERENCES "warehouse"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "alert" ADD CONSTRAINT "FK_6d80a2602a8e0e9ed4871ad909d" FOREIGN KEY ("productId") REFERENCES "product"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+  "ALTER TABLE "alert" ADD CONSTRAINT "FK_0e50368f6f58c7b3c7152485124" FOREIGN KEY ("warehouseId") REFERENCES "warehouse"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl many-to-many runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE TABLE "contact_companies_company" ("contactId" integer NOT NULL, "companyId" integer NOT NULL, CONSTRAINT "PK_a240a097bb1e1d698bc213e0c72" PRIMARY KEY ("contactId", "companyId"))",
+  "CREATE INDEX "IDX_e6e2d85d35645bd6b752226c49" ON "contact_companies_company" ("contactId")",
+  "CREATE INDEX "IDX_30d0ef2a176bf879a2d36df096" ON "contact_companies_company" ("companyId")",
+  "ALTER TABLE "contact_companies_company" ADD CONSTRAINT "FK_e6e2d85d35645bd6b752226c49d" FOREIGN KEY ("contactId") REFERENCES "contact"("id") ON DELETE CASCADE ON UPDATE CASCADE",
+  "ALTER TABLE "contact_companies_company" ADD CONSTRAINT "FK_30d0ef2a176bf879a2d36df0966" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl rename-entity runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "organizationId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "organization" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_472c1f99a32def1b0abb219cd67" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_7719d73cd16a9f57ecc6ac24b3" ON "contact" ("organizationId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_7719d73cd16a9f57ecc6ac24b3d" FOREIGN KEY ("organizationId") REFERENCES "organization"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl rename-field runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "mobilePhone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl required-field runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."company_region_enum" AS ENUM('us', 'eu', 'apac')",
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, "region" "public"."company_region_enum" NOT NULL DEFAULT 'us', CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl split-field runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "firstName" text NOT NULL, "lastName" text, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" text, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
+
+exports[`schemaDdl type-change runs on Postgres and matches its snapshot 1`] = `
+[
+  "CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived')",
+  "CREATE TABLE "contact" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "fullName" text NOT NULL, "phone" character varying(40), "status" "public"."contact_status_enum" NOT NULL DEFAULT 'lead', "score" integer, "companyId" integer NOT NULL, CONSTRAINT "PK_2cbbe00f59ab6b3bb5b8d19f989" PRIMARY KEY ("id"))",
+  "CREATE TABLE "company" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "name" text NOT NULL, CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" PRIMARY KEY ("id"))",
+  "CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId")",
+  "ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION",
+]
+`;
diff --git a/test/lib/ddl/__snapshots__/wrappers.test.ts.snap b/test/lib/ddl/__snapshots__/wrappers.test.ts.snap
new file mode 100644
index 0000000..ac9fa3e
--- /dev/null
+++ b/test/lib/ddl/__snapshots__/wrappers.test.ts.snap
@@ -0,0 +1,343 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`enum-replace Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TYPE \\"public\\".\\"contact_status_enum\\" RENAME TO \\"contact_status_enum_old\\"")
+    op.execute("CREATE TYPE \\"public\\".\\"contact_status_enum\\" AS ENUM('lead', 'active', 'closed')")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" DROP DEFAULT")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" TYPE \\"public\\".\\"contact_status_enum\\" USING (CASE \\"status\\"::text WHEN 'archived' THEN 'closed' ELSE \\"status\\"::text END)::\\"public\\".\\"contact_status_enum\\"")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" SET DEFAULT 'lead'")
+    op.execute("DROP TYPE \\"public\\".\\"contact_status_enum_old\\"")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TYPE \\"public\\".\\"contact_status_enum\\" RENAME TO \\"contact_status_enum_old\\"")
+    op.execute("CREATE TYPE \\"public\\".\\"contact_status_enum\\" AS ENUM('lead', 'active', 'archived')")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" DROP DEFAULT")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" TYPE \\"public\\".\\"contact_status_enum\\" USING (CASE \\"status\\"::text WHEN 'closed' THEN 'archived' ELSE \\"status\\"::text END)::\\"public\\".\\"contact_status_enum\\"")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"status\\" SET DEFAULT 'lead'")
+    op.execute("DROP TYPE \\"public\\".\\"contact_status_enum_old\\"")
+"
+`;
+
+exports[`enum-replace goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TYPE "public"."contact_status_enum" RENAME TO "contact_status_enum_old";
+CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'closed');
+ALTER TABLE "contact" ALTER COLUMN "status" DROP DEFAULT;
+ALTER TABLE "contact" ALTER COLUMN "status" TYPE "public"."contact_status_enum" USING (CASE "status"::text WHEN 'archived' THEN 'closed' ELSE "status"::text END)::"public"."contact_status_enum";
+ALTER TABLE "contact" ALTER COLUMN "status" SET DEFAULT 'lead';
+DROP TYPE "public"."contact_status_enum_old";
+
+-- +goose Down
+ALTER TYPE "public"."contact_status_enum" RENAME TO "contact_status_enum_old";
+CREATE TYPE "public"."contact_status_enum" AS ENUM('lead', 'active', 'archived');
+ALTER TABLE "contact" ALTER COLUMN "status" DROP DEFAULT;
+ALTER TABLE "contact" ALTER COLUMN "status" TYPE "public"."contact_status_enum" USING (CASE "status"::text WHEN 'closed' THEN 'archived' ELSE "status"::text END)::"public"."contact_status_enum";
+ALTER TABLE "contact" ALTER COLUMN "status" SET DEFAULT 'lead';
+DROP TYPE "public"."contact_status_enum_old";
+"
+`;
+
+exports[`extract-entity Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("CREATE TYPE \\"public\\".\\"phone_number_label_enum\\" AS ENUM('mobile', 'work', 'home')")
+    op.execute("CREATE TABLE \\"phone_number\\" (\\"id\\" SERIAL NOT NULL, \\"created_at\\" TIMESTAMP NOT NULL DEFAULT now(), \\"updated_at\\" TIMESTAMP NOT NULL DEFAULT now(), \\"number\\" character varying(40) NOT NULL, \\"label\\" \\"public\\".\\"phone_number_label_enum\\" NOT NULL DEFAULT 'mobile', \\"contactId\\" integer NOT NULL, CONSTRAINT \\"PK_c16f58426537a660b3f2a26e983\\" PRIMARY KEY (\\"id\\"))")
+    op.execute("INSERT INTO \\"phone_number\\" (\\"number\\", \\"contactId\\") SELECT \\"phone\\", \\"id\\" FROM \\"contact\\" WHERE \\"phone\\" IS NOT NULL")
+    op.execute("ALTER TABLE \\"contact\\" DROP COLUMN \\"phone\\"")
+    op.execute("CREATE INDEX \\"IDX_069067410ee19d423487a189e4\\" ON \\"phone_number\\" (\\"contactId\\")")
+    op.execute("ALTER TABLE \\"phone_number\\" ADD CONSTRAINT \\"FK_069067410ee19d423487a189e4d\\" FOREIGN KEY (\\"contactId\\") REFERENCES \\"contact\\"(\\"id\\") ON DELETE CASCADE ON UPDATE NO ACTION")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"phone_number\\" DROP CONSTRAINT \\"FK_069067410ee19d423487a189e4d\\"")
+    op.execute("ALTER TABLE \\"contact\\" ADD \\"phone\\" character varying(40)")
+    op.execute("UPDATE \\"contact\\" SET \\"phone\\" = (SELECT \\"number\\" FROM \\"phone_number\\" x WHERE x.\\"contactId\\" = \\"contact\\".\\"id\\" ORDER BY x.\\"id\\" LIMIT 1) WHERE \\"phone\\" IS NULL")
+    op.execute("DROP TABLE \\"phone_number\\"")
+    op.execute("DROP TYPE \\"public\\".\\"phone_number_label_enum\\"")
+"
+`;
+
+exports[`extract-entity goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+CREATE TYPE "public"."phone_number_label_enum" AS ENUM('mobile', 'work', 'home');
+CREATE TABLE "phone_number" ("id" SERIAL NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "number" character varying(40) NOT NULL, "label" "public"."phone_number_label_enum" NOT NULL DEFAULT 'mobile', "contactId" integer NOT NULL, CONSTRAINT "PK_c16f58426537a660b3f2a26e983" PRIMARY KEY ("id"));
+INSERT INTO "phone_number" ("number", "contactId") SELECT "phone", "id" FROM "contact" WHERE "phone" IS NOT NULL;
+ALTER TABLE "contact" DROP COLUMN "phone";
+CREATE INDEX "IDX_069067410ee19d423487a189e4" ON "phone_number" ("contactId");
+ALTER TABLE "phone_number" ADD CONSTRAINT "FK_069067410ee19d423487a189e4d" FOREIGN KEY ("contactId") REFERENCES "contact"("id") ON DELETE CASCADE ON UPDATE NO ACTION;
+
+-- +goose Down
+ALTER TABLE "phone_number" DROP CONSTRAINT "FK_069067410ee19d423487a189e4d";
+ALTER TABLE "contact" ADD "phone" character varying(40);
+UPDATE "contact" SET "phone" = (SELECT "number" FROM "phone_number" x WHERE x."contactId" = "contact"."id" ORDER BY x."id" LIMIT 1) WHERE "phone" IS NULL;
+DROP TABLE "phone_number";
+DROP TYPE "public"."phone_number_label_enum";
+"
+`;
+
+exports[`many-to-many Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" DROP CONSTRAINT \\"FK_196374b312744cf2c400c962383\\"")
+    op.execute("DROP INDEX \\"public\\".\\"IDX_196374b312744cf2c400c96238\\"")
+    op.execute("CREATE TABLE \\"contact_companies_company\\" (\\"contactId\\" integer NOT NULL, \\"companyId\\" integer NOT NULL, CONSTRAINT \\"PK_a240a097bb1e1d698bc213e0c72\\" PRIMARY KEY (\\"contactId\\", \\"companyId\\"))")
+    op.execute("INSERT INTO \\"contact_companies_company\\" (\\"contactId\\", \\"companyId\\") SELECT \\"id\\", \\"companyId\\" FROM \\"contact\\" WHERE \\"companyId\\" IS NOT NULL")
+    op.execute("ALTER TABLE \\"contact\\" DROP COLUMN \\"companyId\\"")
+    op.execute("CREATE INDEX \\"IDX_e6e2d85d35645bd6b752226c49\\" ON \\"contact_companies_company\\" (\\"contactId\\")")
+    op.execute("CREATE INDEX \\"IDX_30d0ef2a176bf879a2d36df096\\" ON \\"contact_companies_company\\" (\\"companyId\\")")
+    op.execute("ALTER TABLE \\"contact_companies_company\\" ADD CONSTRAINT \\"FK_e6e2d85d35645bd6b752226c49d\\" FOREIGN KEY (\\"contactId\\") REFERENCES \\"contact\\"(\\"id\\") ON DELETE CASCADE ON UPDATE CASCADE")
+    op.execute("ALTER TABLE \\"contact_companies_company\\" ADD CONSTRAINT \\"FK_30d0ef2a176bf879a2d36df0966\\" FOREIGN KEY (\\"companyId\\") REFERENCES \\"company\\"(\\"id\\") ON DELETE NO ACTION ON UPDATE NO ACTION")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"contact_companies_company\\" DROP CONSTRAINT \\"FK_e6e2d85d35645bd6b752226c49d\\"")
+    op.execute("ALTER TABLE \\"contact_companies_company\\" DROP CONSTRAINT \\"FK_30d0ef2a176bf879a2d36df0966\\"")
+    op.execute("ALTER TABLE \\"contact\\" ADD \\"companyId\\" integer")
+    op.execute("UPDATE \\"contact\\" SET \\"companyId\\" = (SELECT j.\\"companyId\\" FROM \\"contact_companies_company\\" j WHERE j.\\"contactId\\" = \\"contact\\".\\"id\\" LIMIT 1) WHERE \\"companyId\\" IS NULL")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"companyId\\" SET NOT NULL")
+    op.execute("DROP TABLE \\"contact_companies_company\\"")
+    op.execute("CREATE INDEX \\"IDX_196374b312744cf2c400c96238\\" ON \\"contact\\" (\\"companyId\\")")
+    op.execute("ALTER TABLE \\"contact\\" ADD CONSTRAINT \\"FK_196374b312744cf2c400c962383\\" FOREIGN KEY (\\"companyId\\") REFERENCES \\"company\\"(\\"id\\") ON DELETE NO ACTION ON UPDATE NO ACTION")
+"
+`;
+
+exports[`many-to-many goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TABLE "contact" DROP CONSTRAINT "FK_196374b312744cf2c400c962383";
+DROP INDEX "public"."IDX_196374b312744cf2c400c96238";
+CREATE TABLE "contact_companies_company" ("contactId" integer NOT NULL, "companyId" integer NOT NULL, CONSTRAINT "PK_a240a097bb1e1d698bc213e0c72" PRIMARY KEY ("contactId", "companyId"));
+INSERT INTO "contact_companies_company" ("contactId", "companyId") SELECT "id", "companyId" FROM "contact" WHERE "companyId" IS NOT NULL;
+ALTER TABLE "contact" DROP COLUMN "companyId";
+CREATE INDEX "IDX_e6e2d85d35645bd6b752226c49" ON "contact_companies_company" ("contactId");
+CREATE INDEX "IDX_30d0ef2a176bf879a2d36df096" ON "contact_companies_company" ("companyId");
+ALTER TABLE "contact_companies_company" ADD CONSTRAINT "FK_e6e2d85d35645bd6b752226c49d" FOREIGN KEY ("contactId") REFERENCES "contact"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "contact_companies_company" ADD CONSTRAINT "FK_30d0ef2a176bf879a2d36df0966" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;
+
+-- +goose Down
+ALTER TABLE "contact_companies_company" DROP CONSTRAINT "FK_e6e2d85d35645bd6b752226c49d";
+ALTER TABLE "contact_companies_company" DROP CONSTRAINT "FK_30d0ef2a176bf879a2d36df0966";
+ALTER TABLE "contact" ADD "companyId" integer;
+UPDATE "contact" SET "companyId" = (SELECT j."companyId" FROM "contact_companies_company" j WHERE j."contactId" = "contact"."id" LIMIT 1) WHERE "companyId" IS NULL;
+ALTER TABLE "contact" ALTER COLUMN "companyId" SET NOT NULL;
+DROP TABLE "contact_companies_company";
+CREATE INDEX "IDX_196374b312744cf2c400c96238" ON "contact" ("companyId");
+ALTER TABLE "contact" ADD CONSTRAINT "FK_196374b312744cf2c400c962383" FOREIGN KEY ("companyId") REFERENCES "company"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;
+"
+`;
+
+exports[`rename-entity Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" RENAME COLUMN \\"companyId\\" TO \\"organizationId\\"")
+    op.execute("ALTER TABLE \\"company\\" RENAME TO \\"organization\\"")
+    op.execute("ALTER SEQUENCE \\"company_id_seq\\" RENAME TO \\"organization_id_seq\\"")
+    op.execute("ALTER TABLE \\"organization\\" RENAME CONSTRAINT \\"PK_056f7854a7afdba7cbd6d45fc20\\" TO \\"PK_472c1f99a32def1b0abb219cd67\\"")
+    op.execute("ALTER TABLE \\"contact\\" RENAME CONSTRAINT \\"FK_196374b312744cf2c400c962383\\" TO \\"FK_7719d73cd16a9f57ecc6ac24b3d\\"")
+    op.execute("ALTER INDEX \\"public\\".\\"IDX_196374b312744cf2c400c96238\\" RENAME TO \\"IDX_7719d73cd16a9f57ecc6ac24b3\\"")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" RENAME COLUMN \\"organizationId\\" TO \\"companyId\\"")
+    op.execute("ALTER TABLE \\"organization\\" RENAME TO \\"company\\"")
+    op.execute("ALTER SEQUENCE \\"organization_id_seq\\" RENAME TO \\"company_id_seq\\"")
+    op.execute("ALTER TABLE \\"company\\" RENAME CONSTRAINT \\"PK_472c1f99a32def1b0abb219cd67\\" TO \\"PK_056f7854a7afdba7cbd6d45fc20\\"")
+    op.execute("ALTER TABLE \\"contact\\" RENAME CONSTRAINT \\"FK_7719d73cd16a9f57ecc6ac24b3d\\" TO \\"FK_196374b312744cf2c400c962383\\"")
+    op.execute("ALTER INDEX \\"public\\".\\"IDX_7719d73cd16a9f57ecc6ac24b3\\" RENAME TO \\"IDX_196374b312744cf2c400c96238\\"")
+"
+`;
+
+exports[`rename-entity goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TABLE "contact" RENAME COLUMN "companyId" TO "organizationId";
+ALTER TABLE "company" RENAME TO "organization";
+ALTER SEQUENCE "company_id_seq" RENAME TO "organization_id_seq";
+ALTER TABLE "organization" RENAME CONSTRAINT "PK_056f7854a7afdba7cbd6d45fc20" TO "PK_472c1f99a32def1b0abb219cd67";
+ALTER TABLE "contact" RENAME CONSTRAINT "FK_196374b312744cf2c400c962383" TO "FK_7719d73cd16a9f57ecc6ac24b3d";
+ALTER INDEX "public"."IDX_196374b312744cf2c400c96238" RENAME TO "IDX_7719d73cd16a9f57ecc6ac24b3";
+
+-- +goose Down
+ALTER TABLE "contact" RENAME COLUMN "organizationId" TO "companyId";
+ALTER TABLE "organization" RENAME TO "company";
+ALTER SEQUENCE "organization_id_seq" RENAME TO "company_id_seq";
+ALTER TABLE "company" RENAME CONSTRAINT "PK_472c1f99a32def1b0abb219cd67" TO "PK_056f7854a7afdba7cbd6d45fc20";
+ALTER TABLE "contact" RENAME CONSTRAINT "FK_7719d73cd16a9f57ecc6ac24b3d" TO "FK_196374b312744cf2c400c962383";
+ALTER INDEX "public"."IDX_7719d73cd16a9f57ecc6ac24b3" RENAME TO "IDX_196374b312744cf2c400c96238";
+"
+`;
+
+exports[`rename-field Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" RENAME COLUMN \\"phone\\" TO \\"mobilePhone\\"")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" RENAME COLUMN \\"mobilePhone\\" TO \\"phone\\"")
+"
+`;
+
+exports[`rename-field goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TABLE "contact" RENAME COLUMN "phone" TO "mobilePhone";
+
+-- +goose Down
+ALTER TABLE "contact" RENAME COLUMN "mobilePhone" TO "phone";
+"
+`;
+
+exports[`required-field Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("CREATE TYPE \\"public\\".\\"company_region_enum\\" AS ENUM('us', 'eu', 'apac')")
+    op.execute("ALTER TABLE \\"company\\" ADD \\"region\\" \\"public\\".\\"company_region_enum\\" NOT NULL DEFAULT 'us'")
+    op.execute("UPDATE \\"company\\" SET \\"region\\" = 'us' WHERE \\"region\\" IS NULL")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"company\\" DROP COLUMN \\"region\\"")
+    op.execute("DROP TYPE \\"public\\".\\"company_region_enum\\"")
+"
+`;
+
+exports[`required-field goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+CREATE TYPE "public"."company_region_enum" AS ENUM('us', 'eu', 'apac');
+ALTER TABLE "company" ADD "region" "public"."company_region_enum" NOT NULL DEFAULT 'us';
+UPDATE "company" SET "region" = 'us' WHERE "region" IS NULL;
+
+-- +goose Down
+ALTER TABLE "company" DROP COLUMN "region";
+DROP TYPE "public"."company_region_enum";
+"
+`;
+
+exports[`split-field Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" ADD \\"firstName\\" text")
+    op.execute("ALTER TABLE \\"contact\\" ADD \\"lastName\\" text")
+    op.execute("UPDATE \\"contact\\" SET \\"firstName\\" = (split_part(btrim(\\"fullName\\"), ' ', 1)), \\"lastName\\" = (NULLIF(btrim(substr(btrim(\\"fullName\\"), length(split_part(btrim(\\"fullName\\"), ' ', 1)) + 1)), ''))")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"firstName\\" SET NOT NULL")
+    op.execute("ALTER TABLE \\"contact\\" DROP COLUMN \\"fullName\\"")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" ADD \\"fullName\\" text")
+    op.execute("UPDATE \\"contact\\" SET \\"fullName\\" = (concat_ws(' ', \\"firstName\\", \\"lastName\\")) WHERE \\"fullName\\" IS NULL")
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"fullName\\" SET NOT NULL")
+    op.execute("ALTER TABLE \\"contact\\" DROP COLUMN \\"firstName\\"")
+    op.execute("ALTER TABLE \\"contact\\" DROP COLUMN \\"lastName\\"")
+"
+`;
+
+exports[`split-field goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TABLE "contact" ADD "firstName" text;
+ALTER TABLE "contact" ADD "lastName" text;
+UPDATE "contact" SET "firstName" = (split_part(btrim("fullName"), ' ', 1)), "lastName" = (NULLIF(btrim(substr(btrim("fullName"), length(split_part(btrim("fullName"), ' ', 1)) + 1)), ''));
+ALTER TABLE "contact" ALTER COLUMN "firstName" SET NOT NULL;
+ALTER TABLE "contact" DROP COLUMN "fullName";
+
+-- +goose Down
+ALTER TABLE "contact" ADD "fullName" text;
+UPDATE "contact" SET "fullName" = (concat_ws(' ', "firstName", "lastName")) WHERE "fullName" IS NULL;
+ALTER TABLE "contact" ALTER COLUMN "fullName" SET NOT NULL;
+ALTER TABLE "contact" DROP COLUMN "firstName";
+ALTER TABLE "contact" DROP COLUMN "lastName";
+"
+`;
+
+exports[`type-change Alembic revision compiles and gives back its SQL 1`] = `
+""""Generated by apso migrate generate from the answered migration plan saved beside this file."""
+from alembic import op
+
+revision = "20231114221320"
+down_revision = "20231101000000"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"score\\" TYPE integer USING (NULLIF(regexp_replace(\\"score\\", '[^0-9-]', '', 'g'), '')::integer)")
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE \\"contact\\" ALTER COLUMN \\"score\\" TYPE text USING \\"score\\"::text")
+"
+`;
+
+exports[`type-change goose file matches its snapshot 1`] = `
+"-- Generated by apso migrate generate from the answered migration plan saved beside this file.
+-- +goose Up
+ALTER TABLE "contact" ALTER COLUMN "score" TYPE integer USING (NULLIF(regexp_replace("score", '[^0-9-]', '', 'g'), '')::integer);
+
+-- +goose Down
+ALTER TABLE "contact" ALTER COLUMN "score" TYPE text USING "score"::text;
+"
+`;
diff --git a/test/lib/ddl/answers.ts b/test/lib/ddl/answers.ts
new file mode 100644
index 0000000..0894308
--- /dev/null
+++ b/test/lib/ddl/answers.ts
@@ -0,0 +1,49 @@
+import { Plan, planMigration } from "../../../src/lib/plan";
+
+// Each migration eval case, answered the way the eval expects. The change
+// must leave the seeded database identical in schema to a fresh build of the
+// new .apsorc, with every row check in checks.sql passing.
+export const answers: Record<
+  string,
+  Record<
+    string,
+    string | { answer: string; sql: string | Record<string, string> }
+  >
+> = {
+  "rename-entity": { "entity:Company": "rename:Organization" },
+  "rename-field": { "field:Contact.phone": "rename:mobilePhone" },
+  "split-field": {
+    "field:Contact.fullName": {
+      answer: "split:firstName,lastName",
+      sql: {
+        firstName: `split_part(btrim("fullName"), ' ', 1)`,
+        lastName: `NULLIF(btrim(substr(btrim("fullName"), length(split_part(btrim("fullName"), ' ', 1)) + 1)), '')`,
+      },
+    },
+  },
+  "extract-entity": { "field:Contact.phone": "move:PhoneNumber.number" },
+  "many-to-many": { "relation:Contact.Company": "copy-links" },
+  "enum-replace": { "enum:Contact.status:archived": "closed" },
+  "required-field": { "backfill:Company.region": "us" },
+  "type-change": {
+    "cast:Contact.score": {
+      answer: "sql",
+      sql: `NULLIF(regexp_replace("score", '[^0-9-]', '', 'g'), '')::integer`,
+    },
+  },
+};
+
+export const answeredPlan = (c: string, before: any, after: any): Plan => {
+  let plan = planMigration(before, after);
+  for (let round = 0; round < 3; round++) {
+    for (const q of plan.questions) {
+      const a = answers[c][q.id];
+      if (a === undefined) continue;
+      if (typeof a === "string") q.answer = a;
+      else Object.assign(q, a);
+    }
+    plan = planMigration(before, after, plan);
+  }
+  return plan;
+};
+
diff --git a/test/lib/ddl/change.test.ts b/test/lib/ddl/change.test.ts
new file mode 100644
index 0000000..24bc39a
--- /dev/null
+++ b/test/lib/ddl/change.test.ts
@@ -0,0 +1,122 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import { parseApsorcV2 } from "../../../src/lib/apsorc-parser";
+import { schemaDdl, schemaModel } from "../../../src/lib/ddl";
+import { changeDdl, downDdl } from "../../../src/lib/ddl/change";
+import { catalogDiff, readCatalog } from "../../../src/lib/ddl/catalog";
+import { openQuestions, planMigration } from "../../../src/lib/plan";
+import { answeredPlan, answers } from "./answers";
+
+const dir = (c: string) => path.join(__dirname, "../../fixtures/plan", c);
+const read = (c: string, f: string) =>
+  fs.readFileSync(path.join(dir(c), f)).toString();
+
+const pglite = async () => {
+  const { PGlite } = await import("@electric-sql/pglite");
+  return new PGlite();
+};
+
+describe("changeDdl on the migration eval cases", () => {
+  test.each(Object.keys(answers))("%s", async (c) => {
+    const before = JSON.parse(read(c, "before.apsorc"));
+    const after = JSON.parse(read(c, "after.apsorc"));
+    const plan = answeredPlan(c, before, after);
+    expect(openQuestions(plan)).toEqual([]);
+
+    const db = await pglite();
+    await db.exec(schemaDdl(parseApsorcV2(before)).join(";\n"));
+    await db.exec(read(c, "seed.sql"));
+    await db.exec(changeDdl(before, after, plan).up.join(";\n"));
+
+    const fresh = await pglite();
+    await fresh.exec(schemaDdl(parseApsorcV2(after)).join(";\n"));
+    expect(
+      catalogDiff(await readCatalog(fresh), await readCatalog(db))
+    ).toEqual([]);
+
+    const failed: string[] = [];
+    const checks = read(c, "checks.sql")
+      .split(";\n")
+      .filter((s) => s.trim());
+    const results = await Promise.all(
+      checks.map((sql) => db.query<{ ok: boolean; label: string }>(sql))
+    );
+    for (const result of results)
+      for (const row of result.rows)
+        if (row.ok !== true) failed.push(row.label);
+    expect(failed).toEqual([]);
+    await db.close();
+    await fresh.close();
+  });
+
+  test("answering drop instead of rename loses the data, and the checks catch it", async () => {
+    const c = "rename-field";
+    const before = JSON.parse(read(c, "before.apsorc"));
+    const after = JSON.parse(read(c, "after.apsorc"));
+    const first = planMigration(before, after);
+    first.questions[0].answer = "drop";
+    const plan = planMigration(before, after, first);
+    const db = await pglite();
+    await db.exec(schemaDdl(parseApsorcV2(before)).join(";\n"));
+    await db.exec(read(c, "seed.sql"));
+    await db.exec(changeDdl(before, after, plan).up.join(";\n"));
+    const result = await db.query<{ ok: boolean }>(
+      read(c, "checks.sql").split(";\n")[0]
+    );
+    expect(result.rows[0].ok).toBe(false);
+    await db.close();
+  });
+
+  test("a plain cast fails on a value that is not a number", async () => {
+    const c = "type-change";
+    const before = JSON.parse(read(c, "before.apsorc"));
+    const after = JSON.parse(read(c, "after.apsorc"));
+    const plan = planMigration(before, after);
+    plan.questions[0].answer = "cast";
+    const db = await pglite();
+    await db.exec(schemaDdl(parseApsorcV2(before)).join(";\n"));
+    await db.exec(read(c, "seed.sql"));
+    await expect(
+      db.exec(changeDdl(before, after, plan).up.join(";\n"))
+    ).rejects.toThrow(/invalid input syntax/);
+    await db.close();
+  });
+});
+
+describe("downDdl reverses each eval case", () => {
+  // Split and cast lose detail by design (trimmed whitespace, 'n/a').
+  const lossy = new Set(["split-field", "type-change"]);
+  test.each(Object.keys(answers))("%s", async (c) => {
+    const before = JSON.parse(read(c, "before.apsorc"));
+    const after = JSON.parse(read(c, "after.apsorc"));
+    const plan = answeredPlan(c, before, after);
+    const reverse = downDdl(before, after, plan);
+    expect(reverse).toHaveProperty("down");
+    const down = (reverse as { down: string[] }).down;
+
+    const db = await pglite();
+    await db.exec(schemaDdl(parseApsorcV2(before)).join(";\n"));
+    await db.exec(read(c, "seed.sql"));
+    const tables = schemaModel(parseApsorcV2(before)).tables.map((t) => t.name);
+    const rows = async () =>
+      Promise.all(
+        tables.map(async (t) => {
+          const r = await db.query(`SELECT * FROM "${t}" ORDER BY 1`);
+          return r.rows;
+        })
+      );
+    const seeded = await rows();
+    await db.exec(changeDdl(before, after, plan).up.join(";\n"));
+    await db.exec(down.join(";\n"));
+
+    const fresh = await pglite();
+    await fresh.exec(schemaDdl(parseApsorcV2(before)).join(";\n"));
+    expect(
+      catalogDiff(await readCatalog(fresh), await readCatalog(db))
+    ).toEqual([]);
+    if (!lossy.has(c)) expect(await rows()).toEqual(seeded);
+    await db.close();
+    await fresh.close();
+  });
+});
diff --git a/test/lib/ddl/ddl.test.ts b/test/lib/ddl/ddl.test.ts
new file mode 100644
index 0000000..7767feb
--- /dev/null
+++ b/test/lib/ddl/ddl.test.ts
@@ -0,0 +1,49 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import { parseApsorcV2 } from "../../../src/lib/apsorc-parser";
+import { constraintName, schemaDdl } from "../../../src/lib/ddl";
+
+// Correctness against real generated services is checked by
+// project-parity.test.ts (opt-in). These run everywhere: the DDL must run on
+// Postgres, and any change to what it writes shows up as a snapshot diff.
+const fixtures = path.join(__dirname, "../../fixtures");
+const cases: [string, string][] = [
+  ...fs
+    .readdirSync(path.join(fixtures, "plan"))
+    .map((c): [string, string] => [
+      c,
+      path.join(fixtures, "plan", c, "after.apsorc"),
+    ]),
+  ["inventory-multi-fk", path.join(fixtures, "inventory-multi-fk.apsorc")],
+  ["coverage", path.join(fixtures, "ddl", "coverage.apsorc")],
+];
+const ddl = (file: string) =>
+  schemaDdl(parseApsorcV2(JSON.parse(fs.readFileSync(file).toString())));
+
+describe("schemaDdl", () => {
+  test("names match TypeORM's DefaultNamingStrategy", () => {
+    // Names from a migration TypeORM generated for contact.companyId.
+    expect(constraintName.foreignKey("contact", ["companyId"])).toBe(
+      "FK_196374b312744cf2c400c962383"
+    );
+    expect(constraintName.index("contact", ["companyId"])).toBe(
+      "IDX_196374b312744cf2c400c96238"
+    );
+    expect(constraintName.primaryKey("organization", ["id"])).toBe(
+      "PK_472c1f99a32def1b0abb219cd67"
+    );
+  });
+
+  test.each(cases)(
+    "%s runs on Postgres and matches its snapshot",
+    async (_name, file) => {
+      const statements = ddl(file);
+      const { PGlite } = await import("@electric-sql/pglite");
+      const db = new PGlite();
+      await db.exec(statements.join(";\n"));
+      await db.close();
+      expect(statements).toMatchSnapshot();
+    }
+  );
+});
diff --git a/test/lib/ddl/migration-file.test.ts b/test/lib/ddl/migration-file.test.ts
new file mode 100644
index 0000000..48b65a9
--- /dev/null
+++ b/test/lib/ddl/migration-file.test.ts
@@ -0,0 +1,86 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  typeormMigration,
+  writePlannedMigration,
+} from "../../../src/lib/ddl/migration-file";
+
+const fixture = (c: string, f: string) =>
+  path.join(__dirname, "../../fixtures/plan", c, f);
+const before = () =>
+  JSON.parse(
+    fs.readFileSync(fixture("rename-field", "before.apsorc")).toString()
+  );
+const project = (c: string) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-planned-"));
+  fs.copyFileSync(fixture(c, "after.apsorc"), path.join(dir, ".apsorc"));
+  return dir;
+};
+
+describe("writePlannedMigration", () => {
+  test("writes nothing while a plan question is open", () => {
+    const dir = project("rename-field");
+    const result = writePlannedMigration(
+      dir,
+      before(),
+      "SchemaUpdate",
+      path.join(dir, ".apso/migration-plan.json")
+    );
+    expect(result.ok).toBe(false);
+    expect(result.open?.map((q) => q.id)).toEqual(["field:Contact.phone"]);
+    expect(fs.existsSync(path.join(dir, "src", "migrations"))).toBe(false);
+  });
+
+  test("writes the migration and its plan once answered", () => {
+    const dir = project("rename-field");
+    const planPath = path.join(dir, ".apso/migration-plan.json");
+    writePlannedMigration(dir, before(), "SchemaUpdate", planPath);
+    const plan = JSON.parse(fs.readFileSync(planPath).toString());
+    plan.questions[0].answer = "rename:mobilePhone";
+    fs.writeFileSync(planPath, JSON.stringify(plan));
+    const result = writePlannedMigration(
+      dir,
+      before(),
+      "SchemaUpdate",
+      planPath,
+      1_700_000_000_000
+    );
+    expect(result.file).toBe(
+      "src/migrations/1700000000000-SchemaUpdate-migration.ts"
+    );
+    const source = fs.readFileSync(path.join(dir, result.file!)).toString();
+    expect(source).toContain(
+      "export class SchemaUpdateMigration1700000000000 implements MigrationInterface"
+    );
+    expect(source).toContain(
+      'ALTER TABLE "contact" RENAME COLUMN "phone" TO "mobilePhone"'
+    );
+    expect(source).toContain(
+      'ALTER TABLE "contact" RENAME COLUMN "mobilePhone" TO "phone"'
+    );
+    expect(fs.existsSync(path.join(dir, result.planFile!))).toBe(true);
+    expect(result.findings).toEqual([]);
+  });
+});
+
+describe("typeormMigration", () => {
+  test("escapes backticks and template placeholders in SQL", () => {
+    // eslint-disable-next-line no-template-curly-in-string
+    const source = typeormMigration("X1", ["SELECT '`${x}`'"], { down: [] });
+    expect(source).toContain(
+      // eslint-disable-next-line no-template-curly-in-string
+      "await queryRunner.query(`SELECT '\\`\\${x}\\`'`);"
+    );
+  });
+
+  test("down() throws, naming what can't be reversed", () => {
+    const source = typeormMigration("X1", ["SELECT 1"], {
+      irreversible: ["backfill:Contact.fullName: needs a value"],
+    });
+    expect(source).toContain(
+      "can't be reversed automatically: backfill:Contact.fullName: needs a value"
+    );
+  });
+});
diff --git a/test/lib/ddl/project-parity.test.ts b/test/lib/ddl/project-parity.test.ts
new file mode 100644
index 0000000..92f04a8
--- /dev/null
+++ b/test/lib/ddl/project-parity.test.ts
@@ -0,0 +1,75 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { parseApsorcV2 } from "../../../src/lib/apsorc-parser";
+import { buildBaseline } from "../../../src/lib/verify";
+import { schemaDdl } from "../../../src/lib/ddl";
+import { catalogDiff, readCatalog } from "../../../src/lib/ddl/catalog";
+
+// The real reference: TypeORM schema:sync on the entities `apso generate`
+// writes into a TypeScript service. Needs a scaffolded project with
+// node_modules, so it runs only when APSO_PARITY_PROJECT points at one:
+//   APSO_PARITY_PROJECT=/path/to/service npm test -- project-parity
+const project = process.env.APSO_PARITY_PROJECT;
+// Under NODE_ENV=test oclif loads src/*.ts; the scaffold step must run dist/.
+process.env.NODE_ENV = "production";
+const cliBin = path.join(__dirname, "../../../bin/run");
+const fixtures = path.join(__dirname, "../../fixtures");
+const cases: [string, string][] = [
+  ...fs
+    .readdirSync(path.join(fixtures, "plan"))
+    .flatMap((c) =>
+      (["before", "after"] as const).map((w): [string, string] => [
+        `${c}/${w}`,
+        path.join(fixtures, "plan", c, `${w}.apsorc`),
+      ])
+    ),
+  ["inventory-multi-fk", path.join(fixtures, "inventory-multi-fk.apsorc")],
+  [
+    "decimal-example",
+    path.join(__dirname, "../../apsorc-json/apsorc-decimal-example.json"),
+  ],
+  ["coverage", path.join(fixtures, "ddl", "coverage.apsorc")],
+];
+
+const catalogOf = async (
+  dataDir: string | undefined,
+  statements: string[] = []
+) => {
+  // The service's own PGlite wrote dataDir; the CLI's older one can't read it.
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const { PGlite } = require(require.resolve("@electric-sql/pglite", {
+    paths: [project!],
+  }));
+  const db = new PGlite(dataDir);
+  await db.exec(statements.join(";\n"));
+  const catalog = await readCatalog(db);
+  await db.close();
+  return catalog;
+};
+
+(project ? describe : describe.skip)(
+  "schemaDdl matches a generated service",
+  () => {
+    test.each(cases)(
+      "%s",
+      async (_name, file) => {
+        const dataDir = fs.mkdtempSync(
+          path.join(os.tmpdir(), "apso-ddl-project-")
+        );
+        const step = await buildBaseline(project!, file, dataDir, cliBin);
+        expect(step.output).toBeUndefined();
+        const input = parseApsorcV2(
+          JSON.parse(fs.readFileSync(file).toString())
+        );
+        const diff = catalogDiff(
+          await catalogOf(dataDir),
+          await catalogOf(undefined, schemaDdl(input))
+        );
+        expect(diff).toEqual([]);
+      },
+      300_000
+    );
+  }
+);
diff --git a/test/lib/ddl/wrappers.test.ts b/test/lib/ddl/wrappers.test.ts
new file mode 100644
index 0000000..d42619e
--- /dev/null
+++ b/test/lib/ddl/wrappers.test.ts
@@ -0,0 +1,206 @@
+import { expect, describe, test } from "@jest/globals";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { changeDdl, downDdl } from "../../../src/lib/ddl/change";
+import {
+  alembicHead,
+  alembicMigration,
+  gooseMigration,
+  migrationSql,
+  writePlannedMigration,
+} from "../../../src/lib/ddl/migration-file";
+import { PythonGenerator } from "../../../src/lib/generators/python";
+import { verifyMigration } from "../../../src/lib/verify";
+import { answeredPlan, answers } from "./answers";
+
+const fixture = (c: string, f: string) =>
+  path.join(__dirname, "../../fixtures/plan", c, f);
+const read = (c: string, f: string) =>
+  JSON.parse(fs.readFileSync(fixture(c, f)).toString());
+const cliBin = path.join(__dirname, "../../../bin/run");
+
+let python = true;
+try {
+  execFileSync("python3", ["--version"], { stdio: "ignore" });
+} catch {
+  python = false;
+}
+/** Python accepts the file. Without python3, every SQL literal must round-trip. */
+const compiles = (source: string) => {
+  if (!python) {
+    for (const m of source.matchAll(/op\.execute\((.*)\)$/gm))
+      expect(typeof JSON.parse(m[1])).toBe("string");
+    return;
+  }
+  const file = path.join(
+    fs.mkdtempSync(path.join(os.tmpdir(), "apso-py-")),
+    "m.py"
+  );
+  fs.writeFileSync(file, source);
+  execFileSync("python3", ["-m", "py_compile", file]);
+};
+
+describe.each(Object.keys(answers))("%s", (c) => {
+  const before = read(c, "before.apsorc");
+  const after = read(c, "after.apsorc");
+  const plan = answeredPlan(c, before, after);
+  const { up } = changeDdl(before, after, plan);
+  const down = downDdl(before, after, plan);
+
+  test("Alembic revision compiles and gives back its SQL", () => {
+    const source = alembicMigration("20231114221320", "20231101000000", up, down);
+    expect(source).toMatchSnapshot();
+    compiles(source);
+    const sql = migrationSql("x.py", source);
+    expect(sql.up).toBe(up.join(";\n"));
+    expect(sql.down).toBe((down as { down: string[] }).down.join(";\n"));
+  });
+
+  test("goose file matches its snapshot", () => {
+    expect(gooseMigration(up, down)).toMatchSnapshot();
+  });
+});
+
+describe("wrappers", () => {
+  test("SQL ending in a quoted identifier stays valid Python (#148)", async () => {
+    const [file] = await new PythonGenerator({
+      language: "python",
+    } as any).generateMigration({
+      entities: [],
+      upSql: ['DROP TABLE "user"'],
+      downSql: ['CREATE TABLE "user" ("id" integer, "note" text DEFAULT \'a\\b """\')'],
+    } as any);
+    compiles(file.content);
+    expect(file.content).toContain('op.execute("DROP TABLE \\"user\\"")');
+  });
+
+  test("an irreversible down refuses to run", () => {
+    const irreversible = { irreversible: ["backfill:Contact.fullName: 100%"] };
+    const py = alembicMigration("2", undefined, ["SELECT 1"], irreversible);
+    compiles(py);
+    expect(py).toContain("raise NotImplementedError(");
+    expect(py).toContain("down_revision = None");
+    expect(migrationSql("x.py", py).down).toBeUndefined();
+    const sql = gooseMigration(["SELECT 1"], irreversible);
+    expect(sql).toContain("-- +goose StatementBegin\nDO $$ BEGIN RAISE EXCEPTION");
+    expect(sql).toContain("100%%");
+    expect(migrationSql("x.sql", sql)).toEqual({ up: "\nSELECT 1;\n\n", down: undefined });
+  });
+
+  test("a statement with its own semicolon is fenced for goose", () => {
+    expect(gooseMigration(["SELECT ';'", "SELECT 2"], { down: [] })).toContain(
+      "-- +goose StatementBegin\nSELECT ';';\n-- +goose StatementEnd\nSELECT 2;"
+    );
+  });
+
+  test("the Alembic head is the revision nothing revises", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-alembic-"));
+    expect(alembicHead(dir)).toBeUndefined();
+    const rev = (f: string, r: string, d: string) =>
+      fs.writeFileSync(
+        path.join(dir, f),
+        `revision: str = '${r}'\ndown_revision: Union[str, None] = ${d}\n`
+      );
+    rev("a_init.py", "aaa", "None");
+    rev("c_third.py", "ccc", "'bbb'");
+    rev("b_second.py", "bbb", "'aaa'");
+    expect(alembicHead(dir)).toBe("ccc");
+  });
+});
+
+describe.each(["python", "go"])("apso migrate for %s", (language) => {
+  const project = (c: string) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `apso-${language}-`));
+    const after = { ...read(c, "after.apsorc"), language };
+    fs.writeFileSync(path.join(dir, ".apsorc"), JSON.stringify(after));
+    const plan = answeredPlan(c, read(c, "before.apsorc"), after);
+    const planPath = path.join(dir, ".apso", "migration-plan.json");
+    fs.mkdirSync(path.dirname(planPath));
+    fs.writeFileSync(planPath, JSON.stringify(plan));
+    return { dir, planPath };
+  };
+
+  test("writes the migration where the template keeps them", () => {
+    const { dir, planPath } = project("rename-field");
+    const result = writePlannedMigration(
+      dir,
+      read("rename-field", "before.apsorc"),
+      "SchemaUpdate",
+      planPath,
+      1_700_000_000_000
+    );
+    expect(result.file).toBe(
+      language === "python"
+        ? "alembic/versions/20231114221320_schema_update.py"
+        : "migrations/20231114221320_schema_update.sql"
+    );
+    expect(result.planFile).toBe(
+      result.file!.replace(/\.(py|sql)$/, ".plan.json")
+    );
+    expect(result.findings).toEqual([]);
+  });
+
+  test.each([
+    ["rename-field", []],
+    ["split-field", ["contact.fullName"]],
+    ["extract-entity", []],
+  ])(
+    "%s verifies with its seed and checks",
+    async (c, acceptLoss) => {
+      const { dir, planPath } = project(c);
+      const written = writePlannedMigration(
+        dir,
+        read(c, "before.apsorc"),
+        "SchemaUpdate",
+        planPath
+      );
+      const result = await verifyMigration(
+        dir,
+        fixture(c, "before.apsorc"),
+        written.file!,
+        cliBin,
+        {
+          seedFile: fixture(c, "seed.sql"),
+          checkFile: fixture(c, "checks.sql"),
+          acceptLoss: acceptLoss as string[],
+        }
+      );
+      expect(result.steps).toEqual(
+        ["baseline", "seed", "migrate", "count", "data", "check", "drift", "down", "down drift"].map(
+          (name) => expect.objectContaining({ name, ok: true })
+        )
+      );
+      expect(result.ok).toBe(true);
+    },
+    60_000
+  );
+
+  test("drift fails when the migration leaves the schema short", async () => {
+    const { dir, planPath } = project("rename-field");
+    const written = writePlannedMigration(
+      dir,
+      read("rename-field", "before.apsorc"),
+      "SchemaUpdate",
+      planPath
+    );
+    const file = path.join(dir, written.file!);
+    // Drop the rename: the deployed column stays "phone".
+    fs.writeFileSync(
+      file,
+      fs
+        .readFileSync(file)
+        .toString()
+        .replace(/^.*RENAME COLUMN \\?"phone\\?" TO .*$/m, "")
+    );
+    const result = await verifyMigration(
+      dir,
+      fixture("rename-field", "before.apsorc"),
+      written.file!,
+      cliBin
+    );
+    expect(result.ok).toBe(false);
+    expect(result.steps[result.steps.length - 1]).toMatchObject({ name: "drift", ok: false });
+  }, 60_000);
+});
diff --git a/test/lib/plan/baseline.test.ts b/test/lib/plan/baseline.test.ts
new file mode 100644
index 0000000..9631b68
--- /dev/null
+++ b/test/lib/plan/baseline.test.ts
@@ -0,0 +1,96 @@
+import { expect, describe, test } from "@jest/globals";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { resolveBaseline } from "../../../src/lib/plan/baseline";
+
+const schema = (n: number) =>
+  ({
+    version: 2,
+    rootFolder: "src",
+    entities: [{ name: `E${n}`, fields: [] }],
+    relationships: [],
+  } as any);
+const project = () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-baseline-"));
+  fs.mkdirSync(path.join(dir, "src", "migrations"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".apsorc"), JSON.stringify(schema(9)));
+  return dir;
+};
+const savePlan = (dir: string, ts: number, before: number, after: number) =>
+  fs.writeFileSync(
+    path.join(
+      dir,
+      "src",
+      "migrations",
+      `${ts}-SchemaUpdate-migration.plan.json`
+    ),
+    JSON.stringify({
+      version: 1,
+      questions: [],
+      before: schema(before),
+      after: schema(after),
+    })
+  );
+const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", ...args], {
+    cwd,
+    stdio: "ignore",
+  });
+
+describe("resolveBaseline", () => {
+  test("the newest migration's after schema", () => {
+    const dir = project();
+    savePlan(dir, 1000, 1, 2);
+    savePlan(dir, 2000, 2, 3);
+    const b = resolveBaseline(dir, schema(9));
+    expect(b.schema.entities[0].name).toBe("E3");
+    expect(b.source).toBe(
+      "src/migrations/2000-SchemaUpdate-migration.plan.json"
+    );
+  });
+
+  test("a plan in progress beats the newest migration", () => {
+    const dir = project();
+    savePlan(dir, 1000, 1, 2);
+    const planPath = path.join(dir, ".apso", "migration-plan.json");
+    fs.mkdirSync(path.dirname(planPath));
+    fs.writeFileSync(
+      planPath,
+      JSON.stringify({ questions: [], before: schema(5) })
+    );
+    expect(
+      resolveBaseline(dir, schema(9), undefined, planPath).schema.entities[0]
+        .name
+    ).toBe("E5");
+  });
+
+  test("--baseline beats everything", () => {
+    const dir = project();
+    savePlan(dir, 1000, 1, 2);
+    const file = path.join(dir, "deployed.apsorc");
+    fs.writeFileSync(file, JSON.stringify(schema(7)));
+    expect(resolveBaseline(dir, schema(9), file).schema.entities[0].name).toBe(
+      "E7"
+    );
+  });
+
+  test("without planned migrations, the .apsorc from the last commit that changed them", () => {
+    const dir = project();
+    git(dir, "init", "-q");
+    fs.writeFileSync(path.join(dir, ".apsorc"), JSON.stringify(schema(1)));
+    fs.writeFileSync(path.join(dir, "src", "migrations", "1-Init.ts"), "");
+    git(dir, "add", "-A");
+    git(dir, "commit", "-qm", "init");
+    fs.writeFileSync(path.join(dir, ".apsorc"), JSON.stringify(schema(2)));
+    git(dir, "commit", "-qam", "schema change, no migration yet");
+    const b = resolveBaseline(dir, schema(2));
+    expect(b.schema.entities[0].name).toBe("E1");
+    expect(b.source).toMatch(/the last commit that changed src\/migrations/);
+  });
+
+  test("says what to do when nothing tells it", () => {
+    expect(() => resolveBaseline(project(), schema(9))).toThrow(/--baseline/);
+  });
+});
diff --git a/test/lib/plan/plan.test.ts b/test/lib/plan/plan.test.ts
new file mode 100644
index 0000000..e62872d
--- /dev/null
+++ b/test/lib/plan/plan.test.ts
@@ -0,0 +1,162 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import {
+  isAnswered,
+  openQuestions,
+  planMigration,
+  Plan,
+} from "../../../src/lib/plan";
+import { describeQuestion } from "../../../src/lib/plan/prompts";
+
+// Each case is one migration eval from apso-skills: the deployed .apsorc and
+// the one the user changed it to.
+const schema = (c: string, which: "before" | "after") =>
+  JSON.parse(
+    fs
+      .readFileSync(
+        path.join(__dirname, "../../fixtures/plan", c, `${which}.apsorc`)
+      )
+      .toString()
+  );
+const plan = (c: string, previous?: Plan) =>
+  planMigration(schema(c, "before"), schema(c, "after"), previous);
+const asked = (c: string, previous?: Plan) =>
+  plan(c, previous).questions.map((q) => ({
+    id: q.id,
+    options: q.options,
+    ...(q.suggested ? { suggested: q.suggested } : {}),
+  }));
+
+describe("planMigration on the migration eval cases", () => {
+  test("rename-entity: rename suggested, nothing else asked", () => {
+    expect(asked("rename-entity")).toEqual([
+      {
+        id: "entity:Company",
+        options: ["rename:Organization", "drop"],
+        suggested: "rename:Organization",
+      },
+    ]);
+  });
+
+  test("rename-field: rename suggested", () => {
+    expect(asked("rename-field")).toEqual([
+      {
+        id: "field:Contact.phone",
+        options: ["rename:mobilePhone", "drop"],
+        suggested: "rename:mobilePhone",
+      },
+    ]);
+  });
+
+  test("split-field: split offered, no rename guessed, no backfill yet", () => {
+    expect(asked("split-field")).toEqual([
+      {
+        id: "field:Contact.fullName",
+        options: [
+          "rename:firstName",
+          "rename:lastName",
+          "split:firstName,lastName",
+          "drop",
+        ],
+      },
+    ]);
+  });
+
+  test("extract-entity: phone can move to PhoneNumber.number", () => {
+    expect(asked("extract-entity")).toEqual([
+      {
+        id: "field:Contact.phone",
+        options: ["move:PhoneNumber.number", "drop"],
+      },
+    ]);
+  });
+
+  test("many-to-many: asks whether to copy the existing links", () => {
+    expect(asked("many-to-many")).toEqual([
+      { id: "relation:Contact.Company", options: ["copy-links", "drop-links"] },
+    ]);
+  });
+
+  test("enum-replace: the removed value needs a new home", () => {
+    expect(asked("enum-replace")).toEqual([
+      {
+        id: "enum:Contact.status:archived",
+        options: ["lead", "active", "closed"],
+      },
+    ]);
+  });
+
+  test("required-field: existing rows need a region", () => {
+    expect(asked("required-field")).toEqual([
+      { id: "backfill:Company.region", options: ["us", "eu", "apac", "sql"] },
+    ]);
+  });
+
+  test("type-change: cast or custom SQL", () => {
+    expect(asked("type-change")).toEqual([
+      { id: "cast:Contact.score", options: ["cast", "sql"] },
+    ]);
+  });
+});
+
+describe("answers", () => {
+  test("a split needs one SQL expression per target field", () => {
+    const p = plan("split-field");
+    const q = p.questions[0];
+    q.answer = "split:firstName,lastName";
+    q.sql = { firstName: `split_part("fullName", ' ', 1)` };
+    expect(isAnswered(q)).toBe(false);
+    q.sql.lastName = `NULLIF(split_part("fullName", ' ', 2), '')`;
+    expect(isAnswered(q)).toBe(true);
+    expect(openQuestions(p)).toEqual([]);
+  });
+
+  test("an answer that is not an option stays open", () => {
+    const p = plan("enum-replace");
+    p.questions[0].answer = "archived";
+    expect(openQuestions(p)).toHaveLength(1);
+  });
+
+  test("re-planning keeps answers whose question still exists", () => {
+    const first = plan("rename-field");
+    first.questions[0].answer = "rename:mobilePhone";
+    const again = plan("rename-field", first);
+    expect(again.questions[0].answer).toBe("rename:mobilePhone");
+    expect(again.from).toBe(first.from);
+  });
+
+  test("dropping the split source asks for backfills on the new required field", () => {
+    const first = plan("split-field");
+    first.questions[0].answer = "drop";
+    const again = plan("split-field", first);
+    expect(again.questions.map((q) => q.id)).toEqual([
+      "field:Contact.fullName",
+      "backfill:Contact.firstName",
+    ]);
+  });
+
+  test("renaming the source claims the target, so no backfill is asked", () => {
+    const first = plan("split-field");
+    first.questions[0].answer = "rename:firstName";
+    expect(plan("split-field", first).questions.map((q) => q.id)).toEqual([
+      "field:Contact.fullName",
+    ]);
+  });
+});
+
+describe("describeQuestion", () => {
+  it("gives each option its words and each two-way split a starting rule", () => {
+    const d = describeQuestion({
+      id: "field:Contact.fullName",
+      kind: "removedField",
+      subject: "Contact.fullName was removed",
+      options: ["split:firstName,lastName", "drop"],
+      suggested: "split:firstName,lastName",
+    });
+    expect(d.labels.drop).toBe("Dropped (deletes its data)");
+    expect(d.labels["split:firstName,lastName"]).toMatch(/Split into firstName and lastName.*\(suggested\)/);
+    expect(d.splitDefaults!["split:firstName,lastName"].firstName).toContain("split_part");
+    expect(d.sqlHint).toBeUndefined();
+  });
+});
diff --git a/test/lib/verify/review.test.ts b/test/lib/verify/review.test.ts
new file mode 100644
index 0000000..2170b72
--- /dev/null
+++ b/test/lib/verify/review.test.ts
@@ -0,0 +1,156 @@
+import { expect, describe, test } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import { reviewMigration } from "../../../src/lib/verify/review";
+import { dataLoss, unaccepted } from "../../../src/lib/verify";
+
+// Each fixture is what `apso migrate generate` (TypeORM migration:generate)
+// wrote for one .apsorc change to a Company/Contact schema.
+const fixture = (name: string) =>
+  fs.readFileSync(path.join(__dirname, "../../fixtures/typeorm-migrations", `${name}.ts`), "utf8");
+const codes = (name: string) =>
+  reviewMigration(fixture(name)).map((f) => `${f.code} ${f.table}.${f.column}`);
+
+describe("reviewMigration on TypeORM output", () => {
+  test("a field rename TypeORM already emits as RENAME COLUMN is clean", () => {
+    expect(codes("rename-field")).toEqual([]);
+  });
+
+  test("a type change done as DROP + ADD", () => {
+    expect(codes("type-change")).toEqual(["TYPE_CHANGE_DROPS_DATA contact.score"]);
+  });
+
+  test("an enum swap that removes a value", () => {
+    const [f] = reviewMigration(fixture("enum-replace"));
+    expect(f.code).toBe("ENUM_VALUES_REMOVED");
+    expect(`${f.table}.${f.column}`).toBe("contact.status");
+    expect(f.message).toContain("'archived'");
+    const mapped = fixture("enum-replace").replace(
+      `USING "status"::"text"::"public"."contact_status_enum"`,
+      `USING (CASE "status"::text WHEN 'archived' THEN 'closed' ELSE "status"::text END)::"public"."contact_status_enum"`
+    );
+    expect(reviewMigration(mapped)).toEqual([]);
+  });
+
+  test("a required enum field backfilled by its default", () => {
+    expect(codes("required-field")).toEqual(["DEFAULT_BACKFILLS_ROWS company.region"]);
+  });
+
+  test("an entity rename that creates an empty table", () => {
+    expect(codes("rename-entity")).toEqual(["FOREIGN_KEY_TO_NEW_TABLE contact.organizationId"]);
+  });
+});
+
+const migration = (...up: string[]) =>
+  `public async up(queryRunner) {\n${up.map((q) => `await queryRunner.query(\`${q}\`);`).join("\n")}\n}\npublic async down(queryRunner) {}`;
+
+describe("reviewMigration rules", () => {
+  test("a dropped column with another added is a possible rename", () => {
+    const f = reviewMigration(
+      migration(`ALTER TABLE "contact" DROP COLUMN "phone"`, `ALTER TABLE "contact" ADD "mobile" integer`)
+    );
+    expect(f.map((x) => x.code)).toEqual(["POSSIBLE_RENAME"]);
+  });
+
+  test("drops, NOT NULL without default, SET NOT NULL, unique and casts on existing tables", () => {
+    const f = reviewMigration(
+      migration(
+        `ALTER TABLE "company" DROP COLUMN "notes"`,
+        `DROP TABLE "legacy"`,
+        `ALTER TABLE "contact" ADD "email" text NOT NULL`,
+        `ALTER TABLE "contact" ALTER COLUMN "phone" SET NOT NULL`,
+        `CREATE UNIQUE INDEX "IDX_1" ON "contact" ("email") `,
+        `ALTER TABLE "contact" ADD CONSTRAINT "UQ_1" UNIQUE ("phone")`,
+        `ALTER TABLE "contact" ALTER COLUMN "age" TYPE integer USING "age"::integer`
+      )
+    );
+    expect(f.map((x) => x.code)).toEqual([
+      "DROPS_COLUMN",
+      "DROPS_TABLE",
+      "NOT_NULL_WITHOUT_BACKFILL",
+      "SET_NOT_NULL",
+      "UNIQUE_ON_EXISTING_ROWS",
+      "UNIQUE_ON_EXISTING_ROWS",
+      "TYPE_CAST",
+    ]);
+  });
+
+  test("a drop or SET NOT NULL after the data is copied or backfilled is clean", () => {
+    expect(
+      reviewMigration(
+        migration(
+          `ALTER TABLE "contact" ADD "firstName" text`,
+          `UPDATE "contact" SET "firstName" = split_part("fullName", ' ', 1)`,
+          `ALTER TABLE "contact" ALTER COLUMN "firstName" SET NOT NULL`,
+          `ALTER TABLE "contact" DROP COLUMN "fullName"`
+        )
+      )
+    ).toEqual([]);
+  });
+
+  test("statements on a table the migration creates are safe", () => {
+    expect(
+      reviewMigration(
+        migration(
+          `CREATE TABLE "note" ("id" SERIAL NOT NULL, CONSTRAINT "PK_1" PRIMARY KEY ("id"))`,
+          `ALTER TABLE "note" ADD "body" text NOT NULL`,
+          `CREATE UNIQUE INDEX "IDX_2" ON "note" ("body") `
+        )
+      )
+    ).toEqual([]);
+  });
+});
+
+describe("dataLoss", () => {
+  const before = {
+    company: { rows: 2, values: { id: 2, name: 2 } },
+    contact: { rows: 4, values: { id: 4, phone: 3, score: 4 } },
+  };
+
+  test("follows renamed tables and columns", () => {
+    const after = {
+      organization: { rows: 2, values: { id: 2, name: 2 } },
+      contact: { rows: 4, values: { id: 4, mobilePhone: 3, score: 4 } },
+    };
+    const sql = `ALTER TABLE "company" RENAME TO "organization"; ALTER TABLE "contact" RENAME COLUMN "phone" TO "mobilePhone"`;
+    expect(dataLoss(before, after, sql)).toEqual([]);
+  });
+
+  test("reports lost rows, tables and values", () => {
+    const after = { contact: { rows: 3, values: { id: 3, phone: 3, score: 0 } } };
+    expect(dataLoss(before, after, "")).toEqual([
+      "table company: all 2 rows",
+      "table contact: 1 of 4 rows",
+      "contact.id: 1 of 4 values",
+      "contact.score: 4 of 4 values",
+    ]);
+  });
+
+  test("data moved to another table or a join table is not lost", () => {
+    const seeded = {
+      contact: {
+        rows: 3,
+        values: { id: 3, phone: 2, companyId: 3 },
+        distinct: { id: ["1", "2", "3"], phone: ["555-01", "555-02"], companyId: ["1", "2"] },
+      },
+    };
+    const after = {
+      contact: { rows: 3, values: { id: 3 }, distinct: { id: ["1", "2", "3"] } },
+      "phone_number": { rows: 2, values: { number: 2 }, distinct: { number: ["555-01", "555-02"] } },
+      "contact_companies_company": { rows: 3, values: { companyId: 3 }, distinct: { companyId: ["1", "2"] } },
+    };
+    expect(dataLoss(seeded, after, "")).toEqual([]);
+    const dropped = { ...after, "phone_number": { rows: 1, values: { number: 1 }, distinct: { number: ["555-01"] } } };
+    expect(dataLoss(seeded, dropped, "")).toEqual(["contact.phone: 2 of 2 values"]);
+    const company = { rows: 2, values: { id: 2 }, distinct: { id: ["1", "2"] } };
+    const emptyJoin = { contact: after.contact, company, "contact_companies_company": { rows: 0, values: { companyId: 0 }, distinct: { companyId: [] } } };
+    expect(dataLoss({ ...seeded, company }, { ...emptyJoin, "phone_number": after.phone_number }, "")).toEqual([
+      "contact.companyId: 3 of 3 values",
+    ]);
+  });
+
+  test("accepted losses are named by table or column", () => {
+    const lost = ["table legacy: all 2 rows", "contact.fullName: 4 of 4 values", "contact.score: 1 of 4 values"];
+    expect(unaccepted(lost, ["legacy", "contact.fullName"])).toEqual(["contact.score: 1 of 4 values"]);
+  });
+});