@prisma/orm-target-mysql 0.0.0-stage → 8.0.0-rc.21

package/dist/runner-C4r6yEd1-BWQrxW9q.mjs

@@ -0,0 +1,1644 @@
+import { t as mysqlError } from "./errors-rvH_F2Yj-BQrO_--u.mjs";
+import { n as quoteIdentifier } from "./sql-utils-Db0IQO_B-PaULnfrE.mjs";
+import { t as CONTROL_TABLE_NAMES } from "./control-tables-CcQ77JE7-CxTQYoQJ.mjs";
+import { t as createTable } from "./ddl-DDmMHyA_-Bb8sXoS0.mjs";
+import { t as mysqlResolveDefault } from "./default-normalizer-BDUgHXUn-Xk7HQJuI.mjs";
+import { i as withMarkerLock } from "./marker-lock-CmGvN4hw-Com29AtQ.mjs";
+import { dataTypeParams } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, PrimaryKeyConstraint, UniqueConstraint, opaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
+import { isSqlDataType, renderSqlTypeName } from "@prisma/orm-family-sql/contract/data-type";
+import { contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, diffSchemas, expectAbsent, expectPresent, failedPostcheckWhy, failedPrecheckWhy, issueOutcome, migrationRunnerFailure, orderIssuesByDependencies, schemaCheckWhy, withDatabaseUnchanged, withFailingSpace } from "@prisma/orm-framework/components/control";
+import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma/orm-framework/components/ir";
+import { NO_RENAMED_ORIGINS, contractToSchemaIR, createSqlTextSources, plannerFailure, runnerFailure, runnerSuccess, sqlTypeLookupsOf, subjectsOfCalls } from "@prisma/orm-family-sql/family/control";
+import { RelationalSchemaNodeKind, SqlSchemaIR, sqlColumnTypesEqual } from "@prisma/orm-family-sql/schema-ir/types";
+import { notOk, ok, okVoid } from "@prisma/orm-framework/utils/result";
+import { TsExpression, jsonToTsSource, renderImports } from "@prisma/orm-framework/ts-render";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { isThenable } from "@prisma/orm-framework/utils/promise";
+import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
+import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
+//#region ../../../3-targets/mysql/1-target/dist/runner-C4r6yEd1.mjs
+/**
+* The schema IR a contract describes on MySQL: one flat tree of tables, each column typed by the data type its codec represents. A MySQL database holds no schemas, so foreign keys name no referenced schema, as introspection reports them.
+*/
+function mysqlContractToSchema(contract, types) {
+	return contractToSchemaIR(contract, {
+		annotationNamespace: "mysql",
+		resolveDefault: mysqlResolveDefault,
+		dataTypeLookup: types.dataTypeLookup,
+		codecLookup: types.codecLookup
+	});
+}
+/** The control policy of the table an issue is about. The tree is flat, so the table's name is the second segment of the issue's path. */
+function resolveControlPolicy(issue, contract) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return void 0;
+	for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+		const table = entityAt(contract.storage, {
+			namespaceId,
+			entityKind: "table",
+			entityName: tableName
+		});
+		if (table !== void 0) return table.control;
+	}
+}
+/** The full-tree diff `db verify` derives its verdict from: the contract's tree against the one introspection built. */
+function diffMysqlSchema(input) {
+	if (!(input.schema instanceof SqlSchemaIR)) throw mysqlError("CONTRACT.TARGET_MISMATCH", "The MySQL schema diff received a schema tree that MySQL introspection did not build.");
+	const expected = mysqlContractToSchema(input.contract, sqlTypeLookupsOf(input.frameworkComponents));
+	const actual = input.schema;
+	const namespacesWithTables = Object.values(input.contract.storage.namespaces).filter((ns) => Object.keys(ns.entries.table ?? {}).length > 0);
+	return {
+		issues: diffSchemas(expected, actual),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, input.contract),
+		namespacePairs: namespacesWithTables.map(() => ({ actual }))
+	};
+}
+/** The type DDL writes for a column node: the type it is stored as, with the parameters the contract writes, as MySQL reports it in `COLUMN_TYPE`. */
+function columnTypeSql(column) {
+	const type = column.storedType;
+	if (type === void 0 || !isSqlDataType(type)) throw new InternalError(`column "${column.name}" has no data type; the expected tree must be derived via contractToSchemaIR for planning`);
+	return renderSqlTypeName(type, dataTypeParams(type, column.codecRef?.typeParams));
+}
+function ddlDefaultOf(columnDefault) {
+	if (columnDefault === void 0) return void 0;
+	return columnDefault.kind === "literal" ? new LiteralColumnDefault(columnDefault.value) : new FunctionColumnDefault(opaqueSql(columnDefault.expression));
+}
+/** The default a column node's DDL writes: the one the contract authored, which `resolvedDefault` normalises for the diff. */
+function columnDefaultOf(column) {
+	return column.authoredDefault ?? column.resolvedDefault;
+}
+/** The `DdlColumn` of a column node. An `autoincrement()` default stays a function default, which the adapter writes as `AUTO_INCREMENT`. */
+function ddlColumnFromNode(column) {
+	const columnDefault = ddlDefaultOf(columnDefaultOf(column));
+	return new DdlColumn({
+		name: column.name,
+		type: columnTypeSql(column),
+		...column.nullable ? {} : { notNull: true },
+		...columnDefault === void 0 ? {} : { default: columnDefault },
+		...column.codecRef === void 0 ? {} : { codecRef: column.codecRef }
+	});
+}
+/** The name a unique constraint is created and dropped by; MySQL names an unnamed one after its first column, which the contract never leaves to it. */
+function uniqueName(table, unique) {
+	return unique.name ?? `${table}_${unique.columns.join("_")}_key`;
+}
+/** The constraints `CREATE TABLE` writes for a table node: its primary key and unique constraints. Foreign keys are added after every table exists, so tables can reference each other. */
+function tableConstraintsFromNode(table) {
+	return [...table.primaryKey === void 0 ? [] : [new PrimaryKeyConstraint({ columns: table.primaryKey.columns })], ...table.uniques.map((unique) => new UniqueConstraint({
+		columns: unique.columns,
+		name: uniqueName(table.name, unique)
+	}))];
+}
+function step(description, sql, params, expectation) {
+	return {
+		description,
+		sql,
+		...ifDefined("params", params),
+		...ifDefined("expectation", expectation)
+	};
+}
+const IN_DATABASE = "TABLE_SCHEMA = DATABASE()";
+function count(from, where, params) {
+	return {
+		sql: `SELECT COUNT(*) FROM information_schema.${from} WHERE ${IN_DATABASE} AND ${where}`,
+		params
+	};
+}
+function present(query) {
+	return {
+		sql: `SELECT (${query.sql}) > 0 AS result`,
+		params: query.params
+	};
+}
+function absent(query) {
+	return {
+		sql: `SELECT (${query.sql}) = 0 AS result`,
+		params: query.params
+	};
+}
+const tableQuery = (table) => count("TABLES", "TABLE_NAME = ?", [table]);
+const columnQuery = (table, column) => count("COLUMNS", "TABLE_NAME = ? AND COLUMN_NAME = ?", [table, column]);
+const indexQuery = (table, index) => count("STATISTICS", "TABLE_NAME = ? AND INDEX_NAME = ?", [table, index]);
+const constraintQuery = (table, name, type) => count("TABLE_CONSTRAINTS", "TABLE_NAME = ? AND CONSTRAINT_NAME = ? AND CONSTRAINT_TYPE = ?", [
+	table,
+	name,
+	type
+]);
+/** A step that holds when `query` finds the object, or finds none, as `holds` says. */
+function check(description, query, holds, object) {
+	const { sql, params } = holds === "present" ? present(query) : absent(query);
+	return step(description, sql, params, holds === "present" ? expectPresent(object) : expectAbsent(object));
+}
+const tableChecks = (table) => ({
+	present: (description) => check(description, tableQuery(table), "present", `table "${table}"`),
+	absent: (description) => check(description, tableQuery(table), "absent", `table "${table}"`)
+});
+const columnChecks = (table, column) => ({
+	present: (description) => check(description, columnQuery(table, column), "present", `column "${column}" on "${table}"`),
+	absent: (description) => check(description, columnQuery(table, column), "absent", `column "${column}" on "${table}"`)
+});
+const indexChecks = (table, index) => ({
+	present: (description) => check(description, indexQuery(table, index), "present", `index "${index}" on "${table}"`),
+	absent: (description) => check(description, indexQuery(table, index), "absent", `index "${index}" on "${table}"`)
+});
+const constraintChecks = (table, name, type) => {
+	const object = `${type === "UNIQUE" ? "unique constraint" : "foreign key"} "${name}" on "${table}"`;
+	return {
+		present: (description) => check(description, constraintQuery(table, name, type), "present", object),
+		absent: (description) => check(description, constraintQuery(table, name, type), "absent", object)
+	};
+};
+function columnList(columns) {
+	return columns.map(quoteIdentifier).join(", ");
+}
+/** The column definition `ALTER TABLE … ADD COLUMN` writes, with the default the adapter renders through the column's codec. */
+async function columnDefinitionSql(column, table, lowerer) {
+	const defaultClause = await lowerer.renderColumnDefault(column, table);
+	return [
+		quoteIdentifier(column.name),
+		column.type,
+		...column.notNull ? ["NOT NULL"] : [],
+		...defaultClause.length > 0 ? [defaultClause] : []
+	].join(" ");
+}
+function foreignKeyActionsSql(actions) {
+	return [...actions.onDelete === void 0 ? [] : [` ON DELETE ${REFERENTIAL_ACTION_SQL[actions.onDelete]}`], ...actions.onUpdate === void 0 ? [] : [` ON UPDATE ${REFERENTIAL_ACTION_SQL[actions.onUpdate]}`]].join("");
+}
+/** An operation written out in full in `migration.ts`, such as a table rename made by hand. */
+function rawSql(op) {
+	return op;
+}
+function buildTargetDetails(objectType, name, table) {
+	return {
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
+const TARGET_MIGRATION_MODULE = "@internal/mysql/migration";
+/** The refusal of a `MysqlMigration` operation that needs the control adapter, on an instance built without a control stack. */
+function mysqlMigrationStackMissing(operation) {
+	return mysqlError("MIGRATION.MYSQL_CONTROL_STACK_MISSING", `MysqlMigration.${operation} requires a control adapter`, {
+		why: `MysqlMigration.${operation} was invoked on an instance constructed without a ControlStack, so it cannot render its DDL.`,
+		fix: "Construct the migration via the migration CLI entrypoint, which assembles a ControlStack from prisma.config.ts, or pass a ControlStack with a MySQL adapter to the migration constructor in test fixtures.",
+		meta: { operation }
+	});
+}
+var MysqlOpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+	lowererFor(lowerer) {
+		if (lowerer === void 0) throw mysqlMigrationStackMissing(this.factoryName);
+		return lowerer;
+	}
+};
+/** Whether `call` is one of this target's calls. */
+function isMysqlOpFactoryCall(call) {
+	return call instanceof MysqlOpFactoryCallNode;
+}
+function renderColumnDefault(def, sql) {
+	return def.kind === "literal" ? `lit(${jsonToTsSource(def.value)})` : `fn(${sql.source(def.expression.text)})`;
+}
+function renderColumn(column, sql) {
+	const options = [
+		...column.notNull ? ["notNull: true"] : [],
+		...column.default === void 0 ? [] : [`default: ${renderColumnDefault(column.default, sql)}`],
+		...column.codecRef === void 0 ? [] : [`codecRef: ${jsonToTsSource(column.codecRef)}`]
+	];
+	const optionsSource = options.length > 0 ? `, { ${options.join(", ")} }` : "";
+	return `col(${jsonToTsSource(column.name)}, ${jsonToTsSource(column.type)}${optionsSource})`;
+}
+function renderConstraint(constraint) {
+	const named = constraint.name === void 0 ? "" : `, { name: ${jsonToTsSource(constraint.name)} }`;
+	switch (constraint.kind) {
+		case "primary-key": return `primaryKey(${jsonToTsSource(constraint.columns)}${named})`;
+		case "unique": return `unique(${jsonToTsSource(constraint.columns)}${named})`;
+		case "foreign-key":
+		case "check-expression": throw mysqlError("CONTRACT.CONSTRAINT_INVALID", `The MySQL createTable call writes primary keys and unique constraints only; add ${constraint.kind === "foreign-key" ? "a foreign key with addForeignKey" : "no CHECK constraint"} (constraint "${constraint.name ?? ""}").`, { meta: { constraintKind: constraint.kind } });
+	}
+}
+function columnImports(columns) {
+	const symbols = new Set(columns.length > 0 ? ["col"] : []);
+	for (const column of columns) {
+		if (column.default?.kind === "literal") symbols.add("lit");
+		if (column.default?.kind === "function") symbols.add("fn");
+	}
+	return [...symbols].map((symbol) => ({
+		moduleSpecifier: TARGET_MIGRATION_MODULE,
+		symbol
+	}));
+}
+var CreateTableCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	factoryName = "createTable";
+	operationClass = "additive";
+	label;
+	columns;
+	constraints;
+	constructor(tableName, columns, constraints) {
+		super();
+		this.tableName = tableName;
+		this.columns = Object.freeze([...columns]);
+		this.constraints = Object.freeze([...constraints]);
+		this.label = `Create table ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		const statement = await this.lowererFor(lowerer).lowerToExecuteRequest(createTable({
+			table: this.tableName,
+			columns: this.columns,
+			constraints: this.constraints
+		}));
+		const table = tableChecks(this.tableName);
+		return {
+			id: `table.${this.tableName}`,
+			label: this.label,
+			summary: `Creates table ${this.tableName} with its columns, primary key and unique constraints`,
+			operationClass: "additive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("table", this.tableName)
+			},
+			precheck: [table.absent(`ensure table "${this.tableName}" does not exist`)],
+			execute: [step(`create table "${this.tableName}"`, statement.sql, statement.params)],
+			postcheck: [table.present(`verify table "${this.tableName}" exists`)]
+		};
+	}
+	renderTypeScript() {
+		return this.#written().source;
+	}
+	importRequirements() {
+		return this.#written().imports;
+	}
+	#written() {
+		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
+		const columns = this.columns.map((column) => renderColumn(column, sql)).join(", ");
+		const constraints = this.constraints.map(renderConstraint);
+		const source = `this.createTable({ table: ${jsonToTsSource(this.tableName)}, columns: [${columns}]${constraints.length > 0 ? `, constraints: [${constraints.join(", ")}]` : ""} })`;
+		const constraintImports = [...new Set(this.constraints.map((c) => c.kind === "primary-key" ? "primaryKey" : "unique"))].map((symbol) => ({
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol
+		}));
+		return {
+			source,
+			imports: [
+				...columnImports(this.columns),
+				...constraintImports,
+				...sql.imports()
+			]
+		};
+	}
+};
+var DropTableCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	label;
+	constructor(tableName) {
+		super();
+		this.tableName = tableName;
+		this.label = `Drop table ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const table = tableChecks(this.tableName);
+		return {
+			id: `dropTable.${this.tableName}`,
+			label: this.label,
+			summary: `Drops table ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("table", this.tableName)
+			},
+			precheck: [table.present(`ensure table "${this.tableName}" exists`)],
+			execute: [step(`drop table "${this.tableName}"`, `DROP TABLE ${quoteIdentifier(this.tableName)}`)],
+			postcheck: [table.absent(`verify table "${this.tableName}" is gone`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropTable({ table: ${jsonToTsSource(this.tableName)} })`;
+	}
+};
+var AddColumnCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	column;
+	factoryName = "addColumn";
+	operationClass = "additive";
+	label;
+	columnName;
+	constructor(tableName, column) {
+		super();
+		this.tableName = tableName;
+		this.column = column;
+		this.columnName = column.name;
+		this.label = `Add column ${column.name} on ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		const definition = await columnDefinitionSql(this.column, this.tableName, this.lowererFor(lowerer));
+		const column = columnChecks(this.tableName, this.columnName);
+		return {
+			id: `column.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			summary: `Adds column ${this.columnName} to ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("column", this.columnName, this.tableName)
+			},
+			precheck: [tableChecks(this.tableName).present(`ensure table "${this.tableName}" exists`), column.absent(`ensure column "${this.columnName}" is missing on "${this.tableName}"`)],
+			execute: [step(`add column "${this.columnName}" to "${this.tableName}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD COLUMN ${definition}`)],
+			postcheck: [column.present(`verify column "${this.columnName}" exists on "${this.tableName}"`)]
+		};
+	}
+	renderTypeScript() {
+		return this.#written().source;
+	}
+	importRequirements() {
+		return this.#written().imports;
+	}
+	#written() {
+		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
+		return {
+			source: `this.addColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${renderColumn(this.column, sql)} })`,
+			imports: [...columnImports([this.column]), ...sql.imports()]
+		};
+	}
+};
+var DropColumnCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	columnName;
+	factoryName = "dropColumn";
+	operationClass = "destructive";
+	label;
+	constructor(tableName, columnName) {
+		super();
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop column ${columnName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const column = columnChecks(this.tableName, this.columnName);
+		return {
+			id: `dropColumn.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			summary: `Drops column ${this.columnName} on ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("column", this.columnName, this.tableName)
+			},
+			precheck: [column.present(`ensure column "${this.columnName}" exists on "${this.tableName}"`)],
+			execute: [step(`drop column "${this.columnName}" from "${this.tableName}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} DROP COLUMN ${quoteIdentifier(this.columnName)}`)],
+			postcheck: [column.absent(`verify column "${this.columnName}" is gone from "${this.tableName}"`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.columnName)} })`;
+	}
+};
+var CreateIndexCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	indexName;
+	columns;
+	unique;
+	factoryName = "createIndex";
+	operationClass = "additive";
+	label;
+	constructor(tableName, indexName, columns, unique) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.columns = columns;
+		this.unique = unique;
+		this.label = `Create ${unique ? "unique " : ""}index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const index = indexChecks(this.tableName, this.indexName);
+		return {
+			id: `index.${this.tableName}.${this.indexName}`,
+			label: this.label,
+			summary: `Creates ${this.unique ? "unique " : ""}index ${this.indexName} on ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [index.absent(`ensure index "${this.indexName}" is missing`)],
+			execute: [step(`create index "${this.indexName}"`, `CREATE ${this.unique ? "UNIQUE " : ""}INDEX ${quoteIdentifier(this.indexName)} ON ${quoteIdentifier(this.tableName)} (${columnList(this.columns)})`)],
+			postcheck: [index.present(`verify index "${this.indexName}" exists`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.createIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)}, columns: ${jsonToTsSource(this.columns)}${this.unique ? ", unique: true" : ""} })`;
+	}
+};
+var DropIndexCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	indexName;
+	factoryName = "dropIndex";
+	operationClass = "widening";
+	label;
+	constructor(tableName, indexName) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.label = `Drop index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const index = indexChecks(this.tableName, this.indexName);
+		return {
+			id: `dropIndex.${this.tableName}.${this.indexName}`,
+			label: this.label,
+			summary: `Drops index ${this.indexName} on ${this.tableName} which is not in the contract`,
+			operationClass: "widening",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [index.present(`ensure index "${this.indexName}" exists`)],
+			execute: [step(`drop index "${this.indexName}"`, `DROP INDEX ${quoteIdentifier(this.indexName)} ON ${quoteIdentifier(this.tableName)}`)],
+			postcheck: [index.absent(`verify index "${this.indexName}" is gone`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)} })`;
+	}
+};
+var AddUniqueCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	constraintName;
+	columns;
+	factoryName = "addUnique";
+	operationClass = "additive";
+	label;
+	constructor(tableName, constraintName, columns) {
+		super();
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.columns = columns;
+		this.label = `Add unique constraint ${constraintName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const constraint = constraintChecks(this.tableName, this.constraintName, "UNIQUE");
+		return {
+			id: `unique.${this.tableName}.${this.constraintName}`,
+			label: this.label,
+			summary: `Adds unique constraint ${this.constraintName} on ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("unique", this.constraintName, this.tableName)
+			},
+			precheck: [constraint.absent(`ensure unique constraint "${this.constraintName}" is missing`)],
+			execute: [step(`add unique constraint "${this.constraintName}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD CONSTRAINT ${quoteIdentifier(this.constraintName)} UNIQUE (${columnList(this.columns)})`)],
+			postcheck: [constraint.present(`verify unique constraint "${this.constraintName}" exists`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.addUnique({ table: ${jsonToTsSource(this.tableName)}, name: ${jsonToTsSource(this.constraintName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+};
+var DropUniqueCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	constraintName;
+	factoryName = "dropUnique";
+	operationClass = "widening";
+	label;
+	constructor(tableName, constraintName) {
+		super();
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.label = `Drop unique constraint ${constraintName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const constraint = constraintChecks(this.tableName, this.constraintName, "UNIQUE");
+		return {
+			id: `dropUnique.${this.tableName}.${this.constraintName}`,
+			label: this.label,
+			summary: `Drops unique constraint ${this.constraintName} on ${this.tableName} which is not in the contract`,
+			operationClass: "widening",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("unique", this.constraintName, this.tableName)
+			},
+			precheck: [constraint.present(`ensure unique constraint "${this.constraintName}" exists`)],
+			execute: [step(`drop unique constraint "${this.constraintName}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} DROP INDEX ${quoteIdentifier(this.constraintName)}`)],
+			postcheck: [constraint.absent(`verify unique constraint "${this.constraintName}" is gone`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropUnique({ table: ${jsonToTsSource(this.tableName)}, name: ${jsonToTsSource(this.constraintName)} })`;
+	}
+};
+var AddForeignKeyCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	foreignKey;
+	factoryName = "addForeignKey";
+	operationClass = "additive";
+	label;
+	constructor(tableName, foreignKey) {
+		super();
+		this.tableName = tableName;
+		this.foreignKey = foreignKey;
+		this.label = `Add foreign key ${foreignKey.name} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const { name, columns, references } = this.foreignKey;
+		const constraint = constraintChecks(this.tableName, name, "FOREIGN KEY");
+		return {
+			id: `foreignKey.${this.tableName}.${name}`,
+			label: this.label,
+			summary: `Adds foreign key ${name} on ${this.tableName} referencing ${references.table}`,
+			operationClass: "additive",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("foreignKey", name, this.tableName)
+			},
+			precheck: [constraint.absent(`ensure foreign key "${name}" is missing`)],
+			execute: [step(`add foreign key "${name}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD CONSTRAINT ${quoteIdentifier(name)} FOREIGN KEY (${columnList(columns)}) REFERENCES ${quoteIdentifier(references.table)} (${columnList(references.columns)})${foreignKeyActionsSql(this.foreignKey)}`)],
+			postcheck: [constraint.present(`verify foreign key "${name}" exists`)]
+		};
+	}
+	renderTypeScript() {
+		const { name, columns, references, onDelete, onUpdate } = this.foreignKey;
+		return `this.addForeignKey({ ${[
+			`table: ${jsonToTsSource(this.tableName)}`,
+			`name: ${jsonToTsSource(name)}`,
+			`columns: ${jsonToTsSource(columns)}`,
+			`references: ${jsonToTsSource(references)}`,
+			...onDelete === void 0 ? [] : [`onDelete: ${jsonToTsSource(onDelete)}`],
+			...onUpdate === void 0 ? [] : [`onUpdate: ${jsonToTsSource(onUpdate)}`]
+		].join(", ")} })`;
+	}
+};
+var DropForeignKeyCall = class extends MysqlOpFactoryCallNode {
+	tableName;
+	constraintName;
+	factoryName = "dropForeignKey";
+	operationClass = "widening";
+	label;
+	constructor(tableName, constraintName) {
+		super();
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.label = `Drop foreign key ${constraintName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		const constraint = constraintChecks(this.tableName, this.constraintName, "FOREIGN KEY");
+		return {
+			id: `dropForeignKey.${this.tableName}.${this.constraintName}`,
+			label: this.label,
+			summary: `Drops foreign key ${this.constraintName} on ${this.tableName} which is not in the contract`,
+			operationClass: "widening",
+			target: {
+				id: "mysql",
+				details: buildTargetDetails("foreignKey", this.constraintName, this.tableName)
+			},
+			precheck: [constraint.present(`ensure foreign key "${this.constraintName}" exists`)],
+			execute: [step(`drop foreign key "${this.constraintName}"`, `ALTER TABLE ${quoteIdentifier(this.tableName)} DROP FOREIGN KEY ${quoteIdentifier(this.constraintName)}`)],
+			postcheck: [constraint.absent(`verify foreign key "${this.constraintName}" is gone`)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropForeignKey({ table: ${jsonToTsSource(this.tableName)}, name: ${jsonToTsSource(this.constraintName)} })`;
+	}
+};
+/** An operation built elsewhere, such as the table rename a user writes by hand, carried as it is and written as `rawSql({...})`. */
+var RawSqlCall = class extends MysqlOpFactoryCallNode {
+	op;
+	factoryName = "rawSql";
+	operationClass;
+	label;
+	constructor(op) {
+		super();
+		this.op = op;
+		this.label = op.label;
+		this.operationClass = op.operationClass;
+		this.freeze();
+	}
+	toOp() {
+		return this.op;
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource(this.op)})`;
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "rawSql"
+		}];
+	}
+};
+/** The table rename a user writes by hand on MySQL, which the planner does not plan yet. */
+function renameTableByHandOp(from, to) {
+	const fromTable = tableChecks(from);
+	const toTable = tableChecks(to);
+	return {
+		id: `renameTable.${from}`,
+		label: `Rename table ${from} to ${to}`,
+		operationClass: "widening",
+		target: {
+			id: "mysql",
+			details: buildTargetDetails("table", to)
+		},
+		precheck: [fromTable.present(`ensure table "${from}" exists`), toTable.absent(`ensure table "${to}" does not exist`)],
+		execute: [step(`rename table "${from}" to "${to}"`, `RENAME TABLE ${quoteIdentifier(from)} TO ${quoteIdentifier(to)}`)],
+		postcheck: [toTable.present(`verify table "${to}" exists`), fromTable.absent(`verify table "${from}" no longer exists`)]
+	};
+}
+function foreignKeySpecOf(fk, table) {
+	return {
+		name: fk.name ?? `${table}_${fk.columns.join("_")}_fkey`,
+		columns: fk.columns,
+		references: {
+			table: fk.referencedTable,
+			columns: fk.referencedColumns
+		},
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate)
+	};
+}
+/**
+* Drops each issue under a missing or extra node: the call for a table or column accounts for everything beneath it.
+*/
+function coalesceSubtreeIssues(issues) {
+	const collapsing = issues.filter((issue) => {
+		const outcome = issueOutcome(issue);
+		return outcome === "not-found" || outcome === "not-expected";
+	}).map((issue) => issue.path);
+	return issues.filter((issue) => !collapsing.some((ancestor) => issue.path.length > ancestor.length && ancestor.every((segment, index) => issue.path[index] === segment)));
+}
+function issueNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	return node === void 0 ? void 0 : blindCast(node);
+}
+function expectedNode(issue) {
+	return blindCast(issue.expected);
+}
+function actualNode(issue) {
+	return blindCast(issue.actual);
+}
+function location(table, column) {
+	return {
+		entityKind: "table",
+		...table === void 0 ? {} : { entityName: table },
+		...column === void 0 ? {} : { column }
+	};
+}
+function placeOf(issue, at) {
+	if (at?.entityName === void 0) return issue.path.slice(1).join(".");
+	return at.column === void 0 ? at.entityName : `${at.entityName}.${at.column}`;
+}
+/** The conflict for a change the MySQL planner does not plan yet. */
+function notYetSupported(kind, change, issue, conflictLocation) {
+	return {
+		kind,
+		summary: `${change} is not yet supported on MySQL (${placeOf(issue, conflictLocation)})`,
+		why: "The MySQL planner creates and drops tables, columns, indexes, unique constraints and foreign keys; it does not change a column, a default, a primary key or a CHECK constraint yet. Use `migration new` to write this change by hand.",
+		...conflictLocation === void 0 ? {} : { location: conflictLocation }
+	};
+}
+function createTableCalls(table) {
+	return [
+		new CreateTableCall(table.name, Object.values(table.columns).map(ddlColumnFromNode), tableConstraintsFromNode(table)),
+		...table.indexes.flatMap((index) => index.columns === void 0 ? [] : [new CreateIndexCall(table.name, index.name, index.columns, index.unique)]),
+		...table.foreignKeys.map((fk) => new AddForeignKeyCall(table.name, foreignKeySpecOf(fk, table.name)))
+	];
+}
+function mapTableIssue(issue) {
+	switch (issueOutcome(issue)) {
+		case "not-found": {
+			const table = expectedNode(issue);
+			return table.indexes.find((index) => index.columns === void 0) === void 0 ? ok(createTableCalls(table)) : notOk(notYetSupported("indexIncompatible", "An expression index", issue, location(table.name)));
+		}
+		case "not-expected": {
+			const table = actualNode(issue);
+			return ok(CONTROL_TABLE_NAMES.has(table.name) ? [] : [new DropTableCall(table.name)]);
+		}
+		default: return notOk(notYetSupported("unsupportedOperation", "Changing a table", issue));
+	}
+}
+function mapColumnIssue(issue, table) {
+	switch (issueOutcome(issue)) {
+		case "not-found": {
+			const column = expectedNode(issue);
+			const columnDefault = columnDefaultOf(column);
+			return column.nullable || columnDefault !== void 0 && !(columnDefault.kind === "function" && columnDefault.expression === "autoincrement()") ? ok([new AddColumnCall(table, ddlColumnFromNode(column))]) : notOk(notYetSupported("nullabilityConflict", "Adding a required column without a default", issue, location(table, column.name)));
+		}
+		case "not-expected": return ok([new DropColumnCall(table, actualNode(issue).name)]);
+		default: {
+			const expected = expectedNode(issue);
+			const typesEqual = sqlColumnTypesEqual(expected, actualNode(issue));
+			return notOk(notYetSupported(typesEqual ? "nullabilityConflict" : "typeMismatch", typesEqual ? "Changing a column's nullability" : "Changing a column's type", issue, location(table, expected.name)));
+		}
+	}
+}
+function mapIndexIssue(issue, table) {
+	switch (issueOutcome(issue)) {
+		case "not-found": {
+			const index = expectedNode(issue);
+			return index.columns === void 0 ? notOk(notYetSupported("indexIncompatible", "An expression index", issue, location(table))) : ok([new CreateIndexCall(table, index.name, index.columns, index.unique)]);
+		}
+		case "not-expected": return ok([new DropIndexCall(table, actualNode(issue).name)]);
+		default: return notOk(notYetSupported("indexIncompatible", "Changing an index", issue, location(table)));
+	}
+}
+function mapUniqueIssue(issue, table) {
+	switch (issueOutcome(issue)) {
+		case "not-found": {
+			const unique = expectedNode(issue);
+			return ok([new AddUniqueCall(table, uniqueName(table, unique), unique.columns)]);
+		}
+		case "not-expected": return ok([new DropUniqueCall(table, uniqueName(table, actualNode(issue)))]);
+		default: return notOk(notYetSupported("indexIncompatible", "Changing a unique constraint", issue, location(table)));
+	}
+}
+function mapForeignKeyIssue(issue, table) {
+	switch (issueOutcome(issue)) {
+		case "not-found": return ok([new AddForeignKeyCall(table, foreignKeySpecOf(expectedNode(issue), table))]);
+		case "not-expected": return ok([new DropForeignKeyCall(table, foreignKeySpecOf(actualNode(issue), table).name)]);
+		default: return notOk(notYetSupported("foreignKeyConflict", "Changing a foreign key", issue, location(table)));
+	}
+}
+function mapIssueToCalls(issue) {
+	const node = issueNode(issue);
+	const table = issue.path[1];
+	if (node === void 0) return notOk(notYetSupported("unsupportedOperation", "A change with no node", issue));
+	if (node.nodeKind === RelationalSchemaNodeKind.table) return mapTableIssue(issue);
+	if (table === void 0) return notOk(notYetSupported("unsupportedOperation", `A ${node.nodeKind} change`, issue));
+	switch (node.nodeKind) {
+		case RelationalSchemaNodeKind.column: return mapColumnIssue(issue, table);
+		case RelationalSchemaNodeKind.index: return mapIndexIssue(issue, table);
+		case RelationalSchemaNodeKind.unique: return mapUniqueIssue(issue, table);
+		case RelationalSchemaNodeKind.foreignKey: return mapForeignKeyIssue(issue, table);
+		case RelationalSchemaNodeKind.columnDefault: return notOk(notYetSupported("unsupportedOperation", "Changing a column's default", issue, location(table)));
+		case RelationalSchemaNodeKind.primaryKey: return notOk(notYetSupported("indexIncompatible", "Changing a primary key", issue, location(table)));
+		case RelationalSchemaNodeKind.check: return notOk(notYetSupported("unsupportedOperation", "A CHECK constraint", issue, location(table)));
+		default: return notOk(notYetSupported("unsupportedOperation", `A ${node.nodeKind} change`, issue));
+	}
+}
+/**
+* The order calls run in: foreign keys are dropped before the tables, columns and indexes they use, and added after every table, column and index they need exists. The index InnoDB made for a dropped key is dropped right after the key, before any key is added, so a new key on the same columns makes its own.
+*/
+const CALL_ORDER = [
+	"dropForeignKey",
+	"createTable",
+	"addColumn",
+	"addUnique",
+	"createIndex",
+	"addForeignKey",
+	"dropUnique",
+	"dropIndex",
+	"dropColumn",
+	"dropTable",
+	"rawSql"
+];
+function locationOfCall(call) {
+	return "tableName" in call ? {
+		entityKind: "table",
+		entityName: call.tableName,
+		..."columnName" in call ? { column: call.columnName } : {},
+		..."indexName" in call ? { index: call.indexName } : {}
+	} : void 0;
+}
+function conflictForDisallowedCall(call, allowed) {
+	const callLocation = locationOfCall(call);
+	return {
+		kind: call instanceof CreateIndexCall || call instanceof DropIndexCall ? "indexIncompatible" : "missingButNonAdditive",
+		summary: `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`,
+		why: "Use `migration new` to author a custom migration for this change.",
+		refusedOperationClass: call.operationClass,
+		...callLocation === void 0 ? {} : { location: callLocation }
+	};
+}
+const MAX_IDENTIFIER_CHARACTERS = 64;
+/** The names a call gives new objects, each with where the conflict that refuses it points. */
+function namesGiven(call) {
+	if (call instanceof CreateTableCall) return [
+		{
+			name: call.tableName,
+			at: location(call.tableName)
+		},
+		...call.columns.map((column) => ({
+			name: column.name,
+			at: location(call.tableName, column.name)
+		})),
+		...call.constraints.flatMap((constraint) => constraint.name === void 0 ? [] : [{
+			name: constraint.name,
+			at: {
+				...location(call.tableName),
+				constraint: constraint.name
+			}
+		}])
+	];
+	if (call instanceof AddColumnCall) return [{
+		name: call.column.name,
+		at: location(call.tableName, call.column.name)
+	}];
+	if (call instanceof CreateIndexCall) return [{
+		name: call.indexName,
+		at: {
+			...location(call.tableName),
+			index: call.indexName
+		}
+	}];
+	if (call instanceof AddUniqueCall) return [{
+		name: call.constraintName,
+		at: {
+			...location(call.tableName),
+			constraint: call.constraintName
+		}
+	}];
+	if (call instanceof AddForeignKeyCall) return [{
+		name: call.foreignKey.name,
+		at: {
+			...location(call.tableName),
+			constraint: call.foreignKey.name
+		}
+	}];
+	return [];
+}
+function placeText(at) {
+	return at.column === void 0 ? `${at.entityName}` : `${at.entityName}.${at.column}`;
+}
+/** MySQL refuses a name longer than 64 characters only when the statement runs, after the statements before it committed, so the planner refuses it first. */
+function longNameConflicts(call) {
+	return namesGiven(call).filter(({ name }) => Array.from(name).length > MAX_IDENTIFIER_CHARACTERS).map(({ name, at }) => ({
+		kind: "unsupportedOperation",
+		summary: `The name ${name} is longer than the ${MAX_IDENTIFIER_CHARACTERS} characters MySQL allows (${placeText(at)})`,
+		why: `MySQL refuses a table, column, index or constraint name longer than ${MAX_IDENTIFIER_CHARACTERS} characters. Give it a shorter name in the contract.`,
+		location: at
+	}));
+}
+function isAutoincrement(column) {
+	return column.default?.kind === "function" && column.default.expression.text === "autoincrement()";
+}
+/** MySQL refuses a table whose `AUTO_INCREMENT` column does not lead a key, so the planner refuses it first. */
+function autoincrementKeyConflicts(call) {
+	if (!(call instanceof CreateTableCall)) return [];
+	const keyLeaders = new Set(call.constraints.flatMap((constraint) => constraint.kind === "primary-key" || constraint.kind === "unique" ? constraint.columns.slice(0, 1) : []));
+	return call.columns.filter((column) => isAutoincrement(column) && !column.primaryKey && !keyLeaders.has(column.name)).map((column) => ({
+		kind: "unsupportedOperation",
+		summary: `An autoincrement column that is not the first column of the primary key or a unique constraint is not supported on MySQL (${call.tableName}.${column.name})`,
+		why: "MySQL requires an AUTO_INCREMENT column to be the first column of a key, and refuses the table otherwise.",
+		location: location(call.tableName, column.name)
+	}));
+}
+/** Whether an index on `indexColumns` can serve a foreign key on `keyColumns`: InnoDB needs the key's columns first, in order. */
+function servesKey(indexColumns, keyColumns) {
+	return keyColumns.length <= indexColumns.length && keyColumns.every((column, position) => indexColumns[position] === column);
+}
+function indexColumnLists(table, leaving) {
+	return [
+		...table.primaryKey === void 0 ? [] : [table.primaryKey.columns],
+		...table.uniques.flatMap((unique) => uniqueName(table.name, unique) === leaving ? [] : [unique.columns]),
+		...table.indexes.flatMap((index) => index.name === leaving || index.columns === void 0 ? [] : [index.columns])
+	];
+}
+function isKeyServed(table, keyColumns, leaving) {
+	return indexColumnLists(table, leaving).some((columns) => servesKey(columns, keyColumns));
+}
+/**
+* When a foreign key is dropped and no other index served it, InnoDB made an index of its own, with the key's name, and keeps it after the key is gone. Introspection leaves that index out while the key exists, so it is dropped with the key unless the destination keeps an index of that name.
+*/
+function innoDbIndexDrops(calls, expected, actual) {
+	return calls.flatMap((call) => {
+		if (!(call instanceof DropForeignKeyCall)) return [];
+		const before = actual.tables[call.tableName];
+		const after = expected.tables[call.tableName];
+		const key = before?.foreignKeys.find((fk) => foreignKeySpecOf(fk, call.tableName).name === call.constraintName);
+		if (before === void 0 || after === void 0 || key === void 0) return [];
+		if (isKeyServed(before, key.columns)) return [];
+		if (after.indexes.some((index) => index.name === call.constraintName)) return [];
+		return [{
+			call: new DropIndexCall(call.tableName, call.constraintName),
+			indexName: call.constraintName,
+			columns: key.columns
+		}];
+	});
+}
+function droppedIndexes(calls, actual) {
+	return calls.flatMap((call) => {
+		const table = "tableName" in call ? actual.tables[call.tableName] : void 0;
+		if (table === void 0) return [];
+		if (call instanceof DropIndexCall) {
+			const index = table.indexes.find(({ name }) => name === call.indexName);
+			return index?.columns === void 0 ? [] : [{
+				call,
+				indexName: call.indexName,
+				columns: index.columns
+			}];
+		}
+		if (call instanceof DropUniqueCall) {
+			const unique = table.uniques.find((candidate) => uniqueName(table.name, candidate) === call.constraintName);
+			return unique === void 0 ? [] : [{
+				call,
+				indexName: call.constraintName,
+				columns: unique.columns
+			}];
+		}
+		return [];
+	});
+}
+/**
+* A dropped index that one of `protectedKeys` uses, when no index the destination keeps can take over: MySQL refuses that drop.
+*/
+function conflictForIndexAKeyUses(dropped, expected, protectedKeys) {
+	const tableName = dropped.call.tableName;
+	const table = expected.tables[tableName];
+	const key = table?.foreignKeys.find((fk) => protectedKeys(tableName, fk) && servesKey(dropped.columns, fk.columns) && !isKeyServed(table, fk.columns, dropped.indexName));
+	if (key === void 0) return void 0;
+	return {
+		kind: "indexIncompatible",
+		summary: `Dropping index ${dropped.indexName}, which foreign key ${foreignKeySpecOf(key, tableName).name} uses, is not yet supported on MySQL (${tableName})`,
+		why: "MySQL refuses to drop an index a foreign key uses. Keep an index whose first columns are the foreign key's columns, or use `migration new` to drop the foreign key, drop the index and add the foreign key again.",
+		location: {
+			entityKind: "table",
+			entityName: tableName,
+			index: dropped.indexName
+		}
+	};
+}
+/** The calls that turn `actual` into `expected` for `issues`, in the order they run, or the conflicts that stop the plan. */
+function planIssues(input) {
+	const calls = [];
+	const conflicts = [];
+	const allowed = input.policy.allowedOperationClasses;
+	for (const issue of orderIssuesByDependencies(input.issues)) {
+		const mapped = mapIssueToCalls(issue);
+		if (!mapped.ok) {
+			conflicts.push(mapped.failure);
+			continue;
+		}
+		for (const call of mapped.value) {
+			conflicts.push(...longNameConflicts(call), ...autoincrementKeyConflicts(call));
+			if (allowed.includes(call.operationClass)) calls.push(call);
+			else conflicts.push(conflictForDisallowedCall(call, allowed));
+		}
+	}
+	const droppedKeys = new Set(calls.flatMap((call) => call instanceof DropForeignKeyCall ? [`${call.tableName}.${call.constraintName}`] : []));
+	const isKeptKey = (tableName, fk) => !droppedKeys.has(`${tableName}.${foreignKeySpecOf(fk, tableName).name}`);
+	for (const dropped of droppedIndexes(calls, input.actual)) {
+		const conflict = conflictForIndexAKeyUses(dropped, input.expected, () => true);
+		if (conflict !== void 0) conflicts.push(conflict);
+	}
+	const innoDbIndexes = innoDbIndexDrops(calls, input.expected, input.actual);
+	for (const dropped of innoDbIndexes) {
+		const conflict = conflictForIndexAKeyUses(dropped, input.expected, isKeptKey);
+		if (conflict !== void 0) conflicts.push(conflict);
+		if (!allowed.includes(dropped.call.operationClass)) conflicts.push(conflictForDisallowedCall(dropped.call, allowed));
+	}
+	if (conflicts.length > 0) return notOk(conflicts);
+	const inOrder = (factoryName) => calls.filter((call) => call.factoryName === factoryName);
+	return ok([
+		...inOrder("dropForeignKey"),
+		...innoDbIndexes.map(({ call }) => call),
+		...CALL_ORDER.filter((factoryName) => factoryName !== "dropForeignKey").flatMap(inOrder)
+	]);
+}
+/**
+* The base class of a MySQL `migration.ts`. Each protected method returns the operation its name says, rendered through the MySQL control adapter the migration CLI builds from `prisma.config.ts`.
+*/
+var MysqlMigration = class extends Migration {
+	targetId = "mysql";
+	controlAdapter;
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter === void 0 ? void 0 : blindCast(stack.adapter.create(stack));
+	}
+	adapterFor(operation) {
+		if (this.controlAdapter === void 0) throw mysqlMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	createTable(options) {
+		return new CreateTableCall(options.table, options.columns, options.constraints ?? []).toOp(this.adapterFor("createTable"));
+	}
+	dropTable(options) {
+		return new DropTableCall(options.table).toOp();
+	}
+	addColumn(options) {
+		return new AddColumnCall(options.table, options.column).toOp(this.adapterFor("addColumn"));
+	}
+	dropColumn(options) {
+		return new DropColumnCall(options.table, options.column).toOp();
+	}
+	createIndex(options) {
+		return new CreateIndexCall(options.table, options.index, options.columns, options.unique === true).toOp();
+	}
+	dropIndex(options) {
+		return new DropIndexCall(options.table, options.index).toOp();
+	}
+	addUnique(options) {
+		return new AddUniqueCall(options.table, options.name, options.columns).toOp();
+	}
+	dropUnique(options) {
+		return new DropUniqueCall(options.table, options.name).toOp();
+	}
+	addForeignKey(options) {
+		return new AddForeignKeyCall(options.table, {
+			name: options.name,
+			columns: options.columns,
+			references: options.references,
+			...ifDefined("onDelete", options.onDelete),
+			...ifDefined("onUpdate", options.onUpdate)
+		}).toOp();
+	}
+	dropForeignKey(options) {
+		return new DropForeignKeyCall(options.table, options.name).toOp();
+	}
+};
+function assertMysqlOp(op, factoryName) {
+	const targetId = blindCast(op).target?.id;
+	if (targetId !== "mysql") throw new InternalError(`renderOps: expected a mysql operation but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${factoryName}").`);
+}
+function checkedOp(opOrPromise, factoryName) {
+	if (isThenable(opOrPromise)) {
+		const checked = opOrPromise.then((op) => {
+			assertMysqlOp(op, factoryName);
+			return op;
+		});
+		checked.catch(() => void 0);
+		return checked;
+	}
+	assertMysqlOp(opOrPromise, factoryName);
+	return opOrPromise;
+}
+/** The operations `calls` lower to, in order, each checked to be a MySQL operation. */
+function renderOps(calls, lowerer) {
+	return calls.map((call) => checkedOp(isMysqlOpFactoryCall(call) ? call.toOp(lowerer) : blindCast(call).toOp(lowerer), call.factoryName));
+}
+/** The base class and the CLI entrypoint every scaffold imports, both from the MySQL facade's `migration` module. */
+const BASE_IMPORTS = [{
+	moduleSpecifier: "@internal/mysql/migration",
+	symbol: "Migration"
+}, {
+	moduleSpecifier: "@internal/mysql/migration",
+	symbol: "MigrationCLI"
+}];
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls, meta);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	const hasStart = meta.from !== null;
+	const startField = hasStart ? ["  override readonly startContractJson = startContract;"] : [];
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		`export default class M extends Migration<${hasStart ? "Start" : "never"}, End> {`,
+		...startField,
+		"  override readonly endContractJson = endContract;",
+		"",
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function buildImports(calls, meta) {
+	const requirements = [...BASE_IMPORTS, ...contractImports(meta)];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(resolveRequirementSpecifiers(requirements, meta.resolveImportSpecifier));
+}
+function contractImports(meta) {
+	const reqs = [{
+		moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "endContract",
+		kind: "default",
+		attributes: { type: "json" }
+	}, {
+		moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "Contract",
+		alias: "End",
+		typeOnly: true
+	}];
+	if (meta.from !== null) {
+		reqs.push({
+			moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "startContract",
+			kind: "default",
+			attributes: { type: "json" }
+		});
+		reqs.push({
+			moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "Contract",
+			alias: "Start",
+			typeOnly: true
+		});
+	}
+	return reqs;
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+}
+/** The plan the MySQL planner produces: its operations, and the `migration.ts` that writes them. */
+var TypeScriptRenderableMysqlMigration = class extends MysqlMigration {
+	#calls;
+	#meta;
+	#destination;
+	#spaceId;
+	#snapshotsImportPath;
+	#lowerer;
+	#operationsCache;
+	constructor(options) {
+		super();
+		this.#calls = options.calls;
+		this.#meta = options.meta;
+		this.#spaceId = options.spaceId;
+		this.#snapshotsImportPath = options.snapshotsImportPath;
+		this.#destination = options.destination ?? { storageHash: options.meta.to };
+		this.#lowerer = options.lowerer;
+	}
+	get operations() {
+		this.#operationsCache ??= renderOps(this.#calls, this.#lowerer);
+		return this.#operationsCache;
+	}
+	describe() {
+		return this.#meta;
+	}
+	get destination() {
+		return this.#destination;
+	}
+	get spaceId() {
+		return this.#spaceId;
+	}
+	renderTypeScript(resolveImportSpecifier) {
+		return renderCallsToTypeScript(this.#calls, {
+			from: this.#meta.from,
+			to: this.#meta.to,
+			snapshotsImportPath: this.#snapshotsImportPath,
+			resolveImportSpecifier
+		});
+	}
+};
+const mysqlTableRenameByHand = {
+	renderTableRename: (rename) => new RawSqlCall(renameTableByHandOp(rename.from, rename.to)).renderTypeScript(),
+	tableRenameByHand: (rename) => [`RENAME TABLE ${quoteIdentifier(rename.from)} TO ${quoteIdentifier(rename.to)}`]
+};
+function tableTarget(table, column) {
+	return {
+		storageName: column === void 0 ? table : `${table}.${column}`,
+		table: {
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			table,
+			column
+		}
+	};
+}
+function callSubjects(call) {
+	const dataLoss = call instanceof DropTableCall ? [{
+		...tableTarget(call.tableName),
+		loss: "drop"
+	}] : call instanceof DropColumnCall ? [{
+		...tableTarget(call.tableName, call.columnName),
+		loss: "drop"
+	}] : [];
+	return {
+		operationCount: 1,
+		label: call.label,
+		dataLoss,
+		accessChanges: [],
+		temporaryValues: []
+	};
+}
+/** Whether `issue` is an extra table some contract space owns, which this space must leave alone. */
+function isTableOwnedElsewhere(issue, ownership) {
+	if (issueOutcome(issue) !== "not-expected") return false;
+	if (issueNode(issue)?.nodeKind !== RelationalSchemaNodeKind.table) return false;
+	const table = issue.path[1];
+	return table !== void 0 && ownership.declaresEntity({
+		namespaceId: UNBOUND_NAMESPACE_ID,
+		entityKind: "table",
+		entityName: table
+	});
+}
+/**
+* The MySQL migration planner. It diffs the contract's schema against the live one and plans creating and dropping tables, columns, indexes, unique constraints and foreign keys. Every other change, and every statement such as a rename, is refused with a conflict that says it is not yet supported on MySQL.
+*/
+var MysqlMigrationPlanner = class {
+	#lowerer;
+	constructor(lowerer) {
+		this.#lowerer = lowerer;
+	}
+	plan(options) {
+		return this.#planSql(blindCast(options));
+	}
+	emptyMigration(context, spaceId) {
+		return new TypeScriptRenderableMysqlMigration({
+			calls: [],
+			meta: {
+				from: context.fromHash,
+				to: context.toHash
+			},
+			spaceId,
+			snapshotsImportPath: context.snapshotsImportPath,
+			lowerer: this.#lowerer
+		});
+	}
+	#planSql(options) {
+		if (!options.policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
+			kind: "unsupportedOperation",
+			summary: "Migration planner requires additive operations be allowed",
+			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
+		}]);
+		const [statement] = options.statements;
+		if (statement !== void 0) return plannerFailure([statementNotYetSupported(statement)]);
+		if (!(options.schema instanceof SqlSchemaIR)) throw mysqlError("CONTRACT.TARGET_MISMATCH", "The MySQL planner received a schema tree that neither MySQL introspection nor contractToSchema built.");
+		const expected = mysqlContractToSchema(options.contract, sqlTypeLookupsOf(options.frameworkComponents));
+		const actual = options.schema;
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		const { ownership } = options;
+		const planned = planIssues({
+			issues: coalesceSubtreeIssues(diffSchemas(expected, actual)).filter((issue) => (strict || issueOutcome(issue) !== "not-expected") && (ownership === void 0 || !isTableOwnedElsewhere(issue, ownership))),
+			expected,
+			actual,
+			policy: options.policy
+		});
+		if (!planned.ok) return plannerFailure(planned.failure);
+		const calls = planned.value;
+		return {
+			kind: "success",
+			plan: new TypeScriptRenderableMysqlMigration({
+				calls,
+				meta: {
+					from: options.origin?.storageHash ?? null,
+					to: options.contract.storage.storageHash
+				},
+				spaceId: options.spaceId,
+				snapshotsImportPath: options.snapshotsImportPath,
+				destination: {
+					storageHash: options.contract.storage.storageHash,
+					...options.contract.profileHash === void 0 ? {} : { profileHash: options.contract.profileHash }
+				},
+				lowerer: this.#lowerer
+			}),
+			appliedStatements: [],
+			...subjectsOfCalls(calls.map(callSubjects), {
+				fromContract: options.fromContract,
+				contract: options.contract,
+				origins: NO_RENAMED_ORIGINS,
+				byHand: mysqlTableRenameByHand
+			})
+		};
+	}
+};
+function statementNotYetSupported(statement) {
+	return {
+		kind: "statementRefused",
+		summary: `A ${statement.kind} statement is not yet supported on MySQL`,
+		why: "The MySQL planner plans no rename, conversion or backfill yet. Plan the change without the statement, or write it by hand in a migration of its own with `migration new`.",
+		refusedStatement: statement
+	};
+}
+function createMysqlMigrationPlanner(lowerer) {
+	return new MysqlMigrationPlanner(lowerer);
+}
+/** An error without a structured code, such as a driver's socket error, thrown while a space applied: reported as `MIGRATION.EXECUTION_FAILED`, with its own code, when it has one, in `errorCode`. */
+function failureFromThrown(error) {
+	const errorCode = typeof error === "object" && error !== null ? Reflect.get(error, "code") : void 0;
+	return migrationRunnerFailure("MIGRATION.EXECUTION_FAILED", error instanceof Error ? error.message : String(error), {
+		meta: typeof errorCode === "string" ? { errorCode } : {},
+		cause: error
+	});
+}
+/** The structured error thrown while a space applied, keeping its code, advice and docs link, with the space and whether the database changed added to its facts. */
+function withSpaceFacts(error, failingSpace, databaseUnchanged) {
+	return Object.assign(error, { meta: {
+		...error.meta ?? {},
+		failingSpace,
+		databaseUnchanged
+	} });
+}
+function stepHolds(rows) {
+	const value = rows[0] === void 0 ? void 0 : Object.values(rows[0])[0];
+	if (typeof value === "string") return value !== "0" && value.length > 0;
+	return Boolean(value);
+}
+function skipRecord(operation) {
+	return Object.freeze({
+		id: operation.id,
+		label: operation.label,
+		...ifDefined("summary", operation.summary),
+		operationClass: operation.operationClass,
+		target: operation.target,
+		precheck: Object.freeze([]),
+		execute: Object.freeze([]),
+		postcheck: Object.freeze([...operation.postcheck]),
+		meta: Object.freeze({
+			...operation.meta ?? {},
+			runner: Object.freeze({
+				skipped: true,
+				reason: "postcheck_pre_satisfied"
+			})
+		})
+	});
+}
+/**
+* The MySQL migration runner. MySQL commits every DDL statement as it runs, so no transaction can undo an apply: the runner applies one space at a time, checks each operation before and after it runs, verifies the space's schema with the caller's strictness (every space, not only the app space), and only then writes the space's marker and ledger entries, in one transaction. A failure leaves the spaces before it applied, and running the apply again skips what already holds. The whole apply holds the marker lock, which MySQL keeps for the session, so it is released on the same connection when the apply ends.
+*/
+var MysqlMigrationRunner = class {
+	family;
+	constructor(family) {
+		this.family = family;
+	}
+	async execute(options) {
+		const { driver, perSpaceOptions } = options;
+		if (perSpaceOptions.length === 0) return ok({ perSpaceResults: [] });
+		return withMarkerLock(driver, () => this.#applySpaces(driver, perSpaceOptions), (result) => result.ok);
+	}
+	async executeOnConnection(options) {
+		return this.#applySpace(options, { changedDatabase: false });
+	}
+	async #applySpaces(driver, perSpaceOptions) {
+		const perSpaceResults = [];
+		let changedBefore = false;
+		for (const spaceOptions of perSpaceOptions) {
+			const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
+			const progress = { changedDatabase: false };
+			let result;
+			try {
+				result = await this.#applySpace({
+					...spaceOptions,
+					driver,
+					space
+				}, progress);
+			} catch (error) {
+				if (isInternalError(error)) throw error;
+				const databaseUnchanged = !changedBefore && !progress.changedDatabase;
+				if (isStructuredError(error)) throw withSpaceFacts(error, space, databaseUnchanged);
+				result = notOk(failureFromThrown(error));
+			}
+			if (!result.ok) return notOk(withFailingSpace(withDatabaseUnchanged(result.failure, !changedBefore && !progress.changedDatabase), space));
+			changedBefore ||= progress.changedDatabase;
+			perSpaceResults.push({
+				space,
+				value: result.value
+			});
+		}
+		return ok({ perSpaceResults });
+	}
+	async #applySpace(options, progress) {
+		const { driver } = options;
+		if (options.space !== void 0 && options.space !== options.plan.spaceId) throw mysqlError("MIGRATION.CONTRACT_SPACE_VIOLATION", `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`, { meta: {
+			space: options.space,
+			planSpaceId: options.plan.spaceId
+		} });
+		const space = options.plan.spaceId;
+		const operations = blindCast(await Promise.all(options.plan.operations));
+		const destinationCheck = this.#checkDestination(options.plan.destination, options.destinationContract);
+		if (!destinationCheck.ok) return destinationCheck;
+		const policyCheck = this.#checkPolicy(options.policy, operations);
+		if (!policyCheck.ok) return policyCheck;
+		await this.#ensureControlTables(driver, options);
+		const existingMarker = await this.family.readMarker({
+			driver,
+			space
+		});
+		const originCheck = this.#checkOrigin(existingMarker, options.plan.origin ?? null);
+		if (!originCheck.ok) return originCheck;
+		const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+		const applied = existingMarker !== null && existingMarker.storageHash === options.plan.destination.storageHash && (options.plan.destination.profileHash === void 0 || existingMarker.profileHash === options.plan.destination.profileHash) && options.plan.origin != null && !isSelfEdge ? {
+			result: okVoid(),
+			executed: [],
+			executedCount: 0
+		} : await this.#applyOperations(driver, options, operations, progress);
+		if (!applied.result.ok) return applied.result;
+		const schema = await this.family.introspect({
+			driver,
+			contract: options.destinationContract
+		});
+		const verified = this.family.verifySchema({
+			contract: options.destinationContract,
+			schema,
+			strict: options.strictVerification ?? true,
+			frameworkComponents: options.frameworkComponents
+		});
+		if (!verified.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", verified.summary, {
+			why: schemaCheckWhy(verified.schema.issues),
+			meta: { schemaIssues: verified.schema.issues }
+		});
+		const existingInvariants = new Set(existingMarker?.invariants ?? []);
+		if (!(isSelfEdge && applied.executedCount === 0 && options.plan.providedInvariants.every((id) => existingInvariants.has(id)))) {
+			const written = await this.#writeMarkerAndLedger(driver, options, existingMarker, applied.executed, progress);
+			if (!written.ok) return written;
+		}
+		return runnerSuccess({
+			operationsPlanned: operations.length,
+			operationsExecuted: applied.executedCount
+		});
+	}
+	async #ensureControlTables(driver, options) {
+		for (const query of this.family.bootstrapControlTableQueries()) {
+			const statement = await this.family.lowerAst(query, { contract: options.destinationContract });
+			await driver.query(statement.sql, statement.params);
+		}
+	}
+	async #applyOperations(driver, options, operations, progress) {
+		const checks = options.executionChecks;
+		const runPrechecks = checks?.prechecks !== false;
+		const runPostchecks = checks?.postchecks !== false;
+		const runIdempotency = checks?.idempotencyChecks !== false;
+		const executed = [];
+		let executedCount = 0;
+		const stop = (result) => ({
+			result,
+			executed,
+			executedCount
+		});
+		for (const operation of operations) {
+			options.callbacks?.onOperationStart?.(operation);
+			try {
+				if (runPostchecks && runIdempotency && await this.#allHold(driver, operation.postcheck)) {
+					executed.push(skipRecord(operation));
+					continue;
+				}
+				if (runPrechecks) {
+					const precheck = await this.#runChecks(driver, operation, "precheck");
+					if (!precheck.ok) return stop(precheck);
+				}
+				const execution = await this.#runSteps(driver, operation, progress);
+				if (!execution.ok) return stop(execution);
+				executedCount += 1;
+				if (runPostchecks) {
+					const postcheck = await this.#runChecks(driver, operation, "postcheck");
+					if (!postcheck.ok) return stop(postcheck);
+				}
+				executed.push(operation);
+			} finally {
+				options.callbacks?.onOperationComplete?.(operation);
+			}
+		}
+		return stop(okVoid());
+	}
+	async #allHold(driver, steps) {
+		if (steps.length === 0) return false;
+		for (const step of steps) if (!stepHolds((await driver.query(step.sql, step.params ?? [])).rows)) return false;
+		return true;
+	}
+	async #runChecks(driver, operation, phase) {
+		for (const step of operation[phase]) {
+			if (stepHolds((await driver.query(step.sql, step.params ?? [])).rows)) continue;
+			const failedCheck = {
+				operationId: operation.id,
+				phase,
+				description: step.description,
+				...ifDefined("expectation", step.expectation)
+			};
+			return runnerFailure(phase === "precheck" ? "MIGRATION.PRECHECK_FAILED" : "MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, {
+				why: phase === "precheck" ? failedPrecheckWhy(failedCheck) : failedPostcheckWhy(failedCheck),
+				meta: { failedCheck }
+			});
+		}
+		return okVoid();
+	}
+	/** Runs an operation's steps, and records in `progress` each one that reached the database, which a DDL statement changes for good. */
+	async #runSteps(driver, operation, progress) {
+		for (const step of operation.execute) try {
+			await driver.query(step.sql, step.params ?? []);
+			progress.changedDatabase = true;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return runnerFailure("MIGRATION.EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
+				why: message,
+				meta: {
+					operationId: operation.id,
+					stepDescription: step.description,
+					sql: step.sql
+				}
+			});
+		}
+		return okVoid();
+	}
+	async #writeMarkerAndLedger(driver, options, existingMarker, executed, progress) {
+		const { plan } = options;
+		const destination = {
+			storageHash: plan.destination.storageHash,
+			profileHash: plan.destination.profileHash ?? options.destinationContract.profileHash ?? plan.destination.storageHash,
+			invariants: plan.providedInvariants
+		};
+		await driver.query("START TRANSACTION");
+		try {
+			if (existingMarker === null) await this.family.initMarker({
+				driver,
+				space: plan.spaceId,
+				destination
+			});
+			else if (!await this.family.updateMarker({
+				driver,
+				space: plan.spaceId,
+				expectedFrom: existingMarker.storageHash,
+				destination
+			})) {
+				await driver.query("ROLLBACK");
+				const found = await this.family.readMarker({
+					driver,
+					space: plan.spaceId
+				});
+				return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+					space: plan.spaceId,
+					expectedStorageHash: existingMarker.storageHash,
+					foundStorageHash: found?.storageHash ?? null,
+					destinationStorageHash: plan.destination.storageHash
+				} });
+			}
+			await this.#writeLedger(driver, options, executed);
+		} catch (error) {
+			await driver.query("ROLLBACK").catch(() => void 0);
+			throw error;
+		}
+		progress.changedDatabase = true;
+		await driver.query("COMMIT");
+		return okVoid();
+	}
+	async #writeLedger(driver, options, executed) {
+		const { plan, migrationEdges } = options;
+		const edgeOperations = migrationEdges.reduce((sum, edge) => sum + edge.operationCount, 0);
+		if (edgeOperations !== plan.operations.length) throw new InternalError(`Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${edgeOperations})`);
+		let offset = 0;
+		for (const edge of migrationEdges) {
+			const operations = executed.slice(offset, offset + edge.operationCount);
+			offset += edge.operationCount;
+			await this.family.writeLedgerEntry({
+				driver,
+				space: plan.spaceId,
+				entry: {
+					edgeId: `${edge.from}->${edge.to}`,
+					from: edge.from,
+					to: edge.to,
+					migrationName: edge.dirName,
+					migrationHash: edge.migrationHash,
+					operations
+				}
+			});
+		}
+	}
+	#checkDestination(destination, contract) {
+		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
+			planStorageHash: destination.storageHash,
+			contractStorageHash: contract.storage.storageHash
+		} });
+		if (destination.profileHash !== void 0 && contract.profileHash !== void 0 && destination.profileHash !== contract.profileHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
+			planProfileHash: destination.profileHash,
+			contractProfileHash: contract.profileHash
+		} });
+		return okVoid();
+	}
+	#checkPolicy(policy, operations) {
+		const allowed = new Set(policy.allowedOperationClasses);
+		const refused = operations.find((operation) => !allowed.has(operation.operationClass));
+		if (refused === void 0) return okVoid();
+		return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${refused.id} has class "${refused.operationClass}" which is not allowed by policy.`, {
+			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
+			meta: {
+				operationId: refused.id,
+				operationClass: refused.operationClass,
+				allowedClasses: policy.allowedOperationClasses
+			}
+		});
+	}
+	#checkOrigin(marker, origin) {
+		if (origin === null) return okVoid();
+		if (marker === null) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+			markerStorageHash: marker.storageHash,
+			expectedOriginStorageHash: origin.storageHash
+		} });
+		if (origin.profileHash !== void 0 && marker.profileHash !== origin.profileHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
+			markerProfileHash: marker.profileHash,
+			expectedOriginProfileHash: origin.profileHash
+		} });
+		return okVoid();
+	}
+};
+function createMysqlMigrationRunner(family) {
+	return new MysqlMigrationRunner(family);
+}
+//#endregion
+export { diffMysqlSchema as _, CreateTableCall as a, DropIndexCall as c, MysqlMigration as d, MysqlMigrationPlanner as f, createMysqlMigrationRunner as g, createMysqlMigrationPlanner as h, CreateIndexCall as i, DropTableCall as l, TypeScriptRenderableMysqlMigration as m, AddForeignKeyCall as n, DropColumnCall as o, RawSqlCall as p, AddUniqueCall as r, DropForeignKeyCall as s, AddColumnCall as t, DropUniqueCall as u, mysqlContractToSchema as v, rawSql as y };
+
+//# sourceMappingURL=runner-C4r6yEd1-BWQrxW9q.mjs.map