@prisma-next/adapter-postgres 0.16.0-dev.3 → 0.16.0-dev.31

package/dist/{adapter-BaZsfXGA.mjs → adapter-DlDJIHgB.mjs}

@@ -1,4 +1,4 @@
-import { n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-B6IM_oTR.mjs";
+import { i as adapterError, n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-DKbwTazN.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
@@ -42,7 +42,7 @@ var PostgresAdapterImpl = class {
 		});
 	}
 	lower(ast, context) {
-		if (isDdlNode(ast)) throw new Error("lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.");
+		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);
 	}
 };
@@ -55,7 +55,7 @@ const postgresRawCodecInferer = { inferCodec(value) {
 		case "boolean": return "pg/bool";
 		case "object": if (value instanceof Uint8Array) return "pg/bytea";
 	}
-	throw new Error("unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec");
+	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));
@@ -63,4 +63,4 @@ function createPostgresAdapter(options) {
 //#endregion
 export { postgresRawCodecInferer as n, createPostgresAdapter as t };
 
-//# sourceMappingURL=adapter-BaZsfXGA.mjs.map
+//# sourceMappingURL=adapter-DlDJIHgB.mjs.map

package/dist/adapter-DlDJIHgB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-DlDJIHgB.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecRegistry } from '@prisma-next/framework-components/codec';\nimport { 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 { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } 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 codecLookup: CodecRegistry;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.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.codecLookup);\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  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAmBA,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,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,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,WAAW;CACjE;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,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;cAoCM,+BACO,QAAQ,aAAa,kBAAkB;WAGzC;WACA;WAEA,SAAS;mBACD;cAEL,UAAU;EA0BtB,MACE,KAAK,cAAc,iBACnB,SAAS,eAAe,oBACvB;;;cAWQ,yBAAyB;iBAoBtB,sBAAsB,UAAU,yBAAsB,SAAA"}
+{"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"}

package/dist/adapter.mjs

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

package/dist/{control-adapter-B6IM_oTR.mjs → control-adapter-DKbwTazN.mjs}

@@ -1,22 +1,30 @@
 import { APP_SPACE_ID, extractCodecLookup } from "@prisma-next/framework-components/control";
 import { LiteralExpr, RawExpr, collectOrderedParamRefs, isDdlNode } from "@prisma-next/sql-relational-core/ast";
