@prisma-next/target-postgres 0.4.1 → 0.4.2

package/dist/postgres-migration-BsHJHV9O.mjs

@@ -1,2793 +0,0 @@
-import { ifDefined } from "@prisma-next/utils/defined";
-import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, codec, defineCodecs, sqlCodecDefinitions } from "@prisma-next/sql-relational-core/ast";
-import { type } from "arktype";
-import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
-import { Migration } from "@prisma-next/family-sql/migration";
-
-//#region ../../6-adapters/postgres/dist/sql-utils-DkUJyZmA.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");
-}
-
-//#endregion
-//#region ../../6-adapters/postgres/dist/codec-ids-5g4Gwrgm.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/codecs-DiPlMi3-.mjs
-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);
-}
-const lengthParamsSchema = type({ length: "number.integer > 0" });
-const numericParamsSchema = type({
-	precision: "number.integer > 0 & number.integer <= 1000",
-	"scale?": "number.integer >= 0"
-});
-const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
-function renderLength(typeName, typeParams) {
-	const length = typeParams["length"];
-	if (length === void 0) return;
-	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`);
-	return `${typeName}<${length}>`;
-}
-function renderPrecision(typeName, typeParams) {
-	const precision = typeParams["precision"];
-	if (precision === void 0) return typeName;
-	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`);
-	return `${typeName}<${precision}>`;
-}
-function renderJsonOutputType(typeParams) {
-	const typeName = typeParams["type"];
-	if (typeof typeName === "string" && typeName.trim().length > 0) return typeName.trim();
-	const schema = typeParams["schemaJson"];
-	if (schema && typeof schema === "object") return renderTypeScriptTypeFromJsonSchema(schema);
-	throw new Error(`renderOutputType: JSON codec typeParams must contain "type" (string) or "schemaJson" (object), got keys: ${Object.keys(typeParams).join(", ")}`);
-}
-function aliasCodec(base, options) {
-	return {
-		id: options.typeId,
-		targetTypes: options.targetTypes,
-		...ifDefined("meta", options.meta),
-		...ifDefined("paramsSchema", base.paramsSchema),
-		...ifDefined("init", base.init),
-		...ifDefined("encode", base.encode),
-		...ifDefined("traits", base.traits),
-		...ifDefined("renderOutputType", base.renderOutputType),
-		decode: base.decode,
-		encodeJson: base.encodeJson,
-		decodeJson: base.decodeJson
-	};
-}
-const sqlCharCodec = sqlCodecDefinitions.char.codec;
-const sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;
-const sqlIntCodec = sqlCodecDefinitions.int.codec;
-const sqlFloatCodec = sqlCodecDefinitions.float.codec;
-const sqlTextCodec = sqlCodecDefinitions.text.codec;
-const sqlTimestampCodec = sqlCodecDefinitions.timestamp.codec;
-const pgTextCodec = codec({
-	typeId: PG_TEXT_CODEC_ID,
-	targetTypes: ["text"],
-	traits: [
-		"equality",
-		"order",
-		"textual"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "text" } } } }
-});
-const pgCharCodec = aliasCodec(sqlCharCodec, {
-	typeId: PG_CHAR_CODEC_ID,
-	targetTypes: ["character"],
-	meta: { db: { sql: { postgres: { nativeType: "character" } } } }
-});
-const pgVarcharCodec = aliasCodec(sqlVarcharCodec, {
-	typeId: PG_VARCHAR_CODEC_ID,
-	targetTypes: ["character varying"],
-	meta: { db: { sql: { postgres: { nativeType: "character varying" } } } }
-});
-const pgIntCodec = aliasCodec(sqlIntCodec, {
-	typeId: PG_INT_CODEC_ID,
-	targetTypes: ["int4"],
-	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
-});
-const pgFloatCodec = aliasCodec(sqlFloatCodec, {
-	typeId: PG_FLOAT_CODEC_ID,
-	targetTypes: ["float8"],
-	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
-});
-const pgInt4Codec = codec({
-	typeId: PG_INT4_CODEC_ID,
-	targetTypes: ["int4"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
-});
-const pgNumericCodec = codec({
-	typeId: PG_NUMERIC_CODEC_ID,
-	targetTypes: ["numeric", "decimal"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => {
-		if (typeof wire === "number") return String(wire);
-		return wire;
-	},
-	paramsSchema: numericParamsSchema,
-	renderOutputType: (typeParams) => {
-		const precision = typeParams["precision"];
-		if (precision === void 0) return void 0;
-		if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`);
-		const scale = typeParams["scale"];
-		return typeof scale === "number" ? `Numeric<${precision}, ${scale}>` : `Numeric<${precision}>`;
-	},
-	meta: { db: { sql: { postgres: { nativeType: "numeric" } } } }
-});
-const pgInt2Codec = codec({
-	typeId: PG_INT2_CODEC_ID,
-	targetTypes: ["int2"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "smallint" } } } }
-});
-const pgInt8Codec = codec({
-	typeId: PG_INT8_CODEC_ID,
-	targetTypes: ["int8"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "bigint" } } } }
-});
-const pgFloat4Codec = codec({
-	typeId: PG_FLOAT4_CODEC_ID,
-	targetTypes: ["float4"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "real" } } } }
-});
-const pgFloat8Codec = codec({
-	typeId: PG_FLOAT8_CODEC_ID,
-	targetTypes: ["float8"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
-});
-const pgTimestampCodec = codec({
-	typeId: PG_TIMESTAMP_CODEC_ID,
-	targetTypes: ["timestamp"],
-	traits: ["equality", "order"],
-	encode: (value) => {
-		if (value instanceof Date) return value.toISOString();
-		if (typeof value === "string") return value;
-		return String(value);
-	},
-	decode: (wire) => {
-		if (wire instanceof Date) return wire.toISOString();
-		return wire;
-	},
-	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
-	decodeJson: (json) => {
-		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
-		const date = new Date(json);
-		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
-		return date;
-	},
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => renderPrecision("Timestamp", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "timestamp without time zone" } } } }
-});
-const pgTimestamptzCodec = codec({
-	typeId: PG_TIMESTAMPTZ_CODEC_ID,
-	targetTypes: ["timestamptz"],
-	traits: ["equality", "order"],
-	encode: (value) => {
-		if (value instanceof Date) return value.toISOString();
-		if (typeof value === "string") return value;
-		return String(value);
-	},
-	decode: (wire) => {
-		if (wire instanceof Date) return wire.toISOString();
-		return wire;
-	},
-	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
-	decodeJson: (json) => {
-		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
-		const date = new Date(json);
-		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
-		return date;
-	},
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => renderPrecision("Timestamptz", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "timestamp with time zone" } } } }
-});
-const pgTimeCodec = codec({
-	typeId: PG_TIME_CODEC_ID,
-	targetTypes: ["time"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => renderPrecision("Time", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "time" } } } }
-});
-const pgTimetzCodec = codec({
-	typeId: PG_TIMETZ_CODEC_ID,
-	targetTypes: ["timetz"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => renderPrecision("Timetz", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "timetz" } } } }
-});
-const pgBoolCodec = codec({
-	typeId: PG_BOOL_CODEC_ID,
-	targetTypes: ["bool"],
-	traits: ["equality", "boolean"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	meta: { db: { sql: { postgres: { nativeType: "boolean" } } } }
-});
-const pgBitCodec = codec({
-	typeId: PG_BIT_CODEC_ID,
-	targetTypes: ["bit"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	paramsSchema: lengthParamsSchema,
-	renderOutputType: (typeParams) => renderLength("Bit", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "bit" } } } }
-});
-const pgVarbitCodec = codec({
-	typeId: PG_VARBIT_CODEC_ID,
-	targetTypes: ["bit varying"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	paramsSchema: lengthParamsSchema,
-	renderOutputType: (typeParams) => renderLength("VarBit", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "bit varying" } } } }
-});
-const pgEnumCodec = codec({
-	typeId: PG_ENUM_CODEC_ID,
-	targetTypes: ["enum"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	renderOutputType: (typeParams) => {
-		const values = typeParams["values"];
-		if (!Array.isArray(values)) throw new Error(`renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`);
-		return values.map((value) => `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(" | ");
-	}
-});
-const pgIntervalCodec = codec({
-	typeId: PG_INTERVAL_CODEC_ID,
-	targetTypes: ["interval"],
-	traits: ["equality", "order"],
-	encode: (value) => value,
-	decode: (wire) => {
-		if (typeof wire === "string") return wire;
-		return JSON.stringify(wire);
-	},
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => renderPrecision("Interval", typeParams),
-	meta: { db: { sql: { postgres: { nativeType: "interval" } } } }
-});
-const pgJsonCodec = codec({
-	typeId: PG_JSON_CODEC_ID,
-	targetTypes: ["json"],
-	traits: [],
-	encode: (value) => JSON.stringify(value),
-	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
-	renderOutputType: renderJsonOutputType,
-	meta: { db: { sql: { postgres: { nativeType: "json" } } } }
-});
-const pgJsonbCodec = codec({
-	typeId: PG_JSONB_CODEC_ID,
-	targetTypes: ["jsonb"],
-	traits: ["equality"],
-	encode: (value) => JSON.stringify(value),
-	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
-	renderOutputType: renderJsonOutputType,
-	meta: { db: { sql: { postgres: { nativeType: "jsonb" } } } }
-});
-const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("sql-text", sqlTextCodec).add("sql-timestamp", sqlTimestampCodec).add("text", pgTextCodec).add("character", pgCharCodec).add("character varying", pgVarcharCodec).add("integer", pgIntCodec).add("double precision", pgFloatCodec).add("int4", pgInt4Codec).add("int2", pgInt2Codec).add("int8", pgInt8Codec).add("float4", pgFloat4Codec).add("float8", pgFloat8Codec).add("numeric", pgNumericCodec).add("timestamp", pgTimestampCodec).add("timestamptz", pgTimestamptzCodec).add("time", pgTimeCodec).add("timetz", pgTimetzCodec).add("bool", pgBoolCodec).add("bit", pgBitCodec).add("bit varying", pgVarbitCodec).add("interval", pgIntervalCodec).add("enum", pgEnumCodec).add("json", pgJsonCodec).add("jsonb", pgJsonbCodec);
-const codecDefinitions = codecs.codecDefinitions;
-const dataTypes = codecs.dataTypes;
-
-//#endregion
-//#region ../../6-adapters/postgres/dist/descriptor-meta-BB9XPAFi.mjs
-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$1(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$1(schemaName, nativeType, false)
-		}],
-		execute: [{
-			description: `create type "${nativeType}"`,
-			sql: `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`
-		}],
-		postcheck: [{
-			description: `verify type "${nativeType}" exists`,
-			sql: enumTypeExistsCheck$1(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$1(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$1(options.schemaName, options.nativeType)
-		},
-		{
-			description: `verify temp type "${tempTypeName}" was removed`,
-			sql: enumTypeExistsCheck$1(options.schemaName, tempTypeName, false)
-		},
-		...columnRefs.map((ref) => ({
-			description: `verify ${ref.table}.${ref.column} uses type "${options.nativeType}"`,
-			sql: columnTypeCheck$1({
-				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$1(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",
-			typeName,
-			message: `Type "${typeName}" is missing from database`
-		}];
-		const diff = determineEnumDiff(existing, desired);
-		if (diff.kind === "unchanged") return [];
-		const existingSet = new Set(existing);
-		const desiredSet = new Set(desired);
-		const addedValues = desired.filter((v) => !existingSet.has(v));
-		const removedValues = existing.filter((v) => !desiredSet.has(v));
-		return [{
-			kind: "enum_values_changed",
-			typeName,
-			addedValues,
-			removedValues,
-			message: diff.kind === "add_values" ? `Enum type "${typeName}" needs new values: ${addedValues.join(", ")}` : `Enum type "${typeName}" values changed (requires rebuild): +[${addedValues.join(", ")}] -[${removedValues.join(", ")}]`
-		}];
-	},
-	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;
-	}
-};
-/** Creates a type import spec for codec types */
-const codecTypeImport = (named) => ({
-	package: "@prisma-next/adapter-postgres/codec-types",
-	named,
-	alias: named
-});
-function isPositiveInteger(value) {
-	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
-}
-function isNonNegativeInteger(value) {
-	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
-}
-function expandLength({ nativeType, typeParams }) {
-	if (!typeParams || !("length" in typeParams)) return nativeType;
-	const length = typeParams["length"];
-	if (!isPositiveInteger(length)) throw new Error(`Invalid "length" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(length)}`);
-	return `${nativeType}(${length})`;
-}
-function expandPrecision({ nativeType, typeParams }) {
-	if (!typeParams || !("precision" in typeParams)) return nativeType;
-	const precision = typeParams["precision"];
-	if (!isPositiveInteger(precision)) throw new Error(`Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`);
-	return `${nativeType}(${precision})`;
-}
-function expandNumeric({ nativeType, typeParams }) {
-	const hasPrecision = typeParams && "precision" in typeParams;
-	const hasScale = typeParams && "scale" in typeParams;
-	if (!hasPrecision && !hasScale) return nativeType;
-	if (!hasPrecision && hasScale) throw new Error(`Invalid type parameters for "${nativeType}": "scale" requires "precision" to be specified`);
-	if (hasPrecision) {
-		const precision = typeParams["precision"];
-		if (!isPositiveInteger(precision)) throw new Error(`Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`);
-		if (hasScale) {
-			const scale = typeParams["scale"];
-			if (!isNonNegativeInteger(scale)) throw new Error(`Invalid "scale" type parameter for "${nativeType}": expected a non-negative integer, got ${JSON.stringify(scale)}`);
-			return `${nativeType}(${precision},${scale})`;
-		}
-		return `${nativeType}(${precision})`;
-	}
-	return nativeType;
-}
-const lengthHooks = { expandNativeType: expandLength };
-const precisionHooks = { expandNativeType: expandPrecision };
-const numericHooks = { expandNativeType: expandNumeric };
-const identityHooks = { expandNativeType: ({ nativeType }) => nativeType };
-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,
-			returning: true,
-			defaultInInsert: true
-		}
-	},
-	types: {
-		codecTypes: {
-			codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
-			import: {
-				package: "@prisma-next/adapter-postgres/codec-types",
-				named: "CodecTypes",
-				alias: "PgTypes"
-			},
-			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]: lengthHooks,
-				[SQL_VARCHAR_CODEC_ID]: lengthHooks,
-				[SQL_TIMESTAMP_CODEC_ID]: precisionHooks,
-				[PG_CHAR_CODEC_ID]: lengthHooks,
-				[PG_VARCHAR_CODEC_ID]: lengthHooks,
-				[PG_NUMERIC_CODEC_ID]: numericHooks,
-				[PG_BIT_CODEC_ID]: lengthHooks,
-				[PG_VARBIT_CODEC_ID]: lengthHooks,
-				[PG_TIMESTAMP_CODEC_ID]: precisionHooks,
-				[PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,
-				[PG_TIME_CODEC_ID]: precisionHooks,
-				[PG_TIMETZ_CODEC_ID]: precisionHooks,
-				[PG_INTERVAL_CODEC_ID]: precisionHooks,
-				[PG_ENUM_CODEC_ID]: pgEnumControlHooks,
-				[PG_JSON_CODEC_ID]: identityHooks,
-				[PG_JSONB_CODEC_ID]: identityHooks
-			}
-		},
-		storage: [
-			{
-				typeId: PG_TEXT_CODEC_ID,
-				familyId: "sql",
-				targetId: "postgres",
-				nativeType: "text"
-			},
-			{
-				typeId: SQL_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: SQL_TIMESTAMP_CODEC_ID,
-				familyId: "sql",
-				targetId: "postgres",
-				nativeType: "timestamp"
-			},
-			{
-				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"
-			}
-		],
-		queryOperationTypes: { import: {
-			package: "@prisma-next/adapter-postgres/operation-types",
-			named: "QueryOperationTypes",
-			alias: "PgAdapterQueryOps"
-		} }
-	}
-};
-
-//#endregion
-//#region ../../../1-framework/2-authoring/ids/dist/index.mjs
-const builtinGeneratorIds = [
-	"ulid",
-	"nanoid",
-	"uuidv7",
-	"uuidv4",
-	"cuid2",
-	"ksuid"
-];
-function resolveNanoidColumnDescriptor(params) {
-	const rawSize = params?.["size"];
-	if (rawSize === void 0) return {
-		type: {
-			codecId: "sql/char@1",
-			nativeType: "character"
-		},
-		typeParams: { length: 21 }
-	};
-	if (typeof rawSize !== "number" || !Number.isInteger(rawSize) || rawSize < 2 || rawSize > 255) throw new Error("nanoid size must be an integer between 2 and 255");
-	return {
-		type: {
-			codecId: "sql/char@1",
-			nativeType: "character"
-		},
-		typeParams: { length: rawSize }
-	};
-}
-const builtinGeneratorMetadataById = {
-	ulid: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 26 }
-		}
-	},
-	nanoid: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 21 }
-		},
-		resolveGeneratedColumnDescriptor: resolveNanoidColumnDescriptor
-	},
-	uuidv7: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 36 }
-		}
-	},
-	uuidv4: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 36 }
-		}
-	},
-	cuid2: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 24 }
-		}
-	},
-	ksuid: {
-		applicableCodecIds: ["pg/text@1", "sql/char@1"],
-		generatedColumnDescriptor: {
-			type: {
-				codecId: "sql/char@1",
-				nativeType: "character"
-			},
-			typeParams: { length: 27 }
-		}
-	}
-};
-const builtinGeneratorRegistryMetadata = builtinGeneratorIds.map((id) => ({
-	id,
-	applicableCodecIds: builtinGeneratorMetadataById[id].applicableCodecIds
-}));
-function resolveBuiltinGeneratedColumnDescriptor(input) {
-	const metadata = builtinGeneratorMetadataById[input.id];
-	if (metadata.resolveGeneratedColumnDescriptor) return metadata.resolveGeneratedColumnDescriptor(input.params);
-	return metadata.generatedColumnDescriptor;
-}
-
-//#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 NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-/**
-* Returns the canonical expression for a timestamp default function, or undefined
-* if the expression is not a recognized timestamp default.
-*
-* Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
-* - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
-* - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
-*
-* These are semantically different in Postgres: now() returns the transaction
-* start time (constant within a transaction), while clock_timestamp() returns
-* the actual wall-clock time (can differ across rows in a single INSERT).
-*/
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-/**
-* 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, used for type-aware parsing (bigint tagging, JSON detection)
-* @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
-*/
-function parsePostgresDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	const isBigInt = normalizedType === "bigint" || normalizedType === "int8";
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	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 (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) {
-		const num = Number(trimmed);
-		if (!Number.isFinite(num)) return void 0;
-		if (isBigInt && !Number.isSafeInteger(num)) return {
-			kind: "literal",
-			value: trimmed
-		};
-		return {
-			kind: "literal",
-			value: num
-		};
-	}
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") try {
-			return {
-				kind: "literal",
-				value: JSON.parse(unescaped)
-			};
-		} catch {}
-		if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
-			const num = Number(unescaped);
-			if (Number.isSafeInteger(num)) return {
-				kind: "literal",
-				value: num
-			};
-			return {
-				kind: "literal",
-				value: unescaped
-			};
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	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";
-	/**
-	* 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 contract - Optional contract 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, _contract, 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,
-           ref_ns.nspname AS referenced_table_schema,
-           ref_cl.relname AS referenced_table_name,
-           ref_att.attname AS referenced_column_name,
-           rc.delete_rule,
-           rc.update_rule
-         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 pg_catalog.pg_constraint pgc
-           ON pgc.conname = tc.constraint_name
-           AND pgc.connamespace = (
-             SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = tc.table_schema
-           )
-         JOIN pg_catalog.pg_class ref_cl
-           ON ref_cl.oid = pgc.confrelid
-         JOIN pg_catalog.pg_namespace ref_ns
-           ON ref_ns.oid = ref_cl.relnamespace
-         JOIN pg_catalog.pg_attribute ref_att
-           ON ref_att.attrelid = pgc.confrelid
-           AND ref_att.attnum = pgc.confkey[kcu.ordinal_position]
-         JOIN information_schema.referential_constraints rc
-           ON rc.constraint_name = tc.constraint_name
-           AND rc.constraint_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,
-					deleteRule: fkRow.delete_rule,
-					updateRule: fkRow.update_rule
-				});
-			}
-			const foreignKeys = Array.from(foreignKeysMap.values()).map((fk) => ({
-				columns: Object.freeze([...fk.columns]),
-				referencedTable: fk.referencedTable,
-				referencedColumns: Object.freeze([...fk.referencedColumns]),
-				name: fk.name,
-				...ifDefined("onDelete", mapReferentialAction(fk.deleteRule)),
-				...ifDefined("onUpdate", mapReferentialAction(fk.updateRule))
-			}));
-			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 dependencies = extensionsResult.rows.map((row) => ({ id: `postgres.extension.${row.extname}` }));
-		const storageTypes = await pgEnumControlHooks.introspectTypes?.({
-			driver,
-			schemaName: schema
-		}) ?? {};
-		return {
-			tables,
-			dependencies,
-			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;
-}
-const PG_REFERENTIAL_ACTION_MAP = {
-	"NO ACTION": "noAction",
-	RESTRICT: "restrict",
-	CASCADE: "cascade",
-	"SET NULL": "setNull",
-	"SET DEFAULT": "setDefault"
-};
-/**
-* Maps a Postgres referential action rule to the canonical SqlReferentialAction.
-* Returns undefined for 'NO ACTION' (the database default) to keep the IR sparse.
-* Throws for unrecognized rules to prevent silent data loss.
-*/
-function mapReferentialAction(rule) {
-	const mapped = PG_REFERENTIAL_ACTION_MAP[rule];
-	if (mapped === void 0) throw new Error(`Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`);
-	if (mapped === "noAction") return void 0;
-	return mapped;
-}
-/**
-* 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;
-}
-function invalidArgumentDiagnostic(input) {
-	return {
-		ok: false,
-		diagnostic: {
-			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
-			message: input.message,
-			sourceId: input.context.sourceId,
-			span: input.span
-		}
-	};
-}
-function executionGenerator(id, params) {
-	return {
-		ok: true,
-		value: {
-			kind: "execution",
-			generated: {
-				kind: "generator",
-				id,
-				...params ? { params } : {}
-			}
-		}
-	};
-}
-function expectNoArgs(input) {
-	if (input.call.args.length === 0) return;
-	return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.span,
-		message: `Default function "${input.call.name}" does not accept arguments. Use ${input.usage}.`
-	});
-}
-function parseIntegerArgument(raw) {
-	const trimmed = raw.trim();
-	if (!/^-?\d+$/.test(trimmed)) return;
-	const value = Number(trimmed);
-	if (!Number.isInteger(value)) return;
-	return value;
-}
-function parseStringLiteral(raw) {
-	const match = raw.trim().match(/^(['"])(.*)\1$/s);
-	if (!match) return;
-	return match[2] ?? "";
-}
-function lowerAutoincrement(input) {
-	const maybeNoArgs = expectNoArgs({
-		call: input.call,
-		context: input.context,
-		usage: "`autoincrement()`"
-	});
-	if (maybeNoArgs) return maybeNoArgs;
-	return {
-		ok: true,
-		value: {
-			kind: "storage",
-			defaultValue: {
-				kind: "function",
-				expression: "autoincrement()"
-			}
-		}
-	};
-}
-function lowerNow(input) {
-	const maybeNoArgs = expectNoArgs({
-		call: input.call,
-		context: input.context,
-		usage: "`now()`"
-	});
-	if (maybeNoArgs) return maybeNoArgs;
-	return {
-		ok: true,
-		value: {
-			kind: "storage",
-			defaultValue: {
-				kind: "function",
-				expression: "now()"
-			}
-		}
-	};
-}
-function lowerUuid(input) {
-	if (input.call.args.length === 0) return executionGenerator("uuidv4");
-	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.span,
-		message: "Default function \"uuid\" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`."
-	});
-	const version = parseIntegerArgument(input.call.args[0]?.raw ?? "");
-	if (version === 4) return executionGenerator("uuidv4");
-	if (version === 7) return executionGenerator("uuidv7");
-	return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.args[0]?.span ?? input.call.span,
-		message: "Default function \"uuid\" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1."
-	});
-}
-function lowerCuid(input) {
-	if (input.call.args.length === 0) return {
-		ok: false,
-		diagnostic: {
-			code: "PSL_UNKNOWN_DEFAULT_FUNCTION",
-			message: "Default function \"cuid()\" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.",
-			sourceId: input.context.sourceId,
-			span: input.call.span
-		}
-	};
-	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.span,
-		message: "Default function \"cuid\" accepts exactly one version argument: `cuid(2)`."
-	});
-	if (parseIntegerArgument(input.call.args[0]?.raw ?? "") === 2) return executionGenerator("cuid2");
-	return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.args[0]?.span ?? input.call.span,
-		message: "Default function \"cuid\" supports only `cuid(2)` in SQL PSL provider v1."
-	});
-}
-function lowerUlid(input) {
-	const maybeNoArgs = expectNoArgs({
-		call: input.call,
-		context: input.context,
-		usage: "`ulid()`"
-	});
-	if (maybeNoArgs) return maybeNoArgs;
-	return executionGenerator("ulid");
-}
-function lowerNanoid(input) {
-	if (input.call.args.length === 0) return executionGenerator("nanoid");
-	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.span,
-		message: "Default function \"nanoid\" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`."
-	});
-	const size = parseIntegerArgument(input.call.args[0]?.raw ?? "");
-	if (size !== void 0 && size >= 2 && size <= 255) return executionGenerator("nanoid", { size });
-	return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.args[0]?.span ?? input.call.span,
-		message: "Default function \"nanoid\" size argument must be an integer between 2 and 255."
-	});
-}
-function lowerDbgenerated(input) {
-	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.span,
-		message: "Default function \"dbgenerated\" requires exactly one string argument: `dbgenerated(\"...\")`."
-	});
-	const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? "");
-	if (rawExpression === void 0) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.args[0]?.span ?? input.call.span,
-		message: "Default function \"dbgenerated\" argument must be a string literal."
-	});
-	if (rawExpression.trim().length === 0) return invalidArgumentDiagnostic({
-		context: input.context,
-		span: input.call.args[0]?.span ?? input.call.span,
-		message: "Default function \"dbgenerated\" argument cannot be empty."
-	});
-	return {
-		ok: true,
-		value: {
-			kind: "storage",
-			defaultValue: {
-				kind: "function",
-				expression: rawExpression
-			}
-		}
-	};
-}
-const postgresDefaultFunctionRegistryEntries = [
-	["autoincrement", {
-		lower: lowerAutoincrement,
-		usageSignatures: ["autoincrement()"]
-	}],
-	["now", {
-		lower: lowerNow,
-		usageSignatures: ["now()"]
-	}],
-	["uuid", {
-		lower: lowerUuid,
-		usageSignatures: [
-			"uuid()",
-			"uuid(4)",
-			"uuid(7)"
-		]
-	}],
-	["cuid", {
-		lower: lowerCuid,
-		usageSignatures: ["cuid(2)"]
-	}],
-	["ulid", {
-		lower: lowerUlid,
-		usageSignatures: ["ulid()"]
-	}],
-	["nanoid", {
-		lower: lowerNanoid,
-		usageSignatures: ["nanoid()", "nanoid(<2-255>)"]
-	}],
-	["dbgenerated", {
-		lower: lowerDbgenerated,
-		usageSignatures: ["dbgenerated(\"...\")"]
-	}]
-];
-const postgresScalarTypeDescriptors = new Map([
-	["String", "pg/text@1"],
-	["Boolean", "pg/bool@1"],
-	["Int", "pg/int4@1"],
-	["BigInt", "pg/int8@1"],
-	["Float", "pg/float8@1"],
-	["Decimal", "pg/numeric@1"],
-	["DateTime", "pg/timestamptz@1"],
-	["Json", "pg/jsonb@1"],
-	["Bytes", "pg/bytea@1"]
-]);
-function createPostgresDefaultFunctionRegistry() {
-	return new Map(postgresDefaultFunctionRegistryEntries);
-}
-function createPostgresMutationDefaultGeneratorDescriptors() {
-	return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
-		id,
-		applicableCodecIds,
-		resolveGeneratedColumnDescriptor: ({ generated }) => {
-			if (generated.kind !== "generator" || generated.id !== id) return;
-			const descriptor = resolveBuiltinGeneratedColumnDescriptor({
-				id,
-				...generated.params ? { params: generated.params } : {}
-			});
-			return {
-				codecId: descriptor.type.codecId,
-				nativeType: descriptor.type.nativeType,
-				...descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {},
-				...descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}
-			};
-		}
-	}));
-}
-function createPostgresScalarTypeDescriptors() {
-	return new Map(postgresScalarTypeDescriptors);
-}
-var control_default = {
-	...postgresAdapterDescriptorMeta,
-	scalarTypeDescriptors: createPostgresScalarTypeDescriptors(),
-	controlMutationDefaults: {
-		defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
-		generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors()
-	},
-	create() {
-		return new PostgresControlAdapter();
-	}
-};
-
-//#endregion
-//#region src/core/migrations/planner-type-resolution.ts
-function resolveColumnTypeMetadata(column, storageTypes) {
-	if (!column.typeRef) return column;
-	const referencedType = storageTypes[column.typeRef];
-	if (!referencedType) return column;
-	return {
-		codecId: referencedType.codecId,
-		nativeType: referencedType.nativeType,
-		typeParams: referencedType.typeParams
-	};
-}
-
-//#endregion
-//#region src/core/migrations/planner-sql-checks.ts
-function qualifyTableName(schema, table) {
-	return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
-}
-function toRegclassLiteral(schema, name) {
-	return `'${escapeLiteral(`${quoteIdentifier(schema)}.${quoteIdentifier(name)}`)}'`;
-}
-/**
-* When `table` is omitted the check matches by name + schema across all tables.
-* Pass `table` to scope the check to a single table (prevents false matches on
-* identically-named constraints in different tables).
-*/
-function constraintExistsCheck({ constraintName, schema, table, exists = true }) {
-	const existsClause = exists ? "EXISTS" : "NOT EXISTS";
-	const tableFilter = table ? `AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})` : "";
-	return `SELECT ${existsClause} (
-  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)}'
-  ${tableFilter}
-)`;
-}
-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 columnNullabilityCheck({ schema, table, column, nullable }) {
-	const expected = nullable ? "YES" : "NO";
-	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 = '${expected}'
-)`;
-}
-function tableIsEmptyCheck(qualifiedTableName) {
-	return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
-}
-function columnHasNoDefaultCheck(opts) {
-	return `SELECT NOT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(opts.schema)}'
-    AND table_name = '${escapeLiteral(opts.table)}'
-    AND column_name = '${escapeLiteral(opts.column)}'
-    AND column_default IS NOT NULL
-)`;
-}
-const FORMAT_TYPE_DISPLAY = new Map([
-	["int2", "smallint"],
-	["int4", "integer"],
-	["int8", "bigint"],
-	["float4", "real"],
-	["float8", "double precision"],
-	["bool", "boolean"],
-	["timestamp", "timestamp without time zone"],
-	["timestamptz", "timestamp with time zone"],
-	["time", "time without time zone"],
-	["timetz", "time with time zone"]
-]);
-const UNQUOTED_POSTGRES_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/;
-const POSTGRES_RESERVED_IDENTIFIER_WORDS = new Set([
-	"all",
-	"analyse",
-	"analyze",
-	"and",
-	"any",
-	"array",
-	"as",
-	"asc",
-	"asymmetric",
-	"authorization",
-	"between",
-	"binary",
-	"both",
-	"case",
-	"cast",
-	"check",
-	"collate",
-	"column",
-	"constraint",
-	"create",
-	"current_catalog",
-	"current_date",
-	"current_role",
-	"current_time",
-	"current_timestamp",
-	"current_user",
-	"default",
-	"deferrable",
-	"desc",
-	"distinct",
-	"do",
-	"else",
-	"end",
-	"except",
-	"false",
-	"fetch",
-	"for",
-	"foreign",
-	"freeze",
-	"from",
-	"full",
-	"grant",
-	"group",
-	"having",
-	"ilike",
-	"in",
-	"initially",
-	"inner",
-	"intersect",
-	"into",
-	"is",
-	"isnull",
-	"join",
-	"lateral",
-	"leading",
-	"left",
-	"like",
-	"limit",
-	"localtime",
-	"localtimestamp",
-	"natural",
-	"not",
-	"notnull",
-	"null",
-	"offset",
-	"on",
-	"only",
-	"or",
-	"order",
-	"outer",
-	"overlaps",
-	"placing",
-	"primary",
-	"references",
-	"right",
-	"select",
-	"session_user",
-	"similar",
-	"some",
-	"symmetric",
-	"table",
-	"then",
-	"to",
-	"trailing",
-	"true",
-	"union",
-	"unique",
-	"user",
-	"using",
-	"variadic",
-	"verbose",
-	"when",
-	"where",
-	"window",
-	"with"
-]);
-function formatUserDefinedTypeName(identifier) {
-	if (UNQUOTED_POSTGRES_IDENTIFIER_PATTERN.test(identifier) && !POSTGRES_RESERVED_IDENTIFIER_WORDS.has(identifier)) return identifier;
-	return quoteIdentifier(identifier);
-}
-function buildExpectedFormatType(column, codecHooks, storageTypes = {}) {
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	if (resolved.typeParams && resolved.codecId) {
-		const hooks = codecHooks.get(resolved.codecId);
-		if (hooks?.expandNativeType) return hooks.expandNativeType({
-			nativeType: resolved.nativeType,
-			codecId: resolved.codecId,
-			typeParams: resolved.typeParams
-		});
-	}
-	if (column.typeRef) return formatUserDefinedTypeName(resolved.nativeType);
-	return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;
-}
-function columnTypeCheck({ schema, table, column, expectedType }) {
-	return `SELECT EXISTS (
-  SELECT 1
-  FROM pg_attribute a
-  JOIN pg_class c ON c.oid = a.attrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = '${escapeLiteral(schema)}'
-    AND c.relname = '${escapeLiteral(table)}'
-    AND a.attname = '${escapeLiteral(column)}'
-    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
-    AND NOT a.attisdropped
-)`;
-}
-function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
-	const nullCheck = exists ? "IS NOT NULL" : "IS NULL";
-	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 column_default ${nullCheck}
-)`;
-}
-
-//#endregion
-//#region src/core/migrations/operations/shared.ts
-function step(description, sql) {
-	return {
-		description,
-		sql
-	};
-}
-function targetDetails(objectType, name, schema, table) {
-	return {
-		id: "postgres",
-		details: {
-			schema,
-			objectType,
-			name,
-			...ifDefined("table", table)
-		}
-	};
-}
-function renderColumnDefinition(column) {
-	return [
-		quoteIdentifier(column.name),
-		column.typeSql,
-		column.defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
-}
-
-//#endregion
-//#region src/core/migrations/operations/columns.ts
-function addColumn(schemaName, tableName, column) {
-	const addSql = [
-		`ALTER TABLE ${qualifyTableName(schemaName, tableName)}`,
-		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
-		column.defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
-	return {
-		id: `column.${tableName}.${column.name}`,
-		label: `Add column "${column.name}" to "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("column", column.name, schemaName, tableName),
-		precheck: [step(`ensure column "${column.name}" is missing`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name,
-			exists: false
-		}))],
-		execute: [step(`add column "${column.name}"`, addSql)],
-		postcheck: [step(`verify column "${column.name}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name
-		}))]
-	};
-}
-function dropColumn(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropColumn.${tableName}.${columnName}`,
-		label: `Drop column "${columnName}" from "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop column "${columnName}"`, `ALTER TABLE ${qualified} DROP COLUMN ${quoteIdentifier(columnName)}`)],
-		postcheck: [step(`verify column "${columnName}" does not exist`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
-	};
-}
-/**
-* `qualifiedTargetType` is the new column type as it appears in the
-* `ALTER COLUMN TYPE` clause (schema-qualified for user-defined types, raw
-* native name for built-ins). `formatTypeExpected` is the unqualified
-* `format_type` form used in the postcheck. `rawTargetTypeForLabel` is the
-* string appearing in the human-readable label (typically `toType` when
-* explicit, else the column's native type).
-*/
-function alterColumnType(schemaName, tableName, columnName, options) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const usingClause = options.using ? ` USING ${options.using}` : ` USING ${quoteIdentifier(columnName)}::${options.qualifiedTargetType}`;
-	return {
-		id: `alterType.${tableName}.${columnName}`,
-		label: `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`alter type of "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} TYPE ${options.qualifiedTargetType}${usingClause}`)],
-		postcheck: [step(`verify column "${columnName}" has type "${options.formatTypeExpected}"`, columnTypeCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			expectedType: options.formatTypeExpected
-		}))],
-		meta: { warning: "TABLE_REWRITE" }
-	};
-}
-function setNotNull(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `alterNullability.setNotNull.${tableName}.${columnName}`,
-		label: `Set NOT NULL on "${tableName}"."${columnName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		})), step(`ensure no NULL values in "${columnName}"`, `SELECT NOT EXISTS (SELECT 1 FROM ${qualified} WHERE ${quoteIdentifier(columnName)} IS NULL)`)],
-		execute: [step(`set NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is NOT NULL`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: false
-		}))]
-	};
-}
-function dropNotNull(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `alterNullability.dropNotNull.${tableName}.${columnName}`,
-		label: `Drop NOT NULL on "${tableName}"."${columnName}"`,
-		operationClass: "widening",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is nullable`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: true
-		}))]
-	};
-}
-/**
-* `defaultSql` is the full `DEFAULT …` clause as produced by
-* `buildColumnDefaultSql` — e.g. `"DEFAULT 42"`,
-* `"DEFAULT (CURRENT_TIMESTAMP)"`, or `"DEFAULT nextval('seq'::regclass)"`.
-*
-* `operationClass` defaults to `'additive'` (setting a default on a column
-* that currently has none). The reconciliation planner passes `'widening'`
-* when the column already has a different default — policy enforcement
-* treats that as a widening change rather than an additive one.
-*/
-function setDefault(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `setDefault.${tableName}.${columnName}`,
-		label: `Set default on "${tableName}"."${columnName}"`,
-		operationClass,
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultSql}`)],
-		postcheck: [step(`verify column "${columnName}" has a default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: true
-		}))]
-	};
-}
-function dropDefault(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropDefault.${tableName}.${columnName}`,
-		label: `Drop default on "${tableName}"."${columnName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`)],
-		postcheck: [step(`verify column "${columnName}" has no default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/operations/constraints.ts
-const REFERENTIAL_ACTION_SQL = {
-	noAction: "NO ACTION",
-	restrict: "RESTRICT",
-	cascade: "CASCADE",
-	setNull: "SET NULL",
-	setDefault: "SET DEFAULT"
-};
-function renderForeignKeySql(schemaName, tableName, fk) {
-	let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(fk.name)}
-FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")})
-REFERENCES ${qualifyTableName(schemaName, fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
-	if (fk.onDelete !== void 0) {
-		const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
-		if (!action) throw new Error(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
-		sql += `\nON DELETE ${action}`;
-	}
-	if (fk.onUpdate !== void 0) {
-		const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
-		if (!action) throw new Error(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
-		sql += `\nON UPDATE ${action}`;
-	}
-	return sql;
-}
-function addPrimaryKey(schemaName, tableName, constraintName, columns) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	return {
-		id: `primaryKey.${tableName}.${constraintName}`,
-		label: `Add primary key on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("primaryKey", constraintName, schemaName, tableName),
-		precheck: [step(`ensure primary key "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add primary key "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`)],
-		postcheck: [step(`verify primary key "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-function addUnique(schemaName, tableName, constraintName, columns) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	return {
-		id: `unique.${tableName}.${constraintName}`,
-		label: `Add unique constraint on "${tableName}" (${columns.join(", ")})`,
-		operationClass: "additive",
-		target: targetDetails("unique", constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add unique constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`)],
-		postcheck: [step(`verify constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-function addForeignKey(schemaName, tableName, fk) {
-	return {
-		id: `foreignKey.${tableName}.${fk.name}`,
-		label: `Add foreign key "${fk.name}" on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("foreignKey", fk.name, schemaName, tableName),
-		precheck: [step(`ensure FK "${fk.name}" does not exist`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
-		postcheck: [step(`verify FK "${fk.name}" exists`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-/**
-* `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
-* does not carry kind information in its drop-constraint descriptor, so the
-* default is `'unique'`. The reconciliation planner passes the correct kind
-* (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
-* that produced the drop.
-*/
-function dropConstraint(schemaName, tableName, constraintName, kind = "unique") {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropConstraint.${tableName}.${constraintName}`,
-		label: `Drop constraint "${constraintName}" on "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails(kind, constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))],
-		execute: [step(`drop constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
-		postcheck: [step(`verify constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/operations/dependencies.ts
-function createExtension(extensionName) {
-	return {
-		id: `extension.${extensionName}`,
-		label: `Create extension "${extensionName}"`,
-		operationClass: "additive",
-		target: { id: "postgres" },
-		precheck: [],
-		execute: [step(`Create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${quoteIdentifier(extensionName)}`)],
-		postcheck: []
-	};
-}
-function createSchema(schemaName) {
-	return {
-		id: `schema.${schemaName}`,
-		label: `Create schema "${schemaName}"`,
-		operationClass: "additive",
-		target: { id: "postgres" },
-		precheck: [],
-		execute: [step(`Create schema "${schemaName}"`, `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schemaName)}`)],
-		postcheck: []
-	};
-}
-
-//#endregion
-//#region src/core/migrations/operations/enums.ts
-function enumTypeExistsCheck(schemaName, nativeType, exists = true) {
-	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
-  SELECT 1
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  WHERE n.nspname = '${escapeLiteral(schemaName)}'
-    AND t.typname = '${escapeLiteral(nativeType)}'
-)`;
-}
-function createEnumType(schemaName, typeName, values) {
-	const qualifiedType = qualifyName(schemaName, typeName);
-	const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
-	return {
-		id: `type.${typeName}`,
-		label: `Create enum type "${typeName}"`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${typeName}" does not exist`, enumTypeExistsCheck(schemaName, typeName, false))],
-		execute: [step(`create enum type "${typeName}"`, `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`)],
-		postcheck: [step(`verify type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))]
-	};
-}
-/**
-* `typeName` is the contract-facing type name (used for id/label).
-* `nativeType` is the Postgres type name to mutate (may differ for external types).
-*/
-function addEnumValues(schemaName, typeName, nativeType, values) {
-	const qualifiedType = qualifyName(schemaName, nativeType);
-	return {
-		id: `type.${typeName}.addValues`,
-		label: `Add values to enum type "${typeName}": ${values.join(", ")}`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))],
-		execute: values.map((value) => step(`add value '${value}' to enum "${nativeType}"`, `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`)),
-		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
-	};
-}
-function dropEnumType(schemaName, typeName) {
-	const qualified = qualifyName(schemaName, typeName);
-	return {
-		id: `type.${typeName}.drop`,
-		label: `Drop enum type "${typeName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
-		execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
-		postcheck: [step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false))]
-	};
-}
-function renameType(schemaName, fromName, toName) {
-	const qualifiedFrom = qualifyName(schemaName, fromName);
-	return {
-		id: `type.${fromName}.rename`,
-		label: `Rename type "${fromName}" to "${toName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", fromName, schemaName),
-		precheck: [step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)), step(`ensure type "${toName}" does not already exist`, enumTypeExistsCheck(schemaName, toName, false))],
-		execute: [step(`rename type "${fromName}" to "${toName}"`, `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`)],
-		postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/operations/indexes.ts
-function createIndex(schemaName, tableName, indexName, columns) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	return {
-		id: `index.${tableName}.${indexName}`,
-		label: `Create index "${indexName}" on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)],
-		execute: [step(`create index "${indexName}"`, `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified} (${columnList})`)],
-		postcheck: [step(`verify index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)]
-	};
-}
-function dropIndex(schemaName, tableName, indexName) {
-	return {
-		id: `dropIndex.${tableName}.${indexName}`,
-		label: `Drop index "${indexName}"`,
-		operationClass: "destructive",
-		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)],
-		execute: [step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`)],
-		postcheck: [step(`verify index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/operations/tables.ts
-function createTable(schemaName, tableName, columns, primaryKey) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnDefs = columns.map(renderColumnDefinition);
-	const constraintDefs = [];
-	if (primaryKey) constraintDefs.push(`PRIMARY KEY (${primaryKey.columns.map(quoteIdentifier).join(", ")})`);
-	const createSql = `CREATE TABLE ${qualified} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`;
-	return {
-		id: `table.${tableName}`,
-		label: `Create table "${tableName}"`,
-		summary: `Creates table "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("table", tableName, schemaName),
-		precheck: [step(`ensure table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)],
-		execute: [step(`create table "${tableName}"`, createSql)],
-		postcheck: [step(`verify table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)]
-	};
-}
-function dropTable(schemaName, tableName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropTable.${tableName}`,
-		label: `Drop table "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails("table", tableName, schemaName),
-		precheck: [step(`ensure table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)],
-		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
-		postcheck: [step(`verify table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)]
-	};
-}
-
-//#endregion
-//#region src/core/migrations/postgres-migration.ts
-/**
-* Target-owned base class for Postgres migrations.
-*
-* Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
-* abstract `targetId` to the Postgres target-id string literal, so both
-* user-authored migrations and renderer-generated scaffolds (the output of
-* `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
-* redeclaring target-local identity.
-*
-* Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer
-* emits `extends Migration` against a target-specific re-export of this
-* class from `@prisma-next/target-postgres/migration`, keeping the
-* authoring surface target-scoped rather than family-scoped.
-*/
-var PostgresMigration = class extends Migration {
-	targetId = "postgres";
-};
-
-//#endregion
-export { normalizeSchemaNativeType as A, buildExpectedFormatType as C, qualifyTableName as D, columnNullabilityCheck as E, escapeLiteral as F, quoteIdentifier as I, codecDefinitions as M, PG_JSONB_CODEC_ID as N, tableIsEmptyCheck as O, PG_JSON_CODEC_ID as P, setNotNull as S, columnHasNoDefaultCheck as T, alterColumnType as _, dropIndex as a, dropNotNull as b, dropEnumType as c, createSchema as d, addForeignKey as f, addColumn as g, dropConstraint as h, createIndex as i, parsePostgresDefault as j, resolveColumnTypeMetadata as k, renameType as l, addUnique as m, createTable as n, addEnumValues as o, addPrimaryKey as p, dropTable as r, createEnumType as s, PostgresMigration as t, createExtension as u, dropColumn as v, columnExistsCheck as w, setDefault as x, dropDefault as y };
-//# sourceMappingURL=postgres-migration-BsHJHV9O.mjs.map