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

package/dist/control-adapter-B9t0g7Pf-HrCxlM65.mjs

@@ -0,0 +1,1901 @@
+import { n as buildPostgresCodecDescriptorRegistry } from "./codec-descriptor-CB6x0xEu-C-Zn2IEz.mjs";
+import { x as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-tX7Svtz--BuOfRaVU.mjs";
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+import { n as isPgEnumParams } from "./codecs-CBl0nD44-CaWPc1bd.mjs";
+import { n as postgresCodecRegistry, t as postgresCodecDescriptorRegistry } from "./codecs-CHIVTNZs.mjs";
+import { i as quoteQualifiedName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-BnBlQxyh-DaX9Nb7Z.mjs";
+import { a as jsonb, c as textArray, i as int8, l as timestamptz, n as buildSignMarkerBootstrapQueries, o as pgTable, r as int4, s as text, t as buildControlTableBootstrapQueries } from "./contract-free-BZUS18FU.mjs";
+import { t as parsePostgresDefault } from "./default-normalizer-Ba5ZebHM-isV86rjy.mjs";
+import { n as PostgresSchemaNodeKind, r as PostgresTableSchemaNode, t as PostgresNativeEnumSchemaNode } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
+import { i as PostgresRoleSchemaNode, n as PostgresNamespaceSchemaNode, r as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
+import { t as normalizeSchemaNativeType } from "./native-type-normalizer-yvd3tqv-.mjs";
+import { LiteralExpr, RawExpr, collectOrderedParamRefs, isDdlNode } from "@prisma/orm-family-sql/relational-core/ast";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { namingOfLiveName } from "@prisma/orm-family-sql/schema-ir/naming";
+import { APP_SPACE_ID, extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { RelationalSchemaNodeKind } from "@prisma/orm-family-sql/schema-ir/types";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+import { parseMarkerRowSafely, rethrowMarkerReadError, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { parseContractMarkerRow } from "@prisma/orm-family-sql/family/verify";
+import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma/orm-family-sql/runtime";
+import { runtimeError } from "@prisma/orm-framework/components/runtime";
+//#region ../../../3-targets/6-adapters/postgres/dist/control-adapter-B9t0g7Pf.mjs
+function adapterError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function buildPostgresCodecRegistry(descriptors) {
+	const descriptorRegistry = buildPostgresCodecDescriptorRegistry(descriptors);
+	const registry = {
+		...extractCodecLookup([{
+			id: "postgres-codecs",
+			types: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }
+		}]),
+		descriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),
+		values: () => descriptorRegistry.values()
+	};
+	return Object.freeze(registry);
+}
+function assemblePostgresCodecRegistry(components) {
+	return buildPostgresCodecRegistry(components.flatMap((component) => component.types?.codecTypes?.codecDescriptors ?? []));
+}
+function createPostgresCodecRegistryWithBuiltins(codecDescriptors = []) {
+	return buildPostgresCodecRegistry([...postgresCodecDescriptorRegistry.values(), ...codecDescriptors]);
+}
+/**
+* Build a coherent PostgreSQL codec registry populated with built-in descriptors only.
+*
+* The returned registry supports both ordinary codec materialization and PostgreSQL target behavior. Stack-composed paths build the same combined registry from their complete ordered descriptor contributions.
+*/
+function createPostgresBuiltinCodecLookup() {
+	return createPostgresCodecRegistryWithBuiltins();
+}
+function ledgerOriginFromStored(originCoreHash) {
+	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "empty") return null;
+	return originCoreHash;
+}
+const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+async function encodeControlQueryParams(lowered, ast, codecs = CONTROL_CODECS) {
+	return encodeParamsWithMetadata(lowered.params.map((slot) => {
+		if (slot.kind === "literal") return slot.value;
+		throw new InternalError(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+	}), deriveParamMetadata(ast), {}, codecs);
+}
+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()
+});
+/**
+* Content-addressed contract store: one row per distinct contract, keyed
+* by its storage hash. The ledger's `origin_core_hash` /
+* `destination_core_hash` resolve here by hash equality, so both
+* endpoints of every edge are direct lookups and a contract revisited by
+* a rollback cycle is stored exactly once (upsert DO NOTHING).
+*/
+const ledgerContract = pgTable({
+	name: "contract",
+	schema: "prisma_contract"
+}, {
+	core_hash: text(),
+	contract_json: 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 [.../* @__PURE__ */ new Set([...current, ...incoming])].sort();
+}
+async function execute(lower, driver, query) {
+	const lowered = lower(query);
+	const encoded = await encodeControlQueryParams(lowered, query);
+	return (await driver.query(lowered.sql, encoded)).rows;
+}
+/**
+* Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a descriptor whose `nativeTypeFor` result 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 target descriptors' `nativeTypeFor` results, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The registry-based cast policy compares against these strings directly.
+*/
+const POSTGRES_INFERRABLE_NATIVE_TYPES = /* @__PURE__ */ 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, codecDescriptorRegistry, many, typeParams) {
+	if (codecId === void 0) return `$${index}`;
+	const descriptor = codecDescriptorRegistry.descriptorFor(codecId);
+	if (descriptor === void 0) throw adapterError("RUNTIME.PARAM_REF_MISSING_CODEC", `Postgres lowering: ParamRef carries codecId "${codecId}" but the validated PostgreSQL codec registry 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. \`extensions: [pgvectorRuntime]\`), or use the codec directly from \`@internal/target-postgres/codecs\` if it's a builtin.`, { meta: { codecId } });
+	const ref = {
+		codecId,
+		...ifDefined("many", many),
+		...ifDefined("typeParams", typeParams)
+	};
+	const nativeType = descriptor.nativeTypeFor(ref);
+	const arraySuffix = many ? "[]" : "";
+	if (isPgEnumParams(typeParams)) return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
+	if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType) || many) return `$${index}::${nativeType}${arraySuffix}`;
+	return `$${index}`;
+}
+function unreachableKind(value) {
+	const candidate = value;
+	if (typeof candidate === "object" && candidate !== null && "kind" in candidate && typeof candidate.kind === "string") return candidate.kind;
+	return "unknown";
+}
+/**
+* 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, codecDescriptorRegistry) {
+	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,
+		codecDescriptorRegistry
+	};
+	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: assertNever(node, `Unsupported AST node kind: ${unreachableKind(node)}`);
+	}
+	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) {
+	const sourcesByRef = collectTableSources(ast);
+	return [
+		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, sourcesByRef, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
+		ast.from !== void 0 ? `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 `${renderOrderByExpr(order.expr, sourcesByRef, 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();
+}
+/**
+* Map a SELECT's table references (the FROM source and any JOIN sources) to their storage coordinate, keyed by the name a `ColumnRef.table` would carry (the alias when present, otherwise the table name). Derived-table sources are skipped — their columns are projected through a sub-select, not a base storage column, so the enum hook does not apply.
+*/
+function collectTableSources(ast) {
+	const sources = /* @__PURE__ */ new Map();
+	const add = (source) => {
+		if (source.kind !== "table-source") return;
+		const ref = source.alias ?? source.name;
+		sources.set(ref, {
+			name: source.name,
+			namespaceId: source.namespaceId
+		});
+	};
+	if (ast.from !== void 0) add(ast.from);
+	for (const join of ast.joins ?? []) add(join.source);
+	return sources;
+}
+/**
+* Ordered, codec-encoded values of the value-set a storage column restricts to, or `undefined` when the referenced column carries no value-set (the common, non-enum case). Resolves the column's storage coordinate from the SELECT's table sources, then the column's `valueSet` ref to the value-set's `values`.
+*/
+function allStrings(values) {
+	return values.every((value) => typeof value === "string");
+}
+function resolveEnumOrderValues(ref, sourcesByRef, contract) {
+	const source = sourcesByRef.get(ref.table);
+	if (source === void 0 || source.namespaceId === void 0) return;
+	const sourceNs = contract.storage.namespaces[source.namespaceId];
+	const valueSet = (sourceNs !== void 0 ? sourceNs.entries.table?.[source.name]?.columns[ref.column] : void 0)?.valueSet;
+	if (valueSet === void 0) return;
+	const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+	return valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
+}
+/**
+* Ordered values for an unqualified ORDER BY column (an `identifier-ref`, the shape the sql-builder emits for `.orderBy('col')`). Scans every FROM/JOIN source for a column of that name. Resolves only when exactly one source has a column of that name and it carries a value-set; if more than one source has such a column the bare identifier is ambiguous (regardless of which are enum-backed), so it falls through to the plain column rendering.
+*/
+function resolveEnumOrderValuesForIdentifier(name, sourcesByRef, contract) {
+	let matchedColumns = 0;
+	let resolved;
+	for (const source of sourcesByRef.values()) {
+		if (source.namespaceId === void 0) continue;
+		const identNs = contract.storage.namespaces[source.namespaceId];
+		const column = identNs !== void 0 ? identNs.entries.table?.[source.name]?.columns[name] : void 0;
+		if (column === void 0) continue;
+		matchedColumns += 1;
+		if (matchedColumns > 1) return;
+		const valueSet = column.valueSet;
+		if (valueSet === void 0) return;
+		const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+		resolved = valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
+	}
+	return resolved;
+}
+/**
+* Render an ORDER BY expression. A column reference onto an enum-restricted column sorts by declaration order via `array_position(ARRAY[…]::text[], <col>)` over the value-set's ordered values (NULLs return `NULL` from `array_position`, sorting per the clause's default NULL handling). Both qualified `column-ref`s and the unqualified `identifier-ref`s the sql-builder emits for `.orderBy('col')` are intercepted. Every other expression renders unchanged.
+*/
+function renderOrderByExpr(expr, sourcesByRef, contract, pim) {
+	if (expr.kind === "column-ref") {
+		const orderValues = resolveEnumOrderValues(expr, sourcesByRef, contract);
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${renderColumn(expr)})`;
+	}
+	if (expr.kind === "identifier-ref") {
+		const orderValues = resolveEnumOrderValuesForIdentifier(expr.name, sourcesByRef, contract);
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${quoteIdentifier(expr.name)})`;
+	}
+	return renderExpr(expr, contract, pim);
+}
+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, sourcesByRef, contract, pim) {
+	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderOrderByExpr(expr, sourcesByRef, contract, pim)).join(", ")}) `;
+	if (distinct) return "DISTINCT ";
+	return "";
+}
+function hasExplicitSchema(table) {
+	return "schema" in table && typeof table.schema === "string";
+}
+function qualifyTableFromNamespaceCoordinate(table, contract) {
+	if (hasExplicitSchema(table)) 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 adapterError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`, { meta: {
+		table: table.name,
+		namespaceId: table.namespaceId,
+		reason: "not-present"
+	} });
+	const qualifyTable = namespace.qualifyTable;
+	if (qualifyTable === void 0) throw adapterError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`, { meta: {
+		table: table.name,
+		namespaceId: table.namespaceId,
+		reason: "not-materialised"
+	} });
+	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)}`;
+		case "function-source": {
+			const args = node.args.map((arg) => renderExpr(arg, contract, pim)).join(", ");
+			return `${`${node.fn}(${args})`}${node.ordinality ? " WITH ORDINALITY" : ""}${node.alias === void 0 ? "" : ` AS ${quoteIdentifier(node.alias)}`}${node.columnAliases === void 0 ? "" : `(${node.columnAliases.map((column) => quoteIdentifier(column)).join(", ")})`}`;
+		}
+		// v8 ignore next 4
+		default: assertNever(node, `Unsupported source node kind: ${unreachableKind(node)}`);
+	}
+}
+function assertScalarSubquery(query) {
+	if (query.projection.length !== 1) throw adapterError("RUNTIME.AST_INVALID", "Subquery expressions must project exactly one column", { meta: { node: "subquery-expr" } });
+}
+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 "function-call":
+		case "cast":
+		case "case":
+		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 renderFunctionCallExpr(expr, contract, pim) {
+	const args = expr.args.map((arg) => renderExpr(arg, contract, pim)).join(", ");
+	return `${expr.fn}(${args})`;
+}
+function renderCastExpr(expr, contract, pim) {
+	return `CAST(${renderExpr(expr.expr, contract, pim)} AS ${expr.targetType})`;
+}
+function renderCaseExpr(expr, contract, pim) {
+	return `CASE ${expr.branches.map((branch) => `WHEN ${renderExpr(branch.condition, contract, pim)} THEN ${renderExpr(branch.value, contract, pim)}`).join(" ")}${expr.elseExpr === void 0 ? "" : ` ELSE ${renderExpr(expr.elseExpr, contract, pim)}`} END`;
+}
+function renderJsonValueProjection(projection, contract, pim) {
+	return projection.accept({
+		codec: ({ value, codec }) => renderExpr(projectJsonThroughCodec(value, codec, pim), contract, pim),
+		native: ({ value }) => renderExpr(value, contract, pim),
+		document: ({ value }) => renderExpr(value, contract, pim)
+	});
+}
+function projectJsonThroughCodec(value, codec, pim) {
+	const descriptor = pim.codecDescriptorRegistry.descriptorFor(codec.codecId);
+	if (descriptor === void 0) throw adapterError("RUNTIME.PARAM_REF_MISSING_CODEC", `Postgres lowering: a JSON projection carries codecId "${codec.codecId}" but the validated PostgreSQL codec registry 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. \`extensions: [pgvectorRuntime]\`), or use the codec directly from \`@internal/target-postgres/codecs\` if it's a builtin.`, { meta: { codecId: codec.codecId } });
+	return descriptor.projectJson(value, codec);
+}
+function renderJsonObjectExpr(expr, contract, pim) {
+	return `json_build_object(${expr.entries.flatMap((entry) => {
+		return [`'${escapeLiteral(entry.key)}'`, renderJsonValueProjection(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(${renderJsonValueProjection(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 "function-call": return renderFunctionCallExpr(node, contract, pim);
+		case "cast": return renderCastExpr(node, contract, pim);
+		case "case": return renderCaseExpr(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: assertNever(node, `Unsupported expression node kind: ${unreachableKind(node)}`);
+	}
+}
+function renderParamRef(ref, pim) {
+	const index = pim.indexMap.get(ref);
+	if (index === void 0) throw new InternalError("ParamRef not found in index map");
+	if (ref.kind === "prepared-param-ref") return renderTypedParam(index, ref.codec.codecId, pim.codecDescriptorRegistry, ref.codec.many, ref.codec.typeParams);
+	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.codecDescriptorRegistry, ref.codec.many, ref.codec.typeParams);
+}
+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 adapterError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Operation lowering template for "${expr.method}" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`, { meta: { method: expr.method } });
+		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) {
+		const ns = contract.storage.namespaces[tableRef.namespaceId];
+		table = ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
+	}
+	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 adapterError("RUNTIME.AST_INVALID", `INSERT target table not found in contract storage: ${tableName}`, { meta: {
+		node: "insert",
+		table: 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: assertNever(value, `Unsupported value node in INSERT: ${unreachableKind(value)}`);
+	}
+}
+function renderInsert(ast, contract, pim) {
+	const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
+	const rows = ast.rows;
+	if (rows.length === 0) throw adapterError("RUNTIME.AST_INVALID", "INSERT requires at least one row", { meta: { node: "insert" } });
+	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 adapterError("RUNTIME.AST_INVALID", "INSERT onConflict requires at least one conflict column", { meta: { node: "insert-on-conflict" } });
+		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 adapterError("RUNTIME.AST_INVALID", "INSERT onConflict do-update-set requires at least one assignment", { meta: { node: "insert-on-conflict" } });
+				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: assertNever(action, `Unsupported onConflict action: ${unreachableKind(action)}`);
+		}
+	})() : ""}${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 adapterError("RUNTIME.AST_INVALID", "UPDATE requires at least one SET assignment", { meta: { node: "update" } });
+	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("");
+}
+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 {
+	codecRegistry;
+	familyId = "sql";
+	targetId = "postgres";
+	constructor(codecRegistry) {
+		this.codecRegistry = codecRegistry;
+	}
+	/**
+	* 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;
+	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)) throw adapterError("RUNTIME.DDL_UNSUPPORTED", "lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().", { meta: { surface: "control-adapter" } });
+		return renderLoweredSql(ast, blindCast(context.contract), this.codecRegistry);
+	}
+	/**
+	* Lower an AST all the way to a driver-ready statement. For DDL nodes,
+	* literal column defaults are formatted as inline SQL with proper quoting and
+	* `::nativeType` cast suffixes. For query ASTs, params are kept as `$N`
+	* placeholders; wire values go in `params`. Does NOT call `this.lower()` —
+	* independent implementation.
+	*/
+	async lowerToExecuteRequest(ast, context) {
+		if (isDdlNode(ast)) return pgRenderDdlExecuteRequest(blindCast(ast), this.codecRegistry);
+		const lowered = renderLoweredSql(ast, blindCast(context?.contract), this.codecRegistry);
+		const params = await encodeControlQueryParams(lowered, ast, blindCast(this.codecRegistry));
+		return {
+			sql: lowered.sql,
+			params
+		};
+	}
+	/**
+	* 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`. When the edge carries a
+	* destination contract snapshot, the content-addressed
+	* `prisma_contract.contract` store is populated first (keyed by the
+	* destination hash, DO NOTHING on revisit) so a reader never sees a
+	* ledger row whose stored destination contract is missing. See the
+	* `SqlControlAdapter.writeLedgerEntry` contract.
+	*/
+	async writeLedgerEntry(driver, space, entry) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if (entry.destinationContractJson !== void 0) await execute(lower, driver, ledgerContract.upsert({
+			core_hash: entry.to,
+			contract_json: entry.destinationContractJson
+		}).onConflict(ledgerContract.core_hash).doNothing().build());
+		await execute(lower, 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 - SqlControlDriverInstance<'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 resolvedSchemas = declaredNamespaces.length > 0 ? await this.resolveNamespaceSchemas(driver, declaredNamespaces) : [schema];
+		const namespaces = {};
+		let pgVersion = "unknown";
+		for (const resolved of resolvedSchemas) {
+			const { namespace, pgVersion: version } = await this.introspectSchema(driver, resolved);
+			namespaces[resolved] = namespace;
+			pgVersion = version;
+		}
+		return new PostgresDatabaseSchemaNode({
+			namespaces,
+			roles: await this.introspectRoles(driver),
+			existingSchemas: await this.listExistingSchemas(driver),
+			pgVersion
+		});
+	}
+	/**
+	* Reads cluster-scoped database roles. Roles are not schema-qualified, so
+	* this is queried once for the whole database rather than per namespace.
+	*/
+	async introspectRoles(driver) {
+		return (await driver.query(`SELECT rolname
+       FROM pg_catalog.pg_roles
+       WHERE rolname NOT LIKE 'pg_%'
+         AND rolname != 'postgres'
+       ORDER BY rolname`)).rows.map((row) => new PostgresRoleSchemaNode({
+			name: row.rolname,
+			namespaceId: UNBOUND_NAMESPACE_ID
+		}));
+	}
+	/**
+	* 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);
+	}
+	/**
+	* Resolves the declared namespace ids to their live DDL schema names,
+	* mapping `UNBOUND_NAMESPACE_ID` to the connection's `current_schema()`
+	* and de-duplicating. The caller introspects one namespace node per
+	* resolved schema — there is no flat cross-schema merge, so two schemas
+	* holding a same-named table no longer collide.
+	*/
+	async resolveNamespaceSchemas(driver, namespaceIds) {
+		const resolvedSchemas = [];
+		for (const id of namespaceIds) if (id === UNBOUND_NAMESPACE_ID) {
+			const { rows } = await driver.query("SELECT current_schema() AS current_schema");
+			resolvedSchemas.push(rows[0]?.current_schema ?? "public");
+		} else resolvedSchemas.push(id);
+		return Array.from(new Set(resolvedSchemas));
+	}
+	/**
+	* Introspects a single Postgres schema and returns the namespace node for
+	* that schema (its tables, their policies, and its native enum type names),
+	* alongside the cluster-scoped Postgres version. Used by `introspect` as
+	* the per-namespace walk.
+	*/
+	async introspectSchema(driver, schema) {
+		const tablesResult = await driver.query(`SELECT table_name
+         FROM information_schema.tables
+         WHERE table_schema = $1
+           AND table_type = 'BASE TABLE'
+         ORDER BY table_name`, [schema]);
+		const columnsResult = await 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,
+           a.attidentity
+         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]);
+		const pkResult = await driver.query(`SELECT
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS ordinal_position
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
+         WHERE ns.nspname = $1
+           AND con.contype = 'p'
+         ORDER BY cl.relname, k.ord`, [schema]);
+		const fkResult = await driver.query(`SELECT
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS ordinal_position,
+           ref_ns.nspname AS referenced_table_schema,
+           ref_cl.relname AS referenced_table_name,
+           ref_att.attname AS referenced_column_name,
+           CASE con.confdeltype
+             WHEN 'a' THEN 'NO ACTION'
+             WHEN 'r' THEN 'RESTRICT'
+             WHEN 'c' THEN 'CASCADE'
+             WHEN 'n' THEN 'SET NULL'
+             WHEN 'd' THEN 'SET DEFAULT'
+           END AS delete_rule,
+           CASE con.confupdtype
+             WHEN 'a' THEN 'NO ACTION'
+             WHEN 'r' THEN 'RESTRICT'
+             WHEN 'c' THEN 'CASCADE'
+             WHEN 'n' THEN 'SET NULL'
+             WHEN 'd' THEN 'SET DEFAULT'
+           END AS update_rule
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
+         JOIN pg_catalog.pg_class ref_cl
+           ON ref_cl.oid = con.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 = con.confrelid
+           AND ref_att.attnum = con.confkey[k.ord]
+         WHERE ns.nspname = $1
+           AND con.contype = 'f'
+         ORDER BY cl.relname, con.conname, k.ord`, [schema]);
+		const uniqueResult = await driver.query(`SELECT
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS ordinal_position
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
+         WHERE ns.nspname = $1
+           AND con.contype = 'u'
+         ORDER BY cl.relname, con.conname, k.ord`, [schema]);
+		const indexResult = await driver.query(`SELECT
+           i.tablename,
+           i.indexname,
+           ix.indisunique,
+           pg_get_expr(ix.indpred, ix.indrelid) AS where_predicate,
+           a.attname,
+           CASE WHEN 0 = ANY(ix.indkey::int[]) THEN pg_get_indexdef(ix.indexrelid, k.ord::int, true) END AS element_def,
+           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 pg_catalog.pg_constraint con
+             WHERE con.conindid = ic.oid
+               AND con.contype IN ('p', 'u', 'x')
+           )
+         ORDER BY i.tablename, i.indexname, k.ord`, [schema]);
+		const checkResult = await driver.query(`SELECT
+           cl.relname AS table_name,
+           c.conname AS constraint_name,
+           pg_get_constraintdef(c.oid) AS constraintdef
+         FROM pg_catalog.pg_constraint c
+         JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         WHERE ns.nspname = $1
+           AND c.contype = 'c'
+         ORDER BY cl.relname, c.conname`, [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 checksByTable = groupBy(checkResult.rows, "table_name");
+		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 tableInputs = {};
+		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;
+				const many = nativeType.endsWith("[]") ? true : void 0;
+				if (many) nativeType = normalizeSchemaNativeType(nativeType.slice(0, -2));
+				const resolvedNativeType = `${normalizeSchemaNativeType(nativeType)}${many ? "[]" : ""}`;
+				const rawDefault = colRow.column_default ?? void 0;
+				const resolvedDefault = colRow.attidentity === "a" || colRow.attidentity === "d" ? {
+					kind: "function",
+					expression: "autoincrement()"
+				} : rawDefault !== void 0 ? parsePostgresDefault(rawDefault, resolvedNativeType) : void 0;
+				columns[colRow.column_name] = {
+					name: colRow.column_name,
+					nativeType,
+					nullable: colRow.is_nullable === "YES",
+					...ifDefined("default", rawDefault),
+					...ifDefined("many", many),
+					resolvedNativeType,
+					...ifDefined("resolvedDefault", resolvedDefault)
+				};
+			}
+			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 } : {},
+				dependsOn: postgresColumnDependsOn(schema, tableName, primaryKeyColumns)
+			} : 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)),
+				dependsOn: [postgresTableDependsOn(fk.referencedSchema, fk.referencedTable), ...postgresColumnDependsOn(schema, tableName, fk.columns)]
+			}));
+			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,
+				dependsOn: postgresColumnDependsOn(schema, tableName, uq.columns)
+			}));
+			const indexesMap = /* @__PURE__ */ new Map();
+			for (const idxRow of indexesByTable.get(tableName) ?? []) {
+				const existing = indexesMap.get(idxRow.indexname);
+				if (existing) existing.elements.push({
+					attname: idxRow.attname,
+					elementDef: idxRow.element_def
+				});
+				else {
+					const indexType = idxRow.amname ?? void 0;
+					const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
+					indexesMap.set(idxRow.indexname, {
+						name: idxRow.indexname,
+						elements: [{
+							attname: idxRow.attname,
+							elementDef: idxRow.element_def
+						}],
+						unique: idxRow.indisunique,
+						where: idxRow.where_predicate,
+						type: indexType,
+						options: indexOptions
+					});
+				}
+			}
+			const indexes = Array.from(indexesMap.values()).map((idx) => {
+				const isExpression = idx.elements.some((el) => el.attname === null);
+				const columnNames = idx.elements.flatMap((el) => el.attname !== null ? [el.attname] : []);
+				const base = {
+					naming: namingOfLiveName(idx.name),
+					where: idx.where ?? void 0,
+					unique: idx.unique,
+					partial: idx.where !== null,
+					type: idx.type,
+					options: idx.options,
+					annotations: void 0,
+					dependsOn: postgresColumnDependsOn(schema, tableName, isExpression ? Object.keys(columns) : columnNames)
+				};
+				return isExpression ? {
+					...base,
+					expression: idx.elements.map((el) => el.elementDef ?? "").join(", ")
+				} : {
+					...base,
+					columns: Object.freeze([...columnNames])
+				};
+			});
+			const checksForTable = [];
+			for (const checkRow of checksByTable.get(tableName) ?? []) {
+				const parsed = parseCheckConstraintDef(checkRow.constraintdef);
+				if (parsed) checksForTable.push({
+					name: checkRow.constraint_name,
+					column: parsed.column,
+					permittedValues: parsed.permittedValues
+				});
+			}
+			tableInputs[tableName] = {
+				name: tableName,
+				columns,
+				...ifDefined("primaryKey", primaryKey),
+				foreignKeys,
+				uniques,
+				indexes,
+				...ifDefined("checks", checksForTable.length > 0 ? checksForTable : void 0)
+			};
+		}
+		const enums = (await driver.query(`SELECT t.typname, array_agg(e.enumlabel ORDER BY e.enumsortorder) AS enumvalues
+         FROM pg_catalog.pg_type t
+         JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+         JOIN pg_catalog.pg_enum e ON e.enumtypid = t.oid
+         WHERE t.typtype = 'e'
+           AND n.nspname = $1
+         GROUP BY t.typname
+         ORDER BY t.typname`, [schema])).rows.map((r) => new PostgresNativeEnumSchemaNode({
+			typeName: r.typname,
+			namespaceId: schema,
+			members: parsePgNameArray(r.enumvalues)
+		}));
+		const policiesResult = await driver.query(`SELECT schemaname, tablename, policyname, cmd, roles, qual, with_check, permissive
+       FROM pg_catalog.pg_policies
+       WHERE schemaname = $1
+       ORDER BY tablename, policyname`, [schema]);
+		const policiesByTable = /* @__PURE__ */ new Map();
+		for (const row of policiesResult.rows) {
+			const operation = mapPgCmd(row.cmd);
+			const policyRoles = [...new Set(parsePgNameArray(row.roles).map((r) => r.toLowerCase()))].sort();
+			const permissive = row.permissive.toUpperCase() === "PERMISSIVE";
+			const policy = new PostgresPolicySchemaNode({
+				naming: namingOfLiveName(row.policyname),
+				tableName: row.tablename,
+				namespaceId: row.schemaname,
+				operation,
+				roles: policyRoles,
+				using: row.qual ?? void 0,
+				withCheck: row.with_check ?? void 0,
+				permissive,
+				dependsOn: [postgresTableDependsOn(row.schemaname, row.tablename), ...policyRoles.map(postgresRoleDependsOn)]
+			});
+			const list = policiesByTable.get(row.tablename) ?? [];
+			list.push(policy);
+			policiesByTable.set(row.tablename, list);
+		}
+		const rlsEnabledResult = await driver.query(`SELECT c.relname AS tablename, c.relrowsecurity AS rls_enabled
+         FROM pg_catalog.pg_class c
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+         WHERE n.nspname = $1
+           AND c.relkind IN ('r', 'p')
+         ORDER BY c.relname`, [schema]);
+		const rlsEnabledByTable = new Map(rlsEnabledResult.rows.map((row) => [row.tablename, row.rls_enabled]));
+		const tables = {};
+		for (const [tableName, input] of Object.entries(tableInputs)) tables[tableName] = new PostgresTableSchemaNode({
+			...input,
+			policies: policiesByTable.get(tableName) ?? [],
+			rlsEnabled: rlsEnabledByTable.get(tableName) ?? false
+		});
+		return {
+			namespace: new PostgresNamespaceSchemaNode({
+				schemaName: schema,
+				tables,
+				nativeEnums: enums
+			}),
+			pgVersion: await this.getPostgresVersion(driver)
+		};
+	}
+	/**
+	* 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";
+	}
+};
+/**
+* Normalises a `name[]` column value from `pg_policies.roles`.
+*
+* The `pg` client's type-parser registry handles `text[]` (OID 1009) but not
+* `name[]` (OID 1003). When the parser is absent the raw Postgres text-array
+* literal (`{role1,role2}`) is returned as a string instead of a JS array.
+* This function accepts either form and returns a plain string array.
+*
+* The string branch honors Postgres array-literal quoting: an element
+* containing a comma, quote, backslash, brace, or significant whitespace is
+* emitted double-quoted with `\"` / `\\` escapes, and unquoted elements are
+* whitespace-trimmed — so a label like `in progress` or `say "hi"` parses to
+* its true value instead of being split or kept escaped.
+*/
+function parsePgNameArray(value) {
+	if (Array.isArray(value)) return value.map(String);
+	if (typeof value !== "string") return [];
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return [];
+	const inner = trimmed.slice(1, -1);
+	if (inner === "") return [];
+	const elements = [];
+	let current = "";
+	let inQuotes = false;
+	let wasQuoted = false;
+	const pushCurrent = () => {
+		elements.push(wasQuoted ? current : current.trim());
+		current = "";
+		wasQuoted = false;
+	};
+	let i = 0;
+	while (i < inner.length) {
+		const char = inner.charAt(i);
+		if (inQuotes) {
+			if (char === "\\") {
+				current += inner[i + 1] ?? "";
+				i += 2;
+				continue;
+			}
+			if (char === "\"") {
+				inQuotes = false;
+				i++;
+				continue;
+			}
+			current += char;
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			inQuotes = true;
+			wasQuoted = true;
+			i++;
+			continue;
+		}
+		if (char === ",") {
+			pushCurrent();
+			i++;
+			continue;
+		}
+		current += char;
+		i++;
+	}
+	if (inQuotes) return [];
+	pushCurrent();
+	return elements;
+}
+/**
+* Maps `pg_policies.cmd` text values to the `RlsPolicyOperation` union.
+* The `pg_policies` view renders the internal command code as an uppercase
+* English keyword; this function lowercases to match the IR type.
+*/
+function mapPgCmd(cmd) {
+	switch (cmd.toUpperCase()) {
+		case "SELECT": return "select";
+		case "INSERT": return "insert";
+		case "UPDATE": return "update";
+		case "DELETE": return "delete";
+		default: return "all";
+	}
+}
+/**
+* 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.endsWith("[]")) return `${normalizeFormattedType(formattedType.slice(0, -2), 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 adapterError("CONTRACT.INTROSPECTION_UNSUPPORTED", `Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`, { meta: { rule } });
+	if (mapped === "noAction") return void 0;
+	return mapped;
+}
+/**
+* A FK/policy dependency chain, mirroring the shape the expected-side
+* derivation stamps (`contractToPostgresDatabaseSchemaNode`): the database
+* root's fixed sentinel id, then the namespace, then the table.
+*/
+function postgresTableDependsOn(namespaceId, tableName) {
+	return [
+		{
+			nodeKind: PostgresSchemaNodeKind.database,
+			id: "database"
+		},
+		{
+			nodeKind: PostgresSchemaNodeKind.namespace,
+			id: namespaceId
+		},
+		{
+			nodeKind: PostgresSchemaNodeKind.table,
+			id: tableName
+		}
+	];
+}
+/** A policy's dependency chain onto one of the roles it grants to. */
+function postgresRoleDependsOn(role) {
+	return [{
+		nodeKind: PostgresSchemaNodeKind.database,
+		id: "database"
+	}, {
+		nodeKind: PostgresSchemaNodeKind.role,
+		id: role
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on — the introspection-side
+* mirror of `contractToPostgresDatabaseSchemaNode`'s `columnDependsOn`. An
+* object is dropped before the columns it covers.
+*/
+function postgresColumnDependsOn(namespaceId, tableName, columns) {
+	return columns.map((column) => [...postgresTableDependsOn(namespaceId, tableName), {
+		nodeKind: RelationalSchemaNodeKind.column,
+		id: `column:${column}`
+	}]);
+}
+/**
+* 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 adapterError("CONTRACT.INTROSPECTION_UNSUPPORTED", `Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`, { meta: {
+			entry,
+			indexName
+		} });
+		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;
+}
+/**
+* Parses a Postgres check-constraint definition string (as returned by
+* `pg_get_constraintdef`) into a column name and permitted values array.
+*
+* Handles two shapes that Postgres emits for enum-style checks:
+*
+* 1. `= ANY (ARRAY[...])` — Postgres rewrites `col IN ('a','b')` to this form:
+*    `CHECK ((col = ANY (ARRAY['a'::text, 'b'::text])))`
+*
+* 2. `IN (...)` — stays as-is when written directly:
+*    `CHECK ((col IN ('a', 'b')))`
+*
+* Column names may be plain identifiers (`status`) or double-quoted identifiers
+* (`"my-col"`). Double-quoted identifiers with embedded `""` are un-escaped to a
+* single `"`.
+*
+* String literal values may contain Postgres-style doubled single-quotes (`''`),
+* which are un-escaped to a single `'` (e.g. `O''Brien` → `O'Brien`).
+*
+* Returns `{ column, permittedValues }` when the predicate matches one of
+* the two recognised shapes. Returns `undefined` for anything else (e.g.
+* a free-form SQL predicate that wasn't emitted by this slice).
+*/
+function parseCheckConstraintDef(constraintdef) {
+	const afterCheck = constraintdef.replace(/^CHECK\s*\(/i, "").replace(/\)$/, "").trim();
+	const inner = afterCheck.startsWith("(") && afterCheck.endsWith(")") ? afterCheck.slice(1, -1).trim() : afterCheck;
+	const anyArrayMatch = inner.match(/^(?:"((?:[^"]|"")*)"|(\w+))\s*=\s*ANY\s*\(\s*ARRAY\s*\[(.+)\]\s*\)\s*$/i);
+	if (anyArrayMatch) {
+		const column = anyArrayMatch[1] !== void 0 ? anyArrayMatch[1].replace(/""/g, "\"") : anyArrayMatch[2];
+		const arrayBody = anyArrayMatch[3];
+		if (!column || !arrayBody) return void 0;
+		const permittedValues = extractArrayLiterals(arrayBody);
+		return permittedValues ? {
+			column,
+			permittedValues
+		} : void 0;
+	}
+	const inMatch = inner.match(/^(?:"((?:[^"]|"")*)"|(\w+))\s+IN\s*\((.+)\)\s*$/i);
+	if (inMatch) {
+		const column = inMatch[1] !== void 0 ? inMatch[1].replace(/""/g, "\"") : inMatch[2];
+		const listBody = inMatch[3];
+		if (!column || !listBody) return void 0;
+		const permittedValues = extractQuotedLiterals(listBody);
+		return permittedValues ? {
+			column,
+			permittedValues
+		} : void 0;
+	}
+}
+/**
+* Extracts string literals from an `ARRAY[...]` body.
+* Handles `'value'::type` casts by stripping the cast part.
+* Postgres stores single quotes inside values as doubled single-quotes (`''`);
+* each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
+*/
+function extractArrayLiterals(arrayBody) {
+	const values = [...arrayBody.matchAll(/'((?:[^'\\]|\\.|'')*)'\s*(?:::[^\s,\]]+)?/g)].map((m) => (m[1] ?? "").replace(/''/g, "'"));
+	return values.length > 0 ? values : void 0;
+}
+/**
+* Extracts string literals from an `IN (...)` list.
+* Handles single-quoted literals with possible escaped quotes.
+* Postgres stores single quotes inside values as doubled single-quotes (`''`);
+* each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
+*/
+function extractQuotedLiterals(listBody) {
+	const values = [...listBody.matchAll(/'((?:[^'\\]|\\.|'')*)'/g)].map((m) => (m[1] ?? "").replace(/''/g, "'"));
+	return values.length > 0 ? values : void 0;
+}
+function pgIsTextLikeNativeType(nativeType) {
+	return nativeType === "text" || nativeType === "varchar" || nativeType.startsWith("varchar(") || nativeType === "character varying" || nativeType.startsWith("character varying(") || nativeType === "char" || nativeType.startsWith("char(") || nativeType === "character" || nativeType.startsWith("character(");
+}
+function pgRenderArrayElement(el) {
+	if (el === null) return "NULL";
+	if (typeof el === "number" || typeof el === "boolean") return String(el);
+	if (typeof el === "string") return `'${escapeLiteral(el)}'`;
+	return `'${escapeLiteral(JSON.stringify(el))}'`;
+}
+function pgRenderArrayLiteral(elements) {
+	if (elements.length === 0) return "'{}'";
+	return `ARRAY[${elements.map(pgRenderArrayElement).join(", ")}]`;
+}
+function pgInlineLiteral(wire, nativeType) {
+	if (wire === null) return "NULL";
+	if (typeof wire === "boolean") return wire ? "true" : "false";
+	if (typeof wire === "number") {
+		if (!Number.isFinite(wire)) throw adapterError("CONTRACT.DEFAULT_INVALID", `pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`, { meta: { nativeType } });
+		return String(wire);
+	}
+	if (typeof wire === "bigint") return String(wire);
+	if (wire instanceof Date) {
+		if (Number.isNaN(wire.getTime())) throw adapterError("CONTRACT.DEFAULT_INVALID", `pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`, { meta: { nativeType } });
+		const quoted = `'${escapeLiteral(wire.toISOString())}'`;
+		return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+	}
+	if (typeof wire === "string") {
+		const quoted = `'${escapeLiteral(wire)}'`;
+		return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+	}
+	if (wire instanceof Uint8Array) return `'\\x${Array.from(wire).map((b) => b.toString(16).padStart(2, "0")).join("")}'::${nativeType}`;
+	if (Array.isArray(wire) && nativeType.endsWith("[]")) return pgRenderArrayLiteral(wire);
+	if (typeof wire === "object") return `${`'${escapeLiteral(JSON.stringify(wire))}'`}::${nativeType}`;
+	throw adapterError("CONTRACT.PACK_CONTRIBUTION_INVALID", `pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`, { meta: {
+		wireType: typeof wire,
+		nativeType
+	} });
+}
+async function pgRenderDdlColumnDefault(def, nativeType, codecLookup, codecRef) {
+	if (def.kind === "function") {
+		if (def.expression === "autoincrement()") return "";
+		return `DEFAULT (${def.expression})`;
+	}
+	if (codecRef !== void 0) {
+		const codec = codecLookup.get(codecRef.codecId);
+		if (codec !== void 0) return `DEFAULT ${pgInlineLiteral(await codec.encode(def.value, {}), nativeType)}`;
+	}
+	return `DEFAULT ${pgInlineLiteral(def.value, nativeType)}`;
+}
+async function pgRenderDdlColumn(column, codecLookup) {
+	const parts = [quoteIdentifier(column.name), column.type];
+	if (column.default) {
+		const clause = await pgRenderDdlColumnDefault(column.default, column.type, codecLookup, column.codecRef);
+		if (clause.length > 0) parts.push(clause);
+	}
+	if (column.notNull) parts.push("NOT NULL");
+	if (column.primaryKey) parts.push("PRIMARY KEY");
+	return parts.join(" ");
+}
+function pgRenderDdlConstraint(constraint) {
+	if (constraint.kind === "primary-key") {
+		const cols = constraint.columns.map(quoteIdentifier).join(", ");
+		if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+		return `PRIMARY KEY (${cols})`;
+	}
+	if (constraint.kind === "foreign-key") {
+		let sql = `FOREIGN KEY (${constraint.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${constraint.refTable.split(".").map(quoteIdentifier).join(".")} (${constraint.refColumns.map(quoteIdentifier).join(", ")})`;
+		if (constraint.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
+		if (constraint.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
+		if (constraint.name !== void 0) sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
+		return sql;
+	}
+	if (constraint.kind === "check-expression") return `CONSTRAINT ${quoteIdentifier(constraint.name)} CHECK (${constraint.expression})`;
+	const cols = constraint.columns.map(quoteIdentifier).join(", ");
+	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+	return `UNIQUE (${cols})`;
+}
+async function pgRenderCreateTable(node, codecLookup) {
+	const ifNotExists = node.ifNotExists ? "IF NOT EXISTS " : "";
+	const tableRef = node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}` : quoteIdentifier(node.table);
+	const columnDefs = await Promise.all(node.columns.map((col) => pgRenderDdlColumn(col, codecLookup)));
+	const constraintDefs = node.constraints !== void 0 ? node.constraints.map(pgRenderDdlConstraint) : [];
+	return {
+		sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`,
+		params: []
+	};
+}
+function pgRenderCreateSchema(node) {
+	return {
+		sql: `CREATE SCHEMA ${node.ifNotExists ? "IF NOT EXISTS " : ""}${quoteIdentifier(node.schema)}`,
+		params: []
+	};
+}
+function pgRenderCreateType(node) {
+	return {
+		sql: `CREATE TYPE ${node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.name)}` : quoteIdentifier(node.name)} AS ENUM (${node.values.map((value) => `'${escapeLiteral(value)}'`).join(", ")})`,
+		params: []
+	};
+}
+function pgRenderDropType(node) {
+	return {
+		sql: `DROP TYPE ${node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.name)}` : quoteIdentifier(node.name)}`,
+		params: []
+	};
+}
+async function pgRenderAlterTable(node, codecLookup) {
+	const tableRef = node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}` : quoteIdentifier(node.table);
+	const actionVisitor = {
+		async addColumn(action) {
+			return `ADD COLUMN ${await pgRenderDdlColumn(action.column, codecLookup)}`;
+		},
+		dropDefault(action) {
+			return Promise.resolve(`ALTER COLUMN ${quoteIdentifier(action.columnName)} DROP DEFAULT`);
+		}
+	};
+	return {
+		sql: `ALTER TABLE ${tableRef} ${(await Promise.all(node.actions.map((a) => a.accept(actionVisitor)))).join(", ")}`,
+		params: []
+	};
+}
+const POLICY_OPERATION_SQL = {
+	select: "SELECT",
+	insert: "INSERT",
+	update: "UPDATE",
+	delete: "DELETE",
+	all: "ALL"
+};
+function pgRenderCreatePolicy(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	const permissiveness = node.permissive ? "PERMISSIVE" : "RESTRICTIVE";
+	const command = POLICY_OPERATION_SQL[node.operation];
+	const roles = node.roles.length === 0 ? "PUBLIC" : node.roles.join(", ");
+	let sql = `CREATE POLICY ${quoteIdentifier(node.name)} ON ${tableRef} AS ${permissiveness} FOR ${command} TO ${roles}`;
+	if (node.using !== void 0) sql += ` USING (${node.using})`;
+	if (node.withCheck !== void 0) sql += ` WITH CHECK (${node.withCheck})`;
+	return {
+		sql,
+		params: []
+	};
+}
+function pgRenderDropPolicy(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	return {
+		sql: `DROP POLICY ${quoteIdentifier(node.name)} ON ${tableRef}`,
+		params: []
+	};
+}
+function pgRenderAlterPolicyRename(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	return {
+		sql: `ALTER POLICY ${quoteIdentifier(node.name)} ON ${tableRef} RENAME TO ${quoteIdentifier(node.newName)}`,
+		params: []
+	};
+}
+/**
+* Renders one index reloption value: strings single-quote-escaped, finite
+* numbers verbatim, booleans in the `on`/`off` catalog spelling (the
+* canonical form the wire hash and the option equality commit to).
+*/
+function pgRenderIndexOptionValue(key, value) {
+	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "boolean") return value ? "on" : "off";
+	throw postgresError("CONTRACT.INDEX_INVALID", `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`, { meta: {
+		key,
+		valueType: typeof value
+	} });
+}
+/** Qualifies an object name; an absent schema renders it unqualified (unbound namespace). */
+function pgQualify(schema, name) {
+	return schema === void 0 ? quoteIdentifier(name) : `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+}
+function pgRenderCreateIndex(node) {
+	const elementList = "columns" in node.elements ? node.elements.columns.map(quoteIdentifier).join(", ") : node.elements.expression;
+	const unique = node.unique ? "UNIQUE " : "";
+	const using = node.type !== void 0 ? ` USING ${quoteIdentifier(node.type)}` : "";
+	const withClause = node.options !== void 0 && Object.keys(node.options).length > 0 ? ` WITH (${Object.entries(node.options).map(([key, value]) => `${quoteIdentifier(key)} = ${pgRenderIndexOptionValue(key, value)}`).join(", ")})` : "";
+	const whereClause = node.where !== void 0 ? ` WHERE (${node.where})` : "";
+	return {
+		sql: `CREATE ${unique}INDEX ${quoteIdentifier(node.name)} ON ${pgQualify(node.schema, node.table)}${using} (${elementList})${withClause}${whereClause}`,
+		params: []
+	};
+}
+function pgRenderDropIndex(node) {
+	return {
+		sql: `DROP INDEX ${pgQualify(node.schema, node.name)}`,
+		params: []
+	};
+}
+function pgRenderAlterIndexRename(node) {
+	return {
+		sql: `ALTER INDEX ${pgQualify(node.schema, node.from)} RENAME TO ${quoteIdentifier(node.to)}`,
+		params: []
+	};
+}
+function pgRenderDisableRowLevelSecurity(node) {
+	return {
+		sql: `ALTER TABLE ${`${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`} DISABLE ROW LEVEL SECURITY`,
+		params: []
+	};
+}
+async function pgRenderDdlExecuteRequest(ast, codecLookup) {
+	return ast.accept({
+		createTable: (node) => pgRenderCreateTable(node, codecLookup),
+		createSchema: (node) => Promise.resolve(pgRenderCreateSchema(node)),
+		createType: (node) => Promise.resolve(pgRenderCreateType(node)),
+		dropType: (node) => Promise.resolve(pgRenderDropType(node)),
+		alterTable: (node) => pgRenderAlterTable(node, codecLookup),
+		createPolicy: (node) => Promise.resolve(pgRenderCreatePolicy(node)),
+		dropPolicy: (node) => Promise.resolve(pgRenderDropPolicy(node)),
+		alterPolicyRename: (node) => Promise.resolve(pgRenderAlterPolicyRename(node)),
+		createIndex: (node) => Promise.resolve(pgRenderCreateIndex(node)),
+		dropIndex: (node) => Promise.resolve(pgRenderDropIndex(node)),
+		alterIndexRename: (node) => Promise.resolve(pgRenderAlterIndexRename(node)),
+		disableRowLevelSecurity: (node) => Promise.resolve(pgRenderDisableRowLevelSecurity(node))
+	});
+}
+//#endregion
+export { createPostgresCodecRegistryWithBuiltins as a, createPostgresBuiltinCodecLookup as i, adapterError as n, renderLoweredSql as o, assemblePostgresCodecRegistry as r, PostgresControlAdapter as t };
+
+//# sourceMappingURL=control-adapter-B9t0g7Pf-HrCxlM65.mjs.map