-import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
+import { structuredError } from "@prisma-next/utils/structured-error";
+import { isPgEnumParams, postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
 import { parseMarkerRowSafely, rethrowMarkerReadError, withMarkerReadErrorHandling } from "@prisma-next/errors/execution";
 import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
+import { parseWireName } from "@prisma-next/sql-schema-ir/naming";
 import { RelationalSchemaNodeKind } from "@prisma-next/sql-schema-ir/types";
 import { buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, int4, int8, jsonb, pgTable, text, textArray, timestamptz } from "@prisma-next/target-postgres/contract-free";
 import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
+import { postgresError } from "@prisma-next/target-postgres/errors";
 import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
-import { parseRlsPolicyWireName } from "@prisma-next/target-postgres/rls-canonicalize";
-import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { escapeLiteral, quoteIdentifier, quoteQualifiedName } from "@prisma-next/target-postgres/sql-utils";
 import { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresNativeEnumSchemaNode, PostgresPolicySchemaNode, PostgresRoleSchemaNode, PostgresSchemaNodeKind, PostgresTableSchemaNode } from "@prisma-next/target-postgres/types";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma-next/sql-runtime";
+import { InternalError, assertNever } from "@prisma-next/utils/internal-error";
 import { PG_TIMESTAMPTZ_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { runtimeError } from "@prisma-next/framework-components/runtime";
+//#region src/core/adapter-errors.ts
+function adapterError(code, message, options) {
+	return structuredError(code, message, options);
+}
+//#endregion
 //#region src/core/codec-lookup.ts
 /**
 * Build a {@link CodecRegistry} populated with the Postgres-builtin codec definitions only.
@@ -34,7 +42,7 @@ function createPostgresBuiltinCodecLookup() {
 //#endregion
 //#region ../../../1-framework/3-tooling/migration/dist/exports/ledger-origin.mjs
 function ledgerOriginFromStored(originCoreHash) {
-	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "sha256:empty") return null;
+	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "empty") return null;
 	return originCoreHash;
 }
 //#endregion
@@ -43,7 +51,7 @@ 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 Error(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+		throw new InternalError(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
 	}), deriveParamMetadata(ast), {}, codecs);
 }
 //#endregion
@@ -163,13 +171,14 @@ const POSTGRES_INFERRABLE_NATIVE_TYPES = /* @__PURE__ */ new Set([
 function renderTypedParam(index, codecId, codecLookup, 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 new Error(`Postgres lowering: ParamRef carries codecId "${codecId}" but the assembled codec lookup has no entry for it. This usually indicates a missing extension pack in the runtime stack — register the pack that contributes this codec (e.g. \`extensionPacks: [pgvectorRuntime]\`), or use the codec directly from \`@prisma-next/target-postgres/codecs\` if it's a builtin.`);
+	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}`;
 	}
@@ -178,6 +187,11 @@ function renderTypedParam(index, codecId, codecLookup, many, typeParams) {
 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;
+	return "unknown";
+}
 /**
 * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
 *
@@ -219,7 +233,7 @@ function renderLoweredSql(ast, contract, codecLookup) {
 			sql = renderRawSql(node, contract, pim);
 			break;
 		// v8 ignore next 4
-		default: throw new Error(`Unsupported AST node kind: ${node.kind}`);
+		default: assertNever(node, `Unsupported AST node kind: ${unreachableKind(node)}`);
 	}
 	return Object.freeze({
 		sql,
@@ -342,9 +356,17 @@ 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 new Error(`Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`);
+	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 new Error(`Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`);
+	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) {
@@ -359,15 +381,14 @@ function renderSource(source, contract, pim) {
 		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(", ");
-			const call = `${node.fn}(${args})`;
-			return node.alias !== void 0 ? `${call} AS ${quoteIdentifier(node.alias)}` : call;
+			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: throw new Error(`Unsupported source node kind: ${node.kind}`);
+		default: assertNever(node, `Unsupported source node kind: ${unreachableKind(node)}`);
 	}
 }
 function assertScalarSubquery(query) {
-	if (query.projection.length !== 1) throw new Error("Subquery expressions must project exactly one column");
+	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);
@@ -395,6 +416,9 @@ function isAtomicExpressionKind(kind) {
 		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;
@@ -469,11 +493,26 @@ function renderAggregateExpr(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 }) => renderExpr(value, contract, pim),
+		native: ({ value }) => renderExpr(value, contract, pim),
+		document: ({ value }) => renderExpr(value, contract, pim)
+	});
+}
 function renderJsonObjectExpr(expr, contract, pim) {
 	return `json_build_object(${expr.entries.flatMap((entry) => {
-		const key = `'${escapeLiteral(entry.key)}'`;
-		if (entry.value.kind === "literal") return [key, renderLiteral(entry.value)];
-		return [key, renderExpr(entry.value, contract, pim)];
+		return [`'${escapeLiteral(entry.key)}'`, renderJsonValueProjection(entry.value, contract, pim)];
 	}).join(", ")})`;
 }
 function renderOrderByItems(items, contract, pim) {
@@ -481,7 +520,7 @@ function renderOrderByItems(items, contract, pim) {
 }
 function renderJsonArrayAggExpr(expr, contract, pim) {
 	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : "";
-	const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+	const aggregated = `json_agg(${renderJsonValueProjection(expr.expr, contract, pim)}${aggregateOrderBy})`;
 	if (expr.onEmpty === "emptyArray") return `coalesce(${aggregated}, json_build_array())`;
 	return aggregated;
 }
@@ -494,6 +533,9 @@ function renderExpr(expr, 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);
@@ -512,12 +554,12 @@ function renderExpr(expr, contract, pim) {
 		case "list": return renderListLiteral(node, contract, pim);
 		case "raw-expr": return renderRawExpr(node, contract, pim);
 		// v8 ignore next 4
-		default: throw new Error(`Unsupported expression node kind: ${node.kind}`);
+		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 Error("ParamRef not found in index map");
+	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.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,
@@ -545,7 +587,7 @@ function renderOperation(expr, contract, pim) {
 	return expr.lowering.template.replace(/\{\{self\}\}|\{\{arg(\d+)\}\}/g, (token, argIndex) => {
 		if (token === "{{self}}") return self;
 		const arg = args[Number(argIndex)];
-		if (arg === void 0) throw new Error(`Operation lowering template for "${expr.method}" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`);
+		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;
 	});
 }
@@ -578,7 +620,10 @@ function getInsertColumnOrder(rows, contract, tableRef) {
 			break;
 		}
 	}
-	if (!table) throw new Error(`INSERT target table not found in contract storage: ${tableName}`);
+	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) {
@@ -589,13 +634,13 @@ function renderInsertValue(value, contract, pim) {
 		case "column-ref": return renderColumn(value);
 		case "raw-expr": return renderExpr(value, contract, pim);
 		// v8 ignore next 4
-		default: throw new Error(`Unsupported value node in INSERT: ${value.kind}`);
+		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 new Error("INSERT requires at least one row");
+	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) {
@@ -614,27 +659,27 @@ function renderInsert(ast, contract, pim) {
 		return `INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values}`;
 	})()}${ast.onConflict ? (() => {
 		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
-		if (conflictColumns.length === 0) throw new Error("INSERT onConflict requires at least one conflict column");
+		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 new Error("INSERT onConflict do-update-set requires at least one assignment");
+				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: throw new Error(`Unsupported onConflict action: ${action.kind}`);
+			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 new Error("UPDATE requires at least one SET assignment");
+	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)}`;
 	});
@@ -700,7 +745,7 @@ var PostgresControlAdapter = class {
 	* without instantiating the runtime adapter.
 	*/
 	lower(ast, context) {
-		if (isDdlNode(ast)) throw new Error("lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().");
+		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);
 	}
 	/**
@@ -1087,7 +1132,9 @@ var PostgresControlAdapter = class {
            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
@@ -1215,41 +1262,50 @@ var PostgresControlAdapter = class {
 				dependsOn: postgresColumnDependsOn(schema, tableName, uq.columns)
 			}));
 			const indexesMap = /* @__PURE__ */ new Map();
-			const indexNamesWithExpressionKey = /* @__PURE__ */ new Set();
 			for (const idxRow of indexesByTable.get(tableName) ?? []) {
-				if (!idxRow.attname) {
-					indexNamesWithExpressionKey.add(idxRow.indexname);
-					continue;
-				}
 				const existing = indexesMap.get(idxRow.indexname);
-				if (existing) existing.columns.push(idxRow.attname);
+				if (existing) existing.elements.push({
+					attname: idxRow.attname,
+					elementDef: idxRow.element_def
+				});
 				else {
 					const indexType = idxRow.amname && idxRow.amname !== "btree" ? idxRow.amname : void 0;
 					const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
 					indexesMap.set(idxRow.indexname, {
-						columns: [idxRow.attname],
 						name: idxRow.indexname,
+						elements: [{
+							attname: idxRow.attname,
+							elementDef: idxRow.element_def
+						}],
 						unique: idxRow.indisunique,
+						where: idxRow.where_predicate,
 						type: indexType,
 						options: indexOptions
 					});
 				}
 			}
-			const survivingIndexes = Array.from(indexesMap.values()).filter((idx) => !indexNamesWithExpressionKey.has(idx.name));
-			const bestByColumnTuple = /* @__PURE__ */ new Map();
-			for (const idx of survivingIndexes) {
-				const tupleKey = idx.columns.join(",");
-				const existing = bestByColumnTuple.get(tupleKey);
-				if (!existing || idx.unique && !existing.unique || idx.unique === existing.unique && idx.name < existing.name) bestByColumnTuple.set(tupleKey, idx);
-			}
-			const indexes = Array.from(bestByColumnTuple.values()).map((idx) => ({
-				columns: Object.freeze([...idx.columns]),
-				name: idx.name,
-				unique: idx.unique,
-				...idx.type !== void 0 && { type: idx.type },
-				...idx.options !== void 0 && { options: idx.options },
-				dependsOn: postgresColumnDependsOn(schema, tableName, idx.columns)
-			}));
+			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 = {
+					name: idx.name,
+					prefix: parseWireName(idx.name)?.prefix,
+					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);
@@ -1290,7 +1346,7 @@ var PostgresControlAdapter = class {
 			const operation = mapPgCmd(row.cmd);
 			const policyRoles = [...new Set(parsePgNameArray(row.roles).map((r) => r.toLowerCase()))].sort();
 			const permissive = row.permissive.toUpperCase() === "PERMISSIVE";
-			const prefix = parseRlsPolicyWireName(row.policyname)?.prefix ?? row.policyname;
+			const prefix = parseWireName(row.policyname)?.prefix ?? row.policyname;
 			const policy = new PostgresPolicySchemaNode({
 				name: row.policyname,
 				prefix,
@@ -1462,7 +1518,7 @@ const PG_REFERENTIAL_ACTION_MAP = {
 */
 function mapReferentialAction(rule) {
 	const mapped = PG_REFERENTIAL_ACTION_MAP[rule];
-	if (mapped === void 0) throw new Error(`Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`);
+	if (mapped === 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;
 }
@@ -1529,7 +1585,10 @@ function parsePgReloptions(reloptions, indexName) {
 	const result = {};
 	for (const entry of reloptions) {
 		const eq = entry.indexOf("=");
-		if (eq === -1) throw new Error(`Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`);
+		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);
 	}
@@ -1634,12 +1693,12 @@ 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 new Error(`pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`);
+		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 new Error(`pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`);
+		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}`;
 	}
@@ -1650,7 +1709,10 @@ function pgInlineLiteral(wire, 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 new Error(`pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${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") {
@@ -1768,6 +1830,47 @@ function pgRenderAlterPolicyRename(node) {
 		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`,
@@ -1784,10 +1887,13 @@ async function pgRenderDdlExecuteRequest(ast, 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 { renderLoweredSql as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
+export { adapterError as i, renderLoweredSql as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
 
-//# sourceMappingURL=control-adapter-B6IM_oTR.mjs.map
+//# sourceMappingURL=control-adapter-DKbwTazN.mjs.map