@prisma-next/adapter-postgres 0.16.0-dev.32 → 0.16.0-dev.34

package/README.md

@@ -159,6 +159,10 @@ flowchart TD
 
 ## Usage
 
+### Custom codec descriptors
+
+`createPostgresAdapter({ codecDescriptors })` accepts PostgreSQL-target descriptors and appends them to the built-ins before constructing one structurally validated registry. Stack-based runtime and control construction consume the same descriptors from `types.codecTypes.codecDescriptors`. See the [target-owned SQL codec descriptor guide](../../../../docs/reference/codec-authoring-guide.md#target-owned-sql-codec-descriptors); do not inject separate generic and PostgreSQL lookups.
+
 ### Runtime
 
 ```typescript

package/dist/{adapter-CZfCp5TH.mjs → adapter-CyErVYXZ.mjs}

@@ -1,4 +1,4 @@
-import { i as adapterError, n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-BXXNf5j0.mjs";
+import { a as createPostgresCodecRegistryWithBuiltins, n as renderLoweredSql, o as adapterError, t as PostgresControlAdapter } from "./control-adapter-DyFEWery.mjs";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 import { isDdlNode } from "@prisma-next/sql-relational-core/ast";
 //#region src/core/adapter.ts
@@ -23,12 +23,12 @@ var PostgresAdapterImpl = class {
 	familyId = "sql";
 	targetId = "postgres";
 	profile;
-	codecLookup;
-	constructor(options) {
-		this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();
-		const controlAdapter = new PostgresControlAdapter(this.codecLookup);
+	codecRegistry;
+	constructor(codecRegistry, profileId) {
+		this.codecRegistry = codecRegistry;
+		const controlAdapter = new PostgresControlAdapter(codecRegistry);
 		this.profile = Object.freeze({
-			id: options?.profileId ?? "postgres/default@1",
+			id: profileId ?? "postgres/default@1",
 			target: "postgres",
 			capabilities: defaultCapabilities,
 			readMarker: (queryable) => controlAdapter.readMarkerDiscriminated({
@@ -43,7 +43,7 @@ var PostgresAdapterImpl = class {
 	}
 	lower(ast, context) {
 		if (isDdlNode(ast)) throw adapterError("RUNTIME.DDL_UNSUPPORTED", "lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.", { meta: { surface: "runtime-adapter" } });
-		return renderLoweredSql(ast, context.contract, this.codecLookup);
+		return renderLoweredSql(ast, context.contract, this.codecRegistry);
 	}
 };
 /** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */
@@ -58,9 +58,13 @@ const postgresRawCodecInferer = { inferCodec(value) {
 	throw adapterError("RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION", "unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec", { meta: { valueType: typeof value } });
 } };
 function createPostgresAdapter(options) {
-	return Object.freeze(new PostgresAdapterImpl(options));
+	const codecRegistry = createPostgresCodecRegistryWithBuiltins(options?.codecDescriptors);
+	return Object.freeze(new PostgresAdapterImpl(codecRegistry, options?.profileId));
+}
+function createPostgresAdapterWithCodecRegistry(codecRegistry) {
+	return Object.freeze(new PostgresAdapterImpl(codecRegistry));
 }
 //#endregion
-export { postgresRawCodecInferer as n, createPostgresAdapter as t };
+export { createPostgresAdapterWithCodecRegistry as n, postgresRawCodecInferer as r, createPostgresAdapter as t };
 
-//# sourceMappingURL=adapter-CZfCp5TH.mjs.map
+//# sourceMappingURL=adapter-CyErVYXZ.mjs.map

package/dist/adapter-CyErVYXZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-CyErVYXZ.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { adapterError } from './adapter-errors';\nimport { createPostgresCodecRegistryWithBuiltins } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type {\n  PostgresAdapterOptions,\n  PostgresCodecRegistry,\n  PostgresContract,\n  PostgresLoweredStatement,\n} from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n    distinctOn: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n    lateral: true,\n    scalarList: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecRegistry: PostgresCodecRegistry;\n\n  constructor(codecRegistry: PostgresCodecRegistry, profileId?: string) {\n    this.codecRegistry = codecRegistry;\n    const controlAdapter = new PostgresControlAdapter(codecRegistry);\n    this.profile = Object.freeze({\n      id: profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      throw adapterError(\n        'RUNTIME.DDL_UNSUPPORTED',\n        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',\n        { meta: { surface: 'runtime-adapter' } },\n      );\n    }\n    return renderLoweredSql(ast, context.contract, this.codecRegistry);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw adapterError(\n      'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n      { meta: { valueType: typeof value } },\n    );\n  },\n};\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  const codecRegistry = createPostgresCodecRegistryWithBuiltins(options?.codecDescriptors);\n  return Object.freeze(new PostgresAdapterImpl(codecRegistry, options?.profileId));\n}\n\nexport function createPostgresAdapterWithCodecRegistry(codecRegistry: PostgresCodecRegistry) {\n  return Object.freeze(new PostgresAdapterImpl(codecRegistry));\n}\n"],"mappings":";;;;AAuBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;EACT,YAAY;CACd;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,eAAsC,WAAoB;EACpE,KAAK,gBAAgB;EACrB,MAAM,iBAAiB,IAAI,uBAAuB,aAAa;EAC/D,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,aAAa;GACjB,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,MAAM,aACJ,2BACA,+HACA,EAAE,MAAM,EAAE,SAAS,kBAAkB,EAAE,CACzC;EAEF,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,aAAa;CACnE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,aACJ,6CACA,+GACA,EAAE,MAAM,EAAE,WAAW,OAAO,MAAM,EAAE,CACtC;AACF,EACF;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,MAAM,gBAAgB,wCAAwC,SAAS,gBAAgB;CACvF,OAAO,OAAO,OAAO,IAAI,oBAAoB,eAAe,SAAS,SAAS,CAAC;AACjF;AAEA,SAAgB,uCAAuC,eAAsC;CAC3F,OAAO,OAAO,OAAO,IAAI,oBAAoB,aAAa,CAAC;AAC7D"}

package/dist/adapter.d.mts

@@ -1,4 +1,4 @@
-import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-DyNEvnRB.mjs";
+import { c as PostgresCodecRegistry, l as PostgresContract, s as PostgresAdapterOptions, u as PostgresLoweredStatement } from "./types-BcBENDAr.mjs";
 import { Adapter, AdapterProfile, AnyQueryAst, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { RawCodecInferer } from "@prisma-next/sql-relational-core/expression";
 import { PostgresDdlNode } from "@prisma-next/target-postgres/ddl";
@@ -7,8 +7,8 @@ declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContra
   readonly familyId: "sql";
   readonly targetId: "postgres";
   readonly profile: AdapterProfile<'postgres'>;
-  private readonly codecLookup;
-  constructor(options?: PostgresAdapterOptions);
+  private readonly codecRegistry;
+  constructor(codecRegistry: PostgresCodecRegistry, profileId?: string);
   lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<PostgresContract>): PostgresLoweredStatement;
 }
 /** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;cAqCM,+BACO,QAAQ,aAAa,kBAAkB;WAGzC;WACA;WAEA,SAAS;mBACD;cAEL,UAAU;EA0BtB,MACE,KAAK,cAAc,iBACnB,SAAS,eAAe,oBACvB;;;cAaQ,yBAAyB;iBAsBtB,sBAAsB,UAAU,yBAAsB,SAAA"}
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;cAyCM,+BACO,QAAQ,aAAa,kBAAkB;WAGzC;WACA;WAEA,SAAS;mBACD;cAEL,eAAe,uBAAuB;EA0BlD,MACE,KAAK,cAAc,iBACnB,SAAS,eAAe,oBACvB;;;cAaQ,yBAAyB;iBAsBtB,sBAAsB,UAAU,yBAAsB,SAAA"}

package/dist/adapter.mjs

@@ -1,2 +1,2 @@
-import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CZfCp5TH.mjs";
+import { r as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CyErVYXZ.mjs";
 export { createPostgresAdapter, postgresRawCodecInferer };

package/dist/{control-adapter-BXXNf5j0.mjs → control-adapter-DyFEWery.mjs}

@@ -1,7 +1,8 @@
 import { APP_SPACE_ID, extractCodecLookup } from "@prisma-next/framework-components/control";
 import { LiteralExpr, RawExpr, collectOrderedParamRefs, isDdlNode } from "@prisma-next/sql-relational-core/ast";
 import { structuredError } from "@prisma-next/utils/structured-error";
-import { isPgEnumParams, postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
+import { buildPostgresCodecDescriptorRegistry } from "@prisma-next/target-postgres/codec-descriptor";
+import { isPgEnumParams, postgresCodecDescriptorRegistry, 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";
@@ -26,18 +27,31 @@ function adapterError(code, message, options) {
 }
 //#endregion
 //#region src/core/codec-lookup.ts
+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 {@link CodecRegistry} populated with the Postgres-builtin codec definitions only.
-*
-* This is the default registry used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived registry (e.g. from tests, or one-off scripts that don't compose a full stack).
+* Build a coherent PostgreSQL codec registry populated with built-in descriptors only.
 *
-* 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 registry at construction time.
+* 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 extractCodecLookup([{
-		id: "postgres-builtin-codecs",
-		types: { codecTypes: { codecDescriptors: Array.from(postgresCodecRegistry.values()) } }
-	}]);
+	return createPostgresCodecRegistryWithBuiltins();
 }
 //#endregion
 //#region ../../../1-framework/3-tooling/migration/dist/exports/ledger-origin.mjs
@@ -142,11 +156,11 @@ async function execute(lower, driver, query) {
 //#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.
+* 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 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.
+* 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",
@@ -168,25 +182,21 @@ const POSTGRES_INFERRABLE_NATIVE_TYPES = /* @__PURE__ */ new Set([
 	"bit",
 	"bit varying"
 ]);
-function renderTypedParam(index, codecId, codecLookup, many, typeParams) {
+function renderTypedParam(index, codecId, codecDescriptorRegistry, many, typeParams) {
 	if (codecId === void 0) return `$${index}`;
-	const meta = codecLookup.metaFor(codecId, typeParams);
-	if (!(codecLookup.get(codecId) !== void 0 || meta !== void 0 || codecLookup.targetTypesFor(codecId) !== void 0)) throw adapterError("RUNTIME.PARAM_REF_MISSING_CODEC", `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. \`extensions: [pgvectorRuntime]\`), or use the codec directly from \`@prisma-next/target-postgres/codecs\` if it's a builtin.`, { meta: { codecId } });
-	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") {
-		const arraySuffix = many ? "[]" : "";
-		if (isPgEnumParams(typeParams)) return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
-		if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}${arraySuffix}`;
-		if (many) return `$${index}::${nativeType}${arraySuffix}`;
-	}
+	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 \`@prisma-next/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 isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
 function unreachableKind(value) {
 	const candidate = value;
 	if (typeof candidate === "object" && candidate !== null && "kind" in candidate && typeof candidate.kind === "string") return candidate.kind;
@@ -197,7 +207,7 @@ function unreachableKind(value) {
 *
 * 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) {
+function renderLoweredSql(ast, contract, codecDescriptorRegistry) {
 	const orderedRefs = collectOrderedParamRefs(ast);
 	const indexMap = /* @__PURE__ */ new Map();
 	const params = orderedRefs.map((ref, i) => {
@@ -212,7 +222,7 @@ function renderLoweredSql(ast, contract, codecLookup) {
 	});
 	const pim = {
 		indexMap,
-		codecLookup
+		codecDescriptorRegistry
 	};
 	const node = ast;
 	let sql;
@@ -560,12 +570,12 @@ function renderExpr(expr, contract, pim) {
 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.codecLookup, ref.codec.many, ref.codec.typeParams);
+	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.codecLookup, ref.codec.many, ref.codec.typeParams);
+	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)}'`;
@@ -713,9 +723,9 @@ const POSTGRES_LEDGER_TABLE = "prisma_contract.ledger";
 * Provides target-specific implementations for control-plane domain actions.
 */
 var PostgresControlAdapter = class {
+	codecRegistry;
 	familyId = "sql";
 	targetId = "postgres";
-	codecRegistry;
 	constructor(codecRegistry) {
 		this.codecRegistry = codecRegistry;
 	}
@@ -1894,6 +1904,6 @@ async function pgRenderDdlExecuteRequest(ast, codecLookup) {
 	});
 }
 //#endregion
-export { adapterError as i, renderLoweredSql as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
+export { createPostgresCodecRegistryWithBuiltins as a, createPostgresBuiltinCodecLookup as i, renderLoweredSql as n, adapterError as o, assemblePostgresCodecRegistry as r, PostgresControlAdapter as t };
 
-//# sourceMappingURL=control-adapter-BXXNf5j0.mjs.map
+//# sourceMappingURL=control-adapter-DyFEWery.mjs.map