@prisma-next/target-postgres 0.13.0 → 0.14.0-dev.2

package/dist/{op-factory-call-D2aAUhmS.mjs → op-factory-call-D_p5vxwt.mjs}

@@ -1,18 +1,20 @@
-import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName } from "./sql-utils-DcfMz4MQ.mjs";
-import { n as createTable, t as createSchema } from "./ddl-77SyXgFt.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, n as columnDefaultExistsCheck, o as columnTypeCheck, r as columnExistsCheck, s as constraintExistsCheck } from "./planner-sql-checks-DAdhnI2c.mjs";
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
+import { a as columnDefaultAst, c as columnTypeAst, d as indexExistsAst, f as noNullValuesAst, i as createTable, l as constraintExistsAst, m as tableIsEmptyAst, n as alterTable, o as columnExistsAst, p as tableExistsAst, r as createSchema, s as columnNullabilityAst, t as addColumnAction, u as extensionExistsAst } from "./ddl-QDyOSeLc.mjs";
+import { n as qualifyTableName } from "./planner-sql-checks-jqUUGyQR.mjs";
+import { t as buildAddColumnSql } from "./planner-ddl-builders-B2wOwLqI.mjs";
 import { FunctionColumnDefault, LiteralColumnDefault } from "@prisma-next/sql-relational-core/ast";
+import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { blindCast } from "@prisma-next/utils/casts";
 import { errorUnfilledPlaceholder } from "@prisma-next/errors/migration";
 import { TsExpression, jsonToTsSource } from "@prisma-next/ts-render";
 import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
 //#region src/core/migrations/operations/shared.ts
-function step(description, sql) {
+function step(description, sql, params) {
 	return {
 		description,
-		sql
+		sql,
+		...ifDefined("params", params)
 	};
 }
 function targetDetails(objectType, name, schema, table) {
@@ -28,51 +30,28 @@ function targetDetails(objectType, name, schema, table) {
 }
 //#endregion
 //#region src/core/migrations/operations/columns.ts
-function addColumn(schemaName, tableName, column) {
-	const addSql = [
-		`ALTER TABLE ${qualifyTableName(schemaName, tableName)}`,
-		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
-		column.defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
+async function columnExistsSteps(lowerer, options) {
+	const checks = columnExistsAst(options);
 	return {
-		id: `column.${tableName}.${column.name}`,
-		label: `Add column "${column.name}" to "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("column", column.name, schemaName, tableName),
-		precheck: [step(`ensure column "${column.name}" is missing`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name,
-			exists: false
-		}))],
-		execute: [step(`add column "${column.name}"`, addSql)],
-		postcheck: [step(`verify column "${column.name}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name
-		}))]
+		present: await lowerer.lowerToExecuteRequest(checks.columnPresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.columnAbsent())
 	};
 }
-function dropColumn(schemaName, tableName, columnName) {
+async function dropColumn(schemaName, tableName, columnName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { present, absent } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
 	return {
 		id: `dropColumn.${tableName}.${columnName}`,
 		label: `Drop column "${columnName}" from "${tableName}"`,
 		operationClass: "destructive",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
 		execute: [step(`drop column "${columnName}"`, `ALTER TABLE ${qualified} DROP COLUMN ${quoteIdentifier(columnName)}`)],
-		postcheck: [step(`verify column "${columnName}" does not exist`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
+		postcheck: [step(`verify column "${columnName}" does not exist`, absent.sql, absent.params)]
 	};
 }
 /**
@@ -83,69 +62,80 @@ function dropColumn(schemaName, tableName, columnName) {
 * string appearing in the human-readable label (typically `toType` when
 * explicit, else the column's native type).
 */
-function alterColumnType(schemaName, tableName, columnName, options) {
+async function alterColumnType(schemaName, tableName, columnName, options, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const usingClause = options.using ? ` USING ${options.using}` : ` USING ${quoteIdentifier(columnName)}::${options.qualifiedTargetType}`;
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const typeCheck = await lowerer.lowerToExecuteRequest(columnTypeAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName,
+		expectedType: options.formatTypeExpected
+	}));
 	return {
 		id: `alterType.${tableName}.${columnName}`,
 		label: `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`,
 		operationClass: "destructive",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
 		execute: [step(`alter type of "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} TYPE ${options.qualifiedTargetType}${usingClause}`)],
-		postcheck: [step(`verify column "${columnName}" has type "${options.formatTypeExpected}"`, columnTypeCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			expectedType: options.formatTypeExpected
-		}))],
+		postcheck: [step(`verify column "${columnName}" has type "${options.formatTypeExpected}"`, typeCheck.sql, typeCheck.params)],
 		meta: { warning: "TABLE_REWRITE" }
 	};
 }
-function setNotNull(schemaName, tableName, columnName) {
+async function setNotNull(schemaName, tableName, columnName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const noNulls = await lowerer.lowerToExecuteRequest(noNullValuesAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	}));
+	const notNullable = await lowerer.lowerToExecuteRequest(columnNullabilityAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName,
+		nullable: false
+	}));
 	return {
 		id: `alterNullability.setNotNull.${tableName}.${columnName}`,
 		label: `Set NOT NULL on "${tableName}"."${columnName}"`,
 		operationClass: "destructive",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		})), step(`ensure no NULL values in "${columnName}"`, `SELECT NOT EXISTS (SELECT 1 FROM ${qualified} WHERE ${quoteIdentifier(columnName)} IS NULL)`)],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params), step(`ensure no NULL values in "${columnName}"`, noNulls.sql, noNulls.params)],
 		execute: [step(`set NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is NOT NULL`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: false
-		}))]
+		postcheck: [step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params)]
 	};
 }
