@prisma-next/cli 0.5.0-dev.24 → 0.5.0-dev.26

package/dist/migration-cli.d.mts

@@ -1,4 +1,5 @@
 import { Migration } from "@prisma-next/migration-tools/migration";
+import { Writable } from "node:stream";
 
 //#region src/migration-cli.d.ts
 
@@ -18,6 +19,20 @@ import { Migration } from "@prisma-next/migration-tools/migration";
  * point for additional construction arguments.
  */
 type MigrationConstructor = new (...args: any[]) => Migration;
+/**
+ * Stream surface accepted by `MigrationCLI.run`'s `options.stdout` /
+ * `options.stderr`. Aliases node's `Writable` because clipanion's
+ * `BaseContext.stdout`/`stderr` are typed as `Writable`, and the CLI
+ * forwards the injected streams into clipanion's context.
+ *
+ * `process.stdout` and `process.stderr` are `Writable`-shaped, so the
+ * default-fallback path remains a no-op for existing two-argument
+ * callers like `MigrationCLI.run(import.meta.url, MyMigration)`.
+ *
+ * Tests inject a `Writable` subclass that captures chunks for
+ * assertions.
+ */
+type MigrationCliWritable = Writable;
 /**
  * The CLI surface invoked by an authored `migration.ts` file. Exposed as
  * a class with a static `run` method (rather than a free function) to
@@ -32,19 +47,34 @@ type MigrationConstructor = new (...args: any[]) => Migration;
  */
 declare class MigrationCLI {
   /**
-   * Orchestrates a class-flow `migration.ts` script run. Awaitable:
-   * callers may `await MigrationCLI.run(...)` to surface async failures
-   * from config loading, but the typical usage pattern (top-level call
-   * after the class definition) does not require awaiting because
-   * node's module evaluation keeps the promise alive until completion.
+   * Orchestrates a class-flow `migration.ts` script run.
+   *
+   * The third argument is the in-process testability surface: callers
+   * (and tests) may inject `argv`, `stdout`, and `stderr` instead of
+   * relying on `process.argv` / `process.stdout` / `process.stderr`.
+   * Each option defaults to its `process` global when omitted, so
+   * existing two-argument call sites
+   * (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to
+   * compile and behave identically.
+   *
+   * Returns the exit code so the caller can branch on it. Also writes
+   * the same code to `process.exitCode` so script-style callers that
+   * don't await the return value still surface a non-zero exit when
+   * something fails.
    *
-   * Any throwable inside this function must surface through the internal
-   * try/catch — script callers do not await, so an unhandled rejection
-   * would silently exit 0. Treat the try/catch as load-bearing for the
-   * no-await usage pattern.
+   * Exit codes:
+   * - 0 — success, or `--help`, or imported-not-entrypoint no-op.
+   * - 1 — runtime/orchestration error (config not found, target
+   *   mismatch, etc.).
+   * - 2 — usage error (unknown flag, malformed `--config`). Aligns
+   *   with `docs/CLI Style Guide.md` § Exit Codes.
    */
-  static run(importMetaUrl: string, MigrationClass: MigrationConstructor): Promise<void>;
+  static run(importMetaUrl: string, MigrationClass: MigrationConstructor, options?: {
+    readonly argv?: readonly string[];
+    readonly stdout?: MigrationCliWritable;
+    readonly stderr?: MigrationCliWritable;
+  }): Promise<number>;
 }
 //#endregion
-export { MigrationCLI, MigrationConstructor };
+export { MigrationCLI, MigrationCliWritable, MigrationConstructor };
 //# sourceMappingURL=migration-cli.d.mts.map

