@prisma-next/adapter-postgres 0.5.0-dev.30 → 0.5.0-dev.41

package/README.md

@@ -131,10 +131,13 @@ flowchart TD
 - Exports column descriptors for built-in types and enum helpers (`enumType`, `enumColumn(typeRef, nativeType)`)
 - Parameterized helpers: `charColumn(length)`, `varcharColumn(length)`, `numericColumn(precision, scale?)`, `bitColumn(length)`, `varbitColumn(length)`, `timeColumn(precision?)`, `timetzColumn(precision?)`, `intervalColumn(precision?)`
 
-- Exports JSON helpers:
-  - `jsonColumn`, `jsonbColumn`
-  - `json(schema?)`, `jsonb(schema?)` where `schema` is a Standard Schema value (e.g., Arktype)
-  - When a schema is provided, `typeParams` metadata is derived from the schema's `~standard` interface
+- Exports raw JSON helpers:
+  - `jsonColumn`, `jsonbColumn` — untyped raw JSON / JSONB column descriptors
+  - For schema-typed JSON columns, use the per-library extension package
+    (`@prisma-next/extension-arktype-json` for arktype). The
+    schema-accepting `json(schema)` / `jsonb(schema)` overloads
+    previously shipped here retired in Phase C of the
+    codec-registry-unification project.
 
 ## Dependencies
 
@@ -156,7 +159,7 @@ flowchart TD
 - [ADR 068 - Error mapping to RuntimeError](../../../../docs/architecture%20docs/adrs/ADR%20068%20-%20Error%20mapping%20to%20RuntimeError.md)
 - [ADR 112 - Target Extension Packs](../../../../docs/architecture%20docs/adrs/ADR%20112%20-%20Target%20Extension%20Packs.md)
 - [ADR 114 - Extension codecs & branded types](../../../../docs/architecture%20docs/adrs/ADR%20114%20-%20Extension%20codecs%20&%20branded%20types.md)
-- [ADR 163 - Postgres JSON and JSONB typed columns](../../../../docs/architecture%20docs/adrs/ADR%20163%20-%20Postgres%20JSON%20and%20JSONB%20typed%20columns.md)
+- [ADR 168 - Postgres JSON and JSONB typed columns](../../../../docs/architecture%20docs/adrs/ADR%20168%20-%20Postgres%20JSON%20and%20JSONB%20typed%20columns.md). Schema-typed JSON columns now ship from per-library extension packages (`@prisma-next/extension-arktype-json` for arktype); see [ADR 208 - Higher-order codecs for parameterized types](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md).
 
 ## Usage
 
@@ -277,7 +280,8 @@ Both `json` and `jsonb` accept any valid JSON value:
 ### Authoring helpers
 
 ```typescript
-import { json, jsonb } from '@prisma-next/adapter-postgres/column-types';
+import { jsonbColumn } from '@prisma-next/adapter-postgres/column-types';
+import { arktypeJson } from '@prisma-next/extension-arktype-json/column-types';
 import { type as arktype } from 'arktype';
 
 const auditPayloadSchema = arktype({
@@ -287,26 +291,28 @@ const auditPayloadSchema = arktype({
 
 table('event', (t) =>
   t
-    .column('payload', { type: jsonb(auditPayloadSchema), nullable: false })
-    .column('raw', { type: json(), nullable: true }),
+    // Schema-typed JSONB via the per-library extension package.
+    .column('payload', { type: arktypeJson(auditPayloadSchema), nullable: false })
+    // Untyped raw JSONB via the adapter's static descriptor.
+    .column('raw', { type: jsonbColumn, nullable: true }),
 );
 ```
 
 ### Typed fallback behavior
 
-- If a schema value is provided, emitted `contract.d.ts` derives a concrete type from that schema.
-- If no schema is provided, emitted type falls back to `JsonValue`.
+- For schema-typed columns, use a per-library extension package
+  (e.g. `@prisma-next/extension-arktype-json`). The emit-path renderer
+  reads the schema's `expression` from typeParams and produces a concrete
+  TS type in `contract.d.ts`.
+- For untyped columns (`jsonColumn`, `jsonbColumn`), the emitted type
+  falls back to `JsonValue`.
 - Runtime values still encode/decode as JSON-compatible values.
 
-### Standard Schema integration
-
-`json(schema)` and `jsonb(schema)` accept Standard Schema values. Arktype schemas work out of the box via their Standard Schema adapter (`schema['~standard']`).
-
 ## Exports
 
 - `./adapter`: Adapter implementation (`createPostgresAdapter`)
 - `./codec-types`: PostgreSQL codec types (`CodecTypes`, `JsonValue`, `dataTypes`)
-- `./column-types`: Column type descriptors and authoring helpers (`json`, `jsonb`, `jsonColumn`, `jsonbColumn`, `enumType`, `enumColumn`, `textColumn`, `int4Column`, etc.)
+- `./column-types`: Column type descriptors and authoring helpers (`jsonColumn`, `jsonbColumn`, `enumType`, `enumColumn`, `textColumn`, `int4Column`, etc.)
 - `./types`: PostgreSQL-specific types
 - `./control`: Control-plane entry point (adapter descriptor)
 - `./runtime`: Runtime-plane entry point (runtime adapter descriptor)

package/dist/column-types.d.mts