-function dropNotNull(schemaName, tableName, columnName) {
+async function dropNotNull(schemaName, tableName, columnName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const nullable = await lowerer.lowerToExecuteRequest(columnNullabilityAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName,
+		nullable: true
+	}));
 	return {
 		id: `alterNullability.dropNotNull.${tableName}.${columnName}`,
 		label: `Drop NOT NULL on "${tableName}"."${columnName}"`,
 		operationClass: "widening",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
 		execute: [step(`drop NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is nullable`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: true
-		}))]
+		postcheck: [step(`verify column "${columnName}" is nullable`, nullable.sql, nullable.params)]
 	};
 }
 /**
@@ -158,50 +148,94 @@ function dropNotNull(schemaName, tableName, columnName) {
 * when the column already has a different default — policy enforcement
 * treats that as a widening change rather than an additive one.
 */
-function setDefault(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
+async function setDefault(schemaName, tableName, columnName, defaultSql, lowerer, operationClass = "additive") {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const hasDefault = await lowerer.lowerToExecuteRequest(columnDefaultAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	}).defaultPresent());
 	return {
 		id: `setDefault.${tableName}.${columnName}`,
 		label: `Set default on "${tableName}"."${columnName}"`,
 		operationClass,
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
 		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultSql}`)],
-		postcheck: [step(`verify column "${columnName}" has a default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: true
-		}))]
+		postcheck: [step(`verify column "${columnName}" has a default`, hasDefault.sql, hasDefault.params)]
 	};
 }