package/dist/migration-cli.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-cli.d.mts","names":[],"sources":["../src/migration-cli.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;KAsEY,oBAAA,2BAA+C;;;;;;;;;;;;;cAiE9C,YAAA;;;;;;;;;;;;;oDAa6C,uBAAuB"}
+{"version":3,"file":"migration-cli.d.mts","names":[],"sources":["../src/migration-cli.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;KA6EY,oBAAA,2BAA+C;;;;;;;;;;;;;;KAe/C,oBAAA,GAAuB;;;;;;;;;;;;;cAuEtB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;oDA0BO;;sBAGI;sBACA;MAEnB"}

package/dist/migration-cli.mjs

@@ -1,12 +1,13 @@
 import { t as loadConfig } from "./config-loader-ih8ViDb_.mjs";
-import { CliStructuredError, errorMigrationCliInvalidConfigArg } from "@prisma-next/errors/control";
+import { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from "@prisma-next/errors/control";
 import { dirname, join } from "pathe";
 import { createControlStack } from "@prisma-next/framework-components/control";
 import { errorMigrationTargetMismatch } from "@prisma-next/errors/migration";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { MigrationToolsError, errorInvalidJson } from "@prisma-next/migration-tools/errors";
 import { fileURLToPath } from "node:url";
-import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from "@prisma-next/migration-tools/migration";
+import { buildMigrationArtifacts } from "@prisma-next/migration-tools/migration";
+import { Cli, Command, Option, UsageError } from "clipanion";
 
 //#region src/migration-cli.ts
 /**
@@ -26,7 +27,8 @@ import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from
 * entrypoint (`node migration.ts`), the CLI:
 *
 * 1. Detects whether the file is the direct entrypoint (no-op when imported).
-* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).
+* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via
+*    [clipanion](https://github.com/arcanis/clipanion).
 * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`
 *    the CLI commands use, walking up from the migration file's directory.
 * 4. Probe-instantiates the migration class without a stack so it can read
@@ -45,44 +47,62 @@ import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from
 * on-disk persistence. `@prisma-next/migration-tools` owns the pure
 * conversion from a `Migration` instance to artifact strings; `Migration`
 * stays a pure abstract class.
+*
+* Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`
+* for its in-process testability and runtime-agnostic execution surface; see
+* `docs/architecture docs/research/commander-friction-points.md` for the
+* evaluation rubric and the durable rationale that drove the choice).
 */
 /**
-* Parse the subset of `process.argv` that `MigrationCLI.run` cares about.
-* Recognised flags: `--help`, `--dry-run`, `--config <path>` /
-* `--config=<path>`. Unknown flags are ignored to keep the surface
-* forgiving for ad-hoc tooling that wraps a migration file.
-*
-* Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when
-* `--config` is missing its path argument or is followed by another flag
-* (e.g. `--config --dry-run`); silently consuming the next flag would
-* either drop dry-run handling or serialize against the wrong project.
+* Flags exposed by the migration-file CLI.
 *
-* NOTE: this hand-rolled parser is a known wart, tracked separately by
-* TML-2318 ("Migration CLI: replace handrolled arg parser with shared
-* CLI library"). Until that lands the surface is intentionally tiny.
+* Must stay in sync with the `Option` declarations on
+* `MigrationFileCommand` below. This list is rendered in the
+* `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,
+* so order matters for user-visible output (declaration order is the
+* order users see when they run `--help`).
+*/
+const KNOWN_FLAGS = [
+	"--help",
+	"--dry-run",
+	"--config"
+];
+/**
+* The clipanion command that owns the migration-file CLI's option
+* declarations. The class is internal — `MigrationCLI.run` is the
+* stable public surface. Adding a flag here automatically updates
+* `--help` rendering and the `KNOWN_FLAGS` list (the latter must be
+* updated in tandem).
 */
-function parseArgs(argv) {
-	let help = false;
-	let dryRun = false;
-	let configPath;
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === "--help" || arg === "-h") help = true;
-		else if (arg === "--dry-run") dryRun = true;
-		else if (arg === "--config") {
-			const next = argv[i + 1];
-			if (next === void 0) throw errorMigrationCliInvalidConfigArg();
-			if (next.startsWith("-")) throw errorMigrationCliInvalidConfigArg({ nextToken: next });
-			configPath = next;
-			i++;
-		} else if (arg.startsWith("--config=")) configPath = arg.slice(9);
+var MigrationFileCommand = class extends Command {
+	static paths = [Command.Default];
+	static usage = Command.Usage({
+		description: "Self-emit ops.json and migration.json from a class-flow migration",
+		details: `
+      Loads the project's prisma-next.config.ts, assembles a ControlStack
+      from the configured target/adapter/extensions, and serializes the
+      migration's operations + metadata next to this file.
+    `,
+		examples: [
+			["Self-emit ops.json + migration.json next to migration.ts", "$0"],
+			["Preview without writing files", "$0 --dry-run"],
+			["Use a non-default config path", "$0 --config ./custom.config.ts"]
+		]
+	});
+	dryRun = Option.Boolean("--dry-run", false, { description: "Print operations to stdout without writing files" });
+	config = Option.String("--config", { description: "Path to prisma-next.config.ts" });
+	/**
+	* Unused: orchestration runs inside `MigrationCLI.run` so error
+	* routing stays under our control (clipanion's `cli.run` writes
+	* error output to `context.stdout`, but our contract requires
+	* structured errors on stderr). `cli.process` is used to parse
+	* argv into a populated `MigrationFileCommand` instance whose
+	* fields drive the orchestration directly.
+	*/
+	async execute() {
+		return 0;
 	}
-	return {
-		help,
-		dryRun,
-		configPath
-	};
-}
+};
 /**
 * The CLI surface invoked by an authored `migration.ts` file. Exposed as
 * a class with a static `run` method (rather than a free function) to
@@ -97,41 +117,211 @@ function parseArgs(argv) {
 */
 var MigrationCLI = class {
 	/**
-	* Orchestrates a class-flow `migration.ts` script run. Awaitable:
-	* callers may `await MigrationCLI.run(...)` to surface async failures
-	* from config loading, but the typical usage pattern (top-level call
-	* after the class definition) does not require awaiting because
-	* node's module evaluation keeps the promise alive until completion.
+	* Orchestrates a class-flow `migration.ts` script run.
+	*
+	* The third argument is the in-process testability surface: callers
+	* (and tests) may inject `argv`, `stdout`, and `stderr` instead of
+	* relying on `process.argv` / `process.stdout` / `process.stderr`.
+	* Each option defaults to its `process` global when omitted, so
+	* existing two-argument call sites
+	* (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to
+	* compile and behave identically.
 	*
-	* Any throwable inside this function must surface through the internal
-	* try/catch — script callers do not await, so an unhandled rejection
-	* would silently exit 0. Treat the try/catch as load-bearing for the
-	* no-await usage pattern.
+	* Returns the exit code so the caller can branch on it. Also writes
+	* the same code to `process.exitCode` so script-style callers that
+	* don't await the return value still surface a non-zero exit when
+	* something fails.
+	*
+	* Exit codes:
+	* - 0 — success, or `--help`, or imported-not-entrypoint no-op.
+	* - 1 — runtime/orchestration error (config not found, target
+	*   mismatch, etc.).
+	* - 2 — usage error (unknown flag, malformed `--config`). Aligns
+	*   with `docs/CLI Style Guide.md` § Exit Codes.
 	*/
-	static async run(importMetaUrl, MigrationClass) {
-		if (!importMetaUrl) return;
-		if (!isDirectEntrypoint(importMetaUrl)) return;
-		try {
-			const args = parseArgs(process.argv.slice(2));
-			if (args.help) {
-				printMigrationHelp();
-				return;
+	static async run(importMetaUrl, MigrationClass, options = {}) {
+		if (!importMetaUrl) return 0;
+		const argv = options.argv ?? process.argv;
+		const stdout = options.stdout ?? process.stdout;
+		const stderr = options.stderr ?? process.stderr;
+		if (!isDirectEntrypoint(importMetaUrl, argv)) return 0;
+		const exitCode = await orchestrate(importMetaUrl, MigrationClass, {
+			argv,
+			stdout,
+			stderr
+		});
+		if (exitCode !== 0 || !process.exitCode) process.exitCode = exitCode;
+		return exitCode;
+	}
+};
+/**
+* Argv-aware variant of the entrypoint guard. The shared
+* `@prisma-next/migration-tools` helper of the same name reads
+* `process.argv[1]` directly, which doesn't compose with the new
+* in-process testability surface (tests inject `argv` without mutating
+* the process global). Inlined here so the migration-file CLI's check
+* follows the injected `argv[1]` consistently.
+*/
+function isDirectEntrypoint(importMetaUrl, argv) {
+	const argv1 = argv[1];
+	if (!argv1) return false;
+	try {
+		return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);
+	} catch {
+		return false;
+	}
+}
+/**
+* Argv-and-stream-driven orchestration body. Pulled out of the static
+* method so the entrypoint guard / process-default plumbing stays
+* separate from the parse + load + serialize steps.
+*/
+async function orchestrate(importMetaUrl, MigrationClass, ctx) {
+	const cli = Cli.from([MigrationFileCommand], {
+		binaryName: "migration.ts",
+		binaryLabel: "Migration file CLI"
+	});
+	const input = ctx.argv.slice(2);
+	const configError = detectInvalidConfig(input);
+	if (configError) {
+		writeStructuredError(ctx.stderr, configError);
+		return 2;
+	}
+	let parsed;
+	try {
+		const command = cli.process({
+			input: [...input],
+			context: {
+				stdout: ctx.stdout,
+				stderr: ctx.stderr
 			}
-			const migrationDir = dirname(fileURLToPath(importMetaUrl));
-			const config = await loadConfig(args.configPath);
-			const probe = new MigrationClass();
-			if (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({
-				migrationTargetId: probe.targetId,
-				configTargetId: config.target.targetId
-			});
-			serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, args.dryRun);
-		} catch (err) {
-			if (CliStructuredError.is(err) || MigrationToolsError.is(err)) process.stderr.write(`${err.message}: ${err.why}\n`);
-			else process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
-			process.exitCode = 1;
+		});
+		if (!(command instanceof MigrationFileCommand)) {
+			ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));
+			return 0;
 		}
+		parsed = command;
+	} catch (err) {
+		return renderParseError(err, input, ctx.stderr);
 	}
-};
+	if (parsed.help) {
+		ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));
+		return 0;
+	}
+	try {
+		await runMigration(importMetaUrl, MigrationClass, parsed, ctx);
+		return 0;
+	} catch (err) {
+		if (CliStructuredError.is(err)) writeStructuredError(ctx.stderr, err);
+		else if (MigrationToolsError.is(err)) {
+			const fix = err.fix ? `\n${err.fix}` : "";
+			ctx.stderr.write(`${err.code}: ${err.message}\n${err.why}${fix}\n`);
+		} else ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+		return 1;
+	}
+}
+/**
+* Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`
+* contains a malformed `--config`:
+*
+* - `--config` as the last token (no value follows).
+* - `--config <flag>` where `<flag>` starts with `-` (silently
+*   consuming the next flag would either drop the flag or serialize
+*   against the wrong project).
+* - `--config <empty>` where the value is the empty string. Shells
+*   expand `--config ""` (or `--config "$UNSET_VAR"`) into a real
+*   empty argv token; treating that as a usage error here surfaces
+*   `PN-CLI-4012` instead of a less actionable loader error on an
+*   empty path.
+* - `--config=` (the equals form with an empty value). Same shape as
+*   the empty-string case above; the user expressed intent to override
+*   the config path but the override is empty.
+*
+* `--config=<value>` and `--config <value>` with a non-empty value are
+* both valid (and the equals form's value is allowed to start with
+* `-` — the `=` makes the binding explicit).
+*/
+function detectInvalidConfig(input) {
+	for (let i = 0; i < input.length; i++) {
+		const token = input[i];
+		if (token === "--config") {
+			const next = input[i + 1];
+			if (next === void 0 || next === "") return errorMigrationCliInvalidConfigArg();
+			if (next.startsWith("-")) return errorMigrationCliInvalidConfigArg({ nextToken: next });
+			continue;
+		}
+		if (token === "--config=") return errorMigrationCliInvalidConfigArg();
+	}
+	return null;
+}
+/**
+* Translate clipanion's parse-time errors into the project's structured
+* error envelopes.
+*
+* - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and
+*   the bare-trailing `--config` case (where arity-1 needs a value but
+*   none was supplied). Distinguished by inspecting the input array.
+* - `UsageError` covers schema/validator failures from typanion. None
+*   of the migration-file CLI's options have validators today, but we
+*   still translate it as a usage error (exit 2) for forward-compat.
+* - Anything else re-throws — caller's outer catch will surface it as
+*   exit 1 (runtime error).
+*/
+function renderParseError(err, input, stderr) {
+	if (isUnknownSyntaxError(err)) {
+		writeStructuredError(stderr, errorMigrationCliUnknownFlag({
+			flag: findOffendingFlag(input),
+			knownFlags: KNOWN_FLAGS
+		}));
+		return 2;
+	}
+	if (err instanceof UsageError) {
+		writeStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));
+		return 2;
+	}
+	throw err;
+}
+/**
+* Duck-type check for clipanion's `UnknownSyntaxError`: the class is
+* thrown by the parser but is not re-exported from the package's main
+* entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).
+* Identified by `name === 'UnknownSyntaxError'` and the
+* `clipanion.type === 'none'` discriminator that clipanion's
+* `ErrorWithMeta` interface guarantees.
+*/
+function isUnknownSyntaxError(err) {
+	if (!(err instanceof Error) || err.name !== "UnknownSyntaxError") return false;
+	const meta = err.clipanion;
+	return typeof meta === "object" && meta !== null && meta.type === "none";
+}
+/**
+* Best-effort: pull the first input token that doesn't match a known
+* flag. Falls back to the first token when we can't pinpoint it. The
+* returned name is rendered into the user-visible PN-CLI-4013 envelope
+* (`Unknown flag \`<name>\``) and round-tripped via `meta.flag` so
+* agent consumers can render their own "did you mean" suggestions.
+*/
+function findOffendingFlag(input) {
+	for (const token of input) {
+		if (!token.startsWith("-")) continue;
+		const head = token.split("=", 1)[0] ?? token;
+		if (!KNOWN_FLAGS.includes(head) && head !== "-h") return head;
+	}
+	return input[0] ?? "";
+}
+/**
+* Write a `CliStructuredError` envelope to the given stream. Format
+* matches the legacy hand-rolled writer (`message: why`) so the rest of
+* the project's error rendering stays consistent across surfaces. The
+* full PN code (`PN-<domain>-<code>`) is included so consumers can
+* grep for stable identifiers.
+*/
+function writeStructuredError(stream, err) {
+	const envelope = err.toEnvelope();
+	const why = envelope.why ?? envelope.summary;
+	const fix = envelope.fix ? `\n${envelope.fix}` : "";
+	stream.write(`${envelope.code}: ${envelope.summary}\n${why}${fix}\n`);
+}
 /**
 * Read a previously-scaffolded `migration.json` from disk, returning
 * `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`
@@ -180,18 +370,37 @@ function readExistingMetadata(metadataPath) {
 * legitimate site for combining config loading, stack assembly, and
 * filesystem persistence.
 */