@@ -1,27 +1,8 @@
 import { StorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { ColumnTypeDescriptor } from "@prisma-next/contract-authoring";
 
-//#region src/core/standard-schema.d.ts
-type StandardSchemaJsonSchemaField = {
-  readonly output?: unknown;
-};
-/**
- * Runtime view of the Standard Schema protocol.
- * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,
- * and `.expression` for an optional TypeScript type expression string (Arktype-specific).
- *
- * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads
- * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.
- */
-type StandardSchemaLike = {
-  readonly '~standard'?: {
-    readonly version?: number;
-    readonly jsonSchema?: StandardSchemaJsonSchemaField;
-  };
-  readonly expression?: unknown;
-};
-//#endregion
 //#region src/exports/column-types.d.ts
+
 declare const textColumn: {
   readonly codecId: "pg/text@1";
   readonly nativeType: "text";
@@ -99,16 +80,27 @@ declare function intervalColumn(precision?: number): ColumnTypeDescriptor & {
     readonly precision: number;
   };
 };
+/**
+ * Postgres `json` column descriptor — untyped raw JSON.
+ *
+ * For schema-typed JSON columns, use the per-library extension package
+ * (`@prisma-next/extension-arktype-json` ships `arktypeJson(schema)` for
+ * arktype). The schema-accepting `json(schema)` / `jsonb(schema)`
+ * overloads previously shipped from this module retired in Phase C of
+ * the codec-registry-unification project — see spec § AC-7.
+ */
 declare const jsonColumn: {
   readonly codecId: "pg/json@1";
   readonly nativeType: "json";
 };
+/**
+ * Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement
+ * note as {@link jsonColumn}.
+ */
 declare const jsonbColumn: {
   readonly codecId: "pg/jsonb@1";
   readonly nativeType: "jsonb";
 };
-declare function json(schema?: StandardSchemaLike): ColumnTypeDescriptor;
-declare function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor;
 declare function enumType<const Values extends readonly string[]>(name: string, values: Values): StorageTypeInstance & {
   readonly typeParams: {
     readonly values: Values;
@@ -118,5 +110,5 @@ declare function enumColumn<TypeName extends string>(typeName: TypeName, nativeT
   readonly typeRef: TypeName;
 };
 //#endregion
-export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, json, jsonColumn, jsonb, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
+export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, jsonColumn, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
 //# sourceMappingURL=column-types.d.mts.map

package/dist/column-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;KAEK,6BAAA;;;AAFsB;AAc3B;;;;ACwBA;AAKA;AAUA;AAUa,KDjDD,kBAAA,GCoD6B;EAE5B,SAAA,WAG4B,CAAA,EAAA;IAE5B,SAG4B,OAAA,CAAA,EAAA,MAAA;IAE5B,SAAA,UAG4B,CAAA,EDhEf,6BCgEe;EAE5B,CAAA;EAKG,SAAA,UAAa,CAAA,EAAA,OAG1B;AAUH,CAAA;;;AA/Da,cAAA,UAG4B,EAAA;EAEzB,SAAA,OAAU,EAAA,WAAkB;EAU5B,SAAA,UAAa,EAAA,MAAkB;AAU/C,CAAA;AAKa,iBAzBG,UAAA,CA4ByB,MAAA,EAAA,MAAA,CAAA,EA5BG,oBA4BH,GAAA;EAE5B,SAAA,UAG4B,EAAA;IAE5B,SAAA,MAG4B,EAAA,MAAA;EAE5B,CAAA;AAKb,CAAA;AAaa,iBAhDG,aAAA,CAmDyB,MAAA,EAAA,MAAA,CAAA,EAnDM,oBAmDN,GAAA;EAE5B,SAAA,UAAA,EAG4B;IAEzB,SAAU,MAAA,EAAA,MAAsB;EAUhC,CAAA;AAUhB,CAAA;AAKgB,cAzEH,UAyE8B,EAAA;EAU3B,SAAA,OAAY,EAAA,WAAkB;EAU9B,SAAA,UAAc,EAAA,MAAA;AAU9B,CAAA;AAKa,cAvGA,UA0G4B,EAAA;EA8CzB,SAAI,OAAA,EAAA,WAAU;EAId,SAAK,UAAA,EAAU,MAAA;AAI/B,CAAA;AAEU,cA7JG,UA6JH,EAAA;EACP,SAAA,OAAA,EAAA,WAAA;EAAgE,SAAA,UAAA,EAAA,MAAA;CAAM;AAQzD,cAjKH,YAiKa,EAAA;EACd,SAAA,OAAA,EAAA,aAAA;EAET,SAAA,UAAA,EAAA,QAAA;CAA2C;AAAQ,cA/JzC,YA+JyC,EAAA;;;;iBA1JtC,aAAA,qCAGb;;;;;;cAUU;;;;cAKA;;;;iBAKG,UAAA,sBAAgC;;;;;iBAUhC,YAAA,sBAAkC;;;;;cAUrC;;;;iBAKG,SAAA,kBAA2B;;;;;iBAU3B,YAAA,kBAA8B;;;;;iBAU9B,cAAA,sBAAoC;;;;;cAUvC;;;;cAKA;;;;iBAiDG,IAAA,UAAc,qBAAqB;iBAInC,KAAA,UAAe,qBAAqB;iBAIpC,uEAEN,SACP;;qBAAgE;;;iBAQnD,8CACJ,+BAET;oBAA2C"}
+{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;;AA8Da,cA9BA,UAiC4B,EAAA;EAE5B,SAAA,OAG4B,EAAA,WAAA;EAE5B,SAAA,UAG4B,EAAA,MAAA;AAEzC,CAAA;AAKgB,iBA7CA,UAAA,CAgDb,MAAA,EAAA,MAAA,CAAA,EAhDyC,oBAgDrB,GAAA;EAUV,SAAA,UAG4B,EAAA;IAE5B,SAAA,MAAA,EAG4B,MAAA;EAEzB,CAAA;AAUhB,CAAA;AAUa,iBA9EG,aAAA,CAiFyB,MAAA,EAAA,MAAA,CAAA,EAjFM,oBAiFN,GAAA;EAEzB,SAAA,UAAS,EAAA;IAUT,SAAA,MAAY,EAAA,MAAkB;EAU9B,CAAA;AAmBhB,CAAA;AASa,cAzHA,UA4H4B,EAAA;EAEzB,SAAA,OAAQ,EAAA,WAAA;EAEd,SAAA,UAAA,EAAA,MAAA;CACP;AAAgE,cA5HtD,UA4HsD,EAAA;EAAM,SAAA,OAAA,EAAA,WAAA;EAQzD,SAAA,UAAU,EAAA,MAAA;CACd;AAET,cAlIU,UAkIV,EAAA;EAA2C,SAAA,OAAA,EAAA,WAAA;EAAQ,SAAA,UAAA,EAAA,MAAA;;cA7HzC;;;;cAKA;;;;iBAKG,aAAA,qCAGb;;;;;;cAUU;;;;cAKA;;;;iBAKG,UAAA,sBAAgC;;;;;iBAUhC,YAAA,sBAAkC;;;;;cAUrC;;;;iBAKG,SAAA,kBAA2B;;;;;iBAU3B,YAAA,kBAA8B;;;;;iBAU9B,cAAA,sBAAoC;;;;;;;;;;;;;;cAmBvC;;;;;;;;cASA;;;;iBAKG,uEAEN,SACP;;qBAAgE;;;iBAQnD,8CACJ,+BAET;oBAA2C"}

package/dist/column-types.mjs

@@ -1,32 +1,5 @@
 import { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_ENUM_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_VARBIT_CODEC_ID, SQL_CHAR_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 
-//#region src/core/standard-schema.ts
-function isObjectLike(value) {
-	return (typeof value === "object" || typeof value === "function") && value !== null;
-}
-function resolveOutputJsonSchemaField(schema) {
-	const jsonSchema = schema["~standard"]?.jsonSchema;
-	if (!jsonSchema) return;
-	if (typeof jsonSchema.output === "function") return jsonSchema.output({ target: "draft-07" });
-	return jsonSchema.output;
-}
-function extractStandardSchemaOutputJsonSchema(schema) {
-	const outputSchema = resolveOutputJsonSchemaField(schema);
-	if (!isObjectLike(outputSchema)) return;
-	return outputSchema;
-}
-function extractStandardSchemaTypeExpression(schema) {
-	const expression = schema.expression;
-	if (typeof expression !== "string") return;
-	const trimmedExpression = expression.trim();
-	if (trimmedExpression.length === 0) return;
-	return trimmedExpression;
-}
-function isStandardSchemaLike(value) {
-	return isObjectLike(value) && isObjectLike(value["~standard"]);
-}
-
-//#endregion
 //#region src/exports/column-types.ts
 const textColumn = {
 	codecId: PG_TEXT_CODEC_ID,
@@ -123,43 +96,27 @@ function intervalColumn(precision) {
 		...precision === void 0 ? {} : { typeParams: { precision } }
 	};
 }
+/**
+* Postgres `json` column descriptor — untyped raw JSON.
+*
+* For schema-typed JSON columns, use the per-library extension package
+* (`@prisma-next/extension-arktype-json` ships `arktypeJson(schema)` for
+* arktype). The schema-accepting `json(schema)` / `jsonb(schema)`
+* overloads previously shipped from this module retired in Phase C of
+* the codec-registry-unification project — see spec § AC-7.
+*/
 const jsonColumn = {
 	codecId: PG_JSON_CODEC_ID,
 	nativeType: "json"
 };
+/**
+* Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement
+* note as {@link jsonColumn}.
+*/
 const jsonbColumn = {
 	codecId: PG_JSONB_CODEC_ID,
 	nativeType: "jsonb"
 };
-function createJsonTypeParams(schema) {
-	const outputSchema = extractStandardSchemaOutputJsonSchema(schema);
-	if (!outputSchema) throw new Error("JSON schema must expose ~standard.jsonSchema.output()");
-	const expression = extractStandardSchemaTypeExpression(schema);
-	if (expression) return {
-		schemaJson: outputSchema,
-		type: expression
-	};
-	return { schemaJson: outputSchema };
-}
-function createJsonColumnFactory(codecId, nativeType, staticDescriptor) {
-	return (schema) => {
-		if (!schema) return staticDescriptor;
-		if (!isStandardSchemaLike(schema)) throw new Error(`${nativeType}(schema) expects a Standard Schema value`);
-		return {
-			codecId,
-			nativeType,
-			typeParams: createJsonTypeParams(schema)
-		};
-	};
-}
-const _json = createJsonColumnFactory(PG_JSON_CODEC_ID, "json", jsonColumn);
-const _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, "jsonb", jsonbColumn);
-function json(schema) {
-	return _json(schema);
-}
-function jsonb(schema) {
-	return _jsonb(schema);
-}
 function enumType(name, values) {
 	return {
 		codecId: PG_ENUM_CODEC_ID,
@@ -176,5 +133,5 @@ function enumColumn(typeName, nativeType) {
 }
 
 //#endregion
-export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, json, jsonColumn, jsonb, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
+export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, jsonColumn, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
 //# sourceMappingURL=column-types.mjs.map

package/dist/column-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":["type UnknownRecord = Record<string, unknown>;\n\ntype StandardSchemaJsonSchemaField = {\n  readonly output?: unknown;\n};\n\n/**\n * Runtime view of the Standard Schema protocol.\n * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,\n * and `.expression` for an optional TypeScript type expression string (Arktype-specific).\n *\n * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads\n * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.\n */\nexport type StandardSchemaLike = {\n  readonly '~standard'?: {\n    readonly version?: number;\n    readonly jsonSchema?: StandardSchemaJsonSchemaField;\n  };\n  readonly expression?: unknown;\n};\n\nfunction isObjectLike(value: unknown): value is UnknownRecord {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null;\n}\n\nfunction resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {\n  const jsonSchema = schema['~standard']?.jsonSchema;\n  if (!jsonSchema) {\n    return undefined;\n  }\n\n  if (typeof jsonSchema.output === 'function') {\n    return jsonSchema.output({\n      target: 'draft-07',\n    });\n  }\n\n  return jsonSchema.output;\n}\n\nexport function extractStandardSchemaOutputJsonSchema(\n  schema: StandardSchemaLike,\n): UnknownRecord | undefined {\n  const outputSchema = resolveOutputJsonSchemaField(schema);\n  if (!isObjectLike(outputSchema)) {\n    return undefined;\n  }\n\n  return outputSchema;\n}\n\nexport function extractStandardSchemaTypeExpression(\n  schema: StandardSchemaLike,\n): string | undefined {\n  const expression = schema.expression;\n  if (typeof expression !== 'string') {\n    return undefined;\n  }\n\n  const trimmedExpression = expression.trim();\n  if (trimmedExpression.length === 0) {\n    return undefined;\n  }\n\n  return trimmedExpression;\n}\n\nexport function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {\n  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);\n}\n","/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\nimport {\n  extractStandardSchemaOutputJsonSchema,\n  extractStandardSchemaTypeExpression,\n  isStandardSchemaLike,\n  type StandardSchemaLike,\n} from '../core/standard-schema';\n\nexport const textColumn = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int2Column = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int8Column = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float4Column = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float8Column = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const timestamptzColumn = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const jsonColumn = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const jsonbColumn = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const satisfies ColumnTypeDescriptor;\n\ntype JsonSchemaTypeParams = {\n  readonly schemaJson: Record<string, unknown>;\n  readonly type?: string;\n};\n\nfunction createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {\n  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);\n  if (!outputSchema) {\n    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');\n  }\n\n  const expression = extractStandardSchemaTypeExpression(schema);\n  if (expression) {\n    return { schemaJson: outputSchema, type: expression };\n  }\n\n  return { schemaJson: outputSchema };\n}\n\nfunction createJsonColumnFactory(\n  codecId: string,\n  nativeType: string,\n  staticDescriptor: ColumnTypeDescriptor,\n) {\n  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {\n    if (!schema) {\n      return staticDescriptor;\n    }\n\n    if (!isStandardSchemaLike(schema)) {\n      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);\n    }\n\n    return {\n      codecId,\n      nativeType,\n      typeParams: createJsonTypeParams(schema),\n    };\n  };\n}\n\nconst _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);\nconst _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);\n\nexport function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _json(schema);\n}\n\nexport function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _jsonb(schema);\n}\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":";;;AAsBA,SAAS,aAAa,OAAwC;AAC5D,SAAQ,OAAO,UAAU,YAAY,OAAO,UAAU,eAAe,UAAU;;AAGjF,SAAS,6BAA6B,QAAqC;CACzE,MAAM,aAAa,OAAO,cAAc;AACxC,KAAI,CAAC,WACH;AAGF,KAAI,OAAO,WAAW,WAAW,WAC/B,QAAO,WAAW,OAAO,EACvB,QAAQ,YACT,CAAC;AAGJ,QAAO,WAAW;;AAGpB,SAAgB,sCACd,QAC2B;CAC3B,MAAM,eAAe,6BAA6B,OAAO;AACzD,KAAI,CAAC,aAAa,aAAa,CAC7B;AAGF,QAAO;;AAGT,SAAgB,oCACd,QACoB;CACpB,MAAM,aAAa,OAAO;AAC1B,KAAI,OAAO,eAAe,SACxB;CAGF,MAAM,oBAAoB,WAAW,MAAM;AAC3C,KAAI,kBAAkB,WAAW,EAC/B;AAGF,QAAO;;AAGT,SAAgB,qBAAqB,OAA6C;AAChF,QAAO,aAAa,MAAM,IAAI,aAAc,MAA6B,aAAa;;;;;AC/BxF,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,SAAgB,WAAW,QAEzB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,cAAc,QAE5B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;AAED,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;AAED,SAAgB,cACd,WACA,OAGA;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,UAAU,SAAY,EAAE,WAAW,GAAG;GAAE;GAAW;GAAO;EACvE;;AAGH,MAAa,kBAAkB;CAC7B,SAAS;CACT,YAAY;CACb;AAED,MAAa,oBAAoB;CAC/B,SAAS;CACT,YAAY;CACb;AAED,SAAgB,WAAW,WAEzB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;AAGH,SAAgB,aAAa,WAE3B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;AAGH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,SAAgB,UAAU,QAExB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,aAAa,QAE3B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,eAAe,WAE7B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;AAGH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,cAAc;CACzB,SAAS;CACT,YAAY;CACb;AAOD,SAAS,qBAAqB,QAAkD;CAC9E,MAAM,eAAe,sCAAsC,OAAO;AAClE,KAAI,CAAC,aACH,OAAM,IAAI,MAAM,wDAAwD;CAG1E,MAAM,aAAa,oCAAoC,OAAO;AAC9D,KAAI,WACF,QAAO;EAAE,YAAY;EAAc,MAAM;EAAY;AAGvD,QAAO,EAAE,YAAY,cAAc;;AAGrC,SAAS,wBACP,SACA,YACA,kBACA;AACA,SAAQ,WAAsD;AAC5D,MAAI,CAAC,OACH,QAAO;AAGT,MAAI,CAAC,qBAAqB,OAAO,CAC/B,OAAM,IAAI,MAAM,GAAG,WAAW,0CAA0C;AAG1E,SAAO;GACL;GACA;GACA,YAAY,qBAAqB,OAAO;GACzC;;;AAIL,MAAM,QAAQ,wBAAwB,kBAAkB,QAAQ,WAAW;AAC3E,MAAM,SAAS,wBAAwB,mBAAmB,SAAS,YAAY;AAE/E,SAAgB,KAAK,QAAmD;AACtE,QAAO,MAAM,OAAO;;AAGtB,SAAgB,MAAM,QAAmD;AACvE,QAAO,OAAO,OAAO;;AAGvB,SAAgB,SACd,MACA,QAC4E;AAC5E,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,WACd,UACA,YACuD;AACvD,QAAO;EACL,SAAS;EACT;EACA,SAAS;EACV"}
+{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/exports/column-types.ts"],"sourcesContent":["/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\n\nexport const textColumn = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int2Column = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int8Column = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float4Column = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float8Column = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const timestamptzColumn = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\n/**\n * Postgres `json` column descriptor — untyped raw JSON.\n *\n * For schema-typed JSON columns, use the per-library extension package\n * (`@prisma-next/extension-arktype-json` ships `arktypeJson(schema)` for\n * arktype). The schema-accepting `json(schema)` / `jsonb(schema)`\n * overloads previously shipped from this module retired in Phase C of\n * the codec-registry-unification project — see spec § AC-7.\n */\nexport const jsonColumn = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const satisfies ColumnTypeDescriptor;\n\n/**\n * Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement\n * note as {@link jsonColumn}.\n */\nexport const jsonbColumn = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":";;;AAgCA,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,SAAgB,WAAW,QAEzB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,cAAc,QAE5B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;AAED,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;AAED,SAAgB,cACd,WACA,OAGA;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,UAAU,SAAY,EAAE,WAAW,GAAG;GAAE;GAAW;GAAO;EACvE;;AAGH,MAAa,kBAAkB;CAC7B,SAAS;CACT,YAAY;CACb;AAED,MAAa,oBAAoB;CAC/B,SAAS;CACT,YAAY;CACb;AAED,SAAgB,WAAW,WAEzB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;AAGH,SAAgB,aAAa,WAE3B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;AAGH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;AAED,SAAgB,UAAU,QAExB;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,aAAa,QAE3B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,eAAe,WAE7B;AACA,QAAO;EACL,SAAS;EACT,YAAY;EACZ,GAAI,cAAc,SAAY,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE;EACjE;;;;;;;;;;;AAYH,MAAa,aAAa;CACxB,SAAS;CACT,YAAY;CACb;;;;;AAMD,MAAa,cAAc;CACzB,SAAS;CACT,YAAY;CACb;AAED,SAAgB,SACd,MACA,QAC4E;AAC5E,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB;;AAGH,SAAgB,WACd,UACA,YACuD;AACvD,QAAO;EACL,SAAS;EACT;EACA,SAAS;EACV"}

package/dist/runtime.d.mts

@@ -2,18 +2,10 @@ import { c as PostgresContract, l as PostgresLoweredStatement } from "./types-tL
 import { Adapter, AnyQueryAst } from "@prisma-next/sql-relational-core/ast";
 import { SqlRuntimeAdapterDescriptor } from "@prisma-next/sql-runtime";
 import { RuntimeAdapterInstance } from "@prisma-next/framework-components/execution";
-import { JsonSchemaValidateFn } from "@prisma-next/sql-relational-core/query-lane-context";
 
 //#region src/exports/runtime.d.ts
 interface SqlRuntimeAdapter extends RuntimeAdapterInstance<'sql', 'postgres'>, Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}
-/**
- * Helper returned by the JSON/JSONB `init` hook.
- * Contains a compiled JSON Schema validate function for runtime conformance checks.
- */
-type JsonCodecHelper = {
-  readonly validate: JsonSchemaValidateFn;
-};
 declare const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>;
 //#endregion
-export { JsonCodecHelper, SqlRuntimeAdapter, postgresRuntimeAdapterDescriptor as default };
+export { SqlRuntimeAdapter, postgresRuntimeAdapterDescriptor as default };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;;;;UAsBiB,iBAAA,SACP,2CACN,QAAQ,aAAa,kBAAkB;AAF3C;;;;AACU,KAuBE,eAAA,GAvBF;EACN,SAAA,QAAA,EAsB+C,oBAtB/C;CAAO;AAsBX,cA+BM,gCA/B6C,EA+BX,2BA/B+B,CAAA,UAAA,EA+BS,iBA/BT,CAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;;;UAgBiB,iBAAA,SACP,2CACN,QAAQ,aAAa,kBAAkB;AAF3C,cAmCM,gCAlCJ,EAkCsC,2BAlCtC,CAAA,UAAA,EAkC8E,iBAlC9E,CAAA"}

package/dist/runtime.mjs

@@ -2,64 +2,16 @@ import { t as createPostgresAdapter } from "./adapter-_L4wXA4O.mjs";
 import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-Dxnoq_rr.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
-import { PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { builtinGeneratorIds } from "@prisma-next/ids";
 import { extractCodecLookup } from "@prisma-next/framework-components/control";
 import { generateId } from "@prisma-next/ids/runtime";
-import { type } from "arktype";
-import Ajv from "ajv";
 
-//#region src/core/json-schema-validator.ts
-/**
-* Shared Ajv instance for all JSON Schema validators.
-* Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.
-*/
-let sharedAjv;
-function getSharedAjv() {
-	if (!sharedAjv) sharedAjv = new Ajv({
-		allErrors: false,
-		strict: false
-	});
-	return sharedAjv;
-}
-/**
-* Compiles a JSON Schema object into a reusable validate function using Ajv.
-*
-* The returned function validates a value against the schema and returns
-* a structured result with error details on failure.
-*
-* Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)
-* to minimize memory and CPU overhead.
-*
-* @param schema - A JSON Schema object (draft-07 compatible)
-* @returns A validate function
-*/
-function compileJsonSchemaValidator(schema) {
-	const validate = getSharedAjv().compile(schema);
-	return (value) => {
-		if (validate(value)) return { valid: true };
-		return {
-			valid: false,
-			errors: validate.errors.map((err) => ({
-				path: err.instancePath || "/",
-				message: err.message ?? "unknown validation error",
-				keyword: err.keyword
-			}))
-		};
-	};
-}
-
-//#endregion
 //#region src/exports/runtime.ts
 function createPostgresCodecRegistry() {
 	const registry = createCodecRegistry();
 	for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
 	return registry;
 }
-const jsonTypeParamsSchema = type({
-	schemaJson: "object",
-	"type?": "string"
-});
 function createPostgresMutationDefaultGenerators() {
 	return builtinGeneratorIds.map((id) => ({
 		id,
@@ -71,18 +23,18 @@ function createPostgresMutationDefaultGenerators() {
 		}
 	}));
 }
-function initJsonCodecHelper(params) {
-	return { validate: compileJsonSchemaValidator(params.schemaJson) };
-}
-const parameterizedCodecDescriptors = [{
-	codecId: PG_JSON_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}, {
-	codecId: PG_JSONB_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}];
+/**
+* Phase C of codec-registry-unification: the postgres adapter retains
+* only static raw-JSON / raw-JSONB column descriptors. Schema-typed JSON
+* columns ship from per-library extension packages now —
+* `@prisma-next/extension-arktype-json` for arktype, future zod / valibot
+* extensions when each lands. The previously-shipped
+* `parameterizedCodecDescriptors` for `pg/json@1` / `pg/jsonb@1` retired
+* with the schema-typed surface; the unified descriptor map auto-lifts
+* the raw json/jsonb codecs from `codecs:` via the synthesis bridge for
+* codec-id-keyed metadata reads.
+*/
+const parameterizedCodecDescriptors = [];
 const postgresRuntimeAdapterDescriptor = {
 	...postgresAdapterDescriptorMeta,
 	codecs: createPostgresCodecRegistry,

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["sharedAjv: Ajv | undefined","arktype","postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>"],"sources":["../src/core/json-schema-validator.ts","../src/exports/runtime.ts"],"sourcesContent":["import type {\n  JsonSchemaValidateFn,\n  JsonSchemaValidationError,\n  JsonSchemaValidationResult,\n} from '@prisma-next/sql-relational-core/query-lane-context';\nimport Ajv from 'ajv';\n\nexport type { JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult };\n\n/**\n * Shared Ajv instance for all JSON Schema validators.\n * Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.\n */\nlet sharedAjv: Ajv | undefined;\n\nfunction getSharedAjv(): Ajv {\n  if (!sharedAjv) {\n    sharedAjv = new Ajv({ allErrors: false, strict: false });\n  }\n  return sharedAjv;\n}\n\n/**\n * Compiles a JSON Schema object into a reusable validate function using Ajv.\n *\n * The returned function validates a value against the schema and returns\n * a structured result with error details on failure.\n *\n * Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)\n * to minimize memory and CPU overhead.\n *\n * @param schema - A JSON Schema object (draft-07 compatible)\n * @returns A validate function\n */\nexport function compileJsonSchemaValidator(schema: Record<string, unknown>): JsonSchemaValidateFn {\n  const ajv = getSharedAjv();\n  const validate = ajv.compile(schema);\n\n  return (value: unknown): JsonSchemaValidationResult => {\n    const valid = validate(value);\n    if (valid) {\n      return { valid: true };\n    }\n\n    // biome-ignore lint/style/noNonNullAssertion: Ajv guarantees `errors` is populated whenever `validate(...)` returns false.\n    const errors: JsonSchemaValidationError[] = validate.errors!.map((err) => ({\n      path: err.instancePath || '/',\n      message: err.message ?? 'unknown validation error',\n      keyword: err.keyword,\n    }));\n\n    return { valid: false, errors };\n  };\n}\n","import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport { extractCodecLookup } from '@prisma-next/framework-components/control';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeAdapterDescriptor,\n} from '@prisma-next/sql-runtime';\nimport { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { type as arktype } from 'arktype';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport {\n  compileJsonSchemaValidator,\n  type JsonSchemaValidateFn,\n} from '../core/json-schema-validator';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresCodecRegistry(): CodecRegistry {\n  const registry = createCodecRegistry();\n  for (const definition of Object.values(codecDefinitions)) {\n    registry.register(definition.codec);\n  }\n  return registry;\n}\n\nconst jsonTypeParamsSchema = arktype({\n  schemaJson: 'object',\n  'type?': 'string',\n});\n\n/** The inferred type params shape from the arktype schema. */\ntype JsonTypeParams = typeof jsonTypeParamsSchema.infer;\n\n/**\n * Helper returned by the JSON/JSONB `init` hook.\n * Contains a compiled JSON Schema validate function for runtime conformance checks.\n */\nexport type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };\n\nfunction createPostgresMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => {\n      const spec: GeneratedValueSpec = params ? { id, params } : { id };\n      return generateId(spec);\n    },\n  }));\n}\n\nfunction initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {\n  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };\n}\n\nconst parameterizedCodecDescriptors = [\n  {\n    codecId: PG_JSON_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n  {\n    codecId: PG_JSONB_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n] as const satisfies ReadonlyArray<\n  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>\n>;\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: createPostgresCodecRegistry,\n    parameterizedCodecs: () => parameterizedCodecDescriptors,\n    queryOperations: () => postgresQueryOperations(),\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(stack): SqlRuntimeAdapter {\n      // The runtime `ExecutionStack` does not (yet) carry a pre-assembled\n      // `codecLookup` field the way the control `ControlStack` does, so we\n      // derive an equivalent lookup here from the stack's component metadata\n      // (target + adapter + extension packs) using the same assembly helper\n      // that `createControlStack` uses. This keeps the renderer fed with the\n      // same codec set on both planes — including extension-contributed\n      // codecs like `pg/vector@1` from `@prisma-next/extension-pgvector`.\n      const codecLookup = extractCodecLookup([\n        stack.target,\n        stack.adapter,\n        ...stack.extensionPacks,\n      ]);\n      return createPostgresAdapter({ codecLookup });\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;AAaA,IAAIA;AAEJ,SAAS,eAAoB;AAC3B,KAAI,CAAC,UACH,aAAY,IAAI,IAAI;EAAE,WAAW;EAAO,QAAQ;EAAO,CAAC;AAE1D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,2BAA2B,QAAuD;CAEhG,MAAM,WADM,cAAc,CACL,QAAQ,OAAO;AAEpC,SAAQ,UAA+C;AAErD,MADc,SAAS,MAAM,CAE3B,QAAO,EAAE,OAAO,MAAM;AAUxB,SAAO;GAAE,OAAO;GAAO,QANqB,SAAS,OAAQ,KAAK,SAAS;IACzE,MAAM,IAAI,gBAAgB;IAC1B,SAAS,IAAI,WAAW;IACxB,SAAS,IAAI;IACd,EAAE;GAE4B;;;;;;ACzBnC,SAAS,8BAA6C;CACpD,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,QAAO;;AAGT,MAAM,uBAAuBC,KAAQ;CACnC,YAAY;CACZ,SAAS;CACV,CAAC;AAWF,SAAS,0CAA0C;AACjD,QAAO,oBAAoB,KAAK,QAAQ;EACtC;EACA,WAAW,WAAqC;AAE9C,UAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAE1B,EAAE;;AAGL,SAAS,oBAAoB,QAAyC;AACpE,QAAO,EAAE,UAAU,2BAA2B,OAAO,WAAsC,EAAE;;AAG/F,MAAM,gCAAgC,CACpC;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,EACD;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,CACF;AAID,MAAMC,mCACJ;CACE,GAAG;CACH,QAAQ;CACR,2BAA2B;CAC3B,uBAAuB,yBAAyB;CAChD,2BAA2B;CAC3B,OAAO,OAA0B;AAa/B,SAAO,sBAAsB,EAAE,aALX,mBAAmB;GACrC,MAAM;GACN,MAAM;GACN,GAAG,MAAM;GACV,CAAC,EAC0C,CAAC;;CAEhD;AAEH,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":["parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor>","postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport { extractCodecLookup } from '@prisma-next/framework-components/control';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeAdapterDescriptor,\n} from '@prisma-next/sql-runtime';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresCodecRegistry(): CodecRegistry {\n  const registry = createCodecRegistry();\n  for (const definition of Object.values(codecDefinitions)) {\n    registry.register(definition.codec);\n  }\n  return registry;\n}\n\nfunction createPostgresMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => {\n      const spec: GeneratedValueSpec = params ? { id, params } : { id };\n      return generateId(spec);\n    },\n  }));\n}\n\n/**\n * Phase C of codec-registry-unification: the postgres adapter retains\n * only static raw-JSON / raw-JSONB column descriptors. Schema-typed JSON\n * columns ship from per-library extension packages now —\n * `@prisma-next/extension-arktype-json` for arktype, future zod / valibot\n * extensions when each lands. The previously-shipped\n * `parameterizedCodecDescriptors` for `pg/json@1` / `pg/jsonb@1` retired\n * with the schema-typed surface; the unified descriptor map auto-lifts\n * the raw json/jsonb codecs from `codecs:` via the synthesis bridge for\n * codec-id-keyed metadata reads.\n */\nconst parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor> = [];\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: createPostgresCodecRegistry,\n    parameterizedCodecs: () => parameterizedCodecDescriptors,\n    queryOperations: () => postgresQueryOperations(),\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(stack): SqlRuntimeAdapter {\n      // The runtime `ExecutionStack` does not (yet) carry a pre-assembled\n      // `codecLookup` field the way the control `ControlStack` does, so we\n      // derive an equivalent lookup here from the stack's component metadata\n      // (target + adapter + extension packs) using the same assembly helper\n      // that `createControlStack` uses. This keeps the renderer fed with the\n      // same codec set on both planes — including extension-contributed\n      // codecs like `pg/vector@1` from `@prisma-next/extension-pgvector`.\n      const codecLookup = extractCodecLookup([\n        stack.target,\n        stack.adapter,\n        ...stack.extensionPacks,\n      ]);\n      return createPostgresAdapter({ codecLookup });\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;AAoBA,SAAS,8BAA6C;CACpD,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,QAAO;;AAGT,SAAS,0CAA0C;AACjD,QAAO,oBAAoB,KAAK,QAAQ;EACtC;EACA,WAAW,WAAqC;AAE9C,UAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAE1B,EAAE;;;;;;;;;;;;;AAcL,MAAMA,gCAAoF,EAAE;AAE5F,MAAMC,mCACJ;CACE,GAAG;CACH,QAAQ;CACR,2BAA2B;CAC3B,uBAAuB,yBAAyB;CAChD,2BAA2B;CAC3B,OAAO,OAA0B;AAa/B,SAAO,sBAAsB,EAAE,aALX,mBAAmB;GACrC,MAAM;GACN,MAAM;GACN,GAAG,MAAM;GACV,CAAC,EAC0C,CAAC;;CAEhD;AAEH,sBAAe"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/adapter-postgres",
-  "version": "0.5.0-dev.30",
+  "version": "0.5.0-dev.41",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -8,35 +8,34 @@
     "src"
   ],
   "dependencies": {
-    "ajv": "^8.18.0",
     "arktype": "^2.0.0",
-    "@prisma-next/contract-authoring": "0.5.0-dev.30",
-    "@prisma-next/contract": "0.5.0-dev.30",
-    "@prisma-next/family-sql": "0.5.0-dev.30",
-    "@prisma-next/framework-components": "0.5.0-dev.30",
-    "@prisma-next/ids": "0.5.0-dev.30",
-    "@prisma-next/sql-contract": "0.5.0-dev.30",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.30",
-    "@prisma-next/sql-operations": "0.5.0-dev.30",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.30",
-    "@prisma-next/sql-contract-psl": "0.5.0-dev.30",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.30",
-    "@prisma-next/target-postgres": "0.5.0-dev.30",
-    "@prisma-next/sql-runtime": "0.5.0-dev.30",
-    "@prisma-next/utils": "0.5.0-dev.30"
+    "@prisma-next/contract": "0.5.0-dev.41",
+    "@prisma-next/family-sql": "0.5.0-dev.41",
+    "@prisma-next/contract-authoring": "0.5.0-dev.41",
+    "@prisma-next/sql-contract": "0.5.0-dev.41",
+    "@prisma-next/sql-contract-psl": "0.5.0-dev.41",
+    "@prisma-next/framework-components": "0.5.0-dev.41",
+    "@prisma-next/ids": "0.5.0-dev.41",
+    "@prisma-next/sql-operations": "0.5.0-dev.41",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.41",
+    "@prisma-next/sql-runtime": "0.5.0-dev.41",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.41",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.41",
+    "@prisma-next/target-postgres": "0.5.0-dev.41",
+    "@prisma-next/utils": "0.5.0-dev.41"
   },
   "devDependencies": {
     "pathe": "^2.0.3",
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/cli": "0.5.0-dev.30",
-    "@prisma-next/errors": "0.5.0-dev.30",
-    "@prisma-next/extension-pgvector": "0.5.0-dev.30",
-    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/driver-postgres": "0.5.0-dev.41",
+    "@prisma-next/cli": "0.5.0-dev.41",
+    "@prisma-next/errors": "0.5.0-dev.41",
     "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/driver-postgres": "0.5.0-dev.30"
+    "@prisma-next/extension-pgvector": "0.5.0-dev.41"
   },
   "exports": {
     "./adapter": "./dist/adapter.mjs",

package/src/exports/column-types.ts

@@ -29,12 +29,6 @@ import {
   SQL_CHAR_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
 } from '@prisma-next/target-postgres/codec-ids';
-import {
-  extractStandardSchemaOutputJsonSchema,
-  extractStandardSchemaTypeExpression,
-  isStandardSchemaLike,
-  type StandardSchemaLike,
-} from '../core/standard-schema';
 
 export const textColumn = {
   codecId: PG_TEXT_CODEC_ID,
@@ -164,68 +158,29 @@ export function intervalColumn(precision?: number): ColumnTypeDescriptor & {
   } as const;
 }
 
+/**
+ * Postgres `json` column descriptor — untyped raw JSON.
+ *
+ * For schema-typed JSON columns, use the per-library extension package
+ * (`@prisma-next/extension-arktype-json` ships `arktypeJson(schema)` for
+ * arktype). The schema-accepting `json(schema)` / `jsonb(schema)`
+ * overloads previously shipped from this module retired in Phase C of
+ * the codec-registry-unification project — see spec § AC-7.
+ */
 export const jsonColumn = {
   codecId: PG_JSON_CODEC_ID,
   nativeType: 'json',
 } as const satisfies ColumnTypeDescriptor;
 
+/**
+ * Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement
+ * note as {@link jsonColumn}.
+ */
 export const jsonbColumn = {
   codecId: PG_JSONB_CODEC_ID,
   nativeType: 'jsonb',
 } as const satisfies ColumnTypeDescriptor;
 
-type JsonSchemaTypeParams = {
-  readonly schemaJson: Record<string, unknown>;
-  readonly type?: string;
-};
-
-function createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {
-  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);
-  if (!outputSchema) {
-    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');
-  }
-
-  const expression = extractStandardSchemaTypeExpression(schema);
-  if (expression) {
-    return { schemaJson: outputSchema, type: expression };
-  }
-
-  return { schemaJson: outputSchema };
-}
-
-function createJsonColumnFactory(
-  codecId: string,
-  nativeType: string,
-  staticDescriptor: ColumnTypeDescriptor,
-) {
-  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {
-    if (!schema) {
-      return staticDescriptor;
-    }
-
-    if (!isStandardSchemaLike(schema)) {
-      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);
-    }
-
-    return {
-      codecId,
-      nativeType,
-      typeParams: createJsonTypeParams(schema),
-    };
-  };
-}
-
-const _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);
-const _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);
-
-export function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {
-  return _json(schema);
-}
-
-export function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {
-  return _jsonb(schema);
-}
-
 export function enumType<const Values extends readonly string[]>(
   name: string,
   values: Values,

package/src/exports/runtime.ts

@@ -9,15 +9,9 @@ import type {
   RuntimeParameterizedCodecDescriptor,
   SqlRuntimeAdapterDescriptor,
 } from '@prisma-next/sql-runtime';
-import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
 import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
-import { type as arktype } from 'arktype';
 import { createPostgresAdapter } from '../core/adapter';
 import { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';
-import {
-  compileJsonSchemaValidator,
-  type JsonSchemaValidateFn,
-} from '../core/json-schema-validator';
 import type { PostgresContract, PostgresLoweredStatement } from '../core/types';
 
 export interface SqlRuntimeAdapter
@@ -32,20 +26,6 @@ function createPostgresCodecRegistry(): CodecRegistry {
   return registry;
 }
 
-const jsonTypeParamsSchema = arktype({
-  schemaJson: 'object',
-  'type?': 'string',
-});
-
-/** The inferred type params shape from the arktype schema. */
-type JsonTypeParams = typeof jsonTypeParamsSchema.infer;
-
-/**
- * Helper returned by the JSON/JSONB `init` hook.
- * Contains a compiled JSON Schema validate function for runtime conformance checks.
- */
-export type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };
-
 function createPostgresMutationDefaultGenerators() {
   return builtinGeneratorIds.map((id) => ({
     id,
@@ -56,24 +36,18 @@ function createPostgresMutationDefaultGenerators() {
   }));
 }
 
-function initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {
-  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };
-}
-
-const parameterizedCodecDescriptors = [
-  {
-    codecId: PG_JSON_CODEC_ID,
-    paramsSchema: jsonTypeParamsSchema,
-    init: initJsonCodecHelper,
-  },
-  {
-    codecId: PG_JSONB_CODEC_ID,
-    paramsSchema: jsonTypeParamsSchema,
-    init: initJsonCodecHelper,
-  },
-] as const satisfies ReadonlyArray<
-  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>
->;
+/**
+ * Phase C of codec-registry-unification: the postgres adapter retains
+ * only static raw-JSON / raw-JSONB column descriptors. Schema-typed JSON
+ * columns ship from per-library extension packages now —
+ * `@prisma-next/extension-arktype-json` for arktype, future zod / valibot
+ * extensions when each lands. The previously-shipped
+ * `parameterizedCodecDescriptors` for `pg/json@1` / `pg/jsonb@1` retired
+ * with the schema-typed surface; the unified descriptor map auto-lifts
+ * the raw json/jsonb codecs from `codecs:` via the synthesis bridge for
+ * codec-id-keyed metadata reads.
+ */
+const parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor> = [];
 
 const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =
   {

package/src/core/json-schema-validator.ts

@@ -1,54 +0,0 @@
-import type {
-  JsonSchemaValidateFn,
-  JsonSchemaValidationError,
-  JsonSchemaValidationResult,
-} from '@prisma-next/sql-relational-core/query-lane-context';
-import Ajv from 'ajv';
-
-export type { JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult };
-
-/**
- * Shared Ajv instance for all JSON Schema validators.
- * Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.
- */
-let sharedAjv: Ajv | undefined;
-
-function getSharedAjv(): Ajv {
-  if (!sharedAjv) {
-    sharedAjv = new Ajv({ allErrors: false, strict: false });
-  }
-  return sharedAjv;
-}
-
-/**
- * Compiles a JSON Schema object into a reusable validate function using Ajv.
- *
- * The returned function validates a value against the schema and returns
- * a structured result with error details on failure.
- *
- * Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)
- * to minimize memory and CPU overhead.
- *
- * @param schema - A JSON Schema object (draft-07 compatible)
- * @returns A validate function
- */
-export function compileJsonSchemaValidator(schema: Record<string, unknown>): JsonSchemaValidateFn {
-  const ajv = getSharedAjv();
-  const validate = ajv.compile(schema);
-
-  return (value: unknown): JsonSchemaValidationResult => {
-    const valid = validate(value);
-    if (valid) {
-      return { valid: true };
-    }
-
-    // biome-ignore lint/style/noNonNullAssertion: Ajv guarantees `errors` is populated whenever `validate(...)` returns false.
-    const errors: JsonSchemaValidationError[] = validate.errors!.map((err) => ({
-      path: err.instancePath || '/',
-      message: err.message ?? 'unknown validation error',
-      keyword: err.keyword,
-    }));
-
-    return { valid: false, errors };
-  };
-}

package/src/core/standard-schema.ts

@@ -1,71 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-
-type StandardSchemaJsonSchemaField = {
-  readonly output?: unknown;
-};
-
-/**
- * Runtime view of the Standard Schema protocol.
- * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,
- * and `.expression` for an optional TypeScript type expression string (Arktype-specific).
- *
- * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads
- * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.
- */
-export type StandardSchemaLike = {
-  readonly '~standard'?: {
-    readonly version?: number;
-    readonly jsonSchema?: StandardSchemaJsonSchemaField;
-  };
-  readonly expression?: unknown;
-};
-
-function isObjectLike(value: unknown): value is UnknownRecord {
-  return (typeof value === 'object' || typeof value === 'function') && value !== null;
-}
-
-function resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {
-  const jsonSchema = schema['~standard']?.jsonSchema;
-  if (!jsonSchema) {
-    return undefined;
-  }
-
-  if (typeof jsonSchema.output === 'function') {
-    return jsonSchema.output({
-      target: 'draft-07',
-    });
-  }
-
-  return jsonSchema.output;
-}
-
-export function extractStandardSchemaOutputJsonSchema(
-  schema: StandardSchemaLike,
-): UnknownRecord | undefined {
-  const outputSchema = resolveOutputJsonSchemaField(schema);
-  if (!isObjectLike(outputSchema)) {
-    return undefined;
-  }
-
-  return outputSchema;
-}
-
-export function extractStandardSchemaTypeExpression(
-  schema: StandardSchemaLike,
-): string | undefined {
-  const expression = schema.expression;
-  if (typeof expression !== 'string') {
-    return undefined;
-  }
-
-  const trimmedExpression = expression.trim();
-  if (trimmedExpression.length === 0) {
-    return undefined;
-  }
-
-  return trimmedExpression;
-}
-
-export function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {
-  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);
-}