-function dropDefault(schemaName, tableName, columnName) {
+async function dropDefault(schemaName, tableName, columnName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const noDefault = await lowerer.lowerToExecuteRequest(columnDefaultAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	}).defaultAbsent());
 	return {
 		id: `dropDefault.${tableName}.${columnName}`,
 		label: `Drop default on "${tableName}"."${columnName}"`,
 		operationClass: "destructive",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
 		execute: [step(`drop default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`)],
-		postcheck: [step(`verify column "${columnName}" has no default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
+		postcheck: [step(`verify column "${columnName}" has no default`, noDefault.sql, noDefault.params)]
+	};
+}
+/**
+* Builds the op for adding a NOT NULL column (no contract default) to a
+* non-empty table. Prechecks assert the column is absent and the table is
+* empty; the execute step is the raw ADD COLUMN SQL passed by the caller
+* (slice-7 deferred); postchecks assert the column exists and is NOT NULL.
+*/
+async function addNotNullColumnDirect(schemaName, tableName, columnName, executeStepSql, lowerer) {
+	const absent = await lowerer.lowerToExecuteRequest(columnExistsAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	}).columnAbsent());
+	const tableEmpty = await lowerer.lowerToExecuteRequest(tableIsEmptyAst(schemaName, tableName));
+	const present = await lowerer.lowerToExecuteRequest(columnExistsAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	}).columnPresent());
+	const notNullable = await lowerer.lowerToExecuteRequest(columnNullabilityAst({
+		schema: schemaName,
+		table: tableName,
+		column: columnName,
+		nullable: false
+	}));
+	return {
+		id: `column.${tableName}.${columnName}`,
+		label: `Add column ${columnName} to ${tableName}`,
+		summary: `Adds column ${columnName} to table ${tableName}`,
+		operationClass: "additive",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params), step(`ensure table "${tableName}" is empty before adding NOT NULL column without default`, tableEmpty.sql, tableEmpty.params)],
+		execute: [step(`add column "${columnName}"`, executeStepSql)],
+		postcheck: [step(`verify column "${columnName}" exists`, present.sql, present.params), step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params)]
 	};
 }
 //#endregion
 //#region src/core/migrations/operations/constraints.ts
+async function constraintCheckSteps(lowerer, options) {
+	const checks = constraintExistsAst(options);
+	return {
+		absent: await lowerer.lowerToExecuteRequest(checks.constraintAbsent()),
+		present: await lowerer.lowerToExecuteRequest(checks.constraintPresent())
+	};
+}
 function renderForeignKeySql(schemaName, tableName, fk) {
 	let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fk.name)}
@@ -219,111 +253,91 @@ REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.
 	}
 	return sql;
 }
-function addPrimaryKey(schemaName, tableName, constraintName, columns) {
+async function addPrimaryKey(schemaName, tableName, constraintName, columns, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const columnList = columns.map(quoteIdentifier).join(", ");
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `primaryKey.${tableName}.${constraintName}`,
 		label: `Add primary key on "${tableName}"`,
 		operationClass: "additive",
 		target: targetDetails("primaryKey", constraintName, schemaName, tableName),
-		precheck: [step(`ensure primary key "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
+		precheck: [step(`ensure primary key "${constraintName}" does not exist`, absent.sql, absent.params)],
 		execute: [step(`add primary key "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`)],
-		postcheck: [step(`verify primary key "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
+		postcheck: [step(`verify primary key "${constraintName}" exists`, present.sql, present.params)]
 	};
 }
-function addUnique(schemaName, tableName, constraintName, columns) {
+async function addUnique(schemaName, tableName, constraintName, columns, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const columnList = columns.map(quoteIdentifier).join(", ");
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `unique.${tableName}.${constraintName}`,
 		label: `Add unique constraint on "${tableName}" (${columns.join(", ")})`,
 		operationClass: "additive",
 		target: targetDetails("unique", constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
+		precheck: [step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params)],
 		execute: [step(`add unique constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`)],
-		postcheck: [step(`verify constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
+		postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)]
 	};
 }
-function addForeignKey(schemaName, tableName, fk) {
+async function addForeignKey(schemaName, tableName, fk, lowerer) {
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName: fk.name,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `foreignKey.${tableName}.${fk.name}`,
 		label: `Add foreign key "${fk.name}" on "${tableName}"`,
 		operationClass: "additive",
 		target: targetDetails("foreignKey", fk.name, schemaName, tableName),
-		precheck: [step(`ensure FK "${fk.name}" does not exist`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
+		precheck: [step(`ensure FK "${fk.name}" does not exist`, absent.sql, absent.params)],
 		execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
-		postcheck: [step(`verify FK "${fk.name}" exists`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName
-		}))]
+		postcheck: [step(`verify FK "${fk.name}" exists`, present.sql, present.params)]
 	};
 }
-function addCheckConstraint(schemaName, tableName, constraintName, column, values) {
+async function addCheckConstraint(schemaName, tableName, constraintName, column, values, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const valueList = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `checkConstraint.${tableName}.${constraintName}`,
 		label: `Add check constraint "${constraintName}" on "${tableName}"."${column}"`,
 		operationClass: "additive",
 		target: targetDetails("checkConstraint", constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
+		precheck: [step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params)],
 		execute: [step(`add check constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${quoteIdentifier(column)} IN (${valueList}))`)],
-		postcheck: [step(`verify constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
+		postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)]
 	};
 }
-function dropCheckConstraint(schemaName, tableName, constraintName) {
+async function dropCheckConstraint(schemaName, tableName, constraintName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `dropCheckConstraint.${tableName}.${constraintName}`,
 		label: `Drop check constraint "${constraintName}" on "${tableName}"`,
 		operationClass: "destructive",
 		target: targetDetails("checkConstraint", constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))],
+		precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
 		execute: [step(`drop check constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
-		postcheck: [step(`verify constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))]
+		postcheck: [step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params)]
 	};
 }
 /**
@@ -333,25 +347,21 @@ function dropCheckConstraint(schemaName, tableName, constraintName) {
 * (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
 * that produced the drop.
 */
-function dropConstraint(schemaName, tableName, constraintName, kind = "unique") {
+async function dropConstraint(schemaName, tableName, constraintName, lowerer, kind = "unique") {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const { absent, present } = await constraintCheckSteps(lowerer, {
+		constraintName,
+		schema: schemaName,
+		table: tableName
+	});
 	return {
 		id: `dropConstraint.${tableName}.${constraintName}`,
 		label: `Drop constraint "${constraintName}" on "${tableName}"`,
 		operationClass: "destructive",
 		target: targetDetails(kind, constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))],
+		precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
 		execute: [step(`drop constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
-		postcheck: [step(`verify constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))]
+		postcheck: [step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params)]
 	};
 }
 //#endregion
@@ -381,11 +391,15 @@ function createExtension(extensionName) {
 * use the bare {@link createExtension} for planner-emitted ops where the
 * caller already controls idempotency through the surrounding plan.
 */
-function installExtension(options) {
+async function installExtension(options, lowerer) {
 	const { extensionName, invariantId, id } = options;
+	const label = options.label ?? `Enable extension "${extensionName}"`;
+	const checks = extensionExistsAst(extensionName);
+	const absent = await lowerer.lowerToExecuteRequest(checks.extensionAbsent());
+	const present = await lowerer.lowerToExecuteRequest(checks.extensionPresent());
 	return {
 		id,
-		label: options.label ?? `Enable extension "${extensionName}"`,
+		label,
 		operationClass: "additive",
 		invariantId,
 		target: {
@@ -396,77 +410,20 @@ function installExtension(options) {
 				name: extensionName
 			}
 		},
-		precheck: [step(`verify extension "${extensionName}" is not already enabled`, `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)],
+		precheck: [step(`verify extension "${extensionName}" is not already enabled`, absent.sql, absent.params)],
 		execute: [step(`create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${extensionName}`)],
-		postcheck: [step(`confirm extension "${extensionName}" is enabled`, `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)]
+		postcheck: [step(`confirm extension "${extensionName}" is enabled`, present.sql, present.params)]
 	};
 }
 //#endregion
-//#region src/core/migrations/operations/enums.ts
-function enumTypeExistsCheck(schemaName, nativeType, exists = true) {
-	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
-  SELECT 1
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  WHERE n.nspname = '${escapeLiteral(schemaName)}'
-    AND t.typname = '${escapeLiteral(nativeType)}'
-)`;
-}
-function createEnumType(schemaName, typeName, values, nativeType = typeName) {
-	const qualifiedType = qualifyName(schemaName, nativeType);
-	const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
-	return {
-		id: `type.${typeName}`,
-		label: `Create enum type "${typeName}"`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${nativeType}" does not exist`, enumTypeExistsCheck(schemaName, nativeType, false))],
-		execute: [step(`create enum type "${typeName}"`, `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`)],
-		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
-	};
-}
-/**
-* `typeName` is the contract-facing type name (used for id/label).
-* `nativeType` is the Postgres type name to mutate (may differ for external types).
-*/
-function addEnumValues(schemaName, typeName, nativeType, values) {
-	const qualifiedType = qualifyName(schemaName, nativeType);
-	return {
-		id: `type.${typeName}.addValues`,
-		label: `Add values to enum type "${typeName}": ${values.join(", ")}`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))],
-		execute: values.map((value) => step(`add value '${value}' to enum "${nativeType}"`, `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`)),
-		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
-	};
-}
-function dropEnumType(schemaName, typeName) {
-	const qualified = qualifyName(schemaName, typeName);
-	return {
-		id: `type.${typeName}.drop`,
-		label: `Drop enum type "${typeName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
-		execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
-		postcheck: [step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false))]
-	};
-}
-function renameType(schemaName, fromName, toName) {
-	const qualifiedFrom = qualifyName(schemaName, fromName);
+//#region src/core/migrations/operations/indexes.ts
+async function indexExistsSteps(lowerer, schemaName, indexName) {
+	const checks = indexExistsAst(schemaName, indexName);
 	return {
-		id: `type.${fromName}.rename`,
-		label: `Rename type "${fromName}" to "${toName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", fromName, schemaName),
-		precheck: [step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)), step(`ensure type "${toName}" does not already exist`, enumTypeExistsCheck(schemaName, toName, false))],
-		execute: [step(`rename type "${fromName}" to "${toName}"`, `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`)],
-		postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))]
+		present: await lowerer.lowerToExecuteRequest(checks.indexPresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.indexAbsent())
 	};
 }
