@prisma-next/adapter-postgres 0.12.0-dev.4 → 0.12.0-dev.41

package/dist/control-adapter-5BSAQMQc.mjs

@@ -0,0 +1,1364 @@
+import { APP_SPACE_ID, extractCodecLookup } from "@prisma-next/framework-components/control";
+import { LiteralExpr, RawExpr, collectOrderedParamRefs, isDdlNode } from "@prisma-next/sql-relational-core/ast";
+import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
+import { parseMarkerRowSafely, rethrowMarkerReadError, withMarkerReadErrorHandling } from "@prisma-next/errors/execution";
+import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { postgresColumnsCompatible } from "@prisma-next/target-postgres/column-type-compatibility";
+import { PostgresTableSource, buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, int4, int8, jsonb, pgTable, text, textArray, timestamptz } from "@prisma-next/target-postgres/contract-free";
+import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
+import { createResolveExistingEnumValues, enumStorageCompoundKey, readExistingEnumValues, readPostgresSchemaIrAnnotations } from "@prisma-next/target-postgres/enum-planning";
+import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
+import { blindCast } from "@prisma-next/utils/casts";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { PG_ENUM_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
+import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma-next/sql-runtime";
+import { runtimeError } from "@prisma-next/framework-components/runtime";
+//#region src/core/codec-lookup.ts
+/**
+* Build a {@link CodecLookup} populated with the Postgres-builtin codec definitions only.
+*
+* This is the default lookup used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived lookup (e.g. from tests, or one-off scripts that don't compose a full stack).
+*
+* Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive lookup at construction time.
+*/
+function createPostgresBuiltinCodecLookup() {
+	return extractCodecLookup([{
+		id: "postgres-builtin-codecs",
+		types: { codecTypes: { codecDescriptors: Array.from(postgresCodecRegistry.values()) } }
+	}]);
+}
+//#endregion
+//#region ../../../1-framework/3-tooling/migration/dist/exports/ledger-origin.mjs
+function ledgerOriginFromStored(originCoreHash) {
+	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "sha256:empty") return null;
+	return originCoreHash;
+}
+//#endregion
+//#region src/core/ddl-renderer.ts
+var PostgresDdlVisitorImpl = class {
+	createTable(node) {
+		return `create table ${node.ifNotExists ? "if not exists " : ""}${node.schema ? `${node.schema}.${node.table}` : node.table} (\n    ${node.columns.map((column) => renderColumn$1(column)).join(",\n    ")}\n  )`;
+	}
+	createSchema(node) {
+		return `create schema ${node.ifNotExists ? "if not exists " : ""}${node.schema}`;
+	}
+};
+const defaultVisitor = {
+	literal(node) {
+		const { value } = node;
+		if (typeof value === "string") return `default '${escapeLiteral(value)}'`;
+		if (typeof value === "number" || typeof value === "boolean") return `default ${String(value)}`;
+		if (value === null) return "default null";
+		return `default '${JSON.stringify(value)}'`;
+	},
+	function(node) {
+		if (node.expression === "autoincrement()") return "";
+		if (node.expression === "now()") return "default now()";
+		return `default (${node.expression})`;
+	}
+};
+function renderColumn$1(column) {
+	const parts = [column.name, column.type];
+	if (column.notNull) parts.push("not null");
+	if (column.primaryKey) parts.push("primary key");
+	const defaultClause = column.default ? column.default.accept(defaultVisitor) : "";
+	if (defaultClause.length > 0) parts.push(defaultClause);
+	return parts.join(" ");
+}
+function renderLoweredDdl(ast) {
+	const sql = ast.accept(new PostgresDdlVisitorImpl());
+	return Object.freeze({
+		sql,
+		params: Object.freeze([])
+	});
+}
+//#endregion
+//#region src/core/enum-control-hooks.ts
+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
+`;
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+* Parses a PostgreSQL array value into a JavaScript string array.
+*
+* The `pg` library returns `array_agg` results either as a JS array
+* (when type parsers are configured) or as a string in PostgreSQL array
+* literal format (`{value1,value2,...}`). Handles PG's quoting rules:
+* - Elements containing commas, quotes, backslashes, or whitespace are
+*   double-quoted.
+* - Inside quoted elements, `\"` represents `"` and `\\` represents `\`.
+*
+* Returns `null` when the input cannot be parsed as a PG array.
+*/
+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;
+}
+/**
+* Reads enum types from the live Postgres schema and returns them in
+* the codec-typed annotation shape consumed by `control-adapter.ts`
+* (which writes them under `schema.annotations.pg.storageTypes`).
+*/
+async function introspectPostgresEnumTypes(options) {
+	const namespace = options.schemaName ?? "public";
+	const result = await options.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;
+}
+//#endregion
+//#region src/core/marker-ledger.ts
+const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+const marker = pgTable({
+	name: "marker",
+	schema: "prisma_contract"
+}, {
+	space: text(),
+	core_hash: text(),
+	profile_hash: text(),
+	contract_json: jsonb({ nullable: true }),
+	canonical_version: int4({ nullable: true }),
+	updated_at: timestamptz(),
+	app_tag: text({ nullable: true }),
+	meta: jsonb({ nullable: true }),
+	invariants: textArray()
+});
+/**
+* Writeable subset of the `prisma_contract.ledger` table. Omits the
+* DB-generated `id` (bigserial) and `created_at` (default `now()`) so the
+* insert path doesn't have to pass them.
+*/
+const ledger = pgTable({
+	name: "ledger",
+	schema: "prisma_contract"
+}, {
+	space: text(),
+	migration_name: text(),
+	migration_hash: text(),
+	origin_core_hash: text({ nullable: true }),
+	destination_core_hash: text(),
+	operations: jsonb()
+});
+/**
+* Read-side handle covering every column of `prisma_contract.ledger`,
+* including the DB-generated `id` (for ORDER BY) and `created_at`.
+*/
+const ledgerReadShape = pgTable({
+	name: "ledger",
+	schema: "prisma_contract"
+}, {
+	id: int8(),
+	space: text(),
+	migration_name: text(),
+	migration_hash: text(),
+	origin_core_hash: text({ nullable: true }),
+	destination_core_hash: text(),
+	operations: jsonb(),
+	created_at: timestamptz()
+});
+const infoSchemaTables = pgTable({
+	name: "tables",
+	schema: "information_schema"
+}, {
+	table_schema: text(),
+	table_name: text()
+});
+const NOW = new RawExpr({
+	parts: ["now()"],
+	returns: {
+		codecId: PG_TIMESTAMPTZ_CODEC_ID,
+		nullable: false
+	}
+});
+function mergeInvariants(current, incoming) {
+	return [...new Set([...current, ...incoming])].sort();
+}
+async function execute(lower, driver, query) {
+	const lowered = lower(query);
+	const encoded = await encodeParamsWithMetadata(lowered.params.map((slot) => {
+		if (slot.kind === "literal") return slot.value;
+		throw new Error("Postgres control DML lowered to a bind parameter, which is unsupported");
+	}), deriveParamMetadata(query), {}, CONTROL_CODECS);
+	return (await driver.query(lowered.sql, encoded)).rows;
+}
+//#endregion
+//#region src/core/sql-renderer.ts
+/**
+* Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a codec whose `meta.db.sql.postgres.nativeType` falls in this set are emitted as plain `$N`; everything else (including `json`, `jsonb`, extension types like `vector`, and unknown user types) is emitted as `$N::<nativeType>` so the planner picks an unambiguous overload.
+*
+* `json` / `jsonb` are intentionally excluded despite being Postgres builtins: their operator overloads make context inference unreliable in expression positions (e.g. `$1 -> 'key'` is ambiguous between the two).
+*
+* Spellings match the on-disk `meta.db.sql.postgres.nativeType` values in `@prisma-next/target-postgres`'s codec definitions, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The lookup-based cast policy compares against these strings directly.
+*/
+const POSTGRES_INFERRABLE_NATIVE_TYPES = new Set([
+	"integer",
+	"smallint",
+	"bigint",
+	"real",
+	"double precision",
+	"numeric",
+	"boolean",
+	"text",
+	"character",
+	"character varying",
+	"timestamp",
+	"timestamp without time zone",
+	"timestamp with time zone",
+	"time",
+	"timetz",
+	"interval",
+	"bit",
+	"bit varying"
+]);
+function renderTypedParam(index, codecId, codecLookup) {
+	if (codecId === void 0) return `$${index}`;
+	const meta = codecLookup.metaFor(codecId);
+	if (!(codecLookup.get(codecId) !== void 0 || meta !== void 0 || codecLookup.targetTypesFor(codecId) !== void 0)) throw new Error(`Postgres lowering: ParamRef carries codecId "${codecId}" but the assembled codec lookup has no entry for it. This usually indicates a missing extension pack in the runtime stack — register the pack that contributes this codec (e.g. \`extensionPacks: [pgvectorRuntime]\`), or use the codec directly from \`@prisma-next/target-postgres/codecs\` if it's a builtin.`);
+	const dbRecord = meta?.db;
+	const sqlBlock = isRecord(dbRecord) ? dbRecord["sql"] : void 0;
+	const dialectBlock = isRecord(sqlBlock) ? sqlBlock["postgres"] : void 0;
+	const nativeType = isRecord(dialectBlock) ? dialectBlock["nativeType"] : void 0;
+	if (typeof nativeType === "string" && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}`;
+	return `$${index}`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
+*
+* Shared between the runtime (`PostgresAdapterImpl.lower`) and control (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time paths produce byte-identical output for the same AST.
+*/
+function renderLoweredSql(ast, contract, codecLookup) {
+	const orderedRefs = collectOrderedParamRefs(ast);
+	const indexMap = /* @__PURE__ */ new Map();
+	const params = orderedRefs.map((ref, i) => {
+		indexMap.set(ref, i + 1);
+		return ref.kind === "prepared-param-ref" ? {
+			kind: "bind",
+			name: ref.name
+		} : {
+			kind: "literal",
+			value: ref.value
+		};
+	});
+	const pim = {
+		indexMap,
+		codecLookup
+	};
+	const node = ast;
+	let sql;
+	switch (node.kind) {
+		case "select":
+			sql = renderSelect(node, contract, pim);
+			break;
+		case "insert":
+			sql = renderInsert(node, contract, pim);
+			break;
+		case "update":
+			sql = renderUpdate(node, contract, pim);
+			break;
+		case "delete":
+			sql = renderDelete(node, contract, pim);
+			break;
+		case "raw-sql":
+			sql = renderRawSql(node, contract, pim);
+			break;
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported AST node kind: ${node.kind}`);
+	}
+	return Object.freeze({
+		sql,
+		params: Object.freeze(params)
+	});
+}
+function renderLimitOffset(keyword, value, contract, pim) {
+	if (value === void 0) return "";
+	if (typeof value === "number") return `${keyword} ${value}`;
+	return `${keyword} ${renderExpr(value, contract, pim)}`;
+}
+function renderSelect(ast, contract, pim) {
+	return [
+		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
+		`FROM ${renderSource(ast.from, contract, pim)}`,
+		ast.joins?.length ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(" ") : "",
+		ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : "",
+		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(", ")}` : "",
+		ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : "",
+		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => {
+			return `${renderExpr(order.expr, contract, pim)} ${order.dir.toUpperCase()}`;
+		}).join(", ")}` : "",
+		renderLimitOffset("LIMIT", ast.limit, contract, pim),
+		renderLimitOffset("OFFSET", ast.offset, contract, pim)
+	].filter((part) => part.length > 0).join(" ").trim();
+}
+function renderProjection(projection, contract, pim) {
+	return projection.map((item) => {
+		const alias = quoteIdentifier(item.alias);
+		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${alias}`;
+		return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
+	}).join(", ");
+}
+function renderReturning(items, contract, pim) {
+	return items.map((item) => {
+		if (item.expr.kind === "column-ref") {
+			const rendered = renderColumn(item.expr);
+			return item.expr.column === item.alias ? rendered : `${rendered} AS ${quoteIdentifier(item.alias)}`;
+		}
+		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${quoteIdentifier(item.alias)}`;
+		return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
+	}).join(", ");
+}
+function renderDistinctPrefix(distinct, distinctOn, contract, pim) {
+	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
+	if (distinct) return "DISTINCT ";
+	return "";
+}
+function qualifyTableFromNamespaceCoordinate(table, contract) {
+	if (table instanceof PostgresTableSource && table.schema !== void 0) return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
+	if (table.namespaceId === void 0) return quoteIdentifier(table.name);
+	const namespace = contract.storage.namespaces[table.namespaceId];
+	if (namespace === void 0) throw new Error(`Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`);
+	const qualifyTable = namespace.qualifyTable;
+	if (qualifyTable === void 0) throw new Error(`Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`);
+	return qualifyTable.call(namespace, table.name);
+}
+function renderTableSource(source, contract) {
+	const qualified = qualifyTableFromNamespaceCoordinate(source, contract);
+	if (!source.alias) return qualified;
+	return `${qualified} AS ${quoteIdentifier(source.alias)}`;
+}
+function renderSource(source, contract, pim) {
+	const node = source;
+	switch (node.kind) {
+		case "table-source": return renderTableSource(node, contract);
+		case "derived-table-source": return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported source node kind: ${node.kind}`);
+	}
+}
+function assertScalarSubquery(query) {
+	if (query.projection.length !== 1) throw new Error("Subquery expressions must project exactly one column");
+}
+function renderSubqueryExpr(expr, contract, pim) {
+	assertScalarSubquery(expr.query);
+	return `(${renderSelect(expr.query, contract, pim)})`;
+}
+function renderWhere(expr, contract, pim) {
+	return renderExpr(expr, contract, pim);
+}
+function renderNullCheck(expr, contract, pim) {
+	const rendered = renderExpr(expr.expr, contract, pim);
+	const renderedExpr = isAtomicExpressionKind(expr.expr.kind) ? rendered : `(${rendered})`;
+	return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+/**
+* Atomic expression kinds whose rendered SQL is already self-delimited (a column reference, parameter, literal, function call, aggregate, etc.) and therefore does not need surrounding parentheses when used as the left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`, or as either operand of a binary infix operator.
+*
+* Anything not in this set is treated as composite (binary, AND/OR/NOT, EXISTS, nested IS NULL, subqueries, operation templates) and gets wrapped to preserve grouping.
+*/
+function isAtomicExpressionKind(kind) {
+	switch (kind) {
+		case "column-ref":
+		case "identifier-ref":
+		case "param-ref":
+		case "prepared-param-ref":
+		case "literal":
+		case "aggregate":
+		case "window-func":
+		case "json-object":
+		case "json-array-agg":
+		case "list": return true;
+		case "subquery":
+		case "operation":
+		case "binary":
+		case "and":
+		case "or":
+		case "exists":
+		case "null-check":
+		case "not":
+		case "raw-expr": return false;
+	}
+}
+function renderBinary(expr, contract, pim) {
+	if (expr.right.kind === "list" && expr.right.values.length === 0) {
+		if (expr.op === "in") return "FALSE";
+		if (expr.op === "notIn") return "TRUE";
+	}
+	const leftExpr = expr.left;
+	const left = renderExpr(leftExpr, contract, pim);
+	const leftRendered = leftExpr.kind === "operation" || leftExpr.kind === "subquery" ? `(${left})` : left;
+	const rightNode = expr.right;
+	let right;
+	switch (rightNode.kind) {
+		case "list":
+			right = renderListLiteral(rightNode, contract, pim);
+			break;
+		case "literal":
+			right = renderLiteral(rightNode);
+			break;
+		case "column-ref":
+			right = renderColumn(rightNode);
+			break;
+		case "param-ref":
+		case "prepared-param-ref":
+			right = renderParamRef(rightNode, pim);
+			break;
+		default:
+			right = renderExpr(rightNode, contract, pim);
+			break;
+	}
+	return `${leftRendered} ${{
+		eq: "=",
+		neq: "!=",
+		gt: ">",
+		lt: "<",
+		gte: ">=",
+		lte: "<=",
+		like: "LIKE",
+		in: "IN",
+		notIn: "NOT IN"
+	}[expr.op]} ${right}`;
+}
+function renderListLiteral(expr, contract, pim) {
+	if (expr.values.length === 0) return "(NULL)";
+	return `(${expr.values.map((v) => {
+		if (v.kind === "param-ref" || v.kind === "prepared-param-ref") return renderParamRef(v, pim);
+		if (v.kind === "literal") return renderLiteral(v);
+		return renderExpr(v, contract, pim);
+	}).join(", ")})`;
+}
+function renderColumn(ref) {
+	if (ref.table === "excluded") return `excluded.${quoteIdentifier(ref.column)}`;
+	return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
+}
+function renderAggregateExpr(expr, contract, pim) {
+	const fn = expr.fn.toUpperCase();
+	if (!expr.expr) return `${fn}(*)`;
+	return `${fn}(${renderExpr(expr.expr, contract, pim)})`;
+}
+function renderWindowFuncExpr(expr, contract, pim) {
+	return `${expr.fn.toUpperCase()}(${expr.args.map((arg) => renderExpr(arg, contract, pim)).join(", ")}) OVER (${[expr.partitionBy && expr.partitionBy.length > 0 ? `PARTITION BY ${expr.partitionBy.map((e) => renderExpr(e, contract, pim)).join(", ")}` : "", expr.orderBy && expr.orderBy.length > 0 ? `ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : ""].filter((part) => part.length > 0).join(" ")})`;
+}
+function renderJsonObjectExpr(expr, contract, pim) {
+	return `json_build_object(${expr.entries.flatMap((entry) => {
+		const key = `'${escapeLiteral(entry.key)}'`;
+		if (entry.value.kind === "literal") return [key, renderLiteral(entry.value)];
+		return [key, renderExpr(entry.value, contract, pim)];
+	}).join(", ")})`;
+}
+function renderOrderByItems(items, contract, pim) {
+	return items.map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`).join(", ");
+}
+function renderJsonArrayAggExpr(expr, contract, pim) {
+	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : "";
+	const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+	if (expr.onEmpty === "emptyArray") return `coalesce(${aggregated}, json_build_array())`;
+	return aggregated;
+}
+function renderExpr(expr, contract, pim) {
+	const node = expr;
+	switch (node.kind) {
+		case "column-ref": return renderColumn(node);
+		case "identifier-ref": return quoteIdentifier(node.name);
+		case "operation": return renderOperation(node, contract, pim);
+		case "subquery": return renderSubqueryExpr(node, contract, pim);
+		case "aggregate": return renderAggregateExpr(node, contract, pim);
+		case "window-func": return renderWindowFuncExpr(node, contract, pim);
+		case "json-object": return renderJsonObjectExpr(node, contract, pim);
+		case "json-array-agg": return renderJsonArrayAggExpr(node, contract, pim);
+		case "binary": return renderBinary(node, contract, pim);
+		case "and":
+			if (node.exprs.length === 0) return "TRUE";
+			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" AND ")})`;
+		case "or":
+			if (node.exprs.length === 0) return "FALSE";
+			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" OR ")})`;
+		case "exists": return `${node.notExists ? "NOT " : ""}EXISTS (${renderSelect(node.subquery, contract, pim)})`;
+		case "null-check": return renderNullCheck(node, contract, pim);
+		case "not": return `NOT (${renderExpr(node.expr, contract, pim)})`;
+		case "param-ref":
+		case "prepared-param-ref": return renderParamRef(node, pim);
+		case "literal": return renderLiteral(node);
+		case "list": return renderListLiteral(node, contract, pim);
+		case "raw-expr": return renderRawExpr(node, contract, pim);
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported expression node kind: ${node.kind}`);
+	}
+}
+function renderParamRef(ref, pim) {
+	const index = pim.indexMap.get(ref);
+	if (index === void 0) throw new Error("ParamRef not found in index map");
+	if (ref.kind === "prepared-param-ref") return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+	if (ref.codec === void 0) throw runtimeError("RUNTIME.PARAM_REF_MISSING_CODEC", "Postgres renderer: ParamRef reached lowering without a bound CodecRef. Every column-bound ParamRef must carry a codec under the AST-bound codec contract. This usually indicates a builder path that constructed a ParamRef without threading the column codec.", {
+		paramIndex: index,
+		...ifDefined("name", ref.name)
+	});
+	return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+}
+function renderLiteral(expr) {
+	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
+	if (typeof expr.value === "number" || typeof expr.value === "boolean") return String(expr.value);
+	if (typeof expr.value === "bigint") return String(expr.value);
+	if (expr.value === null) return "NULL";
+	if (expr.value === void 0) return "NULL";
+	if (expr.value instanceof Date) return `'${escapeLiteral(expr.value.toISOString())}'`;
+	if (Array.isArray(expr.value)) return `ARRAY[${expr.value.map((v) => renderLiteral(new LiteralExpr(v))).join(", ")}]`;
+	const json = JSON.stringify(expr.value);
+	if (json === void 0) return "NULL";
+	return `'${escapeLiteral(json)}'`;
+}
+function renderOperation(expr, contract, pim) {
+	const self = renderExpr(expr.self, contract, pim);
+	const args = expr.args.map((arg) => {
+		return renderExpr(arg, contract, pim);
+	});
+	return expr.lowering.template.replace(/\{\{self\}\}|\{\{arg(\d+)\}\}/g, (token, argIndex) => {
+		if (token === "{{self}}") return self;
+		const arg = args[Number(argIndex)];
+		if (arg === void 0) throw new Error(`Operation lowering template for "${expr.method}" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`);
+		return arg;
+	});
+}
+function renderJoin(join, contract, pim) {
+	return `${join.joinType.toUpperCase()} JOIN ${join.lateral ? "LATERAL " : ""}${renderSource(join.source, contract, pim)} ON ${renderJoinOn(join.on, contract, pim)}`;
+}
+function renderJoinOn(on, contract, pim) {
+	if (on.kind === "eq-col-join-on") return `${renderColumn(on.left)} = ${renderColumn(on.right)}`;
+	return renderWhere(on, contract, pim);
+}
+function getInsertColumnOrder(rows, contract, tableRef) {
+	const tableName = tableRef.name;
+	const orderedColumns = [];
+	const seenColumns = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const column of Object.keys(row)) {
+		if (seenColumns.has(column)) continue;
+		seenColumns.add(column);
+		orderedColumns.push(column);
+	}
+	if (orderedColumns.length > 0) return orderedColumns;
+	let table;
+	if (tableRef.namespaceId !== void 0) table = contract.storage.namespaces[tableRef.namespaceId]?.entries.table[tableName];
+	if (table === void 0) for (const ns of Object.values(contract.storage.namespaces)) {
+		const found = ns.entries.table[tableName];
+		if (found !== void 0) {
+			table = found;
+			break;
+		}
+	}
+	if (!table) throw new Error(`INSERT target table not found in contract storage: ${tableName}`);
+	return Object.keys(table.columns);
+}
+function renderInsertValue(value, contract, pim) {
+	if (!value || value.kind === "default-value") return "DEFAULT";
+	switch (value.kind) {
+		case "param-ref":
+		case "prepared-param-ref": return renderParamRef(value, pim);
+		case "column-ref": return renderColumn(value);
+		case "raw-expr": return renderExpr(value, contract, pim);
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported value node in INSERT: ${value.kind}`);
+	}
+}
+function renderInsert(ast, contract, pim) {
+	const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
+	const rows = ast.rows;
+	if (rows.length === 0) throw new Error("INSERT requires at least one row");
+	const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);
+	return `${(() => {
+		if (!hasExplicitValues) {
+			if (rows.length === 1) return `INSERT INTO ${table} DEFAULT VALUES`;
+			const defaultColumns = getInsertColumnOrder(rows, contract, ast.table);
+			if (defaultColumns.length === 0) return `INSERT INTO ${table} VALUES ${rows.map(() => "()").join(", ")}`;
+			const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));
+			const defaultRow = `(${defaultColumns.map(() => "DEFAULT").join(", ")})`;
+			return `INSERT INTO ${table} (${quotedColumns.join(", ")}) VALUES ${rows.map(() => defaultRow).join(", ")}`;
+		}
+		const columnOrder = getInsertColumnOrder(rows, contract, ast.table);
+		const columns = columnOrder.map((column) => quoteIdentifier(column));
+		const values = rows.map((row) => {
+			return `(${columnOrder.map((column) => renderInsertValue(row[column], contract, pim)).join(", ")})`;
+		}).join(", ");
+		return `INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values}`;
+	})()}${ast.onConflict ? (() => {
+		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
+		if (conflictColumns.length === 0) throw new Error("INSERT onConflict requires at least one conflict column");
+		const action = ast.onConflict.action;
+		switch (action.kind) {
+			case "do-nothing": return ` ON CONFLICT (${conflictColumns.join(", ")}) DO NOTHING`;
+			case "do-update-set": {
+				const updateEntries = Object.entries(action.set);
+				if (updateEntries.length === 0) throw new Error("INSERT onConflict do-update-set requires at least one assignment");
+				const updates = updateEntries.map(([colName, value]) => {
+					return `${quoteIdentifier(colName)} = ${renderExpr(value, contract, pim)}`;
+				});
+				return ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
+			}
+			// v8 ignore next 4
+			default: throw new Error(`Unsupported onConflict action: ${action.kind}`);
+		}
+	})() : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
+}
+function renderUpdate(ast, contract, pim) {
+	const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
+	const setEntries = Object.entries(ast.set);
+	if (setEntries.length === 0) throw new Error("UPDATE requires at least one SET assignment");
+	const setClauses = setEntries.map(([col, val]) => {
+		return `${quoteIdentifier(col)} = ${renderExpr(val, contract, pim)}`;
+	});
+	const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : "";
+	const returningClause = ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : "";
+	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
+}
+function renderDelete(ast, contract, pim) {
+	return `DELETE FROM ${qualifyTableFromNamespaceCoordinate(ast.table, contract)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
+}
+function renderRawSql(ast, contract, pim) {
+	const out = [];
+	for (let i = 0; i < ast.fragments.length; i++) {
+		out.push(ast.fragments[i] ?? "");
+		if (i < ast.args.length) {
+			const arg = ast.args[i];
+			if (arg !== void 0) out.push(renderExpr(arg, contract, pim));
+		}
+	}
+	return out.join("");
+}
+function renderRawExpr(node, contract, pim) {
+	return node.parts.map((part) => typeof part === "string" ? part : renderExpr(part, contract, pim)).join("");
+}
+//#endregion
+//#region src/core/control-adapter.ts
+const POSTGRES_MARKER_TABLE = "prisma_contract.marker";
+const POSTGRES_LEDGER_TABLE = "prisma_contract.ledger";
+/**
+* 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";
+	codecLookup;
+	/**
+	* @param codecLookup - Codec lookup used by the SQL renderer to resolve
+	*   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
+	*   lookup when omitted. Stack-aware callers
+	*   (`SqlControlAdapterDescriptor.create(stack)`) supply
+	*   `stack.codecLookup` so extension codecs are visible to the renderer.
+	*/
+	constructor(codecLookup) {
+		this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
+	}
+	/**
+	* 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;
+	/**
+	* Target-supplied compatible-shape relation used under the `external`
+	* control policy. Threading the same relation the migration planner/runner
+	* use keeps runtime verify and migration verify in agreement.
+	*/
+	columnsCompatible = postgresColumnsCompatible;
+	/**
+	* Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
+	* introspection shape (`schema.annotations.pg.storageTypes`). Lets
+	* the family-level schema verifier walk enum types without reaching
+	* into target-specific annotation layouts itself.
+	*/
+	resolveExistingEnumValues = (schema, enumType, namespaceId) => {
+		return readExistingEnumValues(schema, namespaceId === UNBOUND_NAMESPACE_ID ? readPostgresSchemaIrAnnotations(schema).schema ?? "public" : namespaceId, enumType.nativeType);
+	};
+	resolveExistingEnumValuesForContract = (contract) => createResolveExistingEnumValues(contract.storage);
+	bootstrapControlTableQueries() {
+		return buildControlTableBootstrapQueries();
+	}
+	bootstrapSignMarkerQueries() {
+		return buildSignMarkerBootstrapQueries();
+	}
+	/**
+	* Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
+	*
+	* Delegates to the shared `renderLoweredSql` renderer so the control adapter
+	* emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
+	* and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+	* without instantiating the runtime adapter.
+	*/
+	lower(ast, context) {
+		if (isDdlNode(ast)) return renderLoweredDdl(ast);
+		return renderLoweredSql(ast, context.contract, this.codecLookup);
+	}
+	/**
+	* Reads the contract marker from `prisma_contract.marker`. Probes
+	* `information_schema.tables` first so a fresh database (where the
+	* `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+	* "relation does not exist" error — some Postgres wire-protocol clients
+	* (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+	* parse errors, so we probe before reading.
+	*/
+	async readMarker(driver, space) {
+		const result = await this.readMarkerDiscriminated(driver, space);
+		return result.kind === "present" ? result.record : null;
+	}
+	async readMarkerDiscriminated(driver, space) {
+		return withMarkerReadErrorHandling(() => this.readMarkerResult(driver, space), {
+			space,
+			markerLocation: POSTGRES_MARKER_TABLE
+		});
+	}
+	/**
+	* Reads every row from `prisma_contract.marker` and returns them keyed
+	* by `space`. Mirrors the existence probe in {@link readMarker}: a
+	* fresh database without the `prisma_contract` schema returns an empty
+	* map rather than raising "relation does not exist".
+	*/
+	async readAllMarkers(driver) {
+		return withMarkerReadErrorHandling(() => this.readAllMarkersResult(driver), {
+			space: APP_SPACE_ID,
+			markerLocation: POSTGRES_MARKER_TABLE
+		});
+	}
+	async readAllMarkersResult(driver) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, infoSchemaTables.select(infoSchemaTables.table_schema).where(infoSchemaTables.table_schema.eq("prisma_contract").and(infoSchemaTables.table_name.eq("marker"))).build())).length === 0) return /* @__PURE__ */ new Map();
+		await this.assertMarkerTableHasSpaceColumn(driver, APP_SPACE_ID);
+		const rows = blindCast(await execute(lower, driver, marker.select(marker.space, marker.core_hash, marker.profile_hash, marker.contract_json, marker.canonical_version, marker.updated_at, marker.app_tag, marker.meta, marker.invariants).build()));
+		const out = /* @__PURE__ */ new Map();
+		for (const row of rows) out.set(row.space, parseMarkerRowSafely(row, parseContractMarkerRow, {
+			space: row.space,
+			markerLocation: POSTGRES_MARKER_TABLE
+		}));
+		return out;
+	}
+	/**
+	* Reads per-migration ledger rows from `prisma_contract.ledger` in apply
+	* order. Probes `information_schema.tables` first so a fresh database
+	* without the ledger table returns `[]` instead of raising "relation does
+	* not exist".
+	*/
+	async readLedger(driver, space) {
+		return withMarkerReadErrorHandling(() => this.readLedgerResult(driver, space), {
+			space: space ?? "*",
+			markerLocation: POSTGRES_LEDGER_TABLE
+		});
+	}
+	async readLedgerResult(driver, space) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, infoSchemaTables.select(infoSchemaTables.table_schema).where(infoSchemaTables.table_schema.eq("prisma_contract").and(infoSchemaTables.table_name.eq("ledger"))).build())).length === 0) return [];
+		const base = ledgerReadShape.select(ledgerReadShape.space, ledgerReadShape.migration_name, ledgerReadShape.migration_hash, ledgerReadShape.origin_core_hash, ledgerReadShape.destination_core_hash, ledgerReadShape.operations, ledgerReadShape.created_at);
+		return blindCast(await execute(lower, driver, (space !== void 0 ? base.where(ledgerReadShape.space.eq(space)) : base).orderBy(ledgerReadShape.id).build())).map((row) => {
+			const appliedAt = row.created_at instanceof Date ? row.created_at : new Date(row.created_at);
+			return {
+				space: row.space,
+				migrationName: row.migration_name,
+				migrationHash: row.migration_hash,
+				from: ledgerOriginFromStored(row.origin_core_hash),
+				to: row.destination_core_hash,
+				appliedAt,
+				operationCount: Array.isArray(row.operations) ? row.operations.length : 0
+			};
+		});
+	}
+	/**
+	* Stamps the initial marker row for `space` via the shared contract-free DML
+	* builder, lowered through {@link lower} and executed on the driver. See the
+	* `SqlControlAdapter.initMarker` contract.
+	*/
+	async insertMarker(driver, space, destination) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, marker.insert({
+			space,
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			contract_json: null,
+			canonical_version: null,
+			updated_at: NOW,
+			app_tag: null,
+			meta: {},
+			invariants: destination.invariants ?? []
+		}).build());
+	}
+	async initMarker(driver, space, destination) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, marker.upsert({
+			space,
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			contract_json: null,
+			canonical_version: null,
+			updated_at: NOW,
+			app_tag: null,
+			meta: {},
+			invariants: destination.invariants ?? []
+		}).onConflict(marker.space).doUpdate((excluded) => ({
+			core_hash: excluded.core_hash,
+			profile_hash: excluded.profile_hash,
+			contract_json: excluded.contract_json,
+			canonical_version: excluded.canonical_version,
+			updated_at: NOW,
+			app_tag: excluded.app_tag,
+			meta: excluded.meta,
+			invariants: excluded.invariants
+		})).build());
+	}
+	/**
+	* Compare-and-swap advance of the marker row for `space`. See the
+	* `SqlControlAdapter.updateMarker` contract.
+	*/
+	async updateMarker(driver, space, expectedFrom, destination) {
+		const currentInvariants = destination.invariants === void 0 ? [] : (await this.readMarker(driver, space))?.invariants ?? [];
+		const mergedInvariants = destination.invariants === void 0 ? void 0 : mergeInvariants(currentInvariants, destination.invariants);
+		return (await execute((q) => this.lower(q, { contract: void 0 }), driver, marker.update().set({
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			updated_at: NOW,
+			...mergedInvariants !== void 0 ? { invariants: mergedInvariants } : {}
+		}).where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom))).returning(marker.space).build())).length > 0;
+	}
+	/**
+	* Appends a ledger entry for `space`. See the
+	* `SqlControlAdapter.writeLedgerEntry` contract.
+	*/
+	async writeLedgerEntry(driver, space, entry) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, ledger.insert({
+			space,
+			migration_name: entry.migrationName,
+			migration_hash: entry.migrationHash,
+			origin_core_hash: entry.from,
+			destination_core_hash: entry.to,
+			operations: entry.operations
+		}).build());
+	}
+	async assertMarkerTableHasSpaceColumn(driver, space) {
+		const rows = (await driver.query(`select column_name
+         from information_schema.columns
+        where table_schema = 'prisma_contract'
+          and table_name = 'marker'`)).rows;
+		if (rows.length === 0) return;
+		if (!rows.every((row) => typeof row.column_name === "string")) return;
+		if (rows.some((row) => row.column_name === "space")) return;
+		rethrowMarkerReadError(/* @__PURE__ */ new Error("column \"space\" does not exist"), {
+			space,
+			markerLocation: POSTGRES_MARKER_TABLE
+		});
+	}
+	async readMarkerResult(driver, space) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, infoSchemaTables.select(infoSchemaTables.table_schema).where(infoSchemaTables.table_schema.eq("prisma_contract").and(infoSchemaTables.table_name.eq("marker"))).build())).length === 0) return { kind: "no-table" };
+		await this.assertMarkerTableHasSpaceColumn(driver, space);
+		const row = (await execute(lower, driver, marker.select(marker.core_hash, marker.profile_hash, marker.contract_json, marker.canonical_version, marker.updated_at, marker.app_tag, marker.meta, marker.invariants).where(marker.space.eq(space)).build()))[0];
+		if (!row) return { kind: "absent" };
+		return {
+			kind: "present",
+			record: parseContractMarkerRow(row)
+		};
+	}
+	/**
+	* 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.
+	*
+	* When `contract` is provided and its storage declares more than one
+	* namespace (or any explicit bound namespace), the adapter walks every
+	* declared namespace and merges the per-schema introspection results
+	* into a single `SqlSchemaIR`. `UNBOUND_NAMESPACE_ID` resolves to the
+	* connection's `current_schema()` so late-bound tables follow the
+	* runtime `search_path`. When no contract is passed, the adapter falls
+	* back to introspecting the single `schema` argument (defaulting to
+	* `'public'`).
+	*
+	* Uses batched queries to minimize database round trips (6 queries per
+	* schema walked).
+	*
+	* @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+	* @param contract - Optional contract for contract-guided introspection (multi-namespace walk, filtering)
+	* @param schema - Schema name to introspect when no contract is provided (defaults to 'public')
+	* @returns Promise resolving to SqlSchemaIR representing the live database schema
+	*/
+	async introspect(driver, contract, schema = "public") {
+		const declaredNamespaces = extractContractNamespaceIds(contract);
+		const ir = declaredNamespaces.length > 0 ? await this.introspectNamespaces(driver, declaredNamespaces) : await this.introspectSchema(driver, schema);
+		const existingSchemas = await this.listExistingSchemas(driver);
+		const annotations = ir.annotations ?? {};
+		const pg = annotations.pg ?? {};
+		return {
+			...ir,
+			annotations: {
+				...annotations,
+				pg: {
+					...pg,
+					existingSchemas
+				}
+			}
+		};
+	}
+	/**
+	* Lists every non-system schema present in the connected database.
+	* The introspection consumer (`verifyPostgresNamespacePresence`)
+	* treats the result as the authoritative ground truth — declared
+	* namespaces whose `ddlSchemaName` is missing from this list become
+	* `missing_schema` issues, and the planner emits the matching
+	* `CREATE SCHEMA` before table DDL.
+	*/
+	async listExistingSchemas(driver) {
+		return (await driver.query(`SELECT nspname
+       FROM pg_catalog.pg_namespace
+       WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+         AND nspname NOT LIKE 'pg_temp_%'
+         AND nspname NOT LIKE 'pg_toast_temp_%'
+       ORDER BY nspname`)).rows.map((row) => row.nspname);
+	}
+	/**
+	* Walks every declared namespace, resolving `UNBOUND_NAMESPACE_ID` to
+	* the connection's `current_schema()`, and merges the per-schema results
+	* into a single `SqlSchemaIR`. The merged `tables` map is flat (keyed by
+	* table name) so callers that look up by `tableName` see every contract
+	* table regardless of which namespace it lives in.
+	*/
+	async introspectNamespaces(driver, namespaceIds) {
+		const resolvedSchemas = await Promise.all(namespaceIds.map(async (id) => {
+			if (id === UNBOUND_NAMESPACE_ID) {
+				const { rows } = await driver.query("SELECT current_schema() AS current_schema");
+				return rows[0]?.current_schema ?? "public";
+			}
+			return id;
+		}));
+		const uniqueSchemas = Array.from(new Set(resolvedSchemas));
+		const perSchema = await Promise.all(uniqueSchemas.map((s) => this.introspectSchema(driver, s)));
+		const mergedTables = {};
+		for (const ir of perSchema) for (const [tableName, table] of Object.entries(ir.tables)) mergedTables[tableName] = table;
+		const mergedStorageTypes = {};
+		for (let i = 0; i < perSchema.length; i++) {
+			const ir = perSchema[i];
+			const pg = blindCast(ir?.annotations?.["pg"])?.storageTypes;
+			if (!pg) continue;
+			for (const [key, value] of Object.entries(pg)) mergedStorageTypes[key] = value;
+		}
+		const firstAnnotations = perSchema[0]?.annotations;
+		const firstPg = blindCast(firstAnnotations?.["pg"]) ?? {};
+		return {
+			tables: mergedTables,
+			...ifDefined("annotations", {
+				...firstAnnotations,
+				pg: {
+					...firstPg,
+					...ifDefined("storageTypes", Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : void 0)
+				}
+			})
+		};
+	}
+	/**
+	* Introspects a single Postgres schema and returns a raw SqlSchemaIR
+	* containing only the tables in that schema. Used by `introspect` as
+	* the per-namespace walk.
+	*/
+	async introspectSchema(driver, schema) {
+		const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult] = 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,
+           k.ord AS index_position,
+           am.amname,
+           ic.reloptions
+         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_am am ON am.oid = ic.relam
+         JOIN pg_class t ON t.oid = ix.indrelid
+         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
+         JOIN LATERAL unnest(ix.indkey::int[]) WITH ORDINALITY AS k(attnum, ord) ON true
+         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum 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, k.ord`, [schema])
+		]);
+		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,
+					referencedSchema: fkRow.referenced_table_schema,
+					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,
+				referencedSchema: fk.referencedSchema,
+				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 {
+					const indexType = idxRow.amname && idxRow.amname !== "btree" ? idxRow.amname : void 0;
+					const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
+					indexesMap.set(idxRow.indexname, {
+						columns: [idxRow.attname],
+						name: idxRow.indexname,
+						unique: idxRow.indisunique,
+						type: indexType,
+						options: indexOptions
+					});
+				}
+			}
+			const indexes = Array.from(indexesMap.values()).map((idx) => ({
+				columns: Object.freeze([...idx.columns]),
+				name: idx.name,
+				unique: idx.unique,
+				...idx.type !== void 0 && { type: idx.type },
+				...idx.options !== void 0 && { options: idx.options }
+			}));
+			tables[tableName] = {
+				name: tableName,
+				columns,
+				...ifDefined("primaryKey", primaryKey),
+				foreignKeys,
+				uniques,
+				indexes
+			};
+		}
+		const rawStorageTypes = await introspectPostgresEnumTypes({
+			driver,
+			schemaName: schema
+		});
+		const storageTypes = {};
+		for (const [typeName, annotation] of Object.entries(rawStorageTypes)) storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
+		return {
+			tables,
+			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";
+	}
+};
+/**
+* Extracts the namespace coordinate ids declared on a contract's storage,
+* or returns an empty array when no contract (or no storage / namespaces)
+* is present. Used by `PostgresControlAdapter.introspect` to decide
+* between the multi-namespace walk and the single-schema fallback.
+*/
+function extractContractNamespaceIds(contract) {
+	if (contract === null || typeof contract !== "object") return [];
+	const storage = contract.storage;
+	if (storage === null || typeof storage !== "object") return [];
+	const namespaces = storage.namespaces;
+	if (namespaces === null || typeof namespaces !== "object") return [];
+	return Object.keys(namespaces);
+}
+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.
+*/
+/**
+* Parses a `pg_class.reloptions` array into a `Record<string, string>`.
+*
+* Postgres returns reloptions as a `text[]` whose entries are `key=value`
+* strings; the value side is always a string regardless of the underlying
+* scalar type. The verifier compares contract options to introspected
+* options after coercing both sides to strings, so keeping the raw text
+* here is correct.
+*
+* Returns `undefined` when the input is null/empty (no WITH clause).
+*/
+function parsePgReloptions(reloptions, indexName) {
+	if (!reloptions || reloptions.length === 0) return;
+	const result = {};
+	for (const entry of reloptions) {
+		const eq = entry.indexOf("=");
+		if (eq === -1) throw new Error(`Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`);
+		const key = entry.slice(0, eq);
+		result[key] = entry.slice(eq + 1);
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+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;
+}
+//#endregion
+export { createPostgresBuiltinCodecLookup as i, renderLoweredSql as n, renderLoweredDdl as r, PostgresControlAdapter as t };
+
+//# sourceMappingURL=control-adapter-5BSAQMQc.mjs.map