@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/op-factory-call-DifL68KT-Bo6pxs-R.mjs

@@ -0,0 +1,2009 @@
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
+import { a as validateEnumValueLength, i as quoteQualifiedName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-BnBlQxyh-DaX9Nb7Z.mjs";
+import { C as nativeEnumValueExistsAst, D as tableExistsAst, E as rlsPolicyExistsAst, O as tableIsEmptyAst, S as nativeEnumTypeExistsAst, T as rlsEnabledAst, _ as dropIndex$1, a as columnDefaultAst, b as extensionExistsAst, c as columnTypeAst, d as createPolicy, f as createSchema, g as dropDefaultAction, h as disableRowLevelSecurity$1, i as alterTable, l as constraintExistsAst, m as createType, n as alterIndexRename, o as columnExistsAst, p as createTable, r as alterPolicyRename, s as columnNullabilityAst, t as addColumnAction, u as createIndex$1, v as dropPolicy, w as noNullValuesAst, x as indexExistsAst, y as dropType } from "./ddl-BdP4q3KY-Duef4uHw.mjs";
+import { n as qualifyTableName } from "./planner-sql-checks-DRc_78n8-C9nHOrvU.mjs";
+import { n as buildColumnTypeSql } from "./planner-ddl-builders-CbfICQfm-CxYiLrhX.mjs";
+import { FunctionColumnDefault, LiteralColumnDefault } from "@prisma/orm-family-sql/relational-core/ast";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { namingOf } from "@prisma/orm-family-sql/schema-ir/naming";
+import { col } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { errorUnfilledPlaceholder } from "@prisma/orm-framework/errors/migration";
+import { TsExpression, jsonToTsSource } from "@prisma/orm-framework/ts-render";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-DifL68KT.mjs
+/**
+* Maps a planner schema name to the contract-free DDL builder's optional
+* `schema` field: the unbound sentinel becomes `undefined` (the builder omits
+* the schema qualifier), every other name passes through.
+*/
+function boundSchema(schemaName) {
+	return schemaName === UNBOUND_NAMESPACE_ID ? void 0 : schemaName;
+}
+function step(description, sql, params) {
+	return {
+		description,
+		sql,
+		...ifDefined("params", params)
+	};
+}
+function targetDetails(objectType, name, schema, table) {
+	return {
+		id: "postgres",
+		details: {
+			schema,
+			objectType,
+			name,
+			...ifDefined("table", table)
+		}
+	};
+}
+async function columnExistsSteps(lowerer, options) {
+	const checks = columnExistsAst(options);
+	return {
+		present: await lowerer.lowerToExecuteRequest(checks.columnPresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.columnAbsent())
+	};
+}
+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`, present.sql, present.params)],
+		execute: [step(`drop column "${columnName}"`, `ALTER TABLE ${qualified} DROP COLUMN ${quoteIdentifier(columnName)}`)],
+		postcheck: [step(`verify column "${columnName}" does not exist`, absent.sql, absent.params)]
+	};
+}
+/**
+* `qualifiedTargetType` is the new column type as it appears in the
+* `ALTER COLUMN TYPE` clause (schema-qualified for user-defined types, raw
+* native name for built-ins). `formatTypeExpected` is the unqualified
+* `format_type` form used in the postcheck. `rawTargetTypeForLabel` is the
+* string appearing in the human-readable label (typically `toType` when
+* explicit, else the column's native type).
+*/
+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`, 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}"`, typeCheck.sql, typeCheck.params)],
+		meta: { warning: "TABLE_REWRITE" }
+	};
+}
+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`, 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`, notNullable.sql, notNullable.params)]
+	};
+}
+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`, 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`, nullable.sql, nullable.params)]
+	};
+}
+/**
+* `defaultSql` is the full `DEFAULT …` clause as produced by
+* `buildColumnDefaultSql` — e.g. `"DEFAULT 42"`,
+* `"DEFAULT (CURRENT_TIMESTAMP)"`, or `"DEFAULT nextval('seq'::regclass)"`.
+*
+* `operationClass` defaults to `'additive'` (setting a default on a column
+* that currently has none). The reconciliation planner passes `'widening'`
+* when the column already has a different default — policy enforcement
+* treats that as a widening change rather than an additive one.
+*/
+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`, 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`, hasDefault.sql, hasDefault.params)]
+	};
+}
+async function dropDefault(schemaName, tableName, columnName, lowerer) {
+	const { present } = await columnExistsSteps(lowerer, {
+		schema: schemaName,
+		table: tableName,
+		column: columnName
+	});
+	const dropDefaultExec = await lowerer.lowerToExecuteRequest(alterTable({
+		...ifDefined("schema", boundSchema(schemaName)),
+		table: tableName,
+		actions: [dropDefaultAction(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`, present.sql, present.params)],
+		execute: [step(`drop default on "${columnName}"`, dropDefaultExec.sql)],
+		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 lowers the typed `AddColumn` DDL node through the
+* adapter; postchecks assert the column exists and is NOT NULL.
+*/
+async function addNotNullColumnDirect(schemaName, tableName, column, lowerer) {
+	const columnName = column.name;
+	const addColumn = await lowerer.lowerToExecuteRequest(alterTable({
+		...ifDefined("schema", boundSchema(schemaName)),
+		table: tableName,
+		actions: [addColumnAction(column)]
+	}));
+	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}"`, addColumn.sql)],
+		postcheck: [step(`verify column "${columnName}" exists`, present.sql, present.params), step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params)]
+	};
+}
+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)}
+FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")})
+REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (fk.onDelete !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
+		if (!action) throw new InternalError(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
+		sql += `\nON DELETE ${action}`;
+	}
+	if (fk.onUpdate !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
+		if (!action) throw new InternalError(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
+		sql += `\nON UPDATE ${action}`;
+	}
+	return sql;
+}
+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`, 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`, present.sql, present.params)]
+	};
+}
+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`, 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`, present.sql, present.params)]
+	};
+}
+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`, absent.sql, absent.params)],
+		execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
+		postcheck: [step(`verify FK "${fk.name}" exists`, present.sql, present.params)]
+	};
+}
+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`, 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`, present.sql, present.params)]
+	};
+}
+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`, 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`, absent.sql, absent.params)]
+	};
+}
+/**
+* `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
+* does not carry kind information in its drop-constraint descriptor, so the
+* default is `'unique'`. The reconciliation planner passes the correct kind
+* (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the diff issue
+* that produced the drop.
+*/
+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`, present.sql, present.params)],
+		execute: [step(`drop constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
+		postcheck: [step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params)]
+	};
+}
+function createExtension(extensionName) {
+	return {
+		id: `extension.${extensionName}`,
+		label: `Create extension "${extensionName}"`,
+		operationClass: "additive",
+		target: { id: "postgres" },
+		precheck: [],
+		execute: [step(`Create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${quoteIdentifier(extensionName)}`)],
+		postcheck: []
+	};
+}
+/**
+* Install a Postgres extension as the baseline op for an extension-pack
+* contract space. Layered on top of {@link createExtension}: stamps an
+* `invariantId` (required so the per-space marker records the install),
+* scopes the op `id` under a caller-chosen namespace (e.g. `pgvector.`),
+* and emits pre- and postcheck SQL probing `pg_extension`. The richer
+* shape lets the runner's idempotency probe skip the install on re-run
+* (postcheck-pre-satisfied) without firing the precheck.
+*
+* Use this for hand-rolled baseline migrations in contract-space
+* extension packages (e.g. `extension-pgvector`, `extension-paradedb`);
+* use the bare {@link createExtension} for planner-emitted ops where the
+* caller already controls idempotency through the surrounding plan.
+*/
+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,
+		operationClass: "additive",
+		invariantId,
+		target: {
+			id: "postgres",
+			details: {
+				schema: DEFAULT_NAMESPACE_ID,
+				objectType: "dependency",
+				name: 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`, present.sql, present.params)]
+	};
+}
+async function indexExistsSteps(lowerer, schemaName, indexName) {
+	const checks = indexExistsAst(schemaName, indexName);
+	return {
+		present: await lowerer.lowerToExecuteRequest(checks.indexPresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.indexAbsent())
+	};
+}
+/** An unbound-namespace object renders unqualified: the DDL node takes no schema. */
+function ddlSchemaOf(schemaName) {
+	return schemaName === UNBOUND_NAMESPACE_ID ? void 0 : schemaName;
+}
+async function createIndex(schemaName, tableName, indexName, elements, lowerer, extras) {
+	const ddlNode = createIndex$1({
+		schema: ddlSchemaOf(schemaName),
+		table: tableName,
+		name: indexName,
+		unique: extras?.unique === true,
+		elements,
+		type: extras?.type,
+		options: extras?.options,
+		where: extras?.where
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	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`, absent.sql, absent.params)],
+		execute: [step(`create index "${indexName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)]
+	};
+}
+/**
+* `ALTER INDEX … RENAME TO`. `widening` for the same typology reason as the
+* RLS policy rename: a rename is neither additive creation nor destructive,
+* and the class vocabulary has no neutral middle class — it is NOT that a
+* rename widens anything.
+*/
+async function renameIndex(schemaName, tableName, fromName, toName, lowerer) {
+	const fromChecks = indexExistsAst(schemaName, fromName);
+	const toChecks = indexExistsAst(schemaName, toName);
+	const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.indexPresent());
+	const toAbsent = await lowerer.lowerToExecuteRequest(toChecks.indexAbsent());
+	const toPresent = await lowerer.lowerToExecuteRequest(toChecks.indexPresent());
+	const ddlNode = alterIndexRename({
+		schema: ddlSchemaOf(schemaName),
+		from: fromName,
+		to: toName
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	return {
+		id: `index.${schemaName}.${tableName}.${fromName}.rename`,
+		label: `Rename index "${fromName}" to "${toName}" on "${tableName}"`,
+		operationClass: "widening",
+		target: targetDetails("index", toName, schemaName, tableName),
+		precheck: [step(`ensure index "${fromName}" exists`, fromPresent.sql, fromPresent.params), step(`ensure index "${toName}" does not exist`, toAbsent.sql, toAbsent.params)],
+		execute: [step(`rename index "${fromName}" to "${toName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify index "${toName}" exists`, toPresent.sql, toPresent.params)]
+	};
+}
+async function dropIndex(schemaName, tableName, indexName, lowerer) {
+	const ddlNode = dropIndex$1({
+		schema: ddlSchemaOf(schemaName),
+		name: indexName
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	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`, present.sql, present.params)],
+		execute: [step(`drop index "${indexName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)]
+	};
+}
+/**
+* `CREATE TYPE <qualified> AS ENUM (…)` for a managed native enum, built as a
+* typed DDL node and lowered by the control adapter (the type name is quoted,
+* member values render as escaped string literals in declaration order —
+* Postgres enum sort order is semantic). `boundSchema` maps the unbound sentinel
+* to an absent schema so the type name renders unqualified and the connection's
+* `search_path` resolves the schema at runtime.
+*/
+async function createNativeEnumType(schemaName, typeName, members, lowerer) {
+	for (const member of members) validateEnumValueLength(member, typeName);
+	const ddlNode = createType({
+		...ifDefined("schema", boundSchema(schemaName)),
+		name: typeName,
+		values: members
+	});
+	const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+	return {
+		id: `createNativeEnumType.${typeName}`,
+		label: `Create enum type "${typeName}"`,
+		operationClass: "additive",
+		target: targetDetails("type", typeName, schemaName),
+		precheck: [],
+		execute: [step(`create enum type "${typeName}"`, statement.sql, statement.params)],
+		postcheck: []
+	};
+}
+/** `DROP TYPE <qualified>` for an unclaimed managed native enum, via typed DDL. */
+async function dropNativeEnumType(schemaName, typeName, lowerer) {
+	const ddlNode = dropType({
+		...ifDefined("schema", boundSchema(schemaName)),
+		name: typeName
+	});
+	const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+	return {
+		id: `dropNativeEnumType.${typeName}`,
+		label: `Drop enum type "${typeName}"`,
+		operationClass: "destructive",
+		target: targetDetails("type", typeName, schemaName),
+		precheck: [],
+		execute: [step(`drop enum type "${typeName}"`, statement.sql, statement.params)],
+		postcheck: []
+	};
+}
+const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+function validateRoleName(role) {
+	if (!PLAIN_IDENTIFIER.test(role)) throw postgresError("CONTRACT.ROLE_INVALID", `Invalid role name ${JSON.stringify(role)}: role names must be plain SQL identifiers matching ^[A-Za-z_][A-Za-z0-9_$]*$`, { meta: {
+		role,
+		reason: "not-a-plain-identifier"
+	} });
+	return role;
+}
+async function createRlsPolicy(schemaName, tableName, policy, lowerer) {
+	const validatedRoles = policy.roles.map(validateRoleName);
+	const ddlNode = createPolicy({
+		schema: schemaName,
+		table: tableName,
+		name: policy.name,
+		permissive: policy.permissive,
+		operation: policy.operation,
+		roles: validatedRoles,
+		...ifDefined("using", policy.using),
+		...ifDefined("withCheck", policy.withCheck)
+	});
+	const checks = rlsPolicyExistsAst({
+		schema: schemaName,
+		table: tableName,
+		policyName: policy.name
+	});
+	const absent = await lowerer.lowerToExecuteRequest(checks.policyAbsent());
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	const present = await lowerer.lowerToExecuteRequest(checks.policyPresent());
+	return {
+		id: `rlsPolicy.${schemaName}.${tableName}.${policy.name}`,
+		label: `Create RLS policy "${policy.name}" on "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("rlsPolicy", policy.name, schemaName, tableName),
+		precheck: [step(`ensure RLS policy "${policy.name}" does not exist`, absent.sql, absent.params)],
+		execute: [step(`create RLS policy "${policy.name}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify RLS policy "${policy.name}" exists`, present.sql, present.params)]
+	};
+}
+async function dropRlsPolicy(schemaName, tableName, policyName, lowerer) {
+	const ddlNode = dropPolicy({
+		schema: schemaName,
+		table: tableName,
+		name: policyName
+	});
+	const checks = rlsPolicyExistsAst({
+		schema: schemaName,
+		table: tableName,
+		policyName
+	});
+	const present = await lowerer.lowerToExecuteRequest(checks.policyPresent());
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	const absent = await lowerer.lowerToExecuteRequest(checks.policyAbsent());
+	return {
+		id: `rlsPolicy.${schemaName}.${tableName}.${policyName}.drop`,
+		label: `Drop RLS policy "${policyName}" on "${tableName}"`,
+		operationClass: "destructive",
+		target: targetDetails("rlsPolicy", policyName, schemaName, tableName),
+		precheck: [step(`ensure RLS policy "${policyName}" exists`, present.sql, present.params)],
+		execute: [step(`drop RLS policy "${policyName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify RLS policy "${policyName}" is absent`, absent.sql, absent.params)]
+	};
+}
+async function enableRowLevelSecurity(schemaName, tableName, lowerer) {
+	const checks = rlsEnabledAst(schemaName, tableName);
+	const disabled = await lowerer.lowerToExecuteRequest(checks.rlsDisabled());
+	const enabled = await lowerer.lowerToExecuteRequest(checks.rlsEnabled());
+	return {
+		id: `rowLevelSecurity.${schemaName}.${tableName}`,
+		label: `Enable row-level security on "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("rowLevelSecurity", tableName, schemaName),
+		precheck: [step(`check RLS is not already enabled on "${tableName}"`, disabled.sql, disabled.params)],
+		execute: [step(`enable row-level security on "${tableName}"`, `ALTER TABLE ${qualifyTableName(schemaName, tableName)} ENABLE ROW LEVEL SECURITY`)],
+		postcheck: [step(`verify row-level security is enabled on "${tableName}"`, enabled.sql, enabled.params)]
+	};
+}
+async function disableRowLevelSecurity(schemaName, tableName, lowerer) {
+	const ddlNode = disableRowLevelSecurity$1({
+		schema: schemaName,
+		table: tableName
+	});
+	const checks = rlsEnabledAst(schemaName, tableName);
+	const enabled = await lowerer.lowerToExecuteRequest(checks.rlsEnabled());
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	const disabled = await lowerer.lowerToExecuteRequest(checks.rlsDisabled());
+	return {
+		id: `rowLevelSecurity.${schemaName}.${tableName}.disable`,
+		label: `Disable row-level security on "${tableName}"`,
+		operationClass: "destructive",
+		target: targetDetails("rowLevelSecurity", tableName, schemaName),
+		precheck: [step(`check RLS is currently enabled on "${tableName}"`, enabled.sql, enabled.params)],
+		execute: [step(`disable row-level security on "${tableName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify row-level security is disabled on "${tableName}"`, disabled.sql, disabled.params)]
+	};
+}
+async function renameRlsPolicy(schemaName, tableName, oldPolicyName, newPolicyName, lowerer) {
+	const ddlNode = alterPolicyRename({
+		schema: schemaName,
+		table: tableName,
+		name: oldPolicyName,
+		newName: newPolicyName
+	});
+	const oldChecks = rlsPolicyExistsAst({
+		schema: schemaName,
+		table: tableName,
+		policyName: oldPolicyName
+	});
+	const newChecks = rlsPolicyExistsAst({
+		schema: schemaName,
+		table: tableName,
+		policyName: newPolicyName
+	});
+	const oldPresent = await lowerer.lowerToExecuteRequest(oldChecks.policyPresent());
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	const newPresent = await lowerer.lowerToExecuteRequest(newChecks.policyPresent());
+	return {
+		id: `rlsPolicy.${schemaName}.${tableName}.${oldPolicyName}.rename`,
+		label: `Rename RLS policy "${oldPolicyName}" to "${newPolicyName}" on "${tableName}"`,
+		operationClass: "widening",
+		target: targetDetails("rlsPolicy", newPolicyName, schemaName, tableName),
+		precheck: [step(`ensure RLS policy "${oldPolicyName}" exists`, oldPresent.sql, oldPresent.params)],
+		execute: [step(`rename RLS policy "${oldPolicyName}" to "${newPolicyName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify RLS policy "${newPolicyName}" exists`, newPresent.sql, newPresent.params)]
+	};
+}
+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`, present.sql, present.params)],
+		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
+		postcheck: [step(`verify table "${tableName}" does not exist`, absent.sql, absent.params)]
+	};
+}
+function buildTargetDetails(objectType, name, schema, table) {
+	return {
+		schema,
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
+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 ddlColumn = col(columnName, buildColumnTypeSql(column, codecHooks, storageTypes), {
+		notNull: true,
+		default: new FunctionColumnDefault(temporaryDefault)
+	});
+	const addColumn = await lowerer.lowerToExecuteRequest(alterTable({
+		...ifDefined("schema", boundSchema(schema)),
+		table: tableName,
+		actions: [addColumnAction(ddlColumn)]
+	}));
+	const dropTempDefault = await lowerer.lowerToExecuteRequest(alterTable({
+		...ifDefined("schema", boundSchema(schema)),
+		table: tableName,
+		actions: [dropDefaultAction(columnName)]
+	}));
+	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: addColumn.sql
+		}, {
+			description: `drop temporary default from column "${columnName}"`,
+			sql: dropTempDefault.sql
+		}],
+		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)
+		]
+	};
+}
+/**
+* Postgres migration IR: one concrete `*Call` class per pure factory under
+* `operations/`, plus a shared `PostgresOpFactoryCallNode` abstract base.
+*
+* Every call class carries the literal arguments its backing factory would
+* receive, computes a human-readable `label` in its constructor, and
+* implements two polymorphic hooks:
+*
+* - `toOp()` — converts the IR node to a runtime
+*   `SqlMigrationPlanOperation` by delegating to the matching pure factory
+*   under `operations/`. `DataTransformCall.toOp()` always throws
+*   `MIGRATION.UNFILLED_PLACEHOLDER` because a planner-generated data transform is an
+*   unfilled authoring stub by construction.
+* - `renderTypeScript()` / `importRequirements()` — inherited from
+*   `TsExpression`. Used by `renderCallsToTypeScript` to emit the call as
+*   a TypeScript expression inside the scaffolded `migration.ts`.
+*
+* The abstract base and all concrete classes are package-private. External
+* consumers see only the framework-level `OpFactoryCall` interface and the
+* `PostgresOpFactoryCall` union.
+*/
+const POSTGRES_MIGRATION_FACADE = "@internal/postgres/migration";
+var PostgresOpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function postgresDefaultToDdlColumnDefault(columnDefault) {
+	if (!columnDefault) return void 0;
+	switch (columnDefault.kind) {
+		case "literal": return new LiteralColumnDefault(columnDefault.value);
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return void 0;
+			return new FunctionColumnDefault(columnDefault.expression);
+		case "sequence": return new FunctionColumnDefault(`nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`);
+		default: {
+			const exhaustive = columnDefault;
+			return assertNever(exhaustive, `postgresDefaultToDdlColumnDefault: unhandled kind "${blindCast(exhaustive).kind}"`);
+		}
+	}
+}
+function renderDdlColumnDefault(def) {
+	if (!def) return "";
+	if (def.kind === "literal") return `lit(${jsonToTsSource(def.value)})`;
+	return `fn(${jsonToTsSource(def.expression)})`;
+}
+function renderDdlColumnAsTsCall(col) {
+	const opts = [];
+	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})`;
+}
+function renderDdlConstraintAsTsCall(constraint) {
+	switch (constraint.kind) {
+		case "primary-key": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+		case "foreign-key": {
+			const opts = [];
+			if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+			if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+			if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+			const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+			return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+		}
+		case "unique": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+		case "check-expression": return `checkExpression(${jsonToTsSource(constraint.name)}, ${jsonToTsSource(constraint.expression)})`;
+	}
+}
+function needsColOrConstraintImport(columns) {
+	return columns.length > 0;
+}
+function constraintImportSymbols(constraints) {
+	if (!constraints || constraints.length === 0) return [];
+	const symbols = /* @__PURE__ */ new Set();
+	for (const c of constraints) if (c.kind === "primary-key") symbols.add("primaryKey");
+	else if (c.kind === "foreign-key") symbols.add("foreignKey");
+	else if (c.kind === "unique") symbols.add("unique");
+	else if (c.kind === "check-expression") symbols.add("checkExpression");
+	return [...symbols];
+}
+function defaultImportSymbols(columns) {
+	const symbols = /* @__PURE__ */ new Set();
+	for (const col of columns) if (col.default?.kind === "literal") symbols.add("lit");
+	else if (col.default?.kind === "function") symbols.add("fn");
+	return [...symbols];
+}
+var CreateTableCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createTable";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	columns;
+	constraints;
+	label;
+	constructor(schemaName, tableName, columns, constraints) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columns = Object.freeze([...columns]);
+		this.constraints = constraints ? Object.freeze([...constraints]) : void 0;
+		this.label = `Create table "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "CreateTableCall" } });
+		const ddlNode = createTable({
+			...ifDefined("schema", boundSchema(this.schemaName)),
+			table: this.tableName,
+			columns: this.columns,
+			...ifDefined("constraints", this.constraints)
+		});
+		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`, 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() {
+		const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(", ");
+		const constraintsList = this.constraints ? this.constraints.map(renderDdlConstraintAsTsCall).join(", ") : void 0;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`columns: [${columnsList}]`);
+		if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+		return `this.createTable({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		const req = [];
+		if (needsColOrConstraintImport(this.columns)) {
+			req.push({
+				moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+				symbol: "col"
+			});
+			for (const sym of defaultImportSymbols(this.columns)) req.push({
+				moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+				symbol: sym
+			});
+		}
+		for (const sym of constraintImportSymbols(this.constraints)) req.push({
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: sym
+		});
+		return req;
+	}
+};
+var DropTableCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	label;
+	constructor(schemaName, tableName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.label = `Drop table "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropTableCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropTableCall" } });
+		return dropTable(this.schemaName, this.tableName, lowerer);
+	}
+	renderTypeScript() {
+		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 {
+	factoryName = "addColumn";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	column;
+	label;
+	constructor(schemaName, tableName, column) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.column = column;
+		this.label = `Add column "${column.name}" to "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `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.`, { meta: { factory: "AddColumnCall" } });
+		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() {
+		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 {
+	factoryName = "dropColumn";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop column "${columnName}" from "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropColumnCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropColumnCall" } });
+		return dropColumn(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.dropColumn({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var AlterColumnTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "alterColumnType";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	options;
+	label;
+	constructor(schemaName, tableName, columnName, options) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.options = options;
+		this.label = `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AlterColumnTypeCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AlterColumnTypeCall" } });
+		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options, 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)}`);
+		opts.push(`options: ${jsonToTsSource(this.options)}`);
+		return `this.alterColumnType({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var SetNotNullCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "setNotNull";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Set NOT NULL on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `SetNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "SetNotNullCall" } });
+		return setNotNull(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.setNotNull({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DropNotNullCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropNotNull";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop NOT NULL on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropNotNullCall" } });
+		return dropNotNull(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.dropNotNull({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var SetDefaultCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "setDefault";
+	operationClass;
+	schemaName;
+	tableName;
+	columnName;
+	defaultSql;
+	label;
+	constructor(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.defaultSql = defaultSql;
+		this.operationClass = operationClass;
+		this.label = `Set default on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "SetDefaultCall" } });
+		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, lowerer, this.operationClass);
+	}
+	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)}`);
+		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 {
+	factoryName = "dropDefault";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop default on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropDefaultCall" } });
+		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 typed `DdlColumn`
+* and lowers it to an ADD COLUMN execute step via the adapter at `toOp` 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;
+	column;
+	label;
+	constructor(schemaName, tableName, columnName, column) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.column = column;
+		this.label = `Add column ${columnName} to ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddNotNullColumnDirectCall" } });
+		return addNotNullColumnDirect(this.schemaName, this.tableName, this.column, lowerer);
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource({
+			id: `column.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			operationClass: "additive"
+		})})`;
+	}
+};
+/**
+* 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`; both the
+* typed ADD COLUMN execute step and the pre/postchecks are lowered via the
+* adapter at `toOp` time.
+*
+* 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 postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddNotNullColumnWithTempDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddNotNullColumnWithTempDefaultCall" } });
+		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 `rawSql(${jsonToTsSource({
+			id: `column.${this.tableName}.${this.columnName}`,
+			label: this.label,
+			operationClass: "additive"
+		})})`;
+	}
+};
+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";
+	schemaName;
+	tableName;
+	constraintName;
+	columns;
+	label;
+	constructor(schemaName, tableName, constraintName, columns) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.columns = columns;
+		this.label = `Add primary key on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddPrimaryKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddPrimaryKeyCall" } });
+		return addPrimaryKey(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
+	}
+	renderTypeScript() {
+		return `this.addPrimaryKey({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var AddUniqueCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addUnique";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	constraintName;
+	columns;
+	label;
+	constructor(schemaName, tableName, constraintName, columns) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.columns = columns;
+		this.label = `Add unique constraint on "${tableName}" (${columns.join(", ")})`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddUniqueCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddUniqueCall" } });
+		return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
+	}
+	renderTypeScript() {
+		return `this.addUnique({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var AddForeignKeyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addForeignKey";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	fk;
+	label;
+	constructor(schemaName, tableName, fk) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.fk = fk;
+		this.label = `Add foreign key "${fk.name}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `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.`, { meta: { factory: "AddForeignKeyCall" } });
+		return addForeignKey(this.schemaName, this.tableName, this.fk, lowerer);
+	}
+	renderTypeScript() {
+		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 {
+	factoryName = "dropConstraint";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	constraintName;
+	kind;
+	label;
+	constructor(schemaName, tableName, constraintName, kind = "unique") {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.kind = kind;
+		this.label = `Drop constraint "${constraintName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropConstraintCall" } });
+		return dropConstraint(this.schemaName, this.tableName, this.constraintName, lowerer, this.kind);
+	}
+	renderTypeScript() {
+		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 {
+	factoryName = "addCheckConstraint";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	constraintName;
+	column;
+	values;
+	label;
+	constructor(schemaName, tableName, constraintName, column, values) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.column = column;
+		this.values = values;
+		this.label = `Add check constraint "${constraintName}" on "${tableName}"."${column}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddCheckConstraintCall" } });
+		return addCheckConstraint(this.schemaName, this.tableName, this.constraintName, this.column, this.values, lowerer);
+	}
+	renderTypeScript() {
+		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 {
+	factoryName = "dropCheckConstraint";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	constraintName;
+	label;
+	constructor(schemaName, tableName, constraintName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.label = `Drop check constraint "${constraintName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropCheckConstraintCall" } });
+		return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.dropCheckConstraint({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var CreateIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createIndex";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	indexName;
+	/** Column tuple when the index is column-based; absent for expression indexes. */
+	columns;
+	/** Opaque whole element list when the index is expression-based. */
+	expression;
+	indexType;
+	options;
+	where;
+	unique;
+	label;
+	constructor(schemaName, tableName, indexName, elements, extras) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.columns = "columns" in elements ? elements.columns : void 0;
+		this.expression = "expression" in elements ? elements.expression : void 0;
+		this.indexType = extras?.type;
+		this.options = extras?.options;
+		this.where = extras?.where;
+		this.unique = extras?.unique === true;
+		this.label = `Create index "${indexName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `CreateIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "CreateIndexCall" } });
+		const extras = {};
+		if (this.indexType !== void 0) extras.type = this.indexType;
+		if (this.options !== void 0) extras.options = this.options;
+		if (this.where !== void 0) extras.where = this.where;
+		if (this.unique) extras.unique = true;
+		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns !== void 0 ? { columns: this.columns } : { expression: this.expression ?? "" }, lowerer, extras);
+	}
+	renderTypeScript() {
+		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)}`);
+		if (this.columns !== void 0) opts.push(`columns: ${jsonToTsSource(this.columns)}`);
+		else opts.push(`expression: ${jsonToTsSource(this.expression ?? "")}`);
+		if (this.indexType !== void 0 || this.options !== void 0 || this.where !== void 0 || this.unique) {
+			const extrasParts = [];
+			if (this.indexType !== void 0) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
+			if (this.options !== void 0) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+			if (this.where !== void 0) extrasParts.push(`where: ${jsonToTsSource(this.where)}`);
+			if (this.unique) extrasParts.push("unique: true");
+			opts.push(`extras: { ${extrasParts.join(", ")} }`);
+		}
+		return `this.createIndex({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var RenameIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "renameIndex";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	oldIndexName;
+	newIndexName;
+	label;
+	constructor(schemaName, tableName, oldIndexName, newIndexName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.oldIndexName = oldIndexName;
+		this.newIndexName = newIndexName;
+		this.label = `Rename index "${oldIndexName}" to "${newIndexName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `RenameIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.oldIndexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "RenameIndexCall" } });
+		return renameIndex(this.schemaName, this.tableName, this.oldIndexName, this.newIndexName, lowerer);
+	}
+	renderTypeScript() {
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`from: ${jsonToTsSource(this.oldIndexName)}`);
+		opts.push(`to: ${jsonToTsSource(this.newIndexName)}`);
+		return `this.renameIndex({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DropIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropIndex";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	indexName;
+	label;
+	constructor(schemaName, tableName, indexName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.label = `Drop index "${indexName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropIndexCall" } });
+		return dropIndex(this.schemaName, this.tableName, this.indexName, lowerer);
+	}
+	renderTypeScript() {
+		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(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* Laundered pre-built operation.
+*
+* Wraps an already-materialized `SqlMigrationPlanOperation` — typically one
+* produced by a SQL-family method or a codec control hook — so the planner
+* can carry it alongside IR nodes without reverse-engineering it into a
+* structured call class. Doubles as the user-facing escape hatch for raw
+* migrations: authors can pass a full op shape to `rawSql({...})`.
+*
+* `toOp()` returns the stored op unchanged. `renderTypeScript()` emits
+* `rawSql({...})` with the op serialized as a JSON literal — round-tripping
+* requires every field on the op to be JSON-serializable (no closures).
+*/
+var RawSqlCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass;
+	label;
+	op;
+	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)})`;
+	}
+};
+var CreateExtensionCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createExtension";
+	operationClass = "additive";
+	extensionName;
+	label;
+	constructor(extensionName) {
+		super();
+		this.extensionName = extensionName;
+		this.label = `Create extension "${extensionName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return createExtension(this.extensionName);
+	}
+	renderTypeScript() {
+		return `createExtension(${jsonToTsSource(this.extensionName)})`;
+	}
+};
+var CreateSchemaCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createSchema";
+	operationClass = "additive";
+	schemaName;
+	label;
+	constructor(schemaName) {
+		super();
+		this.schemaName = schemaName;
+		this.label = `Create schema "${schemaName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "CreateSchemaCall" } });
+		const ddlNode = createSchema({
+			schema: this.schemaName,
+			ifNotExists: true
+		});
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+		const schemaName = this.schemaName;
+		return {
+			id: `schema.${schemaName}`,
+			label: `Create schema "${schemaName}"`,
+			operationClass: "additive",
+			target: { id: "postgres" },
+			precheck: [],
+			execute: [{
+				description: `Create schema "${schemaName}"`,
+				sql: statement.sql,
+				params: statement.params ?? []
+			}],
+			postcheck: []
+		};
+	}
+	renderTypeScript() {
+		return `this.createSchema({ schema: ${jsonToTsSource(this.schemaName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var CreateNativeEnumTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createNativeEnumType";
+	operationClass = "additive";
+	schemaName;
+	typeName;
+	members;
+	label;
+	constructor(schemaName, typeName, members) {
+		super();
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.members = Object.freeze([...members]);
+		this.label = `Create enum type "${typeName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `CreateNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "CreateNativeEnumTypeCall" } });
+		return createNativeEnumType(this.schemaName, this.typeName, this.members, lowerer);
+	}
+	renderTypeScript() {
+		return `this.createNativeEnumType({ ${[
+			`schema: ${jsonToTsSource(this.schemaName)}`,
+			`typeName: ${jsonToTsSource(this.typeName)}`,
+			`members: ${jsonToTsSource(this.members)}`
+		].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DropNativeEnumTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropNativeEnumType";
+	operationClass = "destructive";
+	schemaName;
+	typeName;
+	label;
+	constructor(schemaName, typeName) {
+		super();
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.label = `Drop enum type "${typeName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropNativeEnumTypeCall" } });
+		return dropNativeEnumType(this.schemaName, this.typeName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.dropNativeEnumType({ ${[`schema: ${jsonToTsSource(this.schemaName)}`, `typeName: ${jsonToTsSource(this.typeName)}`].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/** Schema-qualified, quoted enum type name — unqualified when `schemaName` is the unbound sentinel, matching `boundSchema`'s DDL-node convention. */
+function qualifiedNativeEnumTypeName(schemaName, typeName) {
+	const bound = boundSchema(schemaName);
+	return quoteQualifiedName(bound === void 0 ? typeName : `${bound}.${typeName}`);
+}
+const ADD_VALUE_TRANSACTION_CAVEAT = "A newly added enum value cannot be used until the transaction that adds it commits, so a migration that both appends a value and uses it in the same step will fail at apply.";
+/**
+* `ALTER TYPE <qualified> ADD VALUE '<value>'` for a suffix-appended member on
+* a managed native enum. Built directly as SQL text (qualified via
+* `quoteQualifiedName`, the value escaped via `escapeLiteral`) rather than a
+* typed DDL node — mirrors how `enableRowLevelSecurity` renders its execute
+* step, since no DDL-AST node exists for this statement. Prechecks/postchecks
+* are still typed catalog queries lowered through the control adapter.
+* `validateEnumValueLength` runs at construction, so an over-length value
+* fails before planning produces a call.
+*/
+var AddNativeEnumValueCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addNativeEnumValue";
+	operationClass = "additive";
+	schemaName;
+	typeName;
+	value;
+	label;
+	summary;
+	constructor(schemaName, typeName, value) {
+		super();
+		validateEnumValueLength(value, typeName);
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.value = value;
+		this.label = `Add value "${value}" to enum type "${typeName}"`;
+		this.summary = `Adds value "${value}" to enum type "${typeName}". ${ADD_VALUE_TRANSACTION_CAVEAT}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddNativeEnumValueCall.toOp: a lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddNativeEnumValueCall" } });
+		const { schemaName, typeName, value } = this;
+		const typeChecks = nativeEnumTypeExistsAst(schemaName, typeName);
+		const valueChecks = nativeEnumValueExistsAst({
+			schema: schemaName,
+			typeName,
+			value
+		});
+		const typePresent = await lowerer.lowerToExecuteRequest(typeChecks.typePresent());
+		const valueAbsent = await lowerer.lowerToExecuteRequest(valueChecks.valueAbsent());
+		const valuePresent = await lowerer.lowerToExecuteRequest(valueChecks.valuePresent());
+		const qualifiedType = qualifiedNativeEnumTypeName(schemaName, typeName);
+		return {
+			id: `addNativeEnumValue.${typeName}.${value}`,
+			label: this.label,
+			summary: this.summary,
+			operationClass: "additive",
+			target: targetDetails("type", typeName, schemaName),
+			precheck: [step(`ensure enum type "${typeName}" exists`, typePresent.sql, typePresent.params), step(`ensure value "${value}" is absent from enum type "${typeName}"`, valueAbsent.sql, valueAbsent.params)],
+			execute: [step(`add value "${value}" to enum type "${typeName}"`, `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`)],
+			postcheck: [step(`verify value "${value}" exists on enum type "${typeName}"`, valuePresent.sql, valuePresent.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.addNativeEnumValue({ ${[
+			`schema: ${jsonToTsSource(this.schemaName)}`,
+			`typeName: ${jsonToTsSource(this.typeName)}`,
+			`value: ${jsonToTsSource(this.value)}`
+		].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* A planner-generated data-transform stub. `checkSlot` and `runSlot` name
+* the unfilled authoring slots that the rendered `migration.ts` will expose
+* to the user via `placeholder("…")` calls. `toOp()` always throws
+* `MIGRATION.UNFILLED_PLACEHOLDER`: the planner cannot lower a stubbed transform to a runtime
+* op — the user must fill the rendered `migration.ts` and re-emit.
+*/
+var DataTransformCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dataTransform";
+	operationClass;
+	label;
+	checkSlot;
+	runSlot;
+	constructor(label, checkSlot, runSlot, operationClass = "data") {
+		super();
+		this.label = label;
+		this.checkSlot = checkSlot;
+		this.runSlot = runSlot;
+		this.operationClass = operationClass;
+		this.freeze();
+	}
+	toOp() {
+		throw errorUnfilledPlaceholder(this.label);
+	}
+	renderTypeScript() {
+		return [
+			`this.dataTransform(endContract, ${jsonToTsSource(this.label)}, {`,
+			`  check: () => placeholder(${jsonToTsSource(this.checkSlot)}),`,
+			`  run: () => placeholder(${jsonToTsSource(this.runSlot)}),`,
+			"})"
+		].join("\n");
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: "placeholder"
+		}];
+	}
+};
+var CreatePostgresRlsPolicyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createRlsPolicy";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	policy;
+	label;
+	constructor(schemaName, tableName, policy) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.policy = policy;
+		this.label = `Create RLS policy "${policy.name}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `CreatePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policy.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "CreatePostgresRlsPolicyCall" } });
+		return createRlsPolicy(this.schemaName, this.tableName, this.policy, lowerer);
+	}
+	renderTypeScript() {
+		const p = this.policy;
+		const input = {
+			naming: namingOf(p.name, p.prefix),
+			tableName: p.tableName,
+			namespaceId: p.namespaceId,
+			operation: p.operation,
+			roles: p.roles,
+			...ifDefined("using", p.using),
+			...ifDefined("withCheck", p.withCheck),
+			permissive: p.permissive
+		};
+		return `this.createRlsPolicy({ schema: ${jsonToTsSource(this.schemaName)}, table: ${jsonToTsSource(this.tableName)}, policy: ${jsonToTsSource(input)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DropPostgresRlsPolicyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropRlsPolicy";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	policyName;
+	label;
+	constructor(schemaName, tableName, policyName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.policyName = policyName;
+		this.label = `Drop RLS policy "${policyName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DropPostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DropPostgresRlsPolicyCall" } });
+		return dropRlsPolicy(this.schemaName, this.tableName, this.policyName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.dropRlsPolicy({ schema: ${jsonToTsSource(this.schemaName)}, table: ${jsonToTsSource(this.tableName)}, policy: ${jsonToTsSource(this.policyName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var EnableRowLevelSecurityCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "enableRowLevelSecurity";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	label;
+	constructor(schemaName, tableName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.label = `Enable row-level security on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `EnableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "EnableRowLevelSecurityCall" } });
+		return enableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.enableRowLevelSecurity({ schema: ${jsonToTsSource(this.schemaName)}, table: ${jsonToTsSource(this.tableName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DisableRowLevelSecurityCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "disableRowLevelSecurity";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	label;
+	constructor(schemaName, tableName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.label = `Disable row-level security on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `DisableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "DisableRowLevelSecurityCall" } });
+		return disableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.disableRowLevelSecurity({ schema: ${jsonToTsSource(this.schemaName)}, table: ${jsonToTsSource(this.tableName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var RenamePostgresRlsPolicyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "renameRlsPolicy";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	oldPolicyName;
+	newPolicyName;
+	label;
+	constructor(schemaName, tableName, oldPolicyName, newPolicyName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.oldPolicyName = oldPolicyName;
+		this.newPolicyName = newPolicyName;
+		this.label = `Rename RLS policy "${oldPolicyName}" to "${newPolicyName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `RenamePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.oldPolicyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "RenamePostgresRlsPolicyCall" } });
+		return renameRlsPolicy(this.schemaName, this.tableName, this.oldPolicyName, this.newPolicyName, lowerer);
+	}
+	renderTypeScript() {
+		return `this.renameRlsPolicy({ schema: ${jsonToTsSource(this.schemaName)}, table: ${jsonToTsSource(this.tableName)}, from: ${jsonToTsSource(this.oldPolicyName)}, to: ${jsonToTsSource(this.newPolicyName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+//#endregion
+export { RenamePostgresRlsPolicyCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, installExtension as F, postgresDefaultToDdlColumnDefault as I, SetNotNullCall as M, buildTargetDetails as N, RawSqlCall as O, createExtension as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, SetDefaultCall as j, RenameIndexCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
+
+//# sourceMappingURL=op-factory-call-DifL68KT-Bo6pxs-R.mjs.map