-function serializeMigrationToDisk(instance, migrationDir, dryRun) {
+function serializeMigrationToDisk(instance, migrationDir, dryRun, stdout) {
 	const metadataPath = join(migrationDir, "migration.json");
 	const { opsJson, metadataJson } = buildMigrationArtifacts(instance, readExistingMetadata(metadataPath));
 	if (dryRun) {
-		process.stdout.write(`--- migration.json ---\n${metadataJson}\n`);
-		process.stdout.write("--- ops.json ---\n");
-		process.stdout.write(`${opsJson}\n`);
+		stdout.write(`--- migration.json ---\n${metadataJson}\n`);
+		stdout.write("--- ops.json ---\n");
+		stdout.write(`${opsJson}\n`);
 		return;
 	}
 	writeFileSync(join(migrationDir, "ops.json"), opsJson);
 	writeFileSync(metadataPath, metadataJson);
-	process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+	stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+}
+/**
+* Inner orchestration: load config, probe-construct the migration,
+* verify target, assemble the stack, construct with the stack, persist.
+*
+* Throws `CliStructuredError` for known failure modes (config not
+* found, target mismatch); the outer `orchestrate` translates those to
+* exit 1.
+*/
+async function runMigration(importMetaUrl, MigrationClass, parsed, ctx) {
+	const migrationDir = dirname(fileURLToPath(importMetaUrl));
+	const config = await loadConfig(parsed.config);
+	const probe = new MigrationClass();
+	if (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({
+		migrationTargetId: probe.targetId,
+		configTargetId: config.target.targetId
+	});
+	serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, parsed.dryRun, ctx.stdout);
+	ctx.stderr;
 }
 
 //#endregion

package/dist/migration-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration-cli.mjs","names":["configPath: string | undefined","raw: string"],"sources":["../src/migration-cli.ts"],"sourcesContent":["/**\n * The migration-file CLI interface: the actor invoked when the author runs\n * `node migration.ts` directly.\n *\n * Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n * apply-time runner is the thing `prisma-next migration apply` uses to\n * execute migration JSON ops against a database. `MigrationCLI` is the\n * tiny CLI surface owned by an authored `migration.ts` file: parse the\n * file's argv, load the project's `prisma-next.config.ts`, assemble a\n * `ControlStack`, instantiate the migration class, and serialize.\n *\n * The user authors a migration class, then calls\n * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n * after the class definition. When the file is invoked as a node\n * entrypoint (`node migration.ts`), the CLI:\n *\n * 1. Detects whether the file is the direct entrypoint (no-op when imported).\n * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).\n * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`\n *    the CLI commands use, walking up from the migration file's directory.\n * 4. Probe-instantiates the migration class without a stack so it can read\n *    `targetId` and verify it matches `config.target.targetId`\n *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter\n *    construction runs.\n * 5. Assembles a `ControlStack` from the loaded config descriptors and\n *    constructs the migration with that stack.\n * 6. Reads any previously-scaffolded `migration.json`, then calls\n *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to\n *    produce in-memory `ops.json` + `migration.json` content. Persists\n *    the result to disk (or prints in dry-run mode).\n *\n * File I/O lives here, in `@prisma-next/cli`: this is the only place\n * that legitimately combines config loading, stack assembly, and\n * on-disk persistence. `@prisma-next/migration-tools` owns the pure\n * conversion from a `Migration` instance to artifact strings; `Migration`\n * stays a pure abstract class.\n */\n\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport { CliStructuredError, errorMigrationCliInvalidConfigArg } from '@prisma-next/errors/control';\nimport { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';\nimport { createControlStack } from '@prisma-next/framework-components/control';\nimport { errorInvalidJson, MigrationToolsError } from '@prisma-next/migration-tools/errors';\nimport type { MigrationMetadata } from '@prisma-next/migration-tools/metadata';\nimport {\n  buildMigrationArtifacts,\n  isDirectEntrypoint,\n  type Migration,\n  printMigrationHelp,\n} from '@prisma-next/migration-tools/migration';\nimport { dirname, join } from 'pathe';\nimport { loadConfig } from './config-loader';\n\n/**\n * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses\n * accept an optional `ControlStack` in their constructor (each subclass\n * narrows the stack to its own family/target generics); the CLI always\n * passes one assembled from the loaded config. We use a rest-args `any[]`\n * constructor signature so that subclass constructors with narrower\n * parameter types remain assignable - constructor type compatibility in\n * TS is contravariant in the parameter, and a wider `unknown` parameter\n * on the alias side would reject any narrower subclass signature.\n *\n * The CLI only ever passes one argument (`new MigrationClass(stack)`);\n * the rest-arity is purely a type-compatibility concession for subclass\n * constructors that declare narrower parameter types, not an extension\n * point for additional construction arguments.\n */\n// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures\nexport type MigrationConstructor = new (...args: any[]) => Migration;\n\ninterface ParsedArgs {\n  readonly help: boolean;\n  readonly dryRun: boolean;\n  readonly configPath: string | undefined;\n}\n\n/**\n * Parse the subset of `process.argv` that `MigrationCLI.run` cares about.\n * Recognised flags: `--help`, `--dry-run`, `--config <path>` /\n * `--config=<path>`. Unknown flags are ignored to keep the surface\n * forgiving for ad-hoc tooling that wraps a migration file.\n *\n * Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when\n * `--config` is missing its path argument or is followed by another flag\n * (e.g. `--config --dry-run`); silently consuming the next flag would\n * either drop dry-run handling or serialize against the wrong project.\n *\n * NOTE: this hand-rolled parser is a known wart, tracked separately by\n * TML-2318 (\"Migration CLI: replace handrolled arg parser with shared\n * CLI library\"). Until that lands the surface is intentionally tiny.\n */\nfunction parseArgs(argv: readonly string[]): ParsedArgs {\n  let help = false;\n  let dryRun = false;\n  let configPath: string | undefined;\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i]!;\n    if (arg === '--help' || arg === '-h') {\n      help = true;\n    } else if (arg === '--dry-run') {\n      dryRun = true;\n    } else if (arg === '--config') {\n      const next = argv[i + 1];\n      if (next === undefined) {\n        throw errorMigrationCliInvalidConfigArg();\n      }\n      if (next.startsWith('-')) {\n        throw errorMigrationCliInvalidConfigArg({ nextToken: next });\n      }\n      configPath = next;\n      i++;\n    } else if (arg.startsWith('--config=')) {\n      configPath = arg.slice('--config='.length);\n    }\n  }\n\n  return { help, dryRun, configPath };\n}\n\n/**\n * The CLI surface invoked by an authored `migration.ts` file. Exposed as\n * a class with a static `run` method (rather than a free function) to\n * give the concept a stable identity in the ubiquitous language: this is\n * the \"migration-file CLI\", distinct from the apply-time runner that\n * executes migration JSON ops.\n *\n * Currently a single static method. Future surface (e.g. a programmatic\n * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n * land here without changing the import shape used by every authored\n * migration.\n */\n// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.\nexport class MigrationCLI {\n  /**\n   * Orchestrates a class-flow `migration.ts` script run. Awaitable:\n   * callers may `await MigrationCLI.run(...)` to surface async failures\n   * from config loading, but the typical usage pattern (top-level call\n   * after the class definition) does not require awaiting because\n   * node's module evaluation keeps the promise alive until completion.\n   *\n   * Any throwable inside this function must surface through the internal\n   * try/catch — script callers do not await, so an unhandled rejection\n   * would silently exit 0. Treat the try/catch as load-bearing for the\n   * no-await usage pattern.\n   */\n  static async run(importMetaUrl: string, MigrationClass: MigrationConstructor): Promise<void> {\n    if (!importMetaUrl) return;\n    if (!isDirectEntrypoint(importMetaUrl)) return;\n\n    try {\n      const args = parseArgs(process.argv.slice(2));\n\n      if (args.help) {\n        printMigrationHelp();\n        return;\n      }\n\n      const migrationFile = fileURLToPath(importMetaUrl);\n      const migrationDir = dirname(migrationFile);\n\n      const config = await loadConfig(args.configPath);\n\n      // Probe-instantiate without a stack so we can read `targetId` before\n      // any target-specific constructor side effects (e.g.\n      // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete\n      // subclasses are required to accept the no-arg form; the abstract\n      // `Migration` constructor declares `stack?` and target subclasses\n      // (Postgres, Mongo) propagate that optionality. This makes the\n      // target-mismatch guard fail fast with `PN-MIG-2006` before any\n      // stack-driven adapter construction begins, even if the wrong-target\n      // adapter's `create` would otherwise succeed and silently misshapen\n      // the stored adapter cast.\n      const probe = new MigrationClass();\n\n      if (probe.targetId !== config.target.targetId) {\n        throw errorMigrationTargetMismatch({\n          migrationTargetId: probe.targetId,\n          configTargetId: config.target.targetId,\n        });\n      }\n\n      const stack = createControlStack(config);\n      const instance = new MigrationClass(stack);\n\n      serializeMigrationToDisk(instance, migrationDir, args.dryRun);\n    } catch (err) {\n      if (CliStructuredError.is(err) || MigrationToolsError.is(err)) {\n        process.stderr.write(`${err.message}: ${err.why}\\n`);\n      } else {\n        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n      }\n      process.exitCode = 1;\n    }\n  }\n}\n\n/**\n * Read a previously-scaffolded `migration.json` from disk, returning\n * `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`\n * when the file is present but cannot be parsed as JSON. The CLI feeds\n * this into `buildMigrationArtifacts` so the pure builder can preserve\n * fields owned by `migration plan` (contract bookends, hints, labels,\n * `createdAt`) across re-emits.\n *\n * Author-time path: this loader still does not verify the manifest hash\n * or schema — that is the apply-time loader's job. Hash mismatch is the\n * *expected* outcome of a re-author (the developer's source changes\n * invalidate the prior hash by construction), and verification here\n * would block legitimate regenerations. Syntactic JSON-parse failure,\n * however, is now surfaced rather than swallowed: a malformed\n * `migration.json` indicates either a hand-edit gone wrong or partial\n * write, and silently rebuilding from `describe()` would discard the\n * user's on-disk content (preserved bookends, hints, labels,\n * `createdAt`) without any indication something was wrong on disk.\n * Apply-time consumers always route through the verifying\n * `readMigrationPackage` in `@prisma-next/migration-tools/io` instead.\n */\nfunction readExistingMetadata(metadataPath: string): Partial<MigrationMetadata> | null {\n  let raw: string;\n  try {\n    raw = readFileSync(metadataPath, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    return JSON.parse(raw) as Partial<MigrationMetadata>;\n  } catch (e) {\n    throw errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));\n  }\n}\n\n/**\n * Persist a migration instance's artifacts to `migrationDir`. In\n * `dryRun` mode the artifacts are printed to stdout (with the same\n * `--- migration.json --- / --- ops.json ---` framing the legacy\n * `serializeMigration` helper used) and no files are written. Otherwise\n * `ops.json` and `migration.json` are written next to `migration.ts` and\n * a confirmation line is printed.\n *\n * File I/O lives in the CLI rather than `@prisma-next/migration-tools`\n * so the migration-tools package stays focused on the pure\n * `Migration` → in-memory artifact conversion. The CLI is the only\n * legitimate site for combining config loading, stack assembly, and\n * filesystem persistence.\n */\nfunction serializeMigrationToDisk(\n  instance: Migration,\n  migrationDir: string,\n  dryRun: boolean,\n): void {\n  const metadataPath = join(migrationDir, 'migration.json');\n  const existing = readExistingMetadata(metadataPath);\n  const { opsJson, metadataJson } = buildMigrationArtifacts(instance, existing);\n\n  if (dryRun) {\n    process.stdout.write(`--- migration.json ---\\n${metadataJson}\\n`);\n    process.stdout.write('--- ops.json ---\\n');\n    process.stdout.write(`${opsJson}\\n`);\n    return;\n  }\n\n  writeFileSync(join(migrationDir, 'ops.json'), opsJson);\n  writeFileSync(metadataPath, metadataJson);\n\n  process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FA,SAAS,UAAU,MAAqC;CACtD,IAAI,OAAO;CACX,IAAI,SAAS;CACb,IAAIA;AAEJ,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;AACjB,MAAI,QAAQ,YAAY,QAAQ,KAC9B,QAAO;WACE,QAAQ,YACjB,UAAS;WACA,QAAQ,YAAY;GAC7B,MAAM,OAAO,KAAK,IAAI;AACtB,OAAI,SAAS,OACX,OAAM,mCAAmC;AAE3C,OAAI,KAAK,WAAW,IAAI,CACtB,OAAM,kCAAkC,EAAE,WAAW,MAAM,CAAC;AAE9D,gBAAa;AACb;aACS,IAAI,WAAW,YAAY,CACpC,cAAa,IAAI,MAAM,EAAmB;;AAI9C,QAAO;EAAE;EAAM;EAAQ;EAAY;;;;;;;;;;;;;;AAgBrC,IAAa,eAAb,MAA0B;;;;;;;;;;;;;CAaxB,aAAa,IAAI,eAAuB,gBAAqD;AAC3F,MAAI,CAAC,cAAe;AACpB,MAAI,CAAC,mBAAmB,cAAc,CAAE;AAExC,MAAI;GACF,MAAM,OAAO,UAAU,QAAQ,KAAK,MAAM,EAAE,CAAC;AAE7C,OAAI,KAAK,MAAM;AACb,wBAAoB;AACpB;;GAIF,MAAM,eAAe,QADC,cAAc,cAAc,CACP;GAE3C,MAAM,SAAS,MAAM,WAAW,KAAK,WAAW;GAYhD,MAAM,QAAQ,IAAI,gBAAgB;AAElC,OAAI,MAAM,aAAa,OAAO,OAAO,SACnC,OAAM,6BAA6B;IACjC,mBAAmB,MAAM;IACzB,gBAAgB,OAAO,OAAO;IAC/B,CAAC;AAMJ,4BAFiB,IAAI,eADP,mBAAmB,OAAO,CACE,EAEP,cAAc,KAAK,OAAO;WACtD,KAAK;AACZ,OAAI,mBAAmB,GAAG,IAAI,IAAI,oBAAoB,GAAG,IAAI,CAC3D,SAAQ,OAAO,MAAM,GAAG,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI;OAEpD,SAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,CAAC,IAAI;AAE/E,WAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;AA0BzB,SAAS,qBAAqB,cAAyD;CACrF,IAAIC;AACJ,KAAI;AACF,QAAM,aAAa,cAAc,QAAQ;SACnC;AACN,SAAO;;AAET,KAAI;AACF,SAAO,KAAK,MAAM,IAAI;UACf,GAAG;AACV,QAAM,iBAAiB,cAAc,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE,CAAC;;;;;;;;;;;;;;;;;AAkBpF,SAAS,yBACP,UACA,cACA,QACM;CACN,MAAM,eAAe,KAAK,cAAc,iBAAiB;CAEzD,MAAM,EAAE,SAAS,iBAAiB,wBAAwB,UADzC,qBAAqB,aAAa,CAC0B;AAE7E,KAAI,QAAQ;AACV,UAAQ,OAAO,MAAM,2BAA2B,aAAa,IAAI;AACjE,UAAQ,OAAO,MAAM,qBAAqB;AAC1C,UAAQ,OAAO,MAAM,GAAG,QAAQ,IAAI;AACpC;;AAGF,eAAc,KAAK,cAAc,WAAW,EAAE,QAAQ;AACtD,eAAc,cAAc,aAAa;AAEzC,SAAQ,OAAO,MAAM,sCAAsC,aAAa,IAAI"}
+{"version":3,"file":"migration-cli.mjs","names":["KNOWN_FLAGS: readonly string[]","parsed: MigrationFileCommand","raw: string"],"sources":["../src/migration-cli.ts"],"sourcesContent":["/**\n * The migration-file CLI interface: the actor invoked when the author runs\n * `node migration.ts` directly.\n *\n * Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n * apply-time runner is the thing `prisma-next migration apply` uses to\n * execute migration JSON ops against a database. `MigrationCLI` is the\n * tiny CLI surface owned by an authored `migration.ts` file: parse the\n * file's argv, load the project's `prisma-next.config.ts`, assemble a\n * `ControlStack`, instantiate the migration class, and serialize.\n *\n * The user authors a migration class, then calls\n * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n * after the class definition. When the file is invoked as a node\n * entrypoint (`node migration.ts`), the CLI:\n *\n * 1. Detects whether the file is the direct entrypoint (no-op when imported).\n * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via\n *    [clipanion](https://github.com/arcanis/clipanion).\n * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`\n *    the CLI commands use, walking up from the migration file's directory.\n * 4. Probe-instantiates the migration class without a stack so it can read\n *    `targetId` and verify it matches `config.target.targetId`\n *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter\n *    construction runs.\n * 5. Assembles a `ControlStack` from the loaded config descriptors and\n *    constructs the migration with that stack.\n * 6. Reads any previously-scaffolded `migration.json`, then calls\n *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to\n *    produce in-memory `ops.json` + `migration.json` content. Persists\n *    the result to disk (or prints in dry-run mode).\n *\n * File I/O lives here, in `@prisma-next/cli`: this is the only place\n * that legitimately combines config loading, stack assembly, and\n * on-disk persistence. `@prisma-next/migration-tools` owns the pure\n * conversion from a `Migration` instance to artifact strings; `Migration`\n * stays a pure abstract class.\n *\n * Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`\n * for its in-process testability and runtime-agnostic execution surface; see\n * `docs/architecture docs/research/commander-friction-points.md` for the\n * evaluation rubric and the durable rationale that drove the choice).\n */\n\nimport { readFileSync, realpathSync, writeFileSync } from 'node:fs';\nimport type { Writable } from 'node:stream';\nimport { fileURLToPath } from 'node:url';\nimport {\n  CliStructuredError,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n} from '@prisma-next/errors/control';\nimport { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';\nimport { createControlStack } from '@prisma-next/framework-components/control';\nimport { errorInvalidJson, MigrationToolsError } from '@prisma-next/migration-tools/errors';\nimport type { MigrationMetadata } from '@prisma-next/migration-tools/metadata';\nimport { buildMigrationArtifacts, type Migration } from '@prisma-next/migration-tools/migration';\nimport { Cli, Command, Option, UsageError } from 'clipanion';\nimport { dirname, join } from 'pathe';\nimport { loadConfig } from './config-loader';\n\n/**\n * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses\n * accept an optional `ControlStack` in their constructor (each subclass\n * narrows the stack to its own family/target generics); the CLI always\n * passes one assembled from the loaded config. We use a rest-args `any[]`\n * constructor signature so that subclass constructors with narrower\n * parameter types remain assignable - constructor type compatibility in\n * TS is contravariant in the parameter, and a wider `unknown` parameter\n * on the alias side would reject any narrower subclass signature.\n *\n * The CLI only ever passes one argument (`new MigrationClass(stack)`);\n * the rest-arity is purely a type-compatibility concession for subclass\n * constructors that declare narrower parameter types, not an extension\n * point for additional construction arguments.\n */\n// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures\nexport type MigrationConstructor = new (...args: any[]) => Migration;\n\n/**\n * Stream surface accepted by `MigrationCLI.run`'s `options.stdout` /\n * `options.stderr`. Aliases node's `Writable` because clipanion's\n * `BaseContext.stdout`/`stderr` are typed as `Writable`, and the CLI\n * forwards the injected streams into clipanion's context.\n *\n * `process.stdout` and `process.stderr` are `Writable`-shaped, so the\n * default-fallback path remains a no-op for existing two-argument\n * callers like `MigrationCLI.run(import.meta.url, MyMigration)`.\n *\n * Tests inject a `Writable` subclass that captures chunks for\n * assertions.\n */\nexport type MigrationCliWritable = Writable;\n\n/**\n * Flags exposed by the migration-file CLI.\n *\n * Must stay in sync with the `Option` declarations on\n * `MigrationFileCommand` below. This list is rendered in the\n * `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,\n * so order matters for user-visible output (declaration order is the\n * order users see when they run `--help`).\n */\nconst KNOWN_FLAGS: readonly string[] = ['--help', '--dry-run', '--config'];\n\n/**\n * The clipanion command that owns the migration-file CLI's option\n * declarations. The class is internal — `MigrationCLI.run` is the\n * stable public surface. Adding a flag here automatically updates\n * `--help` rendering and the `KNOWN_FLAGS` list (the latter must be\n * updated in tandem).\n */\nclass MigrationFileCommand extends Command {\n  static override paths = [Command.Default];\n\n  static override usage = Command.Usage({\n    description: 'Self-emit ops.json and migration.json from a class-flow migration',\n    details: `\n      Loads the project's prisma-next.config.ts, assembles a ControlStack\n      from the configured target/adapter/extensions, and serializes the\n      migration's operations + metadata next to this file.\n    `,\n    examples: [\n      ['Self-emit ops.json + migration.json next to migration.ts', '$0'],\n      ['Preview without writing files', '$0 --dry-run'],\n      ['Use a non-default config path', '$0 --config ./custom.config.ts'],\n    ],\n  });\n\n  dryRun = Option.Boolean('--dry-run', false, {\n    description: 'Print operations to stdout without writing files',\n  });\n\n  config = Option.String('--config', {\n    description: 'Path to prisma-next.config.ts',\n  });\n\n  /**\n   * Unused: orchestration runs inside `MigrationCLI.run` so error\n   * routing stays under our control (clipanion's `cli.run` writes\n   * error output to `context.stdout`, but our contract requires\n   * structured errors on stderr). `cli.process` is used to parse\n   * argv into a populated `MigrationFileCommand` instance whose\n   * fields drive the orchestration directly.\n   */\n  override async execute(): Promise<number> {\n    return 0;\n  }\n}\n\n/**\n * The CLI surface invoked by an authored `migration.ts` file. Exposed as\n * a class with a static `run` method (rather than a free function) to\n * give the concept a stable identity in the ubiquitous language: this is\n * the \"migration-file CLI\", distinct from the apply-time runner that\n * executes migration JSON ops.\n *\n * Currently a single static method. Future surface (e.g. a programmatic\n * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n * land here without changing the import shape used by every authored\n * migration.\n */\n// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.\nexport class MigrationCLI {\n  /**\n   * Orchestrates a class-flow `migration.ts` script run.\n   *\n   * The third argument is the in-process testability surface: callers\n   * (and tests) may inject `argv`, `stdout`, and `stderr` instead of\n   * relying on `process.argv` / `process.stdout` / `process.stderr`.\n   * Each option defaults to its `process` global when omitted, so\n   * existing two-argument call sites\n   * (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to\n   * compile and behave identically.\n   *\n   * Returns the exit code so the caller can branch on it. Also writes\n   * the same code to `process.exitCode` so script-style callers that\n   * don't await the return value still surface a non-zero exit when\n   * something fails.\n   *\n   * Exit codes:\n   * - 0 — success, or `--help`, or imported-not-entrypoint no-op.\n   * - 1 — runtime/orchestration error (config not found, target\n   *   mismatch, etc.).\n   * - 2 — usage error (unknown flag, malformed `--config`). Aligns\n   *   with `docs/CLI Style Guide.md` § Exit Codes.\n   */\n  static async run(\n    importMetaUrl: string,\n    MigrationClass: MigrationConstructor,\n    options: {\n      readonly argv?: readonly string[];\n      readonly stdout?: MigrationCliWritable;\n      readonly stderr?: MigrationCliWritable;\n    } = {},\n  ): Promise<number> {\n    if (!importMetaUrl) {\n      return 0;\n    }\n\n    const argv = options.argv ?? process.argv;\n    const stdout = options.stdout ?? process.stdout;\n    const stderr = options.stderr ?? process.stderr;\n\n    if (!isDirectEntrypoint(importMetaUrl, argv)) {\n      return 0;\n    }\n\n    const exitCode = await orchestrate(importMetaUrl, MigrationClass, {\n      argv,\n      stdout,\n      stderr,\n    });\n    // Preserve any pre-existing non-zero `process.exitCode` set by code\n    // running alongside `MigrationCLI.run` (an unhandled rejection\n    // upstream, an explicit `process.exitCode = N` from another\n    // module). Overwriting it with our success would mask the upstream\n    // failure for script-style callers that don't await the return\n    // value. Failures we return here are still surfaced — non-zero\n    // codes always win over the prior status — but successes never\n    // clear it.\n    if (exitCode !== 0 || !process.exitCode) {\n      process.exitCode = exitCode;\n    }\n    return exitCode;\n  }\n}\n\n/**\n * Argv-aware variant of the entrypoint guard. The shared\n * `@prisma-next/migration-tools` helper of the same name reads\n * `process.argv[1]` directly, which doesn't compose with the new\n * in-process testability surface (tests inject `argv` without mutating\n * the process global). Inlined here so the migration-file CLI's check\n * follows the injected `argv[1]` consistently.\n */\nfunction isDirectEntrypoint(importMetaUrl: string, argv: readonly string[]): boolean {\n  const argv1 = argv[1];\n  if (!argv1) {\n    return false;\n  }\n  try {\n    return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Argv-and-stream-driven orchestration body. Pulled out of the static\n * method so the entrypoint guard / process-default plumbing stays\n * separate from the parse + load + serialize steps.\n */\nasync function orchestrate(\n  importMetaUrl: string,\n  MigrationClass: MigrationConstructor,\n  ctx: {\n    readonly argv: readonly string[];\n    readonly stdout: MigrationCliWritable;\n    readonly stderr: MigrationCliWritable;\n  },\n): Promise<number> {\n  const cli = Cli.from([MigrationFileCommand], {\n    binaryName: 'migration.ts',\n    binaryLabel: 'Migration file CLI',\n  });\n\n  const input = ctx.argv.slice(2);\n\n  // Pre-scan for malformed `--config` (no value, or value-shaped-as-flag)\n  // before delegating to clipanion. The legacy parser surfaced both as\n  // `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`); pre-scanning\n  // here keeps that contract independent of how clipanion classifies\n  // the error internally (it variably throws `UnknownSyntaxError` or\n  // accepts the flag-shaped token as the value depending on what other\n  // options are registered).\n  const configError = detectInvalidConfig(input);\n  if (configError) {\n    writeStructuredError(ctx.stderr, configError);\n    return 2;\n  }\n\n  let parsed: MigrationFileCommand;\n  try {\n    const command = cli.process({\n      input: [...input],\n      context: { stdout: ctx.stdout, stderr: ctx.stderr },\n    });\n    if (!(command instanceof MigrationFileCommand)) {\n      // The only registered command class is `MigrationFileCommand`;\n      // any other concrete type indicates clipanion emitted its\n      // built-in `HelpCommand`. Render usage directly so we don't\n      // depend on calling `cli.run` (which routes errors to stdout —\n      // wrong stream for our contract).\n      ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n      return 0;\n    }\n    parsed = command;\n  } catch (err) {\n    return renderParseError(err, input, ctx.stderr);\n  }\n\n  if (parsed.help) {\n    ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n    return 0;\n  }\n\n  try {\n    await runMigration(importMetaUrl, MigrationClass, parsed, ctx);\n    return 0;\n  } catch (err) {\n    if (CliStructuredError.is(err)) {\n      writeStructuredError(ctx.stderr, err);\n    } else if (MigrationToolsError.is(err)) {\n      // Migration-tools errors (e.g. `errorInvalidJson` thrown by\n      // `readExistingMetadata` when migration.json is malformed) carry\n      // their own `code`/`why`/`fix` shape. Render them with the same\n      // visual structure as `CliStructuredError` so consumers grepping\n      // for `MIGRATION.<CODE>` see consistent output across surfaces.\n      const fix = err.fix ? `\\n${err.fix}` : '';\n      ctx.stderr.write(`${err.code}: ${err.message}\\n${err.why}${fix}\\n`);\n    } else {\n      ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n    }\n    return 1;\n  }\n}\n\n/**\n * Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`\n * contains a malformed `--config`:\n *\n * - `--config` as the last token (no value follows).\n * - `--config <flag>` where `<flag>` starts with `-` (silently\n *   consuming the next flag would either drop the flag or serialize\n *   against the wrong project).\n * - `--config <empty>` where the value is the empty string. Shells\n *   expand `--config \"\"` (or `--config \"$UNSET_VAR\"`) into a real\n *   empty argv token; treating that as a usage error here surfaces\n *   `PN-CLI-4012` instead of a less actionable loader error on an\n *   empty path.\n * - `--config=` (the equals form with an empty value). Same shape as\n *   the empty-string case above; the user expressed intent to override\n *   the config path but the override is empty.\n *\n * `--config=<value>` and `--config <value>` with a non-empty value are\n * both valid (and the equals form's value is allowed to start with\n * `-` — the `=` makes the binding explicit).\n */\nfunction detectInvalidConfig(input: readonly string[]): CliStructuredError | null {\n  for (let i = 0; i < input.length; i++) {\n    const token = input[i];\n    if (token === '--config') {\n      const next = input[i + 1];\n      if (next === undefined || next === '') {\n        return errorMigrationCliInvalidConfigArg();\n      }\n      if (next.startsWith('-')) {\n        return errorMigrationCliInvalidConfigArg({ nextToken: next });\n      }\n      continue;\n    }\n    if (token === '--config=') {\n      return errorMigrationCliInvalidConfigArg();\n    }\n  }\n  return null;\n}\n\n/**\n * Translate clipanion's parse-time errors into the project's structured\n * error envelopes.\n *\n * - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and\n *   the bare-trailing `--config` case (where arity-1 needs a value but\n *   none was supplied). Distinguished by inspecting the input array.\n * - `UsageError` covers schema/validator failures from typanion. None\n *   of the migration-file CLI's options have validators today, but we\n *   still translate it as a usage error (exit 2) for forward-compat.\n * - Anything else re-throws — caller's outer catch will surface it as\n *   exit 1 (runtime error).\n */\nfunction renderParseError(\n  err: unknown,\n  input: readonly string[],\n  stderr: MigrationCliWritable,\n): number {\n  if (isUnknownSyntaxError(err)) {\n    const flag = findOffendingFlag(input);\n    writeStructuredError(stderr, errorMigrationCliUnknownFlag({ flag, knownFlags: KNOWN_FLAGS }));\n    return 2;\n  }\n  if (err instanceof UsageError) {\n    // typanion validator failures and similar usage errors. None of\n    // the migration-file CLI's options have validators today, so this\n    // branch is forward-compat scaffolding — kept so that a future\n    // option declaration with a validator routes through the same PN\n    // envelope path rather than escaping as exit 1.\n    writeStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));\n    return 2;\n  }\n  throw err;\n}\n\n/**\n * Duck-type check for clipanion's `UnknownSyntaxError`: the class is\n * thrown by the parser but is not re-exported from the package's main\n * entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).\n * Identified by `name === 'UnknownSyntaxError'` and the\n * `clipanion.type === 'none'` discriminator that clipanion's\n * `ErrorWithMeta` interface guarantees.\n */\nfunction isUnknownSyntaxError(err: unknown): err is Error {\n  if (!(err instanceof Error) || err.name !== 'UnknownSyntaxError') {\n    return false;\n  }\n  // clipanion's `ErrorWithMeta` interface guarantees a `clipanion` field with\n  // a `type` discriminator on every error it throws. Read it via a structural\n  // shape rather than importing the class (it's not re-exported from the\n  // package main).\n  const meta = (err as { clipanion?: { type?: string } }).clipanion;\n  return typeof meta === 'object' && meta !== null && meta.type === 'none';\n}\n\n/**\n * Best-effort: pull the first input token that doesn't match a known\n * flag. Falls back to the first token when we can't pinpoint it. The\n * returned name is rendered into the user-visible PN-CLI-4013 envelope\n * (`Unknown flag \\`<name>\\``) and round-tripped via `meta.flag` so\n * agent consumers can render their own \"did you mean\" suggestions.\n */\nfunction findOffendingFlag(input: readonly string[]): string {\n  for (const token of input) {\n    if (!token.startsWith('-')) {\n      continue;\n    }\n    const head = token.split('=', 1)[0] ?? token;\n    if (!KNOWN_FLAGS.includes(head) && head !== '-h') {\n      return head;\n    }\n  }\n  return input[0] ?? '';\n}\n\n/**\n * Write a `CliStructuredError` envelope to the given stream. Format\n * matches the legacy hand-rolled writer (`message: why`) so the rest of\n * the project's error rendering stays consistent across surfaces. The\n * full PN code (`PN-<domain>-<code>`) is included so consumers can\n * grep for stable identifiers.\n */\nfunction writeStructuredError(stream: MigrationCliWritable, err: CliStructuredError): void {\n  const envelope = err.toEnvelope();\n  const why = envelope.why ?? envelope.summary;\n  const fix = envelope.fix ? `\\n${envelope.fix}` : '';\n  stream.write(`${envelope.code}: ${envelope.summary}\\n${why}${fix}\\n`);\n}\n\n/**\n * Read a previously-scaffolded `migration.json` from disk, returning\n * `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`\n * when the file is present but cannot be parsed as JSON. The CLI feeds\n * this into `buildMigrationArtifacts` so the pure builder can preserve\n * fields owned by `migration plan` (contract bookends, hints, labels,\n * `createdAt`) across re-emits.\n *\n * Author-time path: this loader still does not verify the manifest hash\n * or schema — that is the apply-time loader's job. Hash mismatch is the\n * *expected* outcome of a re-author (the developer's source changes\n * invalidate the prior hash by construction), and verification here\n * would block legitimate regenerations. Syntactic JSON-parse failure,\n * however, is now surfaced rather than swallowed: a malformed\n * `migration.json` indicates either a hand-edit gone wrong or partial\n * write, and silently rebuilding from `describe()` would discard the\n * user's on-disk content (preserved bookends, hints, labels,\n * `createdAt`) without any indication something was wrong on disk.\n * Apply-time consumers always route through the verifying\n * `readMigrationPackage` in `@prisma-next/migration-tools/io` instead.\n */\nfunction readExistingMetadata(metadataPath: string): Partial<MigrationMetadata> | null {\n  let raw: string;\n  try {\n    raw = readFileSync(metadataPath, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    return JSON.parse(raw) as Partial<MigrationMetadata>;\n  } catch (e) {\n    throw errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));\n  }\n}\n\n/**\n * Persist a migration instance's artifacts to `migrationDir`. In\n * `dryRun` mode the artifacts are printed to stdout (with the same\n * `--- migration.json --- / --- ops.json ---` framing the legacy\n * `serializeMigration` helper used) and no files are written. Otherwise\n * `ops.json` and `migration.json` are written next to `migration.ts` and\n * a confirmation line is printed.\n *\n * File I/O lives in the CLI rather than `@prisma-next/migration-tools`\n * so the migration-tools package stays focused on the pure\n * `Migration` → in-memory artifact conversion. The CLI is the only\n * legitimate site for combining config loading, stack assembly, and\n * filesystem persistence.\n */\nfunction serializeMigrationToDisk(\n  instance: Migration,\n  migrationDir: string,\n  dryRun: boolean,\n  stdout: MigrationCliWritable,\n): void {\n  const metadataPath = join(migrationDir, 'migration.json');\n  const existing = readExistingMetadata(metadataPath);\n  const { opsJson, metadataJson } = buildMigrationArtifacts(instance, existing);\n\n  if (dryRun) {\n    stdout.write(`--- migration.json ---\\n${metadataJson}\\n`);\n    stdout.write('--- ops.json ---\\n');\n    stdout.write(`${opsJson}\\n`);\n    return;\n  }\n\n  writeFileSync(join(migrationDir, 'ops.json'), opsJson);\n  writeFileSync(metadataPath, metadataJson);\n\n  stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n\n/**\n * Inner orchestration: load config, probe-construct the migration,\n * verify target, assemble the stack, construct with the stack, persist.\n *\n * Throws `CliStructuredError` for known failure modes (config not\n * found, target mismatch); the outer `orchestrate` translates those to\n * exit 1.\n */\nasync function runMigration(\n  importMetaUrl: string,\n  MigrationClass: MigrationConstructor,\n  parsed: MigrationFileCommand,\n  ctx: {\n    readonly stdout: MigrationCliWritable;\n    readonly stderr: MigrationCliWritable;\n  },\n): Promise<void> {\n  const migrationFile = fileURLToPath(importMetaUrl);\n  const migrationDir = dirname(migrationFile);\n\n  const config = await loadConfig(parsed.config);\n\n  // Probe-instantiate without a stack so we can read `targetId` before\n  // any target-specific constructor side effects (e.g.\n  // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete\n  // subclasses are required to accept the no-arg form; the abstract\n  // `Migration` constructor declares `stack?` and target subclasses\n  // (Postgres, Mongo) propagate that optionality. This makes the\n  // target-mismatch guard fail fast with `PN-MIG-2006` before any\n  // stack-driven adapter construction begins, even if the wrong-target\n  // adapter's `create` would otherwise succeed and silently misshapen\n  // the stored adapter cast.\n  const probe = new MigrationClass();\n\n  if (probe.targetId !== config.target.targetId) {\n    throw errorMigrationTargetMismatch({\n      migrationTargetId: probe.targetId,\n      configTargetId: config.target.targetId,\n    });\n  }\n\n  const stack = createControlStack(config);\n  const instance = new MigrationClass(stack);\n\n  serializeMigrationToDisk(instance, migrationDir, parsed.dryRun, ctx.stdout);\n  void ctx.stderr;\n}\n"],"mappings":"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"}