@prisma-next/target-postgres 0.4.1 → 0.5.0-dev.1

package/dist/control.mjs

@@ -1,1990 +1,17 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DkvCmY98.mjs";
-import { A as normalizeSchemaNativeType, C as buildExpectedFormatType, D as qualifyTableName, E as columnNullabilityCheck, F as escapeLiteral, I as quoteIdentifier, O as tableIsEmptyCheck, S as setNotNull, T as columnHasNoDefaultCheck, _ as alterColumnType, a as dropIndex, b as dropNotNull, c as dropEnumType, d as createSchema, f as addForeignKey, g as addColumn, h as dropConstraint, i as createIndex, j as parsePostgresDefault, k as resolveColumnTypeMetadata, l as renameType, m as addUnique, n as createTable, o as addEnumValues, p as addPrimaryKey, r as dropTable, s as createEnumType, t as PostgresMigration, u as createExtension, v as dropColumn, w as columnExistsCheck, x as setDefault, y as dropDefault } from "./postgres-migration-BsHJHV9O.mjs";
-import { collectInitDependencies, contractToSchemaIR, extractCodecControlHooks, plannerFailure, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BVoVtyp-.mjs";
+import { t as parsePostgresDefault } from "./default-normalizer-DNOpRoOF.mjs";
+import { t as normalizeSchemaNativeType } from "./native-type-normalizer-CInai_oY.mjs";
+import { o as renderDefaultLiteral } from "./planner-ddl-builders-Dxvw1LHw.mjs";
+import "./issue-planner-CFjB0_oO.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-CLUvVhUN.mjs";
+import { a as ensurePrismaContractSchemaStatement, i as ensureMarkerTableStatement, n as buildWriteMarkerStatements, r as ensureLedgerTableStatement, t as buildLedgerInsertStatement } from "./statement-builders-BPnmt6wx.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { contractToSchemaIR, extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
-import { notOk, ok, okVoid } from "@prisma-next/utils/result";
-import { errorUnfilledPlaceholder } from "@prisma-next/errors/migration";
-import { TsExpression, jsonToTsSource, renderImports } from "@prisma-next/ts-render";
-import { detectScaffoldRuntime, shebangLineFor } from "@prisma-next/migration-tools/migration-ts";
+import { ok, okVoid } from "@prisma-next/utils/result";
 import { readMarker } from "@prisma-next/family-sql/verify";
 import { SqlQueryError } from "@prisma-next/sql-errors";
 
-//#region src/core/migrations/op-factory-call.ts
-/**
-* 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
-*   `PN-MIG-2001` 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 TARGET_MIGRATION_MODULE = "@prisma-next/target-postgres/migration";
-var PostgresOpFactoryCallNode = class extends TsExpression {
-	importRequirements() {
-		return [{
-			moduleSpecifier: TARGET_MIGRATION_MODULE,
-			symbol: this.factoryName
-		}];
-	}
-	freeze() {
-		Object.freeze(this);
-	}
-};
-var CreateTableCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "createTable";
-	operationClass = "additive";
-	schemaName;
-	tableName;
-	columns;
-	primaryKey;
-	label;
-	constructor(schemaName, tableName, columns, primaryKey) {
-		super();
-		this.schemaName = schemaName;
-		this.tableName = tableName;
-		this.columns = columns;
-		this.primaryKey = primaryKey;
-		this.label = `Create table "${tableName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return createTable(this.schemaName, this.tableName, this.columns, this.primaryKey);
-	}
-	renderTypeScript() {
-		const args = [
-			jsonToTsSource(this.schemaName),
-			jsonToTsSource(this.tableName),
-			jsonToTsSource(this.columns)
-		];
-		if (this.primaryKey) args.push(jsonToTsSource(this.primaryKey));
-		return `createTable(${args.join(", ")})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropTable(this.schemaName, this.tableName);
-	}
-	renderTypeScript() {
-		return `dropTable(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return addColumn(this.schemaName, this.tableName, this.column);
-	}
-	renderTypeScript() {
-		return `addColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropColumn(this.schemaName, this.tableName, this.columnName);
-	}
-	renderTypeScript() {
-		return `dropColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options);
-	}
-	renderTypeScript() {
-		return `alterColumnType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)}, ${jsonToTsSource(this.options)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return setNotNull(this.schemaName, this.tableName, this.columnName);
-	}
-	renderTypeScript() {
-		return `setNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropNotNull(this.schemaName, this.tableName, this.columnName);
-	}
-	renderTypeScript() {
-		return `dropNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, 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(", ")})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropDefault(this.schemaName, this.tableName, this.columnName);
-	}
-	renderTypeScript() {
-		return `dropDefault(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return addPrimaryKey(this.schemaName, this.tableName, this.constraintName, this.columns);
-	}
-	renderTypeScript() {
-		return `addPrimaryKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns);
-	}
-	renderTypeScript() {
-		return `addUnique(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return addForeignKey(this.schemaName, this.tableName, this.fk);
-	}
-	renderTypeScript() {
-		return `addForeignKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.fk)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropConstraint(this.schemaName, this.tableName, this.constraintName, 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(", ")})`;
-	}
-};
-var CreateIndexCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "createIndex";
-	operationClass = "additive";
-	schemaName;
-	tableName;
-	indexName;
-	columns;
-	label;
-	constructor(schemaName, tableName, indexName, columns) {
-		super();
-		this.schemaName = schemaName;
-		this.tableName = tableName;
-		this.indexName = indexName;
-		this.columns = columns;
-		this.label = `Create index "${indexName}" on "${tableName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns);
-	}
-	renderTypeScript() {
-		return `createIndex(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)}, ${jsonToTsSource(this.columns)})`;
-	}
-};
-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();
-	}
-	toOp() {
-		return dropIndex(this.schemaName, this.tableName, this.indexName);
-	}
-	renderTypeScript() {
-		return `dropIndex(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;
-	}
-};
-var CreateEnumTypeCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "createEnumType";
-	operationClass = "additive";
-	schemaName;
-	typeName;
-	values;
-	label;
-	constructor(schemaName, typeName, values) {
-		super();
-		this.schemaName = schemaName;
-		this.typeName = typeName;
-		this.values = values;
-		this.label = `Create enum type "${typeName}"`;
-		this.freeze();
-	}
-	toOp() {
-		return createEnumType(this.schemaName, this.typeName, this.values);
-	}
-	renderTypeScript() {
-		return `createEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.values)})`;
-	}
-};
-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);
-	}
-	renderTypeScript() {
-		return `renameType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.fromName)}, ${jsonToTsSource(this.toName)})`;
-	}
-};
-/**
-* Laundered pre-built operation.
-*
-* Wraps an already-materialized `SqlMigrationPlanOperation` — typically one
-* produced by a SQL-family method, a codec control hook, or a component
-* `databaseDependencies.init` declaration — 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();
-	}
-	toOp() {
-		return createSchema(this.schemaName);
-	}
-	renderTypeScript() {
-		return `createSchema(${jsonToTsSource(this.schemaName)})`;
-	}
-};
-/**
-* 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
-* `PN-MIG-2001`: 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 [
-			`dataTransform(endContract, ${jsonToTsSource(this.label)}, {`,
-			`  check: () => placeholder(${jsonToTsSource(this.checkSlot)}),`,
-			`  run: () => placeholder(${jsonToTsSource(this.runSlot)}),`,
-			"})"
-		].join("\n");
-	}
-	importRequirements() {
-		return [
-			{
-				moduleSpecifier: TARGET_MIGRATION_MODULE,
-				symbol: this.factoryName
-			},
-			{
-				moduleSpecifier: TARGET_MIGRATION_MODULE,
-				symbol: "placeholder"
-			},
-			{
-				moduleSpecifier: "./end-contract.json",
-				symbol: "endContract",
-				kind: "default",
-				attributes: { type: "json" }
-			}
-		];
-	}
-};
-
-//#endregion
-//#region src/core/migrations/planner-ddl-builders.ts
-/**
-* Pattern for safe PostgreSQL type names.
-* Allows letters, digits, underscores, spaces (for "double precision", "character varying"),
-* and trailing [] for array types.
-*/
-const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
-function assertSafeNativeType(nativeType) {
-	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw new Error(`Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?\$/`);
-}
-/**
-* Sanity check against accidental SQL injection from malformed contract files.
-* Rejects semicolons, SQL comment tokens, and dollar-quoting.
-* Not a comprehensive security boundary — the contract is developer-authored.
-*/
-function assertSafeDefaultExpression(expression) {
-	if (expression.includes(";") || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) throw new Error(`Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.`);
-}
-/**
-* Renders the SQL type for a column in DDL context.
-*
-* @param allowPseudoTypes - When true (default), autoincrement integer columns
-*   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts
-*   like ALTER COLUMN TYPE where pseudo-types are invalid.
-*/
-function buildColumnTypeSql(column, codecHooks, storageTypes = {}, allowPseudoTypes = true) {
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	if (allowPseudoTypes) {
-		const columnDefault = column.default;
-		if (columnDefault?.kind === "function" && columnDefault.expression === "autoincrement()") {
-			if (resolved.nativeType === "int4" || resolved.nativeType === "integer") return "SERIAL";
-			if (resolved.nativeType === "int8" || resolved.nativeType === "bigint") return "BIGSERIAL";
-			if (resolved.nativeType === "int2" || resolved.nativeType === "smallint") return "SMALLSERIAL";
-		}
-	}
-	const expanded = expandParameterizedTypeSql(resolved, codecHooks);
-	if (expanded !== null) return expanded;
-	if (column.typeRef) return quoteIdentifier(resolved.nativeType);
-	assertSafeNativeType(resolved.nativeType);
-	return resolved.nativeType;
-}
-function expandParameterizedTypeSql(column, codecHooks) {
-	if (!column.typeParams) return null;
-	if (!column.codecId) throw new Error(`Column declares typeParams for nativeType "${column.nativeType}" but has no codecId. Ensure the column is associated with a codec.`);
-	const hooks = codecHooks.get(column.codecId);
-	if (!hooks?.expandNativeType) {
-		if (hooks?.planTypeOperations) return null;
-		throw new Error(`Column declares typeParams for nativeType "${column.nativeType}" but no expandNativeType hook is registered for codecId "${column.codecId}". Ensure the extension providing this codec is included in extensionPacks.`);
-	}
-	const expanded = hooks.expandNativeType({
-		nativeType: column.nativeType,
-		codecId: column.codecId,
-		typeParams: column.typeParams
-	});
-	return expanded !== column.nativeType ? expanded : null;
-}
-/** Autoincrement columns use SERIAL types, so this returns empty for them. */
-function buildColumnDefaultSql(columnDefault, column) {
-	if (!columnDefault) return "";
-	switch (columnDefault.kind) {
-		case "literal": return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;
-		case "function":
-			if (columnDefault.expression === "autoincrement()") return "";
-			assertSafeDefaultExpression(columnDefault.expression);
-			return `DEFAULT (${columnDefault.expression})`;
-		case "sequence": return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;
-	}
-}
-function renderDefaultLiteral(value, column) {
-	const isJsonColumn = column?.nativeType === "json" || column?.nativeType === "jsonb";
-	if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
-	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (value === null) return "NULL";
-	const json = JSON.stringify(value);
-	if (isJsonColumn) return `'${escapeLiteral(json)}'::${column.nativeType}`;
-	return `'${escapeLiteral(json)}'`;
-}
-function buildAddColumnSql(qualifiedTableName, columnName, column, codecHooks, temporaryDefault, storageTypes = {}) {
-	const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
-	const defaultSql = buildColumnDefaultSql(column.default, column) || (temporaryDefault ? `DEFAULT ${temporaryDefault}` : "");
-	return [
-		`ALTER TABLE ${qualifiedTableName}`,
-		`ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
-		defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
-}
-
-//#endregion
-//#region src/core/migrations/planner-identity-values.ts
-/**
-* Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
-* Checks codec hooks first (extensions can provide type-specific identity values),
-* then falls back to the built-in map.
-*/
-function resolveIdentityValue(column, codecHooks, storageTypes = {}) {
-	const referencedType = column.typeRef ? storageTypes[column.typeRef] : void 0;
-	const codecId = referencedType?.codecId ?? column.codecId;
-	const nativeType = referencedType?.nativeType ?? column.nativeType;
-	const typeParams = referencedType?.typeParams ?? column.typeParams;
-	if (codecId) {
-		const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({
-			nativeType,
-			codecId,
-			...ifDefined("typeParams", typeParams)
-		});
-		if (hookDefault !== void 0) return hookDefault;
-	}
-	return buildBuiltinIdentityValue(nativeType, typeParams);
-}
-/**
-* Returns the built-in identity value (monoid neutral element) as a SQL literal for the given
-* PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.
-*
-* This is the planner's fallback when no codec hook provides a type-specific identity value.
-*
-* Returns null for unrecognized types (for example enums and extension-owned types without a
-* hook), which causes the planner to fall back to the empty-table precheck.
-*
-* @internal Exported for testing only.
-*/
-function buildBuiltinIdentityValue(nativeType, typeParams) {
-	const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);
-	if (normalizedNativeType.endsWith("[]")) return "'{}'";
-	switch (normalizedNativeType) {
-		case "text":
-		case "character":
-		case "bpchar":
-		case "character varying":
-		case "varchar": return "''";
-		case "int2":
-		case "int4":
-		case "int8":
-		case "integer":
-		case "bigint":
-		case "smallint":
-		case "float4":
-		case "float8":
-		case "real":
-		case "double precision":
-		case "numeric":
-		case "decimal": return "0";
-		case "bool":
-		case "boolean": return "false";
-		case "uuid": return "'00000000-0000-0000-0000-000000000000'";
-		case "json": return "'{}'::json";
-		case "jsonb": return "'{}'::jsonb";
-		case "date":
-		case "timestamp":
-		case "timestamptz":
-		case "timestamp with time zone":
-		case "timestamp without time zone": return "'epoch'";
-		case "time":
-		case "time without time zone": return "'00:00:00'";
-		case "timetz":
-		case "time with time zone": return "'00:00:00+00'";
-		case "interval": return "'0'";
-		case "bytea": return "''::bytea";
-		case "tsvector": return "''::tsvector";
-		case "bit": return buildBitIdentityValue(typeParams);
-		case "bit varying":
-		case "varbit": return "B''";
-		default: return null;
-	}
-}
-function normalizeIdentityValueNativeType(nativeType) {
-	return nativeType.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function buildBitIdentityValue(typeParams) {
-	const length = typeParams?.["length"];
-	if (length === void 0) return "B'0'";
-	if (typeof length !== "number" || !Number.isInteger(length) || length <= 0) return null;
-	return `B'${"0".repeat(length)}'`;
-}
-
-//#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)
-		}
-	};
-}
-function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
-	const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } = options;
-	const qualified = qualifyTableName(schema, tableName);
-	return {
-		...buildAddColumnOperationIdentity(schema, tableName, columnName),
-		operationClass: "additive",
-		precheck: [{
-			description: `ensure column "${columnName}" is missing`,
-			sql: columnExistsCheck({
-				schema,
-				table: tableName,
-				column: columnName,
-				exists: false
-			})
-		}],
-		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: [
-			{
-				description: `verify column "${columnName}" exists`,
-				sql: columnExistsCheck({
-					schema,
-					table: tableName,
-					column: columnName
-				})
-			},
-			{
-				description: `verify column "${columnName}" is NOT NULL`,
-				sql: columnNullabilityCheck({
-					schema,
-					table: tableName,
-					column: columnName,
-					nullable: false
-				})
-			},
-			{
-				description: `verify column "${columnName}" has no default after temporary default removal`,
-				sql: columnHasNoDefaultCheck({
-					schema,
-					table: tableName,
-					column: columnName
-				})
-			}
-		]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/planner-schema-lookup.ts
-function buildSchemaLookupMap(schema) {
-	const map = /* @__PURE__ */ new Map();
-	for (const [tableName, table] of Object.entries(schema.tables)) map.set(tableName, buildSchemaTableLookup(table));
-	return map;
-}
-function buildSchemaTableLookup(table) {
-	return {
-		uniqueKeys: new Set(table.uniques.map((u) => u.columns.join(","))),
-		indexKeys: new Set(table.indexes.map((i) => i.columns.join(","))),
-		uniqueIndexKeys: new Set(table.indexes.filter((i) => i.unique).map((i) => i.columns.join(","))),
-		fkKeys: new Set(table.foreignKeys.map((fk) => `${fk.columns.join(",")}|${fk.referencedTable}|${fk.referencedColumns.join(",")}`))
-	};
-}
-function hasUniqueConstraint(lookup, columns) {
-	const key = columns.join(",");
-	return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);
-}
-function hasForeignKey(lookup, fk) {
-	return lookup.fkKeys.has(`${fk.columns.join(",")}|${fk.references.table}|${fk.references.columns.join(",")}`);
-}
-
-//#endregion
-//#region src/core/migrations/planner-strategies.ts
-const REBUILD_SUFFIX = "__prisma_next_new";
-function buildColumnSpec(table, column, ctx, overrides) {
-	const col = ctx.toContract.storage.tables[table]?.columns[column];
-	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
-	const mutableHooks = ctx.codecHooks;
-	const mutableTypes = ctx.storageTypes;
-	return {
-		name: column,
-		typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
-		defaultSql: buildColumnDefaultSql(col.default, col),
-		nullable: overrides?.nullable ?? col.nullable
-	};
-}
-function buildAlterTypeOptions(table, column, ctx, using) {
-	const col = ctx.toContract.storage.tables[table]?.columns[column];
-	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
-	const mutableHooks = ctx.codecHooks;
-	const mutableTypes = ctx.storageTypes;
-	const qualifiedTargetType = buildColumnTypeSql(col, mutableHooks, mutableTypes, false);
-	return {
-		qualifiedTargetType,
-		formatTypeExpected: buildExpectedFormatType(col, mutableHooks, mutableTypes),
-		rawTargetTypeForLabel: qualifiedTargetType,
-		...using !== void 0 ? { using } : {}
-	};
-}
-const notNullBackfillCallStrategy = (issues, ctx) => {
-	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
-	const matched = [];
-	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
-		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-		if (!column) continue;
-		if (column.nullable === true || column.default !== void 0) continue;
-		matched.push(issue);
-		const spec = buildColumnSpec(issue.table, issue.column, ctx, { nullable: true });
-		calls.push(new AddColumnCall(ctx.schemaName, issue.table, spec), new DataTransformCall(`backfill-${issue.table}-${issue.column}`, `backfill-${issue.table}-${issue.column}:check`, `backfill-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
-	}
-	if (matched.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
-		calls,
-		recipe: true
-	};
-};
-const SAFE_WIDENINGS = new Set([
-	"int2→int4",
-	"int2→int8",
-	"int4→int8",
-	"float4→float8"
-]);
-const typeChangeCallStrategy = (issues, ctx) => {
-	const dataAllowed = ctx.policy.allowedOperationClasses.includes("data");
-	const matched = [];
-	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "type_mismatch") continue;
-		if (!issue.table || !issue.column) continue;
-		const fromColumn = ctx.fromContract?.storage.tables[issue.table]?.columns[issue.column];
-		const toColumn = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-		if (!fromColumn || !toColumn) continue;
-		const fromType = fromColumn.nativeType;
-		const toType = toColumn.nativeType;
-		if (fromType === toType) continue;
-		const isSafeWidening = SAFE_WIDENINGS.has(`${fromType}→${toType}`);
-		if (!isSafeWidening && !dataAllowed) continue;
-		matched.push(issue);
-		const alterOpts = buildAlterTypeOptions(issue.table, issue.column, ctx);
-		if (isSafeWidening) calls.push(new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
-		else calls.push(new DataTransformCall(`typechange-${issue.table}-${issue.column}`, `typechange-${issue.table}-${issue.column}:check`, `typechange-${issue.table}-${issue.column}:run`), new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
-	}
-	if (matched.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
-		calls,
-		recipe: true
-	};
-};
-const nullableTighteningCallStrategy = (issues, ctx) => {
-	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
-	const matched = [];
-	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "nullability_mismatch" || !issue.table || !issue.column) continue;
-		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-		if (!column) continue;
-		if (column.nullable === true) continue;
-		matched.push(issue);
-		calls.push(new DataTransformCall(`handle-nulls-${issue.table}-${issue.column}`, `handle-nulls-${issue.table}-${issue.column}:check`, `handle-nulls-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
-	}
-	if (matched.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
-		calls,
-		recipe: true
-	};
-};
-function enumRebuildCallRecipe(typeName, ctx) {
-	const toType = ctx.toContract.storage.types?.[typeName];
-	if (!toType) return [];
-	const nativeType = toType.nativeType;
-	const desiredValues = toType.typeParams["values"] ?? [];
-	const tempName = `${nativeType}${REBUILD_SUFFIX}`;
-	const columnRefs = [];
-	for (const [tableName, table] of Object.entries(ctx.toContract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName) columnRefs.push({
-		table: tableName,
-		column: columnName
-	});
-	return [
-		new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
-		...columnRefs.map((ref) => {
-			const using = `${ref.column}::text::${tempName}`;
-			return new AlterColumnTypeCall(ctx.schemaName, ref.table, ref.column, {
-				qualifiedTargetType: tempName,
-				formatTypeExpected: tempName,
-				rawTargetTypeForLabel: tempName,
-				using
-			});
-		}),
-		new DropEnumTypeCall(ctx.schemaName, nativeType),
-		new RenameTypeCall(ctx.schemaName, tempName, nativeType)
-	];
-}
-const enumChangeCallStrategy = (issues, ctx) => {
-	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
-	const matched = [];
-	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "enum_values_changed") continue;
-		matched.push(issue);
-		if (issue.removedValues.length > 0) calls.push(new DataTransformCall(`migrate-${issue.typeName}-values`, `migrate-${issue.typeName}-values:check`, `migrate-${issue.typeName}-values:run`), ...enumRebuildCallRecipe(issue.typeName, ctx));
-		else if (issue.addedValues.length === 0) calls.push(...enumRebuildCallRecipe(issue.typeName, ctx));
-		else {
-			const toType = ctx.toContract.storage.types?.[issue.typeName];
-			if (toType) calls.push(new AddEnumValuesCall(ctx.schemaName, issue.typeName, toType.nativeType, issue.addedValues));
-		}
-	}
-	if (matched.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
-		calls,
-		recipe: true
-	};
-};
-/**
-* Dispatches storage types through their codec's `planTypeOperations` hook.
-* Replaces the walk-schema `buildStorageTypeOperations` path: the hook is
-* the authoritative source for codec-driven DDL (enum create/rebuild/add-
-* value, custom type creation, etc.).
-*
-* Runs after `enumChangeCallStrategy` so the structured enum path (value
-* add, rebuild recipe) gets first pick at `enum_values_changed` issues;
-* this strategy then handles remaining `type_missing` / `enum_values_changed`
-* issues for types whose hook produced at least one op.
-*/
-const storageTypePlanCallStrategy = (issues, ctx) => {
-	const storageTypes = ctx.toContract.storage.types ?? {};
-	if (Object.keys(storageTypes).length === 0) return { kind: "no_match" };
-	const calls = [];
-	const handledTypeNames = /* @__PURE__ */ new Set();
-	for (const [typeName, typeInstance] of Object.entries(storageTypes).sort(([a], [b]) => a.localeCompare(b))) {
-		const hook = ctx.codecHooks.get(typeInstance.codecId);
-		if (!hook?.planTypeOperations) continue;
-		const planResult = hook.planTypeOperations({
-			typeName,
-			typeInstance,
-			contract: ctx.toContract,
-			schema: ctx.schema,
-			schemaName: ctx.schemaName,
-			policy: ctx.policy
-		});
-		if (!planResult) continue;
-		if (planResult.operations.length === 0) {
-			handledTypeNames.add(typeName);
-			continue;
-		}
-		handledTypeNames.add(typeName);
-		for (const op of planResult.operations) calls.push(new RawSqlCall({
-			...op,
-			target: {
-				id: op.target.id,
-				details: buildTargetDetails("type", typeName, ctx.schemaName)
-			}
-		}));
-	}
-	const remaining = issues.filter((issue) => !((issue.kind === "type_missing" || issue.kind === "enum_values_changed") && issue.typeName && handledTypeNames.has(issue.typeName)));
-	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: remaining,
-		calls
-	};
-};
-/**
-* Dispatches component-declared database dependencies. Replaces the
-* walk-schema `buildDatabaseDependencyOperations` path. Rather than consuming
-* `dependency_missing` issues (which only carry the id), this strategy
-* re-invokes `collectInitDependencies(frameworkComponents)` at plan time so
-* the handler has access to the structured `install` ops each component
-* declared — including arbitrary SQL launders — and dedupes by dependency id
-* plus per-op id.
-*/
-const dependencyInstallCallStrategy = (issues, ctx) => {
-	const installedIds = new Set(ctx.schema.dependencies.map((d) => d.id));
-	const dependencies = sortDependencies(collectInitDependencies(ctx.frameworkComponents).filter(isPostgresPlannerDependency));
-	const calls = [];
-	const handledDependencyIds = /* @__PURE__ */ new Set();
-	const seenOperationIds = /* @__PURE__ */ new Set();
-	for (const dep of dependencies) {
-		handledDependencyIds.add(dep.id);
-		if (installedIds.has(dep.id)) continue;
-		for (const installOp of dep.install) {
-			if (seenOperationIds.has(installOp.id)) continue;
-			seenOperationIds.add(installOp.id);
-			calls.push(liftInstallOpToCall(installOp));
-		}
-	}
-	const remaining = issues.filter((issue) => issue.kind !== "dependency_missing");
-	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: remaining,
-		calls
-	};
-};
-/**
-* Handles `missing_column` issues for NOT NULL columns without a contract
-* default. Replaces the walk-schema `buildAddColumnItem` non-default branches.
-*
-* Two shapes:
-*  - Shared-temp-default safe: emit a single atomic composite op (add
-*    nullable → backfill identity value → `SET NOT NULL` → `DROP DEFAULT`).
-*  - Empty-table guarded: emit a hand-built op with a `tableIsEmptyCheck`
-*    precheck so the failure message is "table is not empty" rather than the
-*    raw PG NOT NULL violation.
-*
-* "Normal" missing_column cases (nullable or has a contract default) are left
-* for `mapIssueToCall`'s default `AddColumnCall` emission.
-*/
-const notNullAddColumnCallStrategy = (issues, ctx) => {
-	const matched = [];
-	const calls = [];
-	const schemaLookups = buildSchemaLookupMap(ctx.schema);
-	const mutableCodecHooks = ctx.codecHooks;
-	const mutableStorageTypes = ctx.storageTypes;
-	for (const issue of issues) {
-		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
-		const contractTable = ctx.toContract.storage.tables[issue.table];
-		const column = contractTable?.columns[issue.column];
-		if (!column) continue;
-		const notNull = column.nullable !== true;
-		const hasDefault = column.default !== void 0;
-		if (!notNull || hasDefault) continue;
-		const schemaTable = ctx.schema.tables[issue.table];
-		if (!schemaTable) continue;
-		const temporaryDefault = resolveIdentityValue(column, mutableCodecHooks, mutableStorageTypes);
-		const schemaLookup = schemaLookups.get(issue.table);
-		const canUseSharedTempDefault = temporaryDefault !== null && canUseSharedTemporaryDefaultStrategy({
-			table: contractTable,
-			schemaTable,
-			schemaLookup,
-			columnName: issue.column
-		});
-		matched.push(issue);
-		if (canUseSharedTempDefault && temporaryDefault !== null) {
-			calls.push(new RawSqlCall(buildAddNotNullColumnWithTemporaryDefaultOperation({
-				schema: ctx.schemaName,
-				tableName: issue.table,
-				columnName: issue.column,
-				column,
-				codecHooks: mutableCodecHooks,
-				storageTypes: mutableStorageTypes,
-				temporaryDefault
-			})));
-			continue;
-		}
-		const qualified = qualifyTableName(ctx.schemaName, issue.table);
-		calls.push(new RawSqlCall({
-			...buildAddColumnOperationIdentity(ctx.schemaName, issue.table, issue.column),
-			operationClass: "additive",
-			precheck: [{
-				description: `ensure column "${issue.column}" is missing`,
-				sql: columnExistsCheck({
-					schema: ctx.schemaName,
-					table: issue.table,
-					column: issue.column,
-					exists: false
-				})
-			}, {
-				description: `ensure table "${issue.table}" is empty before adding NOT NULL column without default`,
-				sql: tableIsEmptyCheck(qualified)
-			}],
-			execute: [{
-				description: `add column "${issue.column}"`,
-				sql: buildAddColumnSql(qualified, issue.column, column, mutableCodecHooks, void 0, mutableStorageTypes)
-			}],
-			postcheck: [{
-				description: `verify column "${issue.column}" exists`,
-				sql: columnExistsCheck({
-					schema: ctx.schemaName,
-					table: issue.table,
-					column: issue.column
-				})
-			}, {
-				description: `verify column "${issue.column}" is NOT NULL`,
-				sql: columnNullabilityCheck({
-					schema: ctx.schemaName,
-					table: issue.table,
-					column: issue.column,
-					nullable: false
-				})
-			}]
-		}));
-	}
-	if (matched.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !matched.includes(i)),
-		calls
-	};
-};
-function canUseSharedTemporaryDefaultStrategy(options) {
-	const { table, schemaTable, schemaLookup, columnName } = options;
-	if (table.primaryKey?.columns.includes(columnName) && !schemaTable.primaryKey) return false;
-	for (const unique of table.uniques) {
-		if (!unique.columns.includes(columnName)) continue;
-		if (!schemaLookup || !hasUniqueConstraint(schemaLookup, unique.columns)) return false;
-	}
-	for (const foreignKey of table.foreignKeys) {
-		if (foreignKey.constraint === false || !foreignKey.columns.includes(columnName)) continue;
-		if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
-	}
-	return true;
-}
-function isPostgresPlannerDependency(dependency) {
-	return dependency.install.every((operation) => operation.target.id === "postgres");
-}
-function sortDependencies(dependencies) {
-	return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
-}
-/**
-* Lift a component install op into migration IR. Structured shapes — extension
-* and schema installs with predictable SQL — collapse to typed `*Call`
-* subclasses so the scaffolded migration authoring surface stays readable.
-* Everything else (arbitrary SQL) falls through to `RawSqlCall` as an escape
-* hatch.
-*/
-/**
-* Component-declared install ops are wrapped as `RawSqlCall` so the
-* component's original `label`, `precheck`, `execute`, `postcheck`, and op
-* id are preserved verbatim. Structured conversion (to e.g.
-* `CreateExtensionCall`) would drop the precheck/postcheck pair and
-* change the DDL label, breaking walk-schema output parity. Classification
-* as `'dep'` happens in `classifyCall` via the underlying op's id prefix.
-*/
-function liftInstallOpToCall(op) {
-	return new RawSqlCall(op);
-}
-/**
-* Ordered list of Postgres planner strategies, shared by `migration plan`
-* and `db update` / `db init`. The issue planner runs each strategy in
-* order, letting it consume any issues it handles, and routes whatever's
-* left through `mapIssueToCall`. Behavior diverges purely on
-* `policy.allowedOperationClasses`:
-*
-* - When `'data'` is allowed (`migration plan`), the data-safe strategies
-*   (`enumChangeCallStrategy`, `notNullBackfillCallStrategy`,
-*   `typeChangeCallStrategy`, `nullableTighteningCallStrategy`) consume their
-*   matching issues and emit `DataTransformCall` placeholders or recipe ops.
-*
-* - When `'data'` is not allowed (`db update` / `db init`), each data-safe
-*   strategy short-circuits to `no_match`, leaving the issue for the
-*   downstream walk-schema strategies (`storageTypePlanCallStrategy`,
-*   `dependencyInstallCallStrategy`, `notNullAddColumnCallStrategy`) or the
-*   `mapIssueToCall` default to handle with direct DDL.
-*
-* Order matters: data-safe strategies must run before the walk-schema
-* strategies on overlapping issue kinds (e.g. `enum_values_changed`,
-* `missing_column` for NOT NULL) so they take priority when active.
-*/
-const postgresPlannerStrategies = [
-	enumChangeCallStrategy,
-	notNullBackfillCallStrategy,
-	typeChangeCallStrategy,
-	nullableTighteningCallStrategy,
-	storageTypePlanCallStrategy,
-	dependencyInstallCallStrategy,
-	notNullAddColumnCallStrategy
-];
-
-//#endregion
-//#region src/core/migrations/issue-planner.ts
-const ISSUE_KIND_ORDER = {
-	dependency_missing: 1,
-	type_missing: 2,
-	type_values_mismatch: 3,
-	enum_values_changed: 3,
-	extra_foreign_key: 10,
-	extra_unique_constraint: 11,
-	extra_primary_key: 12,
-	extra_index: 13,
-	extra_default: 14,
-	extra_column: 15,
-	extra_table: 16,
-	missing_table: 20,
-	missing_column: 30,
-	type_mismatch: 40,
-	nullability_mismatch: 41,
-	default_missing: 42,
-	default_mismatch: 43,
-	primary_key_mismatch: 50,
-	unique_constraint_mismatch: 51,
-	index_mismatch: 52,
-	foreign_key_mismatch: 60
-};
-function issueOrder(issue) {
-	return ISSUE_KIND_ORDER[issue.kind] ?? 99;
-}
-function issueConflict(kind, summary, location) {
-	return {
-		kind,
-		summary,
-		why: "Use `migration new` to author a custom migration for this change.",
-		...location ? { location } : {}
-	};
-}
-function isMissing(issue) {
-	if (issue.kind === "enum_values_changed") return false;
-	return issue.actual === void 0;
-}
-function toColumnSpec(name, column, codecHooks, storageTypes) {
-	return {
-		name,
-		typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
-		defaultSql: buildColumnDefaultSql(column.default, column),
-		nullable: column.nullable
-	};
-}
-function mapIssueToCall(issue, ctx) {
-	const { schemaName, codecHooks, storageTypes } = ctx;
-	switch (issue.kind) {
-		case "missing_table": {
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
-			const contractTable = ctx.toContract.storage.tables[issue.table];
-			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" reported missing but not found in destination contract`));
-			const columns = Object.entries(contractTable.columns).map(([name, column]) => toColumnSpec(name, column, codecHooks, storageTypes));
-			const primaryKey = contractTable.primaryKey ? { columns: contractTable.primaryKey.columns } : void 0;
-			const calls = [new CreateTableCall(schemaName, issue.table, columns, primaryKey)];
-			for (const index of contractTable.indexes) {
-				const indexName = index.name ?? `${issue.table}_${index.columns.join("_")}_idx`;
-				calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns]));
-			}
-			const explicitIndexColumnSets = new Set(contractTable.indexes.map((idx) => idx.columns.join(",")));
-			for (const fk of contractTable.foreignKeys) {
-				if (fk.constraint) {
-					const fkSpec = {
-						name: fk.name ?? `${issue.table}_${fk.columns.join("_")}_fkey`,
-						columns: fk.columns,
-						references: {
-							table: fk.references.table,
-							columns: fk.references.columns
-						},
-						...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
-						...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
-					};
-					calls.push(new AddForeignKeyCall(schemaName, issue.table, fkSpec));
-				}
-				if (fk.index && !explicitIndexColumnSets.has(fk.columns.join(","))) {
-					const indexName = `${issue.table}_${fk.columns.join("_")}_idx`;
-					calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...fk.columns]));
-				}
-			}
-			for (const unique of contractTable.uniques) {
-				const constraintName = unique.name ?? `${issue.table}_${unique.columns.join("_")}_key`;
-				calls.push(new AddUniqueCall(schemaName, issue.table, constraintName, [...unique.columns]));
-			}
-			return ok(calls);
-		}
-		case "missing_column":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Missing column issue has no table/column name"));
-			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-				if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
-				return ok([new AddColumnCall(schemaName, issue.table, toColumnSpec(issue.column, column, codecHooks, storageTypes))]);
-			}
-		case "default_missing":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default missing issue has no table/column name"));
-			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-				if (!column?.default) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" has no default in contract`));
-				const defaultSql = buildColumnDefaultSql(column.default, column);
-				if (!defaultSql) return ok([]);
-				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql)]);
-			}
-		case "extra_table":
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra table issue has no table name"));
-			return ok([new DropTableCall(schemaName, issue.table)]);
-		case "extra_column":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra column issue has no table/column name"));
-			return ok([new DropColumnCall(schemaName, issue.table, issue.column)]);
-		case "extra_index":
-			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Extra index issue has no table/index name"));
-			return ok([new DropIndexCall(schemaName, issue.table, issue.indexOrConstraint)]);
-		case "extra_unique_constraint":
-		case "extra_foreign_key":
-		case "extra_primary_key": {
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
-			const constraintName = issue.indexOrConstraint ?? (issue.kind === "extra_primary_key" ? `${issue.table}_pkey` : void 0);
-			if (!constraintName) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
-			return ok([new DropConstraintCall(schemaName, issue.table, constraintName, {
-				extra_unique_constraint: "unique",
-				extra_foreign_key: "foreignKey",
-				extra_primary_key: "primaryKey"
-			}[issue.kind])]);
-		}
-		case "extra_default":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra default issue has no table/column name"));
-			return ok([new DropDefaultCall(schemaName, issue.table, issue.column)]);
-		case "nullability_mismatch": {
-			if (!issue.table || !issue.column) return notOk(issueConflict("nullabilityConflict", "Nullability mismatch has no table/column name"));
-			const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-			if (!column) return notOk(issueConflict("nullabilityConflict", `Column "${issue.table}"."${issue.column}" not found in destination contract`));
-			return ok(column.nullable ? [new DropNotNullCall(schemaName, issue.table, issue.column)] : [new SetNotNullCall(schemaName, issue.table, issue.column)]);
-		}
-		case "type_mismatch":
-			if (!issue.table || !issue.column) return notOk(issueConflict("typeMismatch", "Type mismatch has no table/column name"));
-			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-				if (!column) return notOk(issueConflict("typeMismatch", `Column "${issue.table}"."${issue.column}" not in destination contract`));
-				const hooksMap = codecHooks;
-				const typesMap = storageTypes;
-				const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
-				const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
-				return ok([new AlterColumnTypeCall(schemaName, issue.table, issue.column, {
-					qualifiedTargetType,
-					formatTypeExpected,
-					rawTargetTypeForLabel: qualifiedTargetType
-				})]);
-			}
-		case "default_mismatch":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default mismatch has no table/column name"));
-			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
-				if (!column?.default) return ok([]);
-				const defaultSql = buildColumnDefaultSql(column.default, column);
-				if (!defaultSql) return ok([]);
-				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql, "widening")]);
-			}
-		case "primary_key_mismatch":
-			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Primary key issue has no table name"));
-			if (isMissing(issue)) {
-				const pk = ctx.toContract.storage.tables[issue.table]?.primaryKey;
-				if (!pk) return notOk(issueConflict("indexIncompatible", `No primary key in contract for "${issue.table}"`));
-				const constraintName = pk.name ?? `${issue.table}_pkey`;
-				return ok([new AddPrimaryKeyCall(schemaName, issue.table, constraintName, pk.columns)]);
-			}
-			return notOk(issueConflict("indexIncompatible", `Primary key on "${issue.table}" has different columns (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-		case "unique_constraint_mismatch":
-			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Unique constraint issue has no table name"));
-			if (isMissing(issue) && issue.expected) {
-				const columns = issue.expected.split(", ");
-				const constraintName = `${issue.table}_${columns.join("_")}_key`;
-				return ok([new AddUniqueCall(schemaName, issue.table, constraintName, columns)]);
-			}
-			return notOk(issueConflict("indexIncompatible", `Unique constraint on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-		case "index_mismatch":
-			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Index issue has no table name"));
-			if (isMissing(issue) && issue.expected) {
-				const columns = issue.expected.split(", ");
-				const indexName = `${issue.table}_${columns.join("_")}_idx`;
-				return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns)]);
-			}
-			return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-		case "foreign_key_mismatch":
-			if (!issue.table) return notOk(issueConflict("foreignKeyConflict", "Foreign key issue has no table name"));
-			if (isMissing(issue) && issue.expected) {
-				const arrowIdx = issue.expected.indexOf(" -> ");
-				if (arrowIdx >= 0) {
-					const columns = issue.expected.slice(0, arrowIdx).split(", ");
-					const fkName = `${issue.table}_${columns.join("_")}_fkey`;
-					const fk = ctx.toContract.storage.tables[issue.table]?.foreignKeys.find((k) => k.columns.join(", ") === columns.join(", "));
-					if (fk) {
-						const fkSpec = {
-							name: fkName,
-							columns: fk.columns,
-							references: {
-								table: fk.references.table,
-								columns: fk.references.columns
-							},
-							...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
-							...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
-						};
-						return ok([new AddForeignKeyCall(schemaName, issue.table, fkSpec)]);
-					}
-					return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" (${columns.join(", ")}) not found in destination contract`, { table: issue.table }));
-				}
-			}
-			return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-		case "type_missing": {
-			if (!issue.typeName) return notOk(issueConflict("unsupportedOperation", "Type missing issue has no typeName"));
-			const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
-			if (!typeInstance) return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" reported missing but not found in destination contract`));
-			if (typeInstance.codecId.startsWith("pg/enum")) {
-				const values = typeInstance.typeParams["values"] ?? [];
-				return ok([new CreateEnumTypeCall(schemaName, typeInstance.nativeType, values)]);
-			}
-			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only enum types are supported`));
-		}
-		case "type_values_mismatch": return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName ?? "unknown"}" values differ — type alteration not yet supported`));
-		case "dependency_missing":
-			if (!issue.dependencyId) return notOk(issueConflict("unsupportedOperation", "Dependency missing issue has no dependencyId"));
-			if (issue.dependencyId.startsWith("ext:")) return ok([new CreateExtensionCall(issue.dependencyId.slice(4))]);
-			if (issue.dependencyId.startsWith("schema:")) return ok([new CreateSchemaCall(issue.dependencyId.slice(7))]);
-			return notOk(issueConflict("unsupportedOperation", `Unknown dependency type: ${issue.dependencyId}`));
-		default: return notOk(issueConflict("unsupportedOperation", `Unhandled issue kind: ${issue.kind}`));
-	}
-}
-/**
-* Classifies calls into DDL sequencing buckets. The order matches the
-* legacy walk-schema planner's emission order so `db init` and `db update`
-* produce byte-identical plans for the shared shape (deps → drops → tables
-* → columns → alters → PKs → uniques → indexes → FKs).
-*/
-function classifyCall(call) {
-	switch (call.factoryName) {
-		case "createExtension":
-		case "createSchema":
-		case "createEnumType":
-		case "addEnumValues":
-		case "dropEnumType":
-		case "renameType": return "dep";
-		case "dropTable":
-		case "dropColumn":
-		case "dropConstraint":
-		case "dropIndex":
-		case "dropDefault": return "drop";
-		case "createTable": return "table";
-		case "addColumn": return "column";
-		case "alterColumnType":
-		case "setNotNull":
-		case "dropNotNull":
-		case "setDefault": return "alter";
-		case "addPrimaryKey": return "primaryKey";
-		case "addUnique": return "unique";
-		case "createIndex": return "index";
-		case "addForeignKey": return "foreignKey";
-		case "rawSql": {
-			const op = call.op;
-			if (op?.target?.details?.objectType === "type") return "dep";
-			const id = typeof op?.id === "string" ? op.id : "";
-			if (id.startsWith("extension.") || id.startsWith("schema.")) return "dep";
-			return "alter";
-		}
-		default: return "alter";
-	}
-}
-/** Stable lexical key used to order issues within the same kind bucket. */
-function issueKey(issue) {
-	return `${"table" in issue && typeof issue.table === "string" ? issue.table : ""}\u0000${"column" in issue && typeof issue.column === "string" ? issue.column : ""}\u0000${"indexOrConstraint" in issue && typeof issue.indexOrConstraint === "string" ? issue.indexOrConstraint : ""}`;
-}
-const DEFAULT_POLICY = { allowedOperationClasses: [
-	"additive",
-	"widening",
-	"destructive",
-	"data"
-] };
-function emptySchemaIR() {
-	return {
-		tables: {},
-		dependencies: []
-	};
-}
-function conflictKindForCall(call) {
-	switch (call.factoryName) {
-		case "alterColumnType": return "typeMismatch";
-		case "setNotNull":
-		case "dropNotNull": return "nullabilityConflict";
-		case "addForeignKey":
-		case "dropConstraint": return "foreignKeyConflict";
-		case "createIndex":
-		case "dropIndex": return "indexIncompatible";
-		default: return "missingButNonAdditive";
-	}
-}
-function locationForCall(call) {
-	const anyCall = call;
-	const location = {};
-	if (anyCall.tableName) location.table = anyCall.tableName;
-	if (anyCall.columnName) location.column = anyCall.columnName;
-	if (anyCall.indexName) location.index = anyCall.indexName;
-	if (anyCall.constraintName) location.constraint = anyCall.constraintName;
-	if (anyCall.typeName) location.type = anyCall.typeName;
-	return Object.keys(location).length > 0 ? location : void 0;
-}
-function conflictForDisallowedCall(call, allowed) {
-	const summary = `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`;
-	const location = locationForCall(call);
-	return {
-		kind: conflictKindForCall(call),
-		summary,
-		why: "Use `migration new` to author a custom migration for this change.",
-		...location ? { location } : {}
-	};
-}
-function planIssues(options) {
-	const policyProvided = options.policy !== void 0;
-	const policy = options.policy ?? DEFAULT_POLICY;
-	const schema = options.schema ?? emptySchemaIR();
-	const frameworkComponents = options.frameworkComponents ?? [];
-	const context = {
-		toContract: options.toContract,
-		fromContract: options.fromContract,
-		schemaName: options.schemaName,
-		codecHooks: options.codecHooks,
-		storageTypes: options.storageTypes,
-		schema,
-		policy,
-		frameworkComponents
-	};
-	const strategies = options.strategies ?? postgresPlannerStrategies;
-	let remaining = options.issues;
-	const recipeCalls = [];
-	const bucketablePatternCalls = [];
-	for (const strategy of strategies) {
-		const result = strategy(remaining, context);
-		if (result.kind === "match") {
-			remaining = result.issues;
-			if (result.recipe) recipeCalls.push(...result.calls);
-			else bucketablePatternCalls.push(...result.calls);
-		}
-	}
-	const sorted = [...remaining].sort((a, b) => {
-		const kindDelta = issueOrder(a) - issueOrder(b);
-		if (kindDelta !== 0) return kindDelta;
-		const keyA = issueKey(a);
-		const keyB = issueKey(b);
-		return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
-	});
-	const defaultCalls = [];
-	const conflicts = [];
-	for (const issue of sorted) {
-		const result = mapIssueToCall(issue, context);
-		if (result.ok) defaultCalls.push(...result.value);
-		else conflicts.push(result.failure);
-	}
-	const allowed = policy.allowedOperationClasses;
-	let gatedDefault = defaultCalls;
-	let gatedRecipe = recipeCalls;
-	let gatedBucketable = bucketablePatternCalls;
-	if (policyProvided) {
-		const keepIfAllowed = (bucket) => (call) => {
-			if (allowed.includes(call.operationClass)) {
-				bucket.push(call);
-				return;
-			}
-			conflicts.push(conflictForDisallowedCall(call, allowed));
-		};
-		const gatedDefaultBucket = [];
-		const gatedRecipeBucket = [];
-		const gatedBucketableBucket = [];
-		defaultCalls.forEach(keepIfAllowed(gatedDefaultBucket));
-		recipeCalls.forEach(keepIfAllowed(gatedRecipeBucket));
-		bucketablePatternCalls.forEach(keepIfAllowed(gatedBucketableBucket));
-		gatedDefault = gatedDefaultBucket;
-		gatedRecipe = gatedRecipeBucket;
-		gatedBucketable = gatedBucketableBucket;
-	}
-	if (conflicts.length > 0) return notOk(conflicts);
-	const combinedBucketable = [...gatedDefault, ...gatedBucketable];
-	const byCategory = (cat) => combinedBucketable.filter((c) => classifyCall(c) === cat);
-	return ok({ calls: [
-		...byCategory("dep"),
-		...byCategory("drop"),
-		...byCategory("table"),
-		...byCategory("column"),
-		...gatedRecipe,
-		...byCategory("alter"),
-		...byCategory("primaryKey"),
-		...byCategory("unique"),
-		...byCategory("index"),
-		...byCategory("foreignKey")
-	] });
-}
-
-//#endregion
-//#region src/core/migrations/render-ops.ts
-function renderOps(calls) {
-	return calls.map((c) => c.toOp());
-}
-
-//#endregion
-//#region src/core/migrations/render-typescript.ts
-/**
-* Polymorphic TypeScript emitter for the Postgres migration IR.
-*
-* Each `PostgresOpFactoryCall` renders itself via `renderTypeScript()` and
-* declares its own `importRequirements()`; this file just composes the module
-* source around those contributions. The design mirrors the Mongo target's
-* `render-typescript.ts` deliberately — byte-for-byte alignment isn't required
-* (different factory module specifiers, different base-class name) but the
-* shape is, so future consolidation to a framework-level helper is mechanical.
-*/
-/**
-* Always-present base import — the rendered scaffold always extends the
-* target-owned `Migration` (i.e. `PostgresMigration`) re-exported from
-* `@prisma-next/target-postgres/migration`. That re-export fixes the
-* `SqlMigration` generic to `PostgresPlanTargetDetails` and the abstract
-* `targetId` to `'postgres'`, so user-authored migrations don't need to
-* thread target-details or redeclare `targetId`.
-*/
-const BASE_IMPORT = {
-	moduleSpecifier: "@prisma-next/target-postgres/migration",
-	symbol: "Migration"
-};
-function renderCallsToTypeScript(calls, meta) {
-	const imports = buildImports(calls);
-	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
-	return [
-		shebangLineFor(detectScaffoldRuntime()),
-		imports,
-		"",
-		"export default class M extends Migration {",
-		buildDescribeMethod(meta),
-		"  override get operations() {",
-		"    return [",
-		indent(operationsBody, 6),
-		"    ];",
-		"  }",
-		"}",
-		"",
-		"Migration.run(import.meta.url, M);",
-		""
-	].join("\n");
-}
-function buildImports(calls) {
-	const requirements = [BASE_IMPORT];
-	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
-	return renderImports(requirements);
-}
-function buildDescribeMethod(meta) {
-	const lines = [];
-	lines.push("  override describe() {");
-	lines.push("    return {");
-	lines.push(`      from: ${JSON.stringify(meta.from)},`);
-	lines.push(`      to: ${JSON.stringify(meta.to)},`);
-	if (meta.kind) lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
-	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
-	lines.push("    };");
-	lines.push("  }");
-	lines.push("");
-	return lines.join("\n");
-}
-function indent(text, spaces) {
-	const pad = " ".repeat(spaces);
-	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
-}
-
-//#endregion
-//#region src/core/migrations/planner-produced-postgres-migration.ts
-var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
-	#calls;
-	#meta;
-	constructor(calls, meta) {
-		super();
-		this.#calls = calls;
-		this.#meta = meta;
-	}
-	get operations() {
-		return renderOps(this.#calls);
-	}
-	describe() {
-		return this.#meta;
-	}
-	renderTypeScript() {
-		return renderCallsToTypeScript(this.#calls, {
-			from: this.#meta.from,
-			to: this.#meta.to,
-			...ifDefined("kind", this.#meta.kind),
-			...ifDefined("labels", this.#meta.labels)
-		});
-	}
-};
-
-//#endregion
-//#region src/core/migrations/planner.ts
-const DEFAULT_PLANNER_CONFIG = { defaultSchema: "public" };
-function createPostgresMigrationPlanner(config = {}) {
-	return new PostgresMigrationPlanner({
-		...DEFAULT_PLANNER_CONFIG,
-		...config
-	});
-}
-/**
-* Postgres migration planner — a thin wrapper over `planIssues`.
-*
-* `plan()` verifies the live schema against the target contract (producing
-* `SchemaIssue[]`) and delegates to `planIssues` with the unified
-* `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,
-* type-change, nullable-tightening, codec-hook storage types,
-* component-declared dependency installs, and shared-temp-default /
-* empty-table-guarded NOT-NULL add-column. The same strategy list runs for
-* `migration plan`, `db update`, and `db init`; behavior diverges purely on
-* `policy.allowedOperationClasses` (the data-safe strategies short-circuit
-* when `'data'` is excluded). The issue planner applies operation-class
-* policy gates and emits a single `PostgresOpFactoryCall[]` that drives both
-* the runtime-ops view (via `renderOps`) and the `renderTypeScript()`
-* authoring surface.
-*/
-var PostgresMigrationPlanner = class {
-	constructor(config) {
-		this.config = config;
-	}
-	plan(options) {
-		return this.planSql(options, options.fromHash ?? "");
-	}
-	emptyMigration(context) {
-		return new TypeScriptRenderablePostgresMigration([], {
-			from: context.fromHash,
-			to: context.toHash
-		});
-	}
-	planSql(options, fromHash) {
-		const schemaName = options.schemaName ?? this.config.defaultSchema;
-		const policyResult = this.ensureAdditivePolicy(options.policy);
-		if (policyResult) return policyResult;
-		const schemaIssues = this.collectSchemaIssues(options);
-		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-		const storageTypes = options.contract.storage.types ?? {};
-		const result = planIssues({
-			issues: schemaIssues,
-			toContract: options.contract,
-			fromContract: options.fromContract ?? null,
-			schemaName,
-			codecHooks,
-			storageTypes,
-			schema: options.schema,
-			policy: options.policy,
-			frameworkComponents: options.frameworkComponents,
-			strategies: postgresPlannerStrategies
-		});
-		if (!result.ok) return plannerFailure(result.failure);
-		return Object.freeze({
-			kind: "success",
-			plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {
-				from: fromHash,
-				to: options.contract.storage.storageHash
-			})
-		});
-	}
-	ensureAdditivePolicy(policy) {
-		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
-			kind: "unsupportedOperation",
-			summary: "Migration planner requires additive operations be allowed",
-			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
-		}]);
-		return null;
-	}
-	collectSchemaIssues(options) {
-		const allowed = options.policy.allowedOperationClasses;
-		const strict = allowed.includes("widening") || allowed.includes("destructive");
-		return verifySqlSchema({
-			contract: options.contract,
-			schema: options.schema,
-			strict,
-			typeMetadataRegistry: /* @__PURE__ */ new Map(),
-			frameworkComponents: options.frameworkComponents,
-			normalizeDefault: parsePostgresDefault,
-			normalizeNativeType: normalizeSchemaNativeType
-		}).schema.issues;
-	}
-};
-
-//#endregion
-//#region src/core/migrations/statement-builders.ts
-const ensurePrismaContractSchemaStatement = {
-	sql: "create schema if not exists prisma_contract",
-	params: []
-};
-const ensureMarkerTableStatement = {
-	sql: `create table if not exists prisma_contract.marker (
-    id smallint primary key default 1,
-    core_hash text not null,
-    profile_hash text not null,
-    contract_json jsonb,
-    canonical_version int,
-    updated_at timestamptz not null default now(),
-    app_tag text,
-    meta jsonb not null default '{}'
-  )`,
-	params: []
-};
-const ensureLedgerTableStatement = {
-	sql: `create table if not exists prisma_contract.ledger (
-    id bigserial primary key,
-    created_at timestamptz not null default now(),
-    origin_core_hash text,
-    origin_profile_hash text,
-    destination_core_hash text not null,
-    destination_profile_hash text,
-    contract_json_before jsonb,
-    contract_json_after jsonb,
-    operations jsonb not null
-  )`,
-	params: []
-};
-function buildWriteMarkerStatements(input) {
-	const params = [
-		1,
-		input.storageHash,
-		input.profileHash,
-		jsonParam(input.contractJson),
-		input.canonicalVersion ?? null,
-		input.appTag ?? null,
-		jsonParam(input.meta ?? {})
-	];
-	return {
-		insert: {
-			sql: `insert into prisma_contract.marker (
-        id,
-        core_hash,
-        profile_hash,
-        contract_json,
-        canonical_version,
-        updated_at,
-        app_tag,
-        meta
-      ) values (
-        $1,
-        $2,
-        $3,
-        $4::jsonb,
-        $5,
-        now(),
-        $6,
-        $7::jsonb
-      )`,
-			params
-		},
-		update: {
-			sql: `update prisma_contract.marker set
-        core_hash = $2,
-        profile_hash = $3,
-        contract_json = $4::jsonb,
-        canonical_version = $5,
-        updated_at = now(),
-        app_tag = $6,
-        meta = $7::jsonb
-      where id = $1`,
-			params
-		}
-	};
-}
-function buildLedgerInsertStatement(input) {
-	return {
-		sql: `insert into prisma_contract.ledger (
-      origin_core_hash,
-      origin_profile_hash,
-      destination_core_hash,
-      destination_profile_hash,
-      contract_json_before,
-      contract_json_after,
-      operations
-    ) values (
-      $1,
-      $2,
-      $3,
-      $4,
-      $5::jsonb,
-      $6::jsonb,
-      $7::jsonb
-    )`,
-		params: [
-			input.originStorageHash ?? null,
-			input.originProfileHash ?? null,
-			input.destinationStorageHash,
-			input.destinationProfileHash ?? null,
-			jsonParam(input.contractJsonBefore),
-			jsonParam(input.contractJsonAfter),
-			jsonParam(input.operations)
-		]
-	};
-}
-function jsonParam(value) {
-	return JSON.stringify(value ?? null);
-}
-
-//#endregion
 //#region src/core/migrations/runner.ts
 const DEFAULT_CONFIG = { defaultSchema: "public" };
 const LOCK_DOMAIN = "prisma_next.contract.marker";