-//#endregion
-//#region src/core/migrations/operations/indexes.ts
 function renderIndexOptionValue(key, value) {
 	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
 	if (typeof value === "number" && Number.isFinite(value)) return String(value);
@@ -476,45 +433,115 @@ function renderIndexOptionValue(key, value) {
 function renderIndexOptions(options) {
 	return Object.entries(options).map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`).join(", ");
 }
-function createIndex(schemaName, tableName, indexName, columns, extras) {
+async function createIndex(schemaName, tableName, indexName, columns, lowerer, extras) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const columnList = columns.map(quoteIdentifier).join(", ");
 	const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : "";
 	const options = extras?.options;
 	const withClause = options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : "";
+	const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
 	return {
 		id: `index.${tableName}.${indexName}`,
 		label: `Create index "${indexName}" on "${tableName}"`,
 		operationClass: "additive",
 		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)],
+		precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
 		execute: [step(`create index "${indexName}"`, `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`)],
-		postcheck: [step(`verify index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)]
+		postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)]
 	};
 }
-function dropIndex(schemaName, tableName, indexName) {
+async function dropIndex(schemaName, tableName, indexName, lowerer) {
+	const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
 	return {
 		id: `dropIndex.${tableName}.${indexName}`,
 		label: `Drop index "${indexName}"`,
 		operationClass: "destructive",
 		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)],
+		precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
 		execute: [step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`)],
-		postcheck: [step(`verify index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)]
+		postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)]
 	};
 }
 //#endregion
 //#region src/core/migrations/operations/tables.ts
-function dropTable(schemaName, tableName) {
+async function dropTable(schemaName, tableName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
+	const checks = tableExistsAst(schemaName, tableName);
+	const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+	const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
 	return {
 		id: `dropTable.${tableName}`,
 		label: `Drop table "${tableName}"`,
 		operationClass: "destructive",
 		target: targetDetails("table", tableName, schemaName),
-		precheck: [step(`ensure table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)],
+		precheck: [step(`ensure table "${tableName}" exists`, present.sql, present.params)],
 		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
-		postcheck: [step(`verify table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)]
+		postcheck: [step(`verify table "${tableName}" does not exist`, absent.sql, absent.params)]
+	};
+}
+//#endregion
+//#region src/core/migrations/planner-target-details.ts
+function buildTargetDetails(objectType, name, schema, table) {
+	return {
+		schema,
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
+//#endregion
+//#region src/core/migrations/planner-recipes.ts
+function buildAddColumnOperationIdentity(schema, tableName, columnName) {
+	return {
+		id: `column.${tableName}.${columnName}`,
+		label: `Add column ${columnName} to ${tableName}`,
+		summary: `Adds column ${columnName} to table ${tableName}`,
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("table", tableName, schema)
+		}
+	};
+}
+async function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
+	const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault, lowerer } = options;
+	const qualified = qualifyTableName(schema, tableName);
+	const absent = await lowerer.lowerToExecuteRequest(columnExistsAst({
+		schema,
+		table: tableName,
+		column: columnName
+	}).columnAbsent());
+	const present = await lowerer.lowerToExecuteRequest(columnExistsAst({
+		schema,
+		table: tableName,
+		column: columnName
+	}).columnPresent());
+	const notNullable = await lowerer.lowerToExecuteRequest(columnNullabilityAst({
+		schema,
+		table: tableName,
+		column: columnName,
+		nullable: false
+	}));
+	const noDefault = await lowerer.lowerToExecuteRequest(columnDefaultAst({
+		schema,
+		table: tableName,
+		column: columnName
+	}).noDefault());
+	return {
+		...buildAddColumnOperationIdentity(schema, tableName, columnName),
+		operationClass: "additive",
+		precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params)],
+		execute: [{
+			description: `add column "${columnName}"`,
+			sql: buildAddColumnSql(qualified, columnName, column, codecHooks, temporaryDefault, storageTypes)
+		}, {
+			description: `drop temporary default from column "${columnName}"`,
+			sql: `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`
+		}],
+		postcheck: [
+			step(`verify column "${columnName}" exists`, present.sql, present.params),
+			step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params),
+			step(`verify column "${columnName}" has no default after temporary default removal`, noDefault.sql, noDefault.params)
+		]
 	};
 }
 //#endregion
