@prisma-next/target-postgres 0.3.0-dev.34 → 0.3.0-dev.36

package/dist/control.mjs

@@ -0,0 +1,2453 @@
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DxB8oZzB.mjs";
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/sql-relational-core/ast";
+import { arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { createMigrationPlan, extractCodecControlHooks, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
+import { readMarker } from "@prisma-next/family-sql/verify";
+import { SqlQueryError } from "@prisma-next/sql-errors";
+import { ok, okVoid } from "@prisma-next/utils/result";
+
+//#region ../../6-adapters/postgres/dist/codec-ids-Bsm9c7ns.mjs
+const PG_TEXT_CODEC_ID = "pg/text@1";
+const PG_ENUM_CODEC_ID = "pg/enum@1";
+const PG_CHAR_CODEC_ID = "pg/char@1";
+const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
+const PG_INT_CODEC_ID = "pg/int@1";
+const PG_INT2_CODEC_ID = "pg/int2@1";
+const PG_INT4_CODEC_ID = "pg/int4@1";
+const PG_INT8_CODEC_ID = "pg/int8@1";
+const PG_FLOAT_CODEC_ID = "pg/float@1";
+const PG_FLOAT4_CODEC_ID = "pg/float4@1";
+const PG_FLOAT8_CODEC_ID = "pg/float8@1";
+const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
+const PG_BOOL_CODEC_ID = "pg/bool@1";
+const PG_BIT_CODEC_ID = "pg/bit@1";
+const PG_VARBIT_CODEC_ID = "pg/varbit@1";
+const PG_TIMESTAMP_CODEC_ID = "pg/timestamp@1";
+const PG_TIMESTAMPTZ_CODEC_ID = "pg/timestamptz@1";
+const PG_TIME_CODEC_ID = "pg/time@1";
+const PG_TIMETZ_CODEC_ID = "pg/timetz@1";
+const PG_INTERVAL_CODEC_ID = "pg/interval@1";
+const PG_JSON_CODEC_ID = "pg/json@1";
+const PG_JSONB_CODEC_ID = "pg/jsonb@1";
+
+//#endregion
+//#region ../../6-adapters/postgres/dist/descriptor-meta-D7pxo-wo.mjs
+/**
+* Shared SQL utility functions for the Postgres adapter.
+*
+* These functions handle safe SQL identifier and literal escaping
+* with security validations to prevent injection and encoding issues.
+*/
+/**
+* Error thrown when an invalid SQL identifier or literal is detected.
+* Boundary layers map this to structured envelopes.
+*/
+var SqlEscapeError = class extends Error {
+	constructor(message, value, kind) {
+		super(message);
+		this.value = value;
+		this.kind = kind;
+		this.name = "SqlEscapeError";
+	}
+};
+/**
+* Maximum length for PostgreSQL identifiers (NAMEDATALEN - 1).
+*/
+const MAX_IDENTIFIER_LENGTH$1 = 63;
+/**
+* Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+* - Rejects empty identifiers
+* - Warns on identifiers exceeding PostgreSQL's 63-character limit
+*
+* @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+*/
+function quoteIdentifier(identifier) {
+	if (identifier.length === 0) throw new SqlEscapeError("Identifier cannot be empty", identifier, "identifier");
+	if (identifier.includes("\0")) throw new SqlEscapeError("Identifier cannot contain null bytes", identifier.replace(/\0/g, "\\0"), "identifier");
+	if (identifier.length > MAX_IDENTIFIER_LENGTH$1) console.warn(`Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH$1}-character limit and will be truncated`);
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Escapes a string literal for safe use in SQL statements.
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+*
+* Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+* Backslashes are treated as literal characters, not escape sequences.
+*
+* @throws {SqlEscapeError} If the value contains null bytes
+*/
+function escapeLiteral(value) {
+	if (value.includes("\0")) throw new SqlEscapeError("Literal value cannot contain null bytes", value.replace(/\0/g, "\\0"), "literal");
+	return value.replace(/'/g, "''");
+}
+/**
+* Builds a qualified name (schema.object) with proper quoting.
+*/
+function qualifyName(schemaName, objectName) {
+	return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
+}
+/**
+* Validates that an enum value doesn't exceed PostgreSQL's label length limit.
+*
+* PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
+* Unlike identifiers, enum labels that exceed this limit cause an error rather than
+* silent truncation.
+*
+* @param value - The enum value to validate
+* @param enumTypeName - Name of the enum type (for error messages)
+* @throws {SqlEscapeError} If the value exceeds the maximum length
+*/
+function validateEnumValueLength(value, enumTypeName) {
+	if (value.length > MAX_IDENTIFIER_LENGTH$1) throw new SqlEscapeError(`Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH$1}-character label limit`, value, "literal");
+}
+const ENUM_INTROSPECT_QUERY = `
+  SELECT
+    n.nspname AS schema_name,
+    t.typname AS type_name,
+    array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  JOIN pg_enum e ON t.oid = e.enumtypid
+  WHERE n.nspname = $1
+  GROUP BY n.nspname, t.typname
+  ORDER BY n.nspname, t.typname
+`;
+/**
+* Type guard for string arrays. Used for runtime validation of introspected data.
+*/
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+* Parses a PostgreSQL array value into a JavaScript string array.
+*
+* PostgreSQL's `pg` library may return `array_agg` results either as:
+* - A JavaScript array (when type parsers are configured)
+* - A string in PostgreSQL array literal format: `{value1,value2,...}`
+*
+* Handles PostgreSQL's quoting rules for array elements:
+* - Elements containing commas, double quotes, backslashes, or whitespace are double-quoted
+* - Inside quoted elements, `\"` represents `"` and `\\` represents `\`
+*
+* @param value - The value to parse (array or PostgreSQL array string)
+* @returns A string array, or null if the value cannot be parsed
+*/
+function parsePostgresArray(value) {
+	if (isStringArray(value)) return value;
+	if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
+		const inner = value.slice(1, -1);
+		if (inner === "") return [];
+		return parseArrayElements(inner);
+	}
+	return null;
+}
+function parseArrayElements(input) {
+	const result = [];
+	let i = 0;
+	while (i < input.length) {
+		if (input[i] === ",") {
+			i++;
+			continue;
+		}
+		if (input[i] === "\"") {
+			i++;
+			let element = "";
+			while (i < input.length && input[i] !== "\"") {
+				if (input[i] === "\\" && i + 1 < input.length) {
+					i++;
+					element += input[i];
+				} else element += input[i];
+				i++;
+			}
+			i++;
+			result.push(element);
+		} else {
+			const nextComma = input.indexOf(",", i);
+			if (nextComma === -1) {
+				result.push(input.slice(i).trim());
+				i = input.length;
+			} else {
+				result.push(input.slice(i, nextComma).trim());
+				i = nextComma;
+			}
+		}
+	}
+	return result;
+}
+/**
+* Extracts enum values from a StorageTypeInstance.
+* Returns null if values are missing or invalid.
+*/
+function getEnumValues(typeInstance) {
+	const values = typeInstance.typeParams?.["values"];
+	return isStringArray(values) ? values : null;
+}
+/**
+* Reads existing enum values from the schema IR for a given native type.
+* Uses optional chaining to simplify navigation through the annotations structure.
+*/
+function readExistingEnumValues(schema, nativeType) {
+	const existing = ((schema.annotations?.["pg"])?.["storageTypes"])?.[nativeType];
+	if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) return null;
+	return getEnumValues(existing);
+}
+/**
+* Determines what changes are needed to transform existing enum values to desired values.
+*
+* Returns one of:
+* - `unchanged`: No changes needed, values match exactly
+* - `add_values`: New values can be safely appended (PostgreSQL supports this)
+* - `rebuild`: Full enum rebuild required (value removal, reordering, or both)
+*
+* Note: PostgreSQL enums can only have values added (not removed or reordered) without
+* a full type rebuild involving temp type creation and column migration.
+*
+* @param existing - Current enum values in the database
+* @param desired - Target enum values from the contract
+* @returns The type of change required
+*/
+function determineEnumDiff(existing, desired) {
+	if (arraysEqual(existing, desired)) return { kind: "unchanged" };
+	const existingSet = new Set(existing);
+	const desiredSet = new Set(desired);
+	const missingValues = desired.filter((value) => !existingSet.has(value));
+	const removedValues = existing.filter((value) => !desiredSet.has(value));
+	const orderMismatch = missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);
+	if (removedValues.length > 0 || orderMismatch) return {
+		kind: "rebuild",
+		removedValues
+	};
+	return {
+		kind: "add_values",
+		values: missingValues
+	};
+}
+function enumTypeExistsCheck(schemaName, typeName, exists = true) {
+	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
+  SELECT 1
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  WHERE n.nspname = '${escapeLiteral(schemaName)}'
+    AND t.typname = '${escapeLiteral(typeName)}'
+)`;
+}
+function buildCreateEnumOperation(typeName, nativeType, schemaName, values) {
+	for (const value of values) validateEnumValueLength(value, typeName);
+	const literalValues = values.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+	const qualifiedType = qualifyName(schemaName, nativeType);
+	return {
+		id: `type.${typeName}`,
+		label: `Create type ${typeName}`,
+		summary: `Creates enum type ${typeName}`,
+		operationClass: "additive",
+		target: { id: "postgres" },
+		precheck: [{
+			description: `ensure type "${nativeType}" does not exist`,
+			sql: enumTypeExistsCheck(schemaName, nativeType, false)
+		}],
+		execute: [{
+			description: `create type "${nativeType}"`,
+			sql: `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`
+		}],
+		postcheck: [{
+			description: `verify type "${nativeType}" exists`,
+			sql: enumTypeExistsCheck(schemaName, nativeType)
+		}]
+	};
+}
+/**
+* Computes the optimal position for inserting a new enum value to maintain
+* the desired order relative to existing values.
+*
+* PostgreSQL's `ALTER TYPE ADD VALUE` supports BEFORE/AFTER positioning.
+* This function finds the best reference value by:
+* 1. Looking for the nearest preceding value that already exists
+* 2. Falling back to the nearest following value if no preceding exists
+* 3. Defaulting to end-of-list if no reference is found
+*
+* @param options.desired - The target ordered list of all enum values
+* @param options.desiredIndex - Index of the value being inserted in the desired list
+* @param options.current - Current list of enum values (being built up incrementally)
+* @returns SQL clause (e.g., " AFTER 'x'") and insert position for tracking
+*/
+function computeInsertPosition(options) {
+	const { desired, desiredIndex, current } = options;
+	const currentSet = new Set(current);
+	const previous = desired.slice(0, desiredIndex).reverse().find((candidate) => currentSet.has(candidate));
+	const next = desired.slice(desiredIndex + 1).find((candidate) => currentSet.has(candidate));
+	return {
+		clause: previous ? ` AFTER '${escapeLiteral(previous)}'` : next ? ` BEFORE '${escapeLiteral(next)}'` : "",
+		insertAt: previous ? current.indexOf(previous) + 1 : next ? current.indexOf(next) : current.length
+	};
+}
+/**
+* Builds operations to add new enum values to an existing PostgreSQL enum type.
+*
+* Each new value is added with `ALTER TYPE ... ADD VALUE IF NOT EXISTS` for idempotency.
+* Values are inserted in the correct order using BEFORE/AFTER positioning to match
+* the desired final order.
+*
+* This is a safe, non-destructive operation - existing data is not affected.
+*
+* @param options.typeName - Contract-level type name (e.g., 'Role')
+* @param options.nativeType - PostgreSQL type name (e.g., 'role')
+* @param options.schemaName - PostgreSQL schema (e.g., 'public')
+* @param options.desired - Target ordered list of all enum values
+* @param options.existing - Current enum values in the database
+* @returns Array of migration operations to add each missing value
+*/
+function buildAddValueOperations(options) {
+	const { typeName, nativeType, schemaName } = options;
+	const current = [...options.existing];
+	const currentSet = new Set(current);
+	const operations = [];
+	for (let index = 0; index < options.desired.length; index += 1) {
+		const value = options.desired[index];
+		if (value === void 0) continue;
+		if (currentSet.has(value)) continue;
+		validateEnumValueLength(value, typeName);
+		const { clause, insertAt } = computeInsertPosition({
+			desired: options.desired,
+			desiredIndex: index,
+			current
+		});
+		operations.push({
+			id: `type.${typeName}.value.${value}`,
+			label: `Add value ${value} to ${typeName}`,
+			summary: `Adds enum value ${value} to ${typeName}`,
+			operationClass: "widening",
+			target: { id: "postgres" },
+			precheck: [],
+			execute: [{
+				description: `add value "${value}" if not exists`,
+				sql: `ALTER TYPE ${qualifyName(schemaName, nativeType)} ADD VALUE IF NOT EXISTS '${escapeLiteral(value)}'${clause}`
+			}],
+			postcheck: []
+		});
+		current.splice(insertAt, 0, value);
+		currentSet.add(value);
+	}
+	return operations;
+}
+/**
+* Collects columns using the enum type from the contract (desired state).
+* Used for type-safe reference tracking.
+*/
+function collectEnumColumnsFromContract(contract, typeName, nativeType) {
+	const columns = [];
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName || column.nativeType === nativeType && column.codecId === PG_ENUM_CODEC_ID) columns.push({
+		table: tableName,
+		column: columnName
+	});
+	return columns;
+}
+/**
+* Collects columns using the enum type from the schema IR (live database state).
+* This ensures we find ALL dependent columns, including those added outside the contract
+* (e.g., manual DDL), which is critical for safe enum rebuild operations.
+*/
+function collectEnumColumnsFromSchema(schema, nativeType) {
+	const columns = [];
+	for (const [tableName, table] of Object.entries(schema.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.nativeType === nativeType) columns.push({
+		table: tableName,
+		column: columnName
+	});
+	return columns;
+}
+/**
+* Collects all columns using the enum type from both contract AND live database.
+* Merges and deduplicates to ensure we migrate ALL dependent columns during rebuild.
+*
+* This is critical for data integrity: if a column exists in the database using
+* this enum but is not in the contract (e.g., added via manual DDL), we must
+* still migrate it to avoid DROP TYPE failures.
+*/
+function collectAllEnumColumns(contract, schema, typeName, nativeType) {
+	const contractColumns = collectEnumColumnsFromContract(contract, typeName, nativeType);
+	const schemaColumns = collectEnumColumnsFromSchema(schema, nativeType);
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const col of [...contractColumns, ...schemaColumns]) {
+		const key = `${col.table}.${col.column}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(col);
+		}
+	}
+	return result.sort((a, b) => {
+		const tableCompare = a.table.localeCompare(b.table);
+		return tableCompare !== 0 ? tableCompare : a.column.localeCompare(b.column);
+	});
+}
+/**
+* Builds a SQL check to verify a column's type matches an expected type.
+*/
+function columnTypeCheck(options) {
+	return `SELECT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(options.schemaName)}'
+    AND table_name = '${escapeLiteral(options.tableName)}'
+    AND column_name = '${escapeLiteral(options.columnName)}'
+    AND udt_name = '${escapeLiteral(options.expectedType)}'
+)`;
+}
+/** PostgreSQL maximum identifier length (NAMEDATALEN - 1) */
+const MAX_IDENTIFIER_LENGTH = 63;
+/** Suffix added to enum type names during rebuild operations */
+const REBUILD_SUFFIX = "__pn_rebuild";
+/**
+* Builds an SQL check to verify no rows contain any of the removed enum values.
+* This prevents data loss during enum rebuild operations.
+*
+* @param schemaName - PostgreSQL schema name
+* @param tableName - Table containing the enum column
+* @param columnName - Column using the enum type
+* @param removedValues - Array of enum values being removed
+* @returns SQL query that returns true if no rows contain removed values
+*/
+function noRemovedValuesExistCheck(schemaName, tableName, columnName, removedValues) {
+	if (removedValues.length === 0) return "SELECT true";
+	const valuesList = removedValues.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+	return `SELECT NOT EXISTS (
+  SELECT 1 FROM ${qualifyName(schemaName, tableName)}
+  WHERE ${quoteIdentifier(columnName)}::text IN (${valuesList})
+  LIMIT 1
+)`;
+}
+/**
+* Builds a migration operation to recreate a PostgreSQL enum type with updated values.
+*
+* This is required when:
+* - Enum values are removed (PostgreSQL doesn't support direct removal)
+* - Enum values are reordered (PostgreSQL doesn't support reordering)
+*
+* The operation:
+* 1. Creates a new enum type with the desired values (temp name)
+* 2. Migrates all columns to use the new type via text cast
+* 3. Drops the original type
+* 4. Renames the temp type to the original name
+*
+* IMPORTANT: If values are being removed and data exists using those values,
+* the operation will fail at the precheck stage with a clear error message.
+* This prevents silent data loss.
+*
+* @param options.typeName - Contract-level type name
+* @param options.nativeType - PostgreSQL type name
+* @param options.schemaName - PostgreSQL schema
+* @param options.values - Desired final enum values
+* @param options.removedValues - Values being removed (for data loss checks)
+* @param options.contract - Full contract for column discovery
+* @param options.schema - Current schema IR for column discovery
+* @returns Migration operation for full enum rebuild
+*/
+function buildRecreateEnumOperation(options) {
+	const tempTypeName = `${options.nativeType}${REBUILD_SUFFIX}`;
+	if (tempTypeName.length > MAX_IDENTIFIER_LENGTH) {
+		const maxBaseLength = MAX_IDENTIFIER_LENGTH - 12;
+		throw new Error(`Enum type name "${options.nativeType}" is too long for rebuild operation. Maximum length is ${maxBaseLength} characters (type name + "${REBUILD_SUFFIX}" suffix must fit within PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character identifier limit).`);
+	}
+	const qualifiedOriginal = qualifyName(options.schemaName, options.nativeType);
+	const qualifiedTemp = qualifyName(options.schemaName, tempTypeName);
+	const literalValues = options.values.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+	const columnRefs = collectAllEnumColumns(options.contract, options.schema, options.typeName, options.nativeType);
+	const alterColumns = columnRefs.map((ref) => ({
+		description: `alter ${ref.table}.${ref.column} to ${tempTypeName}`,
+		sql: `ALTER TABLE ${qualifyName(options.schemaName, ref.table)}
+ALTER COLUMN ${quoteIdentifier(ref.column)}
+TYPE ${qualifiedTemp}
+USING ${quoteIdentifier(ref.column)}::text::${qualifiedTemp}`
+	}));
+	const postchecks = [
+		{
+			description: `verify type "${options.nativeType}" exists`,
+			sql: enumTypeExistsCheck(options.schemaName, options.nativeType)
+		},
+		{
+			description: `verify temp type "${tempTypeName}" was removed`,
+			sql: enumTypeExistsCheck(options.schemaName, tempTypeName, false)
+		},
+		...columnRefs.map((ref) => ({
+			description: `verify ${ref.table}.${ref.column} uses type "${options.nativeType}"`,
+			sql: columnTypeCheck({
+				schemaName: options.schemaName,
+				tableName: ref.table,
+				columnName: ref.column,
+				expectedType: options.nativeType
+			})
+		}))
+	];
+	return {
+		id: `type.${options.typeName}.rebuild`,
+		label: `Rebuild type ${options.typeName}`,
+		summary: `Recreates enum type ${options.typeName} with updated values`,
+		operationClass: "destructive",
+		target: { id: "postgres" },
+		precheck: [{
+			description: `ensure type "${options.nativeType}" exists`,
+			sql: enumTypeExistsCheck(options.schemaName, options.nativeType)
+		}, ...options.removedValues.length > 0 ? columnRefs.map((ref) => ({
+			description: `ensure no rows in ${ref.table}.${ref.column} contain removed values (${options.removedValues.join(", ")})`,
+			sql: noRemovedValuesExistCheck(options.schemaName, ref.table, ref.column, options.removedValues)
+		})) : []],
+		execute: [
+			{
+				description: `drop orphaned temp type "${tempTypeName}" if exists`,
+				sql: `DROP TYPE IF EXISTS ${qualifiedTemp}`
+			},
+			{
+				description: `create temp type "${tempTypeName}"`,
+				sql: `CREATE TYPE ${qualifiedTemp} AS ENUM (${literalValues})`
+			},
+			...alterColumns,
+			{
+				description: `drop type "${options.nativeType}"`,
+				sql: `DROP TYPE ${qualifiedOriginal}`
+			},
+			{
+				description: `rename type "${tempTypeName}" to "${options.nativeType}"`,
+				sql: `ALTER TYPE ${qualifiedTemp} RENAME TO ${quoteIdentifier(options.nativeType)}`
+			}
+		],
+		postcheck: postchecks
+	};
+}
+/**
+* Postgres enum hooks for planning, verifying, and introspecting `storage.types`.
+*/
+const pgEnumControlHooks = {
+	planTypeOperations: ({ typeName, typeInstance, contract, schema, schemaName }) => {
+		const desired = getEnumValues(typeInstance);
+		if (!desired || desired.length === 0) return { operations: [] };
+		const schemaNamespace = schemaName ?? "public";
+		const existing = readExistingEnumValues(schema, typeInstance.nativeType);
+		if (!existing) return { operations: [buildCreateEnumOperation(typeName, typeInstance.nativeType, schemaNamespace, desired)] };
+		const diff = determineEnumDiff(existing, desired);
+		if (diff.kind === "unchanged") return { operations: [] };
+		if (diff.kind === "rebuild") return { operations: [buildRecreateEnumOperation({
+			typeName,
+			nativeType: typeInstance.nativeType,
+			schemaName: schemaNamespace,
+			values: desired,
+			removedValues: diff.removedValues,
+			contract,
+			schema
+		})] };
+		return { operations: buildAddValueOperations({
+			typeName,
+			nativeType: typeInstance.nativeType,
+			schemaName: schemaNamespace,
+			desired,
+			existing
+		}) };
+	},
+	verifyType: ({ typeName, typeInstance, schema }) => {
+		const desired = getEnumValues(typeInstance);
+		if (!desired) return [];
+		const existing = readExistingEnumValues(schema, typeInstance.nativeType);
+		if (!existing) return [{
+			kind: "type_missing",
+			table: "",
+			typeName,
+			message: `Type "${typeName}" is missing from database`
+		}];
+		if (!arraysEqual(existing, desired)) return [{
+			kind: "type_values_mismatch",
+			table: "",
+			typeName,
+			expected: desired.join(", "),
+			actual: existing.join(", "),
+			message: `Type "${typeName}" values do not match contract`
+		}];
+		return [];
+	},
+	introspectTypes: async ({ driver, schemaName }) => {
+		const namespace = schemaName ?? "public";
+		const result = await driver.query(ENUM_INTROSPECT_QUERY, [namespace]);
+		const types = {};
+		for (const row of result.rows) {
+			const values = parsePostgresArray(row.values);
+			if (!values) throw new Error(`Failed to parse enum values for type "${row.type_name}": unexpected format: ${JSON.stringify(row.values)}`);
+			types[row.type_name] = {
+				codecId: PG_ENUM_CODEC_ID,
+				nativeType: row.type_name,
+				typeParams: { values }
+			};
+		}
+		return types;
+	}
+};
+const MAX_DEPTH = 32;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function escapeStringLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function quotePropertyKey(key) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
+}
+function renderLiteral(value) {
+	if (typeof value === "string") return `'${escapeStringLiteral(value)}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return "unknown";
+}
+function renderUnion(items, depth) {
+	return items.map((item) => render(item, depth)).join(" | ");
+}
+function renderObjectType(schema, depth) {
+	const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
+	const required = Array.isArray(schema["required"]) ? new Set(schema["required"].filter((key) => typeof key === "string")) : /* @__PURE__ */ new Set();
+	const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
+	if (keys.length === 0) {
+		const additionalProperties = schema["additionalProperties"];
+		if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
+		return `Record<string, ${render(additionalProperties, depth)}>`;
+	}
+	return `{ ${keys.map((key) => {
+		const valueSchema = properties[key];
+		const optionalMarker = required.has(key) ? "" : "?";
+		return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
+	}).join("; ")} }`;
+}
+function renderArrayType(schema, depth) {
+	if (Array.isArray(schema["items"])) return `readonly [${schema["items"].map((item) => render(item, depth)).join(", ")}]`;
+	if (schema["items"] !== void 0) {
+		const itemType = render(schema["items"], depth);
+		return itemType.includes(" | ") || itemType.includes(" & ") ? `(${itemType})[]` : `${itemType}[]`;
+	}
+	return "unknown[]";
+}
+function render(schema, depth) {
+	if (depth > MAX_DEPTH || !isRecord(schema)) return "JsonValue";
+	const nextDepth = depth + 1;
+	if ("const" in schema) return renderLiteral(schema["const"]);
+	if (Array.isArray(schema["enum"])) return schema["enum"].map((value) => renderLiteral(value)).join(" | ");
+	if (Array.isArray(schema["oneOf"])) return renderUnion(schema["oneOf"], nextDepth);
+	if (Array.isArray(schema["anyOf"])) return renderUnion(schema["anyOf"], nextDepth);
+	if (Array.isArray(schema["allOf"])) return schema["allOf"].map((item) => render(item, nextDepth)).join(" & ");
+	if (Array.isArray(schema["type"])) return schema["type"].map((item) => render({
+		...schema,
+		type: item
+	}, nextDepth)).join(" | ");
+	switch (schema["type"]) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "array": return renderArrayType(schema, nextDepth);
+		case "object": return renderObjectType(schema, nextDepth);
+		default: break;
+	}
+	return "JsonValue";
+}
+function renderTypeScriptTypeFromJsonSchema(schema) {
+	return render(schema, 0);
+}
+/**
+* Shared utility for expanding parameterized Postgres types to their full SQL representation.
+*
+* This module provides a single source of truth for type expansion logic, used by:
+* - Schema verification (verify-sql-schema.ts) via the expandNativeType codec control hook
+* - Migration planner (planner.ts) via direct import
+*
+* @module
+*/
+/** Set of codec IDs that use the 'length' parameter */
+const LENGTH_CODEC_IDS = new Set([
+	SQL_CHAR_CODEC_ID,
+	SQL_VARCHAR_CODEC_ID,
+	PG_CHAR_CODEC_ID,
+	PG_VARCHAR_CODEC_ID,
+	PG_BIT_CODEC_ID,
+	PG_VARBIT_CODEC_ID
+]);
+/** Set of codec IDs that use the 'precision' parameter for temporal types */
+const TEMPORAL_PRECISION_CODEC_IDS = new Set([
+	PG_TIMESTAMP_CODEC_ID,
+	PG_TIMESTAMPTZ_CODEC_ID,
+	PG_TIME_CODEC_ID,
+	PG_TIMETZ_CODEC_ID,
+	PG_INTERVAL_CODEC_ID
+]);
+/**
+* Validates that a value is a valid type parameter number.
+* Type parameters must be finite, non-negative integers.
+*/
+function isValidTypeParamNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+/**
+* Expands a parameterized native type to its full SQL representation.
+*
+* For example:
+* - { nativeType: 'character varying', typeParams: { length: 255 } } -> 'character varying(255)'
+* - { nativeType: 'numeric', typeParams: { precision: 10, scale: 2 } } -> 'numeric(10,2)'
+* - { nativeType: 'timestamp without time zone', typeParams: { precision: 3 } } -> 'timestamp without time zone(3)'
+*
+* Returns the original nativeType if:
+* - No typeParams are provided
+* - No codecId is provided
+* - The codecId is not a known parameterized type
+* - The typeParams values are invalid
+*/
+function expandParameterizedNativeType(input) {
+	const { nativeType, codecId, typeParams } = input;
+	if (!typeParams || !codecId) return nativeType;
+	if (LENGTH_CODEC_IDS.has(codecId)) {
+		const length = typeParams["length"];
+		if (isValidTypeParamNumber(length)) return `${nativeType}(${length})`;
+		return nativeType;
+	}
+	if (codecId === PG_NUMERIC_CODEC_ID) {
+		const precision = typeParams["precision"];
+		const scale = typeParams["scale"];
+		if (isValidTypeParamNumber(precision)) {
+			if (isValidTypeParamNumber(scale)) return `${nativeType}(${precision},${scale})`;
+			return `${nativeType}(${precision})`;
+		}
+		return nativeType;
+	}
+	if (TEMPORAL_PRECISION_CODEC_IDS.has(codecId)) {
+		const precision = typeParams["precision"];
+		if (isValidTypeParamNumber(precision)) return `${nativeType}(${precision})`;
+		return nativeType;
+	}
+	return nativeType;
+}
+/** Creates a type import spec for codec types */
+const codecTypeImport = (named) => ({
+	package: "@prisma-next/adapter-postgres/codec-types",
+	named,
+	alias: named
+});
+/** Creates a precision-based TypeScript type renderer for temporal types */
+const precisionRenderer = (typeName) => ({
+	kind: "function",
+	render: (params) => {
+		const precision = params["precision"];
+		return typeof precision === "number" ? `${typeName}<${precision}>` : typeName;
+	}
+});
+/** Creates control hooks with just expandNativeType for parameterized types */
+const parameterizedTypeHooks = { expandNativeType: expandParameterizedNativeType };
+/**
+* Validates that a type expression string is safe to embed in generated .d.ts files.
+* Rejects expressions containing patterns that could inject executable code.
+*/
+function isSafeTypeExpression(expr) {
+	return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
+}
+function renderJsonTypeExpression(params) {
+	const typeName = params["type"];
+	if (typeof typeName === "string" && typeName.trim().length > 0) {
+		const trimmed = typeName.trim();
+		if (!isSafeTypeExpression(trimmed)) return "JsonValue";
+		return trimmed;
+	}
+	const schema = params["schemaJson"];
+	if (schema && typeof schema === "object") {
+		const rendered = renderTypeScriptTypeFromJsonSchema(schema);
+		if (!isSafeTypeExpression(rendered)) return "JsonValue";
+		return rendered;
+	}
+	return "JsonValue";
+}
+const postgresAdapterDescriptorMeta = {
+	kind: "adapter",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {
+		postgres: {
+			orderBy: true,
+			limit: true,
+			lateral: true,
+			jsonAgg: true,
+			returning: true
+		},
+		sql: { enums: true }
+	},
+	types: {
+		codecTypes: {
+			import: {
+				package: "@prisma-next/adapter-postgres/codec-types",
+				named: "CodecTypes",
+				alias: "PgTypes"
+			},
+			parameterized: {
+				[SQL_CHAR_CODEC_ID]: "Char<{{length}}>",
+				[SQL_VARCHAR_CODEC_ID]: "Varchar<{{length}}>",
+				[PG_CHAR_CODEC_ID]: "Char<{{length}}>",
+				[PG_VARCHAR_CODEC_ID]: "Varchar<{{length}}>",
+				[PG_NUMERIC_CODEC_ID]: {
+					kind: "function",
+					render: (params) => {
+						const precision = params["precision"];
+						if (typeof precision !== "number") throw new Error("pg/numeric@1 renderer expects precision");
+						const scale = params["scale"];
+						return typeof scale === "number" ? `Numeric<${precision}, ${scale}>` : `Numeric<${precision}>`;
+					}
+				},
+				[PG_BIT_CODEC_ID]: "Bit<{{length}}>",
+				[PG_VARBIT_CODEC_ID]: "VarBit<{{length}}>",
+				[PG_TIMESTAMP_CODEC_ID]: precisionRenderer("Timestamp"),
+				[PG_TIMESTAMPTZ_CODEC_ID]: precisionRenderer("Timestamptz"),
+				[PG_TIME_CODEC_ID]: precisionRenderer("Time"),
+				[PG_TIMETZ_CODEC_ID]: precisionRenderer("Timetz"),
+				[PG_INTERVAL_CODEC_ID]: precisionRenderer("Interval"),
+				[PG_ENUM_CODEC_ID]: {
+					kind: "function",
+					render: (params) => {
+						const values = params["values"];
+						if (!Array.isArray(values)) throw new Error("pg/enum@1 renderer expects values array");
+						return values.map((value) => `'${String(value).replace(/'/g, "\\'")}'`).join(" | ");
+					}
+				},
+				[PG_JSON_CODEC_ID]: {
+					kind: "function",
+					render: renderJsonTypeExpression
+				},
+				[PG_JSONB_CODEC_ID]: {
+					kind: "function",
+					render: renderJsonTypeExpression
+				}
+			},
+			typeImports: [
+				{
+					package: "@prisma-next/adapter-postgres/codec-types",
+					named: "JsonValue",
+					alias: "JsonValue"
+				},
+				codecTypeImport("Char"),
+				codecTypeImport("Varchar"),
+				codecTypeImport("Numeric"),
+				codecTypeImport("Bit"),
+				codecTypeImport("VarBit"),
+				codecTypeImport("Timestamp"),
+				codecTypeImport("Timestamptz"),
+				codecTypeImport("Time"),
+				codecTypeImport("Timetz"),
+				codecTypeImport("Interval")
+			],
+			controlPlaneHooks: {
+				[SQL_CHAR_CODEC_ID]: parameterizedTypeHooks,
+				[SQL_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_CHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_NUMERIC_CODEC_ID]: parameterizedTypeHooks,
+				[PG_BIT_CODEC_ID]: parameterizedTypeHooks,
+				[PG_VARBIT_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMESTAMP_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMESTAMPTZ_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIME_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMETZ_CODEC_ID]: parameterizedTypeHooks,
+				[PG_INTERVAL_CODEC_ID]: parameterizedTypeHooks,
+				[PG_ENUM_CODEC_ID]: pgEnumControlHooks
+			}
+		},
+		storage: [
+			{
+				typeId: PG_TEXT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "text"
+			},
+			{
+				typeId: SQL_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: SQL_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: SQL_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: SQL_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: PG_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: PG_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_INT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_INT2_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int2"
+			},
+			{
+				typeId: PG_INT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int8"
+			},
+			{
+				typeId: PG_FLOAT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float4"
+			},
+			{
+				typeId: PG_FLOAT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_NUMERIC_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "numeric"
+			},
+			{
+				typeId: PG_TIMESTAMP_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamp"
+			},
+			{
+				typeId: PG_TIMESTAMPTZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamptz"
+			},
+			{
+				typeId: PG_TIME_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "time"
+			},
+			{
+				typeId: PG_TIMETZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timetz"
+			},
+			{
+				typeId: PG_BOOL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bool"
+			},
+			{
+				typeId: PG_BIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit"
+			},
+			{
+				typeId: PG_VARBIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit varying"
+			},
+			{
+				typeId: PG_INTERVAL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "interval"
+			},
+			{
+				typeId: PG_JSON_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "json"
+			},
+			{
+				typeId: PG_JSONB_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "jsonb"
+			}
+		]
+	}
+};
+
+//#endregion
+//#region ../../6-adapters/postgres/dist/control.mjs
+/**
+* Pre-compiled regex patterns for performance.
+* These are compiled once at module load time rather than on each function call.
+*/
+const NEXTVAL_PATTERN = /^nextval\s*\(/i;
+const TIMESTAMP_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP|clock_timestamp\s*\(\s*\))$/i;
+const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
+const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
+const TRUE_PATTERN = /^true$/i;
+const FALSE_PATTERN = /^false$/i;
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
+/**
+* Parses a raw Postgres column default expression into a normalized ColumnDefault.
+* This enables semantic comparison between contract defaults and introspected schema defaults.
+*
+* Used by the migration diff layer to normalize raw database defaults during comparison,
+* keeping the introspection layer focused on faithful data capture.
+*
+* @param rawDefault - Raw default expression from information_schema.columns.column_default
+* @param _nativeType - Native column type (currently unused, reserved for future type-aware parsing)
+* @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
+*/
+function parsePostgresDefault(rawDefault, _nativeType) {
+	const trimmed = rawDefault.trim();
+	if (NEXTVAL_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "autoincrement()"
+	};
+	if (TIMESTAMP_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "now()"
+	};
+	if (UUID_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "gen_random_uuid()"
+	};
+	if (UUID_OSSP_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "gen_random_uuid()"
+	};
+	if (TRUE_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		expression: "true"
+	};
+	if (FALSE_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		expression: "false"
+	};
+	if (NUMERIC_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		expression: trimmed
+	};
+	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
+	if (stringMatch?.[1] !== void 0) return {
+		kind: "literal",
+		expression: `'${stringMatch[1]}'`
+	};
+	return {
+		kind: "function",
+		expression: trimmed
+	};
+}
+/**
+* Postgres control plane adapter for control-plane operations like introspection.
+* Provides target-specific implementations for control-plane domain actions.
+*/
+var PostgresControlAdapter = class {
+	familyId = "sql";
+	targetId = "postgres";
+	/**
+	* @deprecated Use targetId instead
+	*/
+	target = "postgres";
+	/**
+	* Target-specific normalizer for raw Postgres default expressions.
+	* Used by schema verification to normalize raw defaults before comparison.
+	*/
+	normalizeDefault = parsePostgresDefault;
+	/**
+	* Target-specific normalizer for Postgres schema native type names.
+	* Used by schema verification to normalize introspected type names
+	* before comparison with contract native types.
+	*/
+	normalizeNativeType = normalizeSchemaNativeType;
+	/**
+	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
+	*
+	* This is a pure schema discovery operation that queries the Postgres catalog
+	* and returns the schema structure without type mapping or contract enrichment.
+	* Type mapping and enrichment are handled separately by enrichment helpers.
+	*
+	* Uses batched queries to minimize database round trips (7 queries instead of 5T+3).
+	*
+	* @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+	* @param contractIR - Optional contract IR for contract-guided introspection (filtering, optimization)
+	* @param schema - Schema name to introspect (defaults to 'public')
+	* @returns Promise resolving to SqlSchemaIR representing the live database schema
+	*/
+	async introspect(driver, _contractIR, schema = "public") {
+		const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, extensionsResult] = await Promise.all([
+			driver.query(`SELECT table_name
+         FROM information_schema.tables
+         WHERE table_schema = $1
+           AND table_type = 'BASE TABLE'
+         ORDER BY table_name`, [schema]),
+			driver.query(`SELECT
+           c.table_name,
+           column_name,
+           data_type,
+           udt_name,
+           is_nullable,
+           character_maximum_length,
+           numeric_precision,
+           numeric_scale,
+           column_default,
+           format_type(a.atttypid, a.atttypmod) AS formatted_type
+         FROM information_schema.columns c
+         JOIN pg_catalog.pg_class cl
+           ON cl.relname = c.table_name
+         JOIN pg_catalog.pg_namespace ns
+           ON ns.nspname = c.table_schema
+           AND ns.oid = cl.relnamespace
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = cl.oid
+           AND a.attname = c.column_name
+           AND a.attnum > 0
+           AND NOT a.attisdropped
+         WHERE c.table_schema = $1
+         ORDER BY c.table_name, c.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'PRIMARY KEY'
+         ORDER BY tc.table_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position,
+           ccu.table_schema AS referenced_table_schema,
+           ccu.table_name AS referenced_table_name,
+           ccu.column_name AS referenced_column_name
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         JOIN information_schema.constraint_column_usage ccu
+           ON ccu.constraint_name = tc.constraint_name
+           AND ccu.table_schema = tc.table_schema
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'FOREIGN KEY'
+         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'UNIQUE'
+         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           i.tablename,
+           i.indexname,
+           ix.indisunique,
+           a.attname,
+           a.attnum
+         FROM pg_indexes i
+         JOIN pg_class ic ON ic.relname = i.indexname
+         JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1
+         JOIN pg_index ix ON ix.indexrelid = ic.oid
+         JOIN pg_class t ON t.oid = ix.indrelid
+         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
+         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey) AND a.attnum > 0
+         WHERE i.schemaname = $1
+           AND NOT EXISTS (
+             SELECT 1
+             FROM information_schema.table_constraints tc
+             WHERE tc.table_schema = $1
+               AND tc.table_name = i.tablename
+               AND tc.constraint_name = i.indexname
+           )
+         ORDER BY i.tablename, i.indexname, a.attnum`, [schema]),
+			driver.query(`SELECT extname
+         FROM pg_extension
+         ORDER BY extname`, [])
+		]);
+		const columnsByTable = groupBy(columnsResult.rows, "table_name");
+		const pksByTable = groupBy(pkResult.rows, "table_name");
+		const fksByTable = groupBy(fkResult.rows, "table_name");
+		const uniquesByTable = groupBy(uniqueResult.rows, "table_name");
+		const indexesByTable = groupBy(indexResult.rows, "tablename");
+		const pkConstraintsByTable = /* @__PURE__ */ new Map();
+		for (const row of pkResult.rows) {
+			let constraints = pkConstraintsByTable.get(row.table_name);
+			if (!constraints) {
+				constraints = /* @__PURE__ */ new Set();
+				pkConstraintsByTable.set(row.table_name, constraints);
+			}
+			constraints.add(row.constraint_name);
+		}
+		const tables = {};
+		for (const tableRow of tablesResult.rows) {
+			const tableName = tableRow.table_name;
+			const columns = {};
+			for (const colRow of columnsByTable.get(tableName) ?? []) {
+				let nativeType = colRow.udt_name;
+				const formattedType = colRow.formatted_type ? normalizeFormattedType(colRow.formatted_type, colRow.data_type, colRow.udt_name) : null;
+				if (formattedType) nativeType = formattedType;
+				else if (colRow.data_type === "character varying" || colRow.data_type === "character") if (colRow.character_maximum_length) nativeType = `${colRow.data_type}(${colRow.character_maximum_length})`;
+				else nativeType = colRow.data_type;
+				else if (colRow.data_type === "numeric" || colRow.data_type === "decimal") if (colRow.numeric_precision && colRow.numeric_scale !== null) nativeType = `${colRow.data_type}(${colRow.numeric_precision},${colRow.numeric_scale})`;
+				else if (colRow.numeric_precision) nativeType = `${colRow.data_type}(${colRow.numeric_precision})`;
+				else nativeType = colRow.data_type;
+				else nativeType = colRow.udt_name || colRow.data_type;
+				columns[colRow.column_name] = {
+					name: colRow.column_name,
+					nativeType,
+					nullable: colRow.is_nullable === "YES",
+					...ifDefined("default", colRow.column_default ?? void 0)
+				};
+			}
+			const pkRows = [...pksByTable.get(tableName) ?? []];
+			const primaryKeyColumns = pkRows.sort((a, b) => a.ordinal_position - b.ordinal_position).map((row) => row.column_name);
+			const primaryKey = primaryKeyColumns.length > 0 ? {
+				columns: primaryKeyColumns,
+				...pkRows[0]?.constraint_name ? { name: pkRows[0].constraint_name } : {}
+			} : void 0;
+			const foreignKeysMap = /* @__PURE__ */ new Map();
+			for (const fkRow of fksByTable.get(tableName) ?? []) {
+				const existing = foreignKeysMap.get(fkRow.constraint_name);
+				if (existing) {
+					existing.columns.push(fkRow.column_name);
+					existing.referencedColumns.push(fkRow.referenced_column_name);
+				} else foreignKeysMap.set(fkRow.constraint_name, {
+					columns: [fkRow.column_name],
+					referencedTable: fkRow.referenced_table_name,
+					referencedColumns: [fkRow.referenced_column_name],
+					name: fkRow.constraint_name
+				});
+			}
+			const foreignKeys = Array.from(foreignKeysMap.values()).map((fk) => ({
+				columns: Object.freeze([...fk.columns]),
+				referencedTable: fk.referencedTable,
+				referencedColumns: Object.freeze([...fk.referencedColumns]),
+				name: fk.name
+			}));
+			const pkConstraints = pkConstraintsByTable.get(tableName) ?? /* @__PURE__ */ new Set();
+			const uniquesMap = /* @__PURE__ */ new Map();
+			for (const uniqueRow of uniquesByTable.get(tableName) ?? []) {
+				if (pkConstraints.has(uniqueRow.constraint_name)) continue;
+				const existing = uniquesMap.get(uniqueRow.constraint_name);
+				if (existing) existing.columns.push(uniqueRow.column_name);
+				else uniquesMap.set(uniqueRow.constraint_name, {
+					columns: [uniqueRow.column_name],
+					name: uniqueRow.constraint_name
+				});
+			}
+			const uniques = Array.from(uniquesMap.values()).map((uq) => ({
+				columns: Object.freeze([...uq.columns]),
+				name: uq.name
+			}));
+			const indexesMap = /* @__PURE__ */ new Map();
+			for (const idxRow of indexesByTable.get(tableName) ?? []) {
+				if (!idxRow.attname) continue;
+				const existing = indexesMap.get(idxRow.indexname);
+				if (existing) existing.columns.push(idxRow.attname);
+				else indexesMap.set(idxRow.indexname, {
+					columns: [idxRow.attname],
+					name: idxRow.indexname,
+					unique: idxRow.indisunique
+				});
+			}
+			const indexes = Array.from(indexesMap.values()).map((idx) => ({
+				columns: Object.freeze([...idx.columns]),
+				name: idx.name,
+				unique: idx.unique
+			}));
+			tables[tableName] = {
+				name: tableName,
+				columns,
+				...ifDefined("primaryKey", primaryKey),
+				foreignKeys,
+				uniques,
+				indexes
+			};
+		}
+		const extensions = extensionsResult.rows.map((row) => row.extname);
+		const storageTypes = await pgEnumControlHooks.introspectTypes?.({
+			driver,
+			schemaName: schema
+		}) ?? {};
+		return {
+			tables,
+			extensions,
+			annotations: { pg: {
+				schema,
+				version: await this.getPostgresVersion(driver),
+				...ifDefined("storageTypes", Object.keys(storageTypes).length > 0 ? storageTypes : void 0)
+			} }
+		};
+	}
+	/**
+	* Gets the Postgres version from the database.
+	*/
+	async getPostgresVersion(driver) {
+		return ((await driver.query("SELECT version() AS version", [])).rows[0]?.version ?? "").match(/PostgreSQL (\d+\.\d+)/)?.[1] ?? "unknown";
+	}
+};
+/**
+* Pre-computed lookup map for simple prefix-based type normalization.
+* Maps short Postgres type names to their canonical SQL names.
+* Using a Map for O(1) lookup instead of multiple startsWith checks.
+*/
+const TYPE_PREFIX_MAP = new Map([
+	["varchar", "character varying"],
+	["bpchar", "character"],
+	["varbit", "bit varying"]
+]);
+/**
+* Normalizes a Postgres schema native type to its canonical form for comparison.
+*
+* Uses a pre-computed lookup map for simple prefix replacements (O(1))
+* and handles complex temporal type normalization separately.
+*/
+function normalizeSchemaNativeType(nativeType) {
+	const trimmed = nativeType.trim();
+	for (const [prefix, replacement] of TYPE_PREFIX_MAP) if (trimmed.startsWith(prefix)) return replacement + trimmed.slice(prefix.length);
+	if (trimmed.includes(" with time zone")) {
+		if (trimmed.startsWith("timestamp")) return `timestamptz${trimmed.slice(9).replace(" with time zone", "")}`;
+		if (trimmed.startsWith("time")) return `timetz${trimmed.slice(4).replace(" with time zone", "")}`;
+	}
+	if (trimmed.includes(" without time zone")) return trimmed.replace(" without time zone", "");
+	return trimmed;
+}
+function normalizeFormattedType(formattedType, dataType, udtName) {
+	if (formattedType === "integer") return "int4";
+	if (formattedType === "smallint") return "int2";
+	if (formattedType === "bigint") return "int8";
+	if (formattedType === "real") return "float4";
+	if (formattedType === "double precision") return "float8";
+	if (formattedType === "boolean") return "bool";
+	if (formattedType.startsWith("varchar")) return formattedType.replace("varchar", "character varying");
+	if (formattedType.startsWith("bpchar")) return formattedType.replace("bpchar", "character");
+	if (formattedType.startsWith("varbit")) return formattedType.replace("varbit", "bit varying");
+	if (dataType === "timestamp with time zone" || udtName === "timestamptz") return formattedType.replace("timestamp", "timestamptz").replace(" with time zone", "").trim();
+	if (dataType === "timestamp without time zone" || udtName === "timestamp") return formattedType.replace(" without time zone", "").trim();
+	if (dataType === "time with time zone" || udtName === "timetz") return formattedType.replace("time", "timetz").replace(" with time zone", "").trim();
+	if (dataType === "time without time zone" || udtName === "time") return formattedType.replace(" without time zone", "").trim();
+	if (formattedType.startsWith("\"") && formattedType.endsWith("\"")) return formattedType.slice(1, -1);
+	return formattedType;
+}
+/**
+* Groups an array of objects by a specified key.
+* Returns a Map for O(1) lookup by group key.
+*/
+function groupBy(items, key) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const groupKey = item[key];
+		let group = map.get(groupKey);
+		if (!group) {
+			group = [];
+			map.set(groupKey, group);
+		}
+		group.push(item);
+	}
+	return map;
+}
+var control_default$1 = {
+	...postgresAdapterDescriptorMeta,
+	operationSignatures: () => [],
+	create() {
+		return new PostgresControlAdapter();
+	}
+};
+
+//#endregion
+//#region src/core/migrations/planner.ts
+const DEFAULT_PLANNER_CONFIG = { defaultSchema: "public" };
+function createPostgresMigrationPlanner(config = {}) {
+	return new PostgresMigrationPlanner({
+		...DEFAULT_PLANNER_CONFIG,
+		...config
+	});
+}
+var PostgresMigrationPlanner = class {
+	constructor(config) {
+		this.config = config;
+	}
+	plan(options) {
+		const schemaName = options.schemaName ?? this.config.defaultSchema;
+		const policyResult = this.ensureAdditivePolicy(options.policy);
+		if (policyResult) return policyResult;
+		const classification = this.classifySchema(options);
+		if (classification.kind === "conflict") return plannerFailure(classification.conflicts);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const operations = [];
+		const storageTypePlan = this.buildStorageTypeOperations(options, schemaName, codecHooks);
+		if (storageTypePlan.conflicts.length > 0) return plannerFailure(storageTypePlan.conflicts);
+		operations.push(...this.buildDatabaseDependencyOperations(options), ...storageTypePlan.operations, ...this.buildTableOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildColumnOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildPrimaryKeyOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildUniqueOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildIndexOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildForeignKeyOperations(options.contract.storage.tables, options.schema, schemaName));
+		return plannerSuccess(createMigrationPlan({
+			targetId: "postgres",
+			origin: null,
+			destination: {
+				storageHash: options.contract.storageHash,
+				...ifDefined("profileHash", options.contract.profileHash)
+			},
+			operations
+		}));
+	}
+	ensureAdditivePolicy(policy) {
+		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
+			kind: "unsupportedOperation",
+			summary: "Init planner requires additive operations be allowed",
+			why: "The init planner only emits additive operations. Update the policy to include \"additive\"."
+		}]);
+		return null;
+	}
+	/**
+	* Builds migration operations from component-owned database dependencies.
+	* These operations install database-side persistence structures declared by components.
+	*/
+	buildDatabaseDependencyOperations(options) {
+		const dependencies = this.collectDependencies(options);
+		const operations = [];
+		const seenDependencyIds = /* @__PURE__ */ new Set();
+		const seenOperationIds = /* @__PURE__ */ new Set();
+		for (const dependency of dependencies) {
+			if (seenDependencyIds.has(dependency.id)) continue;
+			seenDependencyIds.add(dependency.id);
+			if (dependency.verifyDatabaseDependencyInstalled(options.schema).length === 0) continue;
+			for (const installOp of dependency.install) {
+				if (seenOperationIds.has(installOp.id)) continue;
+				seenOperationIds.add(installOp.id);
+				operations.push(installOp);
+			}
+		}
+		return operations;
+	}
+	buildStorageTypeOperations(options, schemaName, codecHooks) {
+		const operations = [];
+		const conflicts = [];
+		const storageTypes = options.contract.storage.types ?? {};
+		for (const [typeName, typeInstance] of sortedEntries(storageTypes)) {
+			const planResult = codecHooks.get(typeInstance.codecId)?.planTypeOperations?.({
+				typeName,
+				typeInstance,
+				contract: options.contract,
+				schema: options.schema,
+				schemaName,
+				policy: options.policy
+			});
+			if (!planResult) continue;
+			for (const operation of planResult.operations) {
+				if (!options.policy.allowedOperationClasses.includes(operation.operationClass)) {
+					conflicts.push({
+						kind: "missingButNonAdditive",
+						summary: `Storage type "${typeName}" requires "${operation.operationClass}" operation "${operation.id}"`,
+						location: { type: typeName }
+					});
+					continue;
+				}
+				operations.push({
+					...operation,
+					target: {
+						id: operation.target.id,
+						details: this.buildTargetDetails("type", typeName, schemaName)
+					}
+				});
+			}
+		}
+		return {
+			operations,
+			conflicts
+		};
+	}
+	collectDependencies(options) {
+		const components = options.frameworkComponents;
+		if (components.length === 0) return [];
+		const deps = [];
+		for (const component of components) {
+			if (!isSqlDependencyProvider(component)) continue;
+			const initDeps = component.databaseDependencies?.init;
+			if (initDeps && initDeps.length > 0) deps.push(...initDeps);
+		}
+		return sortDependencies(deps);
+	}
+	buildTableOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			if (schema.tables[tableName]) continue;
+			const qualified = qualifyTableName(schemaName, tableName);
+			operations.push({
+				id: `table.${tableName}`,
+				label: `Create table ${tableName}`,
+				summary: `Creates table ${tableName} with required columns`,
+				operationClass: "additive",
+				target: {
+					id: "postgres",
+					details: this.buildTargetDetails("table", tableName, schemaName)
+				},
+				precheck: [{
+					description: `ensure table "${tableName}" does not exist`,
+					sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`
+				}],
+				execute: [{
+					description: `create table "${tableName}"`,
+					sql: buildCreateTableSql(qualified, table)
+				}],
+				postcheck: [{
+					description: `verify table "${tableName}" exists`,
+					sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`
+				}]
+			});
+		}
+		return operations;
+	}
+	buildColumnOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			const schemaTable = schema.tables[tableName];
+			if (!schemaTable) continue;
+			for (const [columnName, column] of sortedEntries(table.columns)) {
+				if (schemaTable.columns[columnName]) continue;
+				operations.push(this.buildAddColumnOperation(schemaName, tableName, columnName, column));
+			}
+		}
+		return operations;
+	}
+	buildAddColumnOperation(schema, tableName, columnName, column) {
+		const qualified = qualifyTableName(schema, tableName);
+		const notNull = column.nullable === false;
+		const hasDefault = column.default !== void 0;
+		const requiresEmptyTable = notNull && !hasDefault;
+		const precheck = [{
+			description: `ensure column "${columnName}" is missing`,
+			sql: columnExistsCheck({
+				schema,
+				table: tableName,
+				column: columnName,
+				exists: false
+			})
+		}, ...requiresEmptyTable ? [{
+			description: `ensure table "${tableName}" is empty before adding NOT NULL column without default`,
+			sql: tableIsEmptyCheck(qualified)
+		}] : []];
+		const execute = [{
+			description: `add column "${columnName}"`,
+			sql: buildAddColumnSql(qualified, columnName, column)
+		}];
+		const postcheck = [{
+			description: `verify column "${columnName}" exists`,
+			sql: columnExistsCheck({
+				schema,
+				table: tableName,
+				column: columnName
+			})
+		}, ...notNull ? [{
+			description: `verify column "${columnName}" is NOT NULL`,
+			sql: columnIsNotNullCheck({
+				schema,
+				table: tableName,
+				column: columnName
+			})
+		}] : []];
+		return {
+			id: `column.${tableName}.${columnName}`,
+			label: `Add column ${columnName} to ${tableName}`,
+			summary: `Adds column ${columnName} to table ${tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "postgres",
+				details: this.buildTargetDetails("table", tableName, schema)
+			},
+			precheck,
+			execute,
+			postcheck
+		};
+	}
+	buildPrimaryKeyOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			if (!table.primaryKey) continue;
+			const schemaTable = schema.tables[tableName];
+			if (!schemaTable || schemaTable.primaryKey) continue;
+			const constraintName = table.primaryKey.name ?? `${tableName}_pkey`;
+			operations.push({
+				id: `primaryKey.${tableName}.${constraintName}`,
+				label: `Add primary key ${constraintName} on ${tableName}`,
+				summary: `Adds primary key ${constraintName} on ${tableName}`,
+				operationClass: "additive",
+				target: {
+					id: "postgres",
+					details: this.buildTargetDetails("table", tableName, schemaName)
+				},
+				precheck: [{
+					description: `ensure primary key does not exist on "${tableName}"`,
+					sql: tableHasPrimaryKeyCheck(schemaName, tableName, false)
+				}],
+				execute: [{
+					description: `add primary key "${constraintName}"`,
+					sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(constraintName)}
+PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
+				}],
+				postcheck: [{
+					description: `verify primary key "${constraintName}" exists`,
+					sql: tableHasPrimaryKeyCheck(schemaName, tableName, true, constraintName)
+				}]
+			});
+		}
+		return operations;
+	}
+	buildUniqueOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			const schemaTable = schema.tables[tableName];
+			for (const unique of table.uniques) {
+				if (schemaTable && hasUniqueConstraint(schemaTable, unique.columns)) continue;
+				const constraintName = unique.name ?? `${tableName}_${unique.columns.join("_")}_key`;
+				operations.push({
+					id: `unique.${tableName}.${constraintName}`,
+					label: `Add unique constraint ${constraintName} on ${tableName}`,
+					summary: `Adds unique constraint ${constraintName} on ${tableName}`,
+					operationClass: "additive",
+					target: {
+						id: "postgres",
+						details: this.buildTargetDetails("unique", constraintName, schemaName, tableName)
+					},
+					precheck: [{
+						description: `ensure unique constraint "${constraintName}" is missing`,
+						sql: constraintExistsCheck({
+							constraintName,
+							schema: schemaName,
+							exists: false
+						})
+					}],
+					execute: [{
+						description: `add unique constraint "${constraintName}"`,
+						sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(constraintName)}
+UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
+					}],
+					postcheck: [{
+						description: `verify unique constraint "${constraintName}" exists`,
+						sql: constraintExistsCheck({
+							constraintName,
+							schema: schemaName
+						})
+					}]
+				});
+			}
+		}
+		return operations;
+	}
+	buildIndexOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			const schemaTable = schema.tables[tableName];
+			for (const index of table.indexes) {
+				if (schemaTable && hasIndex(schemaTable, index.columns)) continue;
+				const indexName = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
+				operations.push({
+					id: `index.${tableName}.${indexName}`,
+					label: `Create index ${indexName} on ${tableName}`,
+					summary: `Creates index ${indexName} on ${tableName}`,
+					operationClass: "additive",
+					target: {
+						id: "postgres",
+						details: this.buildTargetDetails("index", indexName, schemaName, tableName)
+					},
+					precheck: [{
+						description: `ensure index "${indexName}" is missing`,
+						sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`
+					}],
+					execute: [{
+						description: `create index "${indexName}"`,
+						sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(schemaName, tableName)} (${index.columns.map(quoteIdentifier).join(", ")})`
+					}],
+					postcheck: [{
+						description: `verify index "${indexName}" exists`,
+						sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`
+					}]
+				});
+			}
+		}
+		return operations;
+	}
+	buildForeignKeyOperations(tables, schema, schemaName) {
+		const operations = [];
+		for (const [tableName, table] of sortedEntries(tables)) {
+			const schemaTable = schema.tables[tableName];
+			for (const foreignKey of table.foreignKeys) {
+				if (schemaTable && hasForeignKey(schemaTable, foreignKey)) continue;
+				const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join("_")}_fkey`;
+				operations.push({
+					id: `foreignKey.${tableName}.${fkName}`,
+					label: `Add foreign key ${fkName} on ${tableName}`,
+					summary: `Adds foreign key ${fkName} referencing ${foreignKey.references.table}`,
+					operationClass: "additive",
+					target: {
+						id: "postgres",
+						details: this.buildTargetDetails("foreignKey", fkName, schemaName, tableName)
+					},
+					precheck: [{
+						description: `ensure foreign key "${fkName}" is missing`,
+						sql: constraintExistsCheck({
+							constraintName: fkName,
+							schema: schemaName,
+							exists: false
+						})
+					}],
+					execute: [{
+						description: `add foreign key "${fkName}"`,
+						sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fkName)}
+FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(", ")})
+REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns.map(quoteIdentifier).join(", ")})`
+					}],
+					postcheck: [{
+						description: `verify foreign key "${fkName}" exists`,
+						sql: constraintExistsCheck({
+							constraintName: fkName,
+							schema: schemaName
+						})
+					}]
+				});
+			}
+		}
+		return operations;
+	}
+	buildTargetDetails(objectType, name, schema, table) {
+		return {
+			schema,
+			objectType,
+			name,
+			...ifDefined("table", table)
+		};
+	}
+	classifySchema(options) {
+		const verifyResult = verifySqlSchema({
+			contract: options.contract,
+			schema: options.schema,
+			strict: false,
+			typeMetadataRegistry: /* @__PURE__ */ new Map(),
+			frameworkComponents: options.frameworkComponents,
+			normalizeDefault: parsePostgresDefault,
+			normalizeNativeType: normalizeSchemaNativeType
+		});
+		const conflicts = this.extractConflicts(verifyResult.schema.issues);
+		if (conflicts.length > 0) return {
+			kind: "conflict",
+			conflicts
+		};
+		return { kind: "ok" };
+	}
+	extractConflicts(issues) {
+		const conflicts = [];
+		for (const issue of issues) {
+			if (isAdditiveIssue(issue)) continue;
+			const conflict = this.convertIssueToConflict(issue);
+			if (conflict) conflicts.push(conflict);
+		}
+		return conflicts.sort(conflictComparator);
+	}
+	convertIssueToConflict(issue) {
+		switch (issue.kind) {
+			case "type_mismatch": return this.buildConflict("typeMismatch", issue);
+			case "nullability_mismatch": return this.buildConflict("nullabilityConflict", issue);
+			case "primary_key_mismatch": return this.buildConflict("indexIncompatible", issue);
+			case "unique_constraint_mismatch": return this.buildConflict("indexIncompatible", issue);
+			case "index_mismatch": return this.buildConflict("indexIncompatible", issue);
+			case "foreign_key_mismatch": return this.buildConflict("foreignKeyConflict", issue);
+			default: return null;
+		}
+	}
+	buildConflict(kind, issue) {
+		const location = buildConflictLocation(issue);
+		const meta = issue.expected || issue.actual ? Object.freeze({
+			...ifDefined("expected", issue.expected),
+			...ifDefined("actual", issue.actual)
+		}) : void 0;
+		return {
+			kind,
+			summary: issue.message,
+			...ifDefined("location", location),
+			...ifDefined("meta", meta)
+		};
+	}
+};
+function isSqlDependencyProvider(component) {
+	if (typeof component !== "object" || component === null) return false;
+	const record = component;
+	if (Object.hasOwn(record, "familyId") && record["familyId"] !== "sql") return false;
+	if (!Object.hasOwn(record, "databaseDependencies")) return false;
+	const deps = record["databaseDependencies"];
+	return deps === void 0 || typeof deps === "object" && deps !== null;
+}
+function sortDependencies(dependencies) {
+	if (dependencies.length <= 1) return dependencies;
+	return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
+}
+function buildCreateTableSql(qualifiedTableName, table) {
+	const columnDefinitions = Object.entries(table.columns).map(([columnName, column]) => {
+		return [
+			quoteIdentifier(columnName),
+			buildColumnTypeSql(column),
+			buildColumnDefaultSql(column.default),
+			column.nullable ? "" : "NOT NULL"
+		].filter(Boolean).join(" ");
+	});
+	const constraintDefinitions = [];
+	if (table.primaryKey) constraintDefinitions.push(`PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`);
+	return `CREATE TABLE ${qualifiedTableName} (\n  ${[...columnDefinitions, ...constraintDefinitions].join(",\n  ")}\n)`;
+}
+/**
+* Builds the column type SQL, handling autoincrement as a special case.
+* For autoincrement on int4/int8, we use SERIAL/BIGSERIAL types.
+*/
+function buildColumnTypeSql(column) {
+	const columnDefault = column.default;
+	if (columnDefault?.kind === "function" && columnDefault.expression === "autoincrement()") {
+		if (column.nativeType === "int4" || column.nativeType === "integer") return "SERIAL";
+		if (column.nativeType === "int8" || column.nativeType === "bigint") return "BIGSERIAL";
+		if (column.nativeType === "int2" || column.nativeType === "smallint") return "SMALLSERIAL";
+	}
+	if (column.typeRef) return quoteIdentifier(column.nativeType);
+	return renderParameterizedTypeSql(column) ?? column.nativeType;
+}
+/**
+* Renders parameterized type SQL for a column, returning null if no expansion is needed.
+*
+* Uses the shared expandParameterizedNativeType utility from the postgres adapter.
+* Returns null when the column has no typeParams, allowing the caller to fall back
+* to the base nativeType.
+*/
+function renderParameterizedTypeSql(column) {
+	if (!column.typeParams) return null;
+	const expanded = expandParameterizedNativeType({
+		nativeType: column.nativeType,
+		codecId: column.codecId,
+		typeParams: column.typeParams
+	});
+	return expanded !== column.nativeType ? expanded : null;
+}
+/**
+* Builds the DEFAULT clause for a column definition.
+* Returns empty string if no default is defined.
+*
+* Note: autoincrement is handled specially via SERIAL types, so we skip it here.
+*/
+function buildColumnDefaultSql(columnDefault) {
+	if (!columnDefault) return "";
+	switch (columnDefault.kind) {
+		case "literal": return `DEFAULT ${columnDefault.expression}`;
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return "";
+			return `DEFAULT ${columnDefault.expression}`;
+		case "sequence": return `DEFAULT nextval(${quoteIdentifier(columnDefault.name)}::regclass)`;
+	}
+}
+function qualifyTableName(schema, table) {
+	return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+function toRegclassLiteral(schema, name) {
+	return `'${escapeLiteral(`${quoteIdentifier(schema)}.${quoteIdentifier(name)}`)}'`;
+}
+function sortedEntries(record) {
+	return Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
+}
+function constraintExistsCheck({ constraintName, schema, exists = true }) {
+	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
+  SELECT 1 FROM pg_constraint c
+  JOIN pg_namespace n ON c.connamespace = n.oid
+  WHERE c.conname = '${escapeLiteral(constraintName)}'
+  AND n.nspname = '${escapeLiteral(schema)}'
+)`;
+}
+function columnExistsCheck({ schema, table, column, exists = true }) {
+	return `SELECT ${exists ? "" : "NOT "}EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+)`;
+}
+function columnIsNotNullCheck({ schema, table, column }) {
+	return `SELECT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+    AND is_nullable = 'NO'
+)`;
+}
+function tableIsEmptyCheck(qualifiedTableName) {
+	return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
+}
+function buildAddColumnSql(qualifiedTableName, columnName, column) {
+	const typeSql = buildColumnTypeSql(column);
+	const defaultSql = buildColumnDefaultSql(column.default);
+	return [
+		`ALTER TABLE ${qualifiedTableName}`,
+		`ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
+		defaultSql,
+		column.nullable ? "" : "NOT NULL"
+	].filter(Boolean).join(" ");
+}
+function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
+	const comparison = exists ? "" : "NOT ";
+	const constraintFilter = constraintName ? `AND c2.relname = '${escapeLiteral(constraintName)}'` : "";
+	return `SELECT ${comparison}EXISTS (
+  SELECT 1
+  FROM pg_index i
+  JOIN pg_class c ON c.oid = i.indrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid
+  WHERE n.nspname = '${escapeLiteral(schema)}'
+    AND c.relname = '${escapeLiteral(table)}'
+    AND i.indisprimary
+    ${constraintFilter}
+)`;
+}
+/**
+* Checks if table has a unique constraint satisfied by the given columns.
+* Uses shared semantic satisfaction predicate from verify-helpers.
+*/
+function hasUniqueConstraint(table, columns) {
+	return isUniqueConstraintSatisfied(table.uniques, table.indexes, columns);
+}
+/**
+* Checks if table has an index satisfied by the given columns.
+* Uses shared semantic satisfaction predicate from verify-helpers.
+*/
+function hasIndex(table, columns) {
+	return isIndexSatisfied(table.indexes, table.uniques, columns);
+}
+function hasForeignKey(table, fk) {
+	return table.foreignKeys.some((candidate) => arraysEqual(candidate.columns, fk.columns) && candidate.referencedTable === fk.references.table && arraysEqual(candidate.referencedColumns, fk.references.columns));
+}
+function isAdditiveIssue(issue) {
+	switch (issue.kind) {
+		case "type_missing":
+		case "type_values_mismatch":
+		case "missing_table":
+		case "missing_column":
+		case "extension_missing": return true;
+		case "primary_key_mismatch": return issue.actual === void 0;
+		case "unique_constraint_mismatch":
+		case "index_mismatch":
+		case "foreign_key_mismatch": return issue.indexOrConstraint === void 0;
+		default: return false;
+	}
+}
+function buildConflictLocation(issue) {
+	const location = {};
+	if (issue.table) location.table = issue.table;
+	if (issue.column) location.column = issue.column;
+	if (issue.indexOrConstraint) location.constraint = issue.indexOrConstraint;
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function conflictComparator(a, b) {
+	if (a.kind !== b.kind) return a.kind < b.kind ? -1 : 1;
+	const aLocation = a.location ?? {};
+	const bLocation = b.location ?? {};
+	const tableCompare = compareStrings(aLocation.table, bLocation.table);
+	if (tableCompare !== 0) return tableCompare;
+	const columnCompare = compareStrings(aLocation.column, bLocation.column);
+	if (columnCompare !== 0) return columnCompare;
+	const constraintCompare = compareStrings(aLocation.constraint, bLocation.constraint);
+	if (constraintCompare !== 0) return constraintCompare;
+	return compareStrings(a.summary, b.summary);
+}
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	if (a === void 0) return -1;
+	if (b === void 0) return 1;
+	return a < b ? -1 : 1;
+}
+
+//#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";
+/**
+* Deep clones and freezes a record object to prevent mutation.
+* Recursively clones nested objects and arrays to ensure complete isolation.
+*/
+function cloneAndFreezeRecord(value) {
+	const cloned = {};
+	for (const [key, val] of Object.entries(value)) if (val === null || val === void 0) cloned[key] = val;
+	else if (Array.isArray(val)) cloned[key] = Object.freeze([...val]);
+	else if (typeof val === "object") cloned[key] = cloneAndFreezeRecord(val);
+	else cloned[key] = val;
+	return Object.freeze(cloned);
+}
+function createPostgresMigrationRunner(family, config = {}) {
+	return new PostgresMigrationRunner(family, {
+		...DEFAULT_CONFIG,
+		...config
+	});
+}
+var PostgresMigrationRunner = class {
+	constructor(family, config) {
+		this.family = family;
+		this.config = config;
+	}
+	async execute(options) {
+		const schema = options.schemaName ?? this.config.defaultSchema;
+		const driver = options.driver;
+		const lockKey = `${LOCK_DOMAIN}:${schema}`;
+		const destinationCheck = this.ensurePlanMatchesDestinationContract(options.plan.destination, options.destinationContract);
+		if (!destinationCheck.ok) return destinationCheck;
+		const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+		if (!policyCheck.ok) return policyCheck;
+		await this.beginTransaction(driver);
+		let committed = false;
+		try {
+			await this.acquireLock(driver, lockKey);
+			await this.ensureControlTables(driver);
+			const existingMarker = await readMarker(driver);
+			const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+			if (!markerCheck.ok) return markerCheck;
+			const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+			let applyValue;
+			if (markerAtDestination) applyValue = {
+				operationsExecuted: 0,
+				executedOperations: []
+			};
+			else {
+				const applyResult = await this.applyPlan(driver, options);
+				if (!applyResult.ok) return applyResult;
+				applyValue = applyResult.value;
+			}
+			const schemaIR = await this.family.introspect({
+				driver,
+				contractIR: options.destinationContract
+			});
+			const schemaVerifyResult = verifySqlSchema({
+				contract: options.destinationContract,
+				schema: schemaIR,
+				strict: options.strictVerification ?? true,
+				context: options.context ?? {},
+				typeMetadataRegistry: this.family.typeMetadataRegistry,
+				frameworkComponents: options.frameworkComponents,
+				normalizeDefault: parsePostgresDefault,
+				normalizeNativeType: normalizeSchemaNativeType
+			});
+			if (!schemaVerifyResult.ok) return runnerFailure("SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
+				why: "The resulting database schema does not satisfy the destination contract.",
+				meta: { issues: schemaVerifyResult.schema.issues }
+			});
+			await this.upsertMarker(driver, options, existingMarker);
+			await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+			await this.commitTransaction(driver);
+			committed = true;
+			return runnerSuccess({
+				operationsPlanned: options.plan.operations.length,
+				operationsExecuted: applyValue.operationsExecuted
+			});
+		} finally {
+			if (!committed) await this.rollbackTransaction(driver);
+		}
+	}
+	async applyPlan(driver, options) {
+		const checks = options.executionChecks;
+		const runPrechecks = checks?.prechecks !== false;
+		const runPostchecks = checks?.postchecks !== false;
+		const runIdempotency = checks?.idempotencyChecks !== false;
+		let operationsExecuted = 0;
+		const executedOperations = [];
+		for (const operation of options.plan.operations) {
+			options.callbacks?.onOperationStart?.(operation);
+			try {
+				if (runPostchecks && runIdempotency) {
+					if (await this.expectationsAreSatisfied(driver, operation.postcheck)) {
+						executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));
+						continue;
+					}
+				}
+				if (runPrechecks) {
+					const precheckResult = await this.runExpectationSteps(driver, operation.precheck, operation, "precheck");
+					if (!precheckResult.ok) return precheckResult;
+				}
+				const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);
+				if (!executeResult.ok) return executeResult;
+				if (runPostchecks) {
+					const postcheckResult = await this.runExpectationSteps(driver, operation.postcheck, operation, "postcheck");
+					if (!postcheckResult.ok) return postcheckResult;
+				}
+				executedOperations.push(operation);
+				operationsExecuted += 1;
+			} finally {
+				options.callbacks?.onOperationComplete?.(operation);
+			}
+		}
+		return ok({
+			operationsExecuted,
+			executedOperations
+		});
+	}
+	async ensureControlTables(driver) {
+		await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
+		await this.executeStatement(driver, ensureMarkerTableStatement);
+		await this.executeStatement(driver, ensureLedgerTableStatement);
+	}
+	async runExpectationSteps(driver, steps, operation, phase) {
+		for (const step of steps) {
+			const result = await driver.query(step.sql);
+			if (!this.stepResultIsTrue(result.rows)) return runnerFailure(phase === "precheck" ? "PRECHECK_FAILED" : "POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, { meta: {
+				operationId: operation.id,
+				phase,
+				stepDescription: step.description
+			} });
+		}
+		return okVoid();
+	}
+	async runExecuteSteps(driver, steps, operation) {
+		for (const step of steps) try {
+			await driver.query(step.sql);
+		} catch (error) {
+			if (SqlQueryError.is(error)) return runnerFailure("EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
+				why: error.message,
+				meta: {
+					operationId: operation.id,
+					stepDescription: step.description,
+					sql: step.sql,
+					sqlState: error.sqlState,
+					constraint: error.constraint,
+					table: error.table,
+					column: error.column,
+					detail: error.detail
+				}
+			});
+			throw error;
+		}
+		return okVoid();
+	}
+	stepResultIsTrue(rows) {
+		if (!rows || rows.length === 0) return false;
+		const firstRow = rows[0];
+		const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
+		if (typeof firstValue === "boolean") return firstValue;
+		if (typeof firstValue === "number") return firstValue !== 0;
+		if (typeof firstValue === "string") {
+			const lower = firstValue.toLowerCase();
+			if (lower === "t" || lower === "true" || lower === "1") return true;
+			if (lower === "f" || lower === "false" || lower === "0") return false;
+			return firstValue.length > 0;
+		}
+		return Boolean(firstValue);
+	}
+	async expectationsAreSatisfied(driver, steps) {
+		if (steps.length === 0) return false;
+		for (const step of steps) {
+			const result = await driver.query(step.sql);
+			if (!this.stepResultIsTrue(result.rows)) return false;
+		}
+		return true;
+	}
+	createPostcheckPreSatisfiedSkipRecord(operation) {
+		const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : void 0;
+		const runnerMeta = Object.freeze({
+			skipped: true,
+			reason: "postcheck_pre_satisfied"
+		});
+		const mergedMeta = Object.freeze({
+			...clonedMeta ?? {},
+			runner: runnerMeta
+		});
+		const frozenPostcheck = Object.freeze([...operation.postcheck]);
+		return Object.freeze({
+			id: operation.id,
+			label: operation.label,
+			...ifDefined("summary", operation.summary),
+			operationClass: operation.operationClass,
+			target: operation.target,
+			precheck: Object.freeze([]),
+			execute: Object.freeze([]),
+			postcheck: frozenPostcheck,
+			...ifDefined("meta", operation.meta || mergedMeta ? mergedMeta : void 0)
+		});
+	}
+	markerMatchesDestination(marker, plan) {
+		if (!marker) return false;
+		if (marker.storageHash !== plan.destination.storageHash) return false;
+		if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) return false;
+		return true;
+	}
+	enforcePolicyCompatibility(policy, operations) {
+		const allowedClasses = new Set(policy.allowedOperationClasses);
+		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
+			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
+			meta: {
+				operationId: operation.id,
+				operationClass: operation.operationClass,
+				allowedClasses: policy.allowedOperationClasses
+			}
+		});
+		return okVoid();
+	}
+	ensureMarkerCompatibility(marker, plan) {
+		const origin = plan.origin ?? null;
+		if (!origin) {
+			if (!marker) return okVoid();
+			if (this.markerMatchesDestination(marker, plan)) return okVoid();
+			return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (no marker expected).`, { meta: {
+				markerStorageHash: marker.storageHash,
+				expectedOrigin: null
+			} });
+		}
+		if (!marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+			markerStorageHash: marker.storageHash,
+			expectedOriginStorageHash: origin.storageHash
+		} });
+		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
+			markerProfileHash: marker.profileHash,
+			expectedOriginProfileHash: origin.profileHash
+		} });
+		return okVoid();
+	}
+	ensurePlanMatchesDestinationContract(destination, contract) {
+		if (destination.storageHash !== contract.storageHash) return runnerFailure("DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storageHash}).`, { meta: {
+			planStorageHash: destination.storageHash,
+			contractStorageHash: contract.storageHash
+		} });
+		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
+			planProfileHash: destination.profileHash,
+			contractProfileHash: contract.profileHash
+		} });
+		return okVoid();
+	}
+	async upsertMarker(driver, options, existingMarker) {
+		const writeStatements = buildWriteMarkerStatements({
+			storageHash: options.plan.destination.storageHash,
+			profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
+			contractJson: options.destinationContract,
+			canonicalVersion: null,
+			meta: {}
+		});
+		const statement = existingMarker ? writeStatements.update : writeStatements.insert;
+		await this.executeStatement(driver, statement);
+	}
+	async recordLedgerEntry(driver, options, existingMarker, executedOperations) {
+		const ledgerStatement = buildLedgerInsertStatement({
+			originStorageHash: existingMarker?.storageHash ?? null,
+			originProfileHash: existingMarker?.profileHash ?? null,
+			destinationStorageHash: options.plan.destination.storageHash,
+			destinationProfileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
+			contractJsonBefore: existingMarker?.contractJson ?? null,
+			contractJsonAfter: options.destinationContract,
+			operations: executedOperations
+		});
+		await this.executeStatement(driver, ledgerStatement);
+	}
+	async acquireLock(driver, key) {
+		await driver.query("select pg_advisory_xact_lock(hashtext($1))", [key]);
+	}
+	async beginTransaction(driver) {
+		await driver.query("BEGIN");
+	}
+	async commitTransaction(driver) {
+		await driver.query("COMMIT");
+	}
+	async rollbackTransaction(driver) {
+		await driver.query("ROLLBACK");
+	}
+	async executeStatement(driver, statement) {
+		if (statement.params.length > 0) {
+			await driver.query(statement.sql, statement.params);
+			return;
+		}
+		await driver.query(statement.sql);
+	}
+};
+
+//#endregion
+//#region src/exports/control.ts
+const postgresTargetDescriptor = {
+	...postgresTargetDescriptorMeta,
+	operationSignatures: () => [],
+	migrations: {
+		createPlanner(_family) {
+			return createPostgresMigrationPlanner();
+		},
+		createRunner(family) {
+			return createPostgresMigrationRunner(family);
+		}
+	},
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	},
+	createPlanner(_family) {
+		return createPostgresMigrationPlanner();
+	},
+	createRunner(family) {
+		return createPostgresMigrationRunner(family);
+	}
+};
+var control_default = postgresTargetDescriptor;
+
+//#endregion
+export { control_default as default };
+//# sourceMappingURL=control.mjs.map