@@ -541,6 +568,9 @@ function dropTable(schemaName, tableName) {
 * `PostgresOpFactoryCall` union.
 */
 const POSTGRES_MIGRATION_FACADE = "@prisma-next/postgres/migration";
+function boundSchema(schemaName) {
+	return schemaName === UNBOUND_NAMESPACE_ID ? void 0 : schemaName;
+}
 var PostgresOpFactoryCallNode = class extends TsExpression {
 	importRequirements() {
 		return [{
@@ -573,6 +603,7 @@ function renderDdlColumnAsTsCall(col) {
 	if (col.notNull) opts.push("notNull: true");
 	if (col.primaryKey) opts.push("primaryKey: true");
 	if (col.default) opts.push(`default: ${renderDdlColumnDefault(col.default)}`);
+	if (col.codecRef) opts.push(`codecRef: ${jsonToTsSource(col.codecRef)}`);
 	const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
 	return `col(${jsonToTsSource(col.name)}, ${jsonToTsSource(col.type)}${optsStr})`;
 }
@@ -630,26 +661,33 @@ var CreateTableCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Create table "${tableName}"`;
 		this.freeze();
 	}
-	toOp(lowerer) {
+	async toOp(lowerer) {
 		if (lowerer === void 0) throw new Error(`CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
 		const ddlNode = createTable({
-			...this.schemaName !== UNBOUND_NAMESPACE_ID ? { schema: this.schemaName } : {},
+			...ifDefined("schema", boundSchema(this.schemaName)),
 			table: this.tableName,
 			columns: this.columns,
-			...this.constraints ? { constraints: this.constraints } : {}
+			...ifDefined("constraints", this.constraints)
 		});
-		const { sql } = lowerer.lower(ddlNode, { contract: {} });
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
 		const schemaName = this.schemaName;
 		const tableName = this.tableName;
+		const checks = tableExistsAst(schemaName, tableName);
+		const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+		const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
 		return {
 			id: `table.${tableName}`,
 			label: `Create table "${tableName}"`,
 			summary: `Creates table "${tableName}"`,
 			operationClass: "additive",
 			target: targetDetails("table", tableName, schemaName),
-			precheck: [step(`ensure table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)],
-			execute: [step(`create table "${tableName}"`, sql)],
-			postcheck: [step(`verify table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)]
+			precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params)],
+			execute: [{
+				description: `create table "${tableName}"`,
+				sql: statement.sql,
+				params: statement.params ?? []
+			}],
+			postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)]
 		};
 	}
 	renderTypeScript() {
@@ -694,11 +732,18 @@ var DropTableCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop table "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropTable(this.schemaName, this.tableName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropTableCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropTable(this.schemaName, this.tableName, lowerer);
 	}
 	renderTypeScript() {
-		return `dropTable(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		return `this.dropTable({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var AddColumnCall = class extends PostgresOpFactoryCallNode {
@@ -716,11 +761,51 @@ var AddColumnCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Add column "${column.name}" to "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return addColumn(this.schemaName, this.tableName, this.column);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddColumnCall.toOp: a DDL lowerer is required on the Postgres planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		const ddlNode = alterTable({
+			...ifDefined("schema", boundSchema(this.schemaName)),
+			table: this.tableName,
+			actions: [addColumnAction(this.column)]
+		});
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+		const schemaName = this.schemaName;
+		const tableName = this.tableName;
+		const columnName = this.column.name;
+		const colChecks = columnExistsAst({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		});
+		const absent = await lowerer.lowerToExecuteRequest(colChecks.columnAbsent());
+		const present = await lowerer.lowerToExecuteRequest(colChecks.columnPresent());
+		return {
+			id: `column.${schemaName}.${tableName}.${columnName}`,
+			label: `Add column "${columnName}" to "${tableName}"`,
+			operationClass: "additive",
+			target: targetDetails("column", columnName, schemaName, tableName),
+			precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params)],
+			execute: [step(`add column "${columnName}"`, statement.sql)],
+			postcheck: [step(`verify column "${columnName}" exists`, present.sql, present.params)]
+		};
 	}
 	renderTypeScript() {
-		return `addColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${renderDdlColumnAsTsCall(this.column)}`);
+		return `this.addColumn({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		const req = [{
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: "col"
+		}];
+		for (const sym of defaultImportSymbols([this.column])) req.push({
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: sym
+		});
+		return req;
 	}
 };
 var DropColumnCall = class extends PostgresOpFactoryCallNode {
@@ -738,11 +823,19 @@ var DropColumnCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop column "${columnName}" from "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropColumn(this.schemaName, this.tableName, this.columnName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropColumnCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropColumn(this.schemaName, this.tableName, this.columnName, lowerer);
 	}
 	renderTypeScript() {
-		return `dropColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		return `this.dropColumn({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var AlterColumnTypeCall = class extends PostgresOpFactoryCallNode {
@@ -762,11 +855,20 @@ var AlterColumnTypeCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`;
 		this.freeze();
 	}
-	toOp() {
-		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AlterColumnTypeCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options, lowerer);
 	}
 	renderTypeScript() {
-		return `alterColumnType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)}, ${jsonToTsSource(this.options)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		opts.push(`options: ${jsonToTsSource(this.options)}`);
+		return `this.alterColumnType({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var SetNotNullCall = class extends PostgresOpFactoryCallNode {
@@ -784,11 +886,19 @@ var SetNotNullCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Set NOT NULL on "${tableName}"."${columnName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return setNotNull(this.schemaName, this.tableName, this.columnName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`SetNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return setNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
 	}
 	renderTypeScript() {
-		return `setNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		return `this.setNotNull({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var DropNotNullCall = class extends PostgresOpFactoryCallNode {
@@ -806,11 +916,19 @@ var DropNotNullCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop NOT NULL on "${tableName}"."${columnName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropNotNull(this.schemaName, this.tableName, this.columnName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
 	}
 	renderTypeScript() {
-		return `dropNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		return `this.dropNotNull({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var SetDefaultCall = class extends PostgresOpFactoryCallNode {
@@ -831,18 +949,21 @@ var SetDefaultCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Set default on "${tableName}"."${columnName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, this.operationClass);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, lowerer, this.operationClass);
 	}
 	renderTypeScript() {
-		const args = [
-			jsonToTsSource(this.schemaName),
-			jsonToTsSource(this.tableName),
-			jsonToTsSource(this.columnName),
-			jsonToTsSource(this.defaultSql)
-		];
-		if (this.operationClass !== "additive") args.push(jsonToTsSource(this.operationClass));
-		return `setDefault(${args.join(", ")})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		opts.push(`defaultSql: ${jsonToTsSource(this.defaultSql)}`);
+		if (this.operationClass !== "additive") opts.push(`operationClass: ${jsonToTsSource(this.operationClass)}`);
+		return `this.setDefault({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var DropDefaultCall = class extends PostgresOpFactoryCallNode {
@@ -860,13 +981,127 @@ var DropDefaultCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop default on "${tableName}"."${columnName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropDefault(this.schemaName, this.tableName, this.columnName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropDefault(this.schemaName, this.tableName, this.columnName, lowerer);
+	}
+	renderTypeScript() {
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
+		return `this.dropDefault({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* Planner-internal call for adding a NOT NULL column (no contract default) to
+* a table that must be empty at migration time. Carries the raw ADD COLUMN SQL
+* (produced by `buildAddColumnSql` at plan time — deferred from slice-7 typed
+* DDL) plus the parameters needed to lower the typed pre/postchecks at render
+* time.
+*
+* No authored `PostgresMigration` method: this call is only emitted by the
+* planner, never hand-written by migration authors.
+*/
+var AddNotNullColumnDirectCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	columnName;
+	executeStepSql;
+	label;
+	constructor(schemaName, tableName, columnName, executeStepSql) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.executeStepSql = executeStepSql;
+		this.label = `Add column ${columnName} to ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return addNotNullColumnDirect(this.schemaName, this.tableName, this.columnName, this.executeStepSql, lowerer);
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource({
+			id: `column.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			operationClass: "additive"
+		})})`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* Planner-internal call for adding a NOT NULL column (no contract default)
+* using a temporary default value for non-empty tables. Carries all parameters
+* needed for `buildAddNotNullColumnWithTemporaryDefaultOperation`; the typed
+* pre/postchecks are lowered at render time via `toOp(lowerer)`. The execute
+* SQL (`buildAddColumnSql`) is still raw per slice-7 deferral.
+*
+* No authored `PostgresMigration` method: this call is only emitted by the
+* planner, never hand-written by migration authors.
+*/
+var AddNotNullColumnWithTempDefaultCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	columnName;
+	column;
+	codecHooks;
+	storageTypes;
+	temporaryDefault;
+	label;
+	constructor(options) {
+		super();
+		this.schemaName = options.schemaName;
+		this.tableName = options.tableName;
+		this.columnName = options.columnName;
+		this.column = options.column;
+		this.codecHooks = options.codecHooks;
+		this.storageTypes = options.storageTypes;
+		this.temporaryDefault = options.temporaryDefault;
+		this.label = `Add column ${options.columnName} to ${options.tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddNotNullColumnWithTempDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return buildAddNotNullColumnWithTemporaryDefaultOperation({
+			schema: this.schemaName,
+			tableName: this.tableName,
+			columnName: this.columnName,
+			column: this.column,
+			codecHooks: this.codecHooks,
+			storageTypes: this.storageTypes,
+			temporaryDefault: this.temporaryDefault,
+			lowerer
+		});
 	}
 	renderTypeScript() {
-		return `dropDefault(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+		return `rawSql(${jsonToTsSource({
+			id: `column.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			operationClass: "additive"
+		})})`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
+function constraintCallOptions(schemaName, tableName, constraintName) {
+	const opts = [];
+	if (schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(schemaName)}`);
+	opts.push(`table: ${jsonToTsSource(tableName)}`);
+	opts.push(`constraint: ${jsonToTsSource(constraintName)}`);
+	return opts.join(", ");
+}
 var AddPrimaryKeyCall = class extends PostgresOpFactoryCallNode {
 	factoryName = "addPrimaryKey";
 	operationClass = "additive";
@@ -884,11 +1119,15 @@ var AddPrimaryKeyCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Add primary key on "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return addPrimaryKey(this.schemaName, this.tableName, this.constraintName, this.columns);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddPrimaryKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return addPrimaryKey(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
 	}
 	renderTypeScript() {
-		return `addPrimaryKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
+		return `this.addPrimaryKey({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var AddUniqueCall = class extends PostgresOpFactoryCallNode {
@@ -908,11 +1147,15 @@ var AddUniqueCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Add unique constraint on "${tableName}" (${columns.join(", ")})`;
 		this.freeze();
 	}
-	toOp() {
-		return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddUniqueCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
 	}
 	renderTypeScript() {
-		return `addUnique(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
+		return `this.addUnique({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var AddForeignKeyCall = class extends PostgresOpFactoryCallNode {
@@ -930,11 +1173,19 @@ var AddForeignKeyCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Add foreign key "${fk.name}" on "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return addForeignKey(this.schemaName, this.tableName, this.fk);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddForeignKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.fk.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return addForeignKey(this.schemaName, this.tableName, this.fk, lowerer);
 	}
 	renderTypeScript() {
-		return `addForeignKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.fk)})`;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`foreignKey: ${jsonToTsSource(this.fk)}`);
+		return `this.addForeignKey({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var DropConstraintCall = class extends PostgresOpFactoryCallNode {
@@ -954,17 +1205,17 @@ var DropConstraintCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop constraint "${constraintName}" on "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropConstraint(this.schemaName, this.tableName, this.constraintName, this.kind);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropConstraint(this.schemaName, this.tableName, this.constraintName, lowerer, this.kind);
 	}
 	renderTypeScript() {
-		const args = [
-			jsonToTsSource(this.schemaName),
-			jsonToTsSource(this.tableName),
-			jsonToTsSource(this.constraintName)
-		];
-		if (this.kind !== "unique") args.push(jsonToTsSource(this.kind));
-		return `dropConstraint(${args.join(", ")})`;
+		const opts = [constraintCallOptions(this.schemaName, this.tableName, this.constraintName)];
+		if (this.kind !== "unique") opts.push(`kind: ${jsonToTsSource(this.kind)}`);
+		return `this.dropConstraint({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var AddCheckConstraintCall = class extends PostgresOpFactoryCallNode {
@@ -986,11 +1237,15 @@ var AddCheckConstraintCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Add check constraint "${constraintName}" on "${tableName}"."${column}"`;
 		this.freeze();
 	}
-	toOp() {
-		return addCheckConstraint(this.schemaName, this.tableName, this.constraintName, this.column, this.values);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`AddCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return addCheckConstraint(this.schemaName, this.tableName, this.constraintName, this.column, this.values, lowerer);
 	}
 	renderTypeScript() {
-		return `addCheckConstraint(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.column)}, ${jsonToTsSource(this.values)})`;
+		return `this.addCheckConstraint({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, column: ${jsonToTsSource(this.column)}, values: ${jsonToTsSource(this.values)} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var DropCheckConstraintCall = class extends PostgresOpFactoryCallNode {
@@ -1008,11 +1263,15 @@ var DropCheckConstraintCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop check constraint "${constraintName}" on "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName, lowerer);
 	}
 	renderTypeScript() {
-		return `dropCheckConstraint(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)})`;
+		return `this.dropCheckConstraint({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var CreateIndexCall = class extends PostgresOpFactoryCallNode {
@@ -1036,26 +1295,29 @@ var CreateIndexCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Create index "${indexName}" on "${tableName}"`;
 		this.freeze();
 	}
-	toOp() {
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`CreateIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
 		const extras = {};
 		if (this.indexType !== void 0) extras.type = this.indexType;
 		if (this.options !== void 0) extras.options = this.options;
-		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns, extras);
+		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns, lowerer, extras);
 	}
 	renderTypeScript() {
-		const args = [
-			jsonToTsSource(this.schemaName),
-			jsonToTsSource(this.tableName),
-			jsonToTsSource(this.indexName),
-			jsonToTsSource(this.columns)
-		];
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`index: ${jsonToTsSource(this.indexName)}`);
+		opts.push(`columns: ${jsonToTsSource(this.columns)}`);
 		if (this.indexType !== void 0 || this.options !== void 0) {
 			const extrasParts = [];
 			if (this.indexType !== void 0) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
 			if (this.options !== void 0) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
-			args.push(`{ ${extrasParts.join(", ")} }`);
+			opts.push(`extras: { ${extrasParts.join(", ")} }`);
 		}
-		return `createIndex(${args.join(", ")})`;
+		return `this.createIndex({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 var DropIndexCall = class extends PostgresOpFactoryCallNode {
@@ -1073,102 +1335,19 @@ var DropIndexCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Drop index "${indexName}"`;
 		this.freeze();
 	}
-	toOp() {
-		return dropIndex(this.schemaName, this.tableName, this.indexName);
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`DropIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		return dropIndex(this.schemaName, this.tableName, this.indexName, lowerer);
 	}
 	renderTypeScript() {
-		return `dropIndex(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;
-	}
-};
-var CreateEnumTypeCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "createEnumType";
-	operationClass = "additive";
-	schemaName;
-	typeName;
-	nativeType;
-	values;
-	label;
-	constructor(schemaName, typeName, values, nativeType = typeName) {
-		super();
-		this.schemaName = schemaName;
-		this.typeName = typeName;
-		this.nativeType = nativeType;
-		this.values = values;
-		this.label = `Create enum type "${typeName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return createEnumType(this.schemaName, this.typeName, this.values, this.nativeType);
-	}
-	renderTypeScript() {
-		const nativeArg = this.nativeType === this.typeName ? "" : `, ${jsonToTsSource(this.nativeType)}`;
-		return `createEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.values)}${nativeArg})`;
-	}
-};
-var AddEnumValuesCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "addEnumValues";
-	operationClass = "additive";
-	schemaName;
-	typeName;
-	nativeType;
-	values;
-	label;
-	constructor(schemaName, typeName, nativeType, values) {
-		super();
-		this.schemaName = schemaName;
-		this.typeName = typeName;
-		this.nativeType = nativeType;
-		this.values = values;
-		this.label = `Add values to enum type "${typeName}": ${values.join(", ")}`;
-		this.freeze();
-	}
-	toOp() {
-		return addEnumValues(this.schemaName, this.typeName, this.nativeType, this.values);
-	}
-	renderTypeScript() {
-		return `addEnumValues(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.nativeType)}, ${jsonToTsSource(this.values)})`;
-	}
-};
-var DropEnumTypeCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "dropEnumType";
-	operationClass = "destructive";
-	schemaName;
-	typeName;
-	label;
-	constructor(schemaName, typeName) {
-		super();
-		this.schemaName = schemaName;
-		this.typeName = typeName;
-		this.label = `Drop enum type "${typeName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return dropEnumType(this.schemaName, this.typeName);
-	}
-	renderTypeScript() {
-		return `dropEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)})`;
-	}
-};
-var RenameTypeCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "renameType";
-	operationClass = "destructive";
-	schemaName;
-	fromName;
-	toName;
-	label;
-	constructor(schemaName, fromName, toName) {
-		super();
-		this.schemaName = schemaName;
-		this.fromName = fromName;
-		this.toName = toName;
-		this.label = `Rename type "${fromName}" to "${toName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return renameType(this.schemaName, this.fromName, this.toName);
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`index: ${jsonToTsSource(this.indexName)}`);
+		return `this.dropIndex({ ${opts.join(", ")} })`;
 	}
-	renderTypeScript() {
-		return `renameType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.fromName)}, ${jsonToTsSource(this.toName)})`;
+	importRequirements() {
+		return [];
 	}
 };
 /**
@@ -1232,13 +1411,13 @@ var CreateSchemaCall = class extends PostgresOpFactoryCallNode {
 		this.label = `Create schema "${schemaName}"`;
 		this.freeze();
 	}
-	toOp(lowerer) {
+	async toOp(lowerer) {
 		if (lowerer === void 0) throw new Error(`CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
 		const ddlNode = createSchema({
 			schema: this.schemaName,
 			ifNotExists: true
 		});
-		const { sql } = lowerer.lower(ddlNode, { contract: {} });
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
 		const schemaName = this.schemaName;
 		return {
 			id: `schema.${schemaName}`,
@@ -1246,7 +1425,11 @@ var CreateSchemaCall = class extends PostgresOpFactoryCallNode {
 			operationClass: "additive",
 			target: { id: "postgres" },
 			precheck: [],
-			execute: [step(`Create schema "${schemaName}"`, sql)],
+			execute: [{
+				description: `Create schema "${schemaName}"`,
+				sql: statement.sql,
+				params: statement.params ?? []
+			}],
 			postcheck: []
 		};
 	}
@@ -1302,6 +1485,6 @@ var DataTransformCall = class extends PostgresOpFactoryCallNode {
 	}
 };
 //#endregion
-export { addEnumValues as A, dropCheckConstraint as B, RenameTypeCall as C, dropTable as D, postgresDefaultToDdlColumnDefault as E, installExtension as F, dropDefault as G, addColumn as H, addCheckConstraint as I, setNotNull as J, dropNotNull as K, addForeignKey as L, dropEnumType as M, renameType as N, createIndex as O, createExtension as P, addPrimaryKey as R, RawSqlCall as S, SetNotNullCall as T, alterColumnType as U, dropConstraint as V, dropColumn as W, DropDefaultCall as _, AddPrimaryKeyCall as a, DropNotNullCall as b, CreateEnumTypeCall as c, CreateSchemaCall as d, CreateTableCall as f, DropConstraintCall as g, DropColumnCall as h, AddForeignKeyCall as i, createEnumType as j, dropIndex as k, CreateExtensionCall as l, DropCheckConstraintCall as m, AddColumnCall as n, AddUniqueCall as o, DataTransformCall as p, setDefault as q, AddEnumValuesCall as r, AlterColumnTypeCall as s, AddCheckConstraintCall as t, CreateIndexCall as u, DropEnumTypeCall as v, SetDefaultCall as w, DropTableCall as x, DropIndexCall as y, addUnique as z };
+export { SetNotNullCall as C, installExtension as D, createExtension as E, SetDefaultCall as S, buildTargetDetails as T, DropDefaultCall as _, AddNotNullColumnWithTempDefaultCall as a, DropTableCall as b, AlterColumnTypeCall as c, CreateSchemaCall as d, CreateTableCall as f, DropConstraintCall as g, DropColumnCall as h, AddNotNullColumnDirectCall as i, CreateExtensionCall as l, DropCheckConstraintCall as m, AddColumnCall as n, AddPrimaryKeyCall as o, DataTransformCall as p, AddForeignKeyCall as r, AddUniqueCall as s, AddCheckConstraintCall as t, CreateIndexCall as u, DropIndexCall as v, postgresDefaultToDdlColumnDefault as w, RawSqlCall as x, DropNotNullCall as y };
 
-//# sourceMappingURL=op-factory-call-D2aAUhmS.mjs.map
+//# sourceMappingURL=op-factory-call-D_p5vxwt.mjs.map