@prisma-next/adapter-postgres 0.5.0-dev.6 → 0.5.0-dev.60

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/{adapter-hNElNHo4.mjs → adapter-_L4wXA4O.mjs}

@@ -1,5 +1,6 @@
-import { t as renderLoweredSql } from "./sql-renderer-pEaSP82_.mjs";
+import { n as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DLwYpnxz.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { parseContractMarkerRow } from "@prisma-next/sql-runtime";
 import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
 import { ifDefined } from "@prisma-next/utils/defined";
 
@@ -32,23 +33,26 @@ var PostgresAdapterImpl = class {
 		for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
 		return registry;
 	})();
+	codecLookup;
 	constructor(options) {
+		this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();
 		this.profile = Object.freeze({
 			id: options?.profileId ?? "postgres/default@1",
 			target: "postgres",
 			capabilities: defaultCapabilities,
 			codecs: () => this.codecRegistry,
 			readMarkerStatement: () => ({
-				sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
+				sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1",
 				params: [1]
-			})
+			}),
+			parseMarkerRow: (row) => parseContractMarkerRow(row)
 		});
 	}
 	parameterizedCodecs() {
 		return parameterizedCodecs;
 	}
 	lower(ast, context) {
-		return renderLoweredSql(ast, context.contract);
+		return renderLoweredSql(ast, context.contract, this.codecLookup);
 	}
 };
 function createPostgresAdapter(options) {
@@ -57,4 +61,4 @@ function createPostgresAdapter(options) {
 
 //#endregion
 export { createPostgresAdapter as t };
-//# sourceMappingURL=adapter-hNElNHo4.mjs.map
+//# sourceMappingURL=adapter-_L4wXA4O.mjs.map

package/dist/adapter-_L4wXA4O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-_L4wXA4O.mjs","names":["parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor>"],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport {\n  type Adapter,\n  type AdapterProfile,\n  type AnyQueryAst,\n  type CodecParamsDescriptor,\n  createCodecRegistry,\n  type LowererContext,\n} from '@prisma-next/sql-relational-core/ast';\nimport { parseContractMarkerRow } from '@prisma-next/sql-runtime';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\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  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n  },\n});\n\ntype AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];\ntype ParameterizedCodec = AdapterCodec & {\n  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;\n};\n\nconst parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)\n  .map((definition) => definition.codec)\n  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)\n  .map((codec) =>\n    Object.freeze({\n      codecId: codec.id,\n      paramsSchema: codec.paramsSchema,\n      ...ifDefined('init', codec.init),\n    }),\n  );\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with\n  // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecRegistry = (() => {\n    const registry = createCodecRegistry();\n    for (const definition of Object.values(codecDefinitions)) {\n      registry.register(definition.codec);\n    }\n    return registry;\n  })();\n  private readonly codecLookup: CodecLookup;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      codecs: () => this.codecRegistry,\n      readMarkerStatement: () => ({\n        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1',\n        params: [1],\n      }),\n      // Postgres' driver hydrates `text[]` columns as native JS arrays, so\n      // the row is already in the shape the shared parser expects.\n      parseMarkerRow: (row: unknown) => parseContractMarkerRow(row),\n    });\n  }\n\n  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {\n    return parameterizedCodecs;\n  }\n\n  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement {\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;;;;AAgBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACZ;CACD,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EAClB;CACF,CAAC;AAOF,MAAMA,sBAA4D,OAAO,OAAO,iBAAiB,CAC9F,KAAK,eAAe,WAAW,MAAM,CACrC,QAAQ,UAAuC,MAAM,iBAAiB,OAAU,CAChF,KAAK,UACJ,OAAO,OAAO;CACZ,SAAS,MAAM;CACf,cAAc,MAAM;CACpB,GAAG,UAAU,QAAQ,MAAM,KAAK;CACjC,CAAC,CACH;AAEH,IAAM,sBAAN,MAEA;CAGE,AAAS,WAAW;CACpB,AAAS,WAAW;CAEpB,AAAS;CACT,AAAiB,uBAAuB;EACtC,MAAM,WAAW,qBAAqB;AACtC,OAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,SAAO;KACL;CACJ,AAAiB;CAEjB,YAAY,SAAkC;AAC5C,OAAK,cAAc,SAAS,eAAe,kCAAkC;AAC7E,OAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,cAAc,KAAK;GACnB,4BAA4B;IAC1B,KAAK;IACL,QAAQ,CAAC,EAAE;IACZ;GAGD,iBAAiB,QAAiB,uBAAuB,IAAI;GAC9D,CAAC;;CAGJ,sBAA4D;AAC1D,SAAO;;CAGT,MAAM,KAAkB,SAAqE;AAC3F,SAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,YAAY;;;AAIpE,SAAgB,sBAAsB,SAAkC;AACtE,QAAO,OAAO,OAAO,IAAI,oBAAoB,QAAQ,CAAC"}

package/dist/adapter.d.mts

@@ -1,4 +1,4 @@
-import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-CfRPdAk8.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-tLtmYqCO.mjs";
 import { Adapter, AdapterProfile, AnyQueryAst, CodecParamsDescriptor, LowererContext } from "@prisma-next/sql-relational-core/ast";
 
 //#region src/core/adapter.d.ts
@@ -7,6 +7,7 @@ declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContra
   readonly targetId: "postgres";
   readonly profile: AdapterProfile<'postgres'>;
   private readonly codecRegistry;
+  private readonly codecLookup;
   constructor(options?: PostgresAdapterOptions);
   parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor>;
   lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement;

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":[],"mappings":";;;;cA4CM,mBAAA,YACO,QAAQ,aAAa,kBAAkB;;EAD9C,SAAA,QAAA,EAAA,UACJ;EAAmB,SAAA,OAAA,EAOD,cAPC,CAAA,UAAA,CAAA;EAAa,iBAAA,aAAA;EAAkB,WAAA,CAAA,OAAA,CAAA,EAgB5B,sBAhB4B;EAOhC,mBAAA,CAAA,CAAA,EAsBK,aAtBL,CAsBmB,qBAtBnB,CAAA;EASI,KAAA,CAAA,GAAA,EAiBX,WAjBW,EAAA,OAAA,EAiBW,cAjBX,CAiB0B,gBAjB1B,CAAA,CAAA,EAiB8C,wBAjB9C;;AAaC,iBAST,qBAAA,CATS,OAAA,CAAA,EASuB,sBATvB,CAAA,EAS6C,QAT7C,CAS6C,mBAT7C,CAAA"}
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":[],"mappings":";;;;cA+CM,mBAAA,YACO,QAAQ,aAAa,kBAAkB;;EAD9C,SAAA,QAAA,EAAA,UACJ;EAAmB,SAAA,OAAA,EAOD,cAPC,CAAA,UAAA,CAAA;EAAa,iBAAA,aAAA;EAAkB,iBAAA,WAAA;EAOhC,WAAA,CAAA,OAAA,CAAA,EAUI,sBAVJ;EAUI,mBAAA,CAAA,CAAA,EAiBC,aAjBD,CAiBe,qBAjBf,CAAA;EAiBe,KAAA,CAAA,GAAA,EAI1B,WAJ0B,EAAA,OAAA,EAIJ,cAJI,CAIW,gBAJX,CAAA,CAAA,EAI+B,wBAJ/B;;AAI1B,iBAKG,qBAAA,CALH,OAAA,CAAA,EAKmC,sBALnC,CAAA,EAKyD,QALzD,CAKyD,mBALzD,CAAA"}

package/dist/adapter.mjs

@@ -1,3 +1,3 @@
-import { t as createPostgresAdapter } from "./adapter-hNElNHo4.mjs";
+import { t as createPostgresAdapter } from "./adapter-_L4wXA4O.mjs";
 
 export { createPostgresAdapter };

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";
@@ -94,21 +75,44 @@ declare function varbitColumn(length: number): ColumnTypeDescriptor & {
     readonly length: number;
   };
 };
+/**
+ * Postgres `bytea` column descriptor — variable-length binary string.
+ *
+ * Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text
+ * encoding (`\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0)
+ * and binary encoding are both handled by the underlying driver; the codec
+ * only normalizes the JS-side representation to a plain `Uint8Array` view.
+ */
+declare const byteaColumn: {
+  readonly codecId: "pg/bytea@1";
+  readonly nativeType: "bytea";
+};
 declare function intervalColumn(precision?: number): ColumnTypeDescriptor & {
   readonly typeParams?: {
     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 +122,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, byteaColumn, 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":";;;;;AA+Da,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;EAkBjC,CAAA;AAKb,CAAA;AAmBa,cA7HA,UAgI4B,EAAA;EAM5B,SAAA,OAG4B,EAAA,WAAA;EAEzB,SAAA,UAAQ,EAAA,MAAA;CAEd;AACP,cAzIU,UAyIV,EAAA;EAAgE,SAAA,OAAA,EAAA,WAAA;EAAM,SAAA,UAAA,EAAA,MAAA;AAQzE,CAAA;AACY,cA7IC,UA6ID,EAAA;EAET,SAAA,OAAA,EAAA,WAAA;EAA2C,SAAA,UAAA,EAAA,MAAA;CAAQ;cA1IzC;;;;cAKA;;;;iBAKG,aAAA,qCAGb;;;;;;cAUU;;;;cAKA;;;;iBAKG,UAAA,sBAAgC;;;;;iBAUhC,YAAA,sBAAkC;;;;;cAUrC;;;;iBAKG,SAAA,kBAA2B;;;;;iBAU3B,YAAA,kBAA8B;;;;;;;;;;;;;cAkBjC;;;;iBAKG,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";
+import { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_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,
@@ -116,6 +89,18 @@ function varbitColumn(length) {
 		typeParams: { length }
 	};
 }
+/**
+* Postgres `bytea` column descriptor — variable-length binary string.
+*
+* Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text
+* encoding (`\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0)
+* and binary encoding are both handled by the underlying driver; the codec
+* only normalizes the JS-side representation to a plain `Uint8Array` view.
+*/
+const byteaColumn = {
+	codecId: PG_BYTEA_CODEC_ID,
+	nativeType: "bytea"
+};
 function intervalColumn(precision) {
 	return {
 		codecId: PG_INTERVAL_CODEC_ID,
@@ -123,43 +108,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 +145,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, byteaColumn, 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_BYTEA_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\n/**\n * Postgres `bytea` column descriptor — variable-length binary string.\n *\n * Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text\n * encoding (`\\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0)\n * and binary encoding are both handled by the underlying driver; the codec\n * only normalizes the JS-side representation to a plain `Uint8Array` view.\n */\nexport const byteaColumn = {\n  codecId: PG_BYTEA_CODEC_ID,\n  nativeType: 'bytea',\n} as const satisfies ColumnTypeDescriptor;\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":";;;AAiCA,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;;;;;;;;;;AAWH,MAAa,cAAc;CACzB,SAAS;CACT,YAAY;CACb;AAED,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/control.d.mts

@@ -1,10 +1,83 @@
+import { AnyQueryAst, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
-import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
-import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
+import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
+import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
 import { SqlControlAdapterDescriptor } from "@prisma-next/family-sql/control";
+import { ControlDriverInstance } from "@prisma-next/framework-components/control";
+import { ContractMarkerRecord } from "@prisma-next/contract/types";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 
+//#region src/core/control-adapter.d.ts
+/**
+ * Postgres control plane adapter for control-plane operations like introspection.
+ * Provides target-specific implementations for control-plane domain actions.
+ */
+declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  private readonly codecLookup;
+  /**
+   * @param codecLookup - Codec lookup used by the SQL renderer to resolve
+   *   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
+   *   lookup when omitted. Stack-aware callers
+   *   (`SqlControlAdapterDescriptor.create(stack)`) supply
+   *   `stack.codecLookup` so extension codecs are visible to the renderer.
+   */
+  constructor(codecLookup?: CodecLookup);
+  /**
+   * Target-specific normalizer for raw Postgres default expressions.
+   * Used by schema verification to normalize raw defaults before comparison.
+   */
+  readonly normalizeDefault: typeof parsePostgresDefault$1;
+  /**
+   * Target-specific normalizer for Postgres schema native type names.
+   * Used by schema verification to normalize introspected type names
+   * before comparison with contract native types.
+   */
+  readonly normalizeNativeType: typeof normalizeSchemaNativeType$1;
+  /**
+   * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
+   *
+   * Delegates to the shared `renderLoweredSql` renderer so the control adapter
+   * emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
+   * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+   * without instantiating the runtime adapter.
+   */
+  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement;
+  /**
+   * Reads the contract marker from `prisma_contract.marker`. Probes
+   * `information_schema.tables` first so a fresh database (where the
+   * `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+   * "relation does not exist" error — some Postgres wire-protocol clients
+   * (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+   * parse errors, so we probe before reading.
+   */
+  readMarker(driver: ControlDriverInstance<'sql', 'postgres'>): Promise<ContractMarkerRecord | null>;
+  /**
+   * Introspects a Postgres database schema and returns a raw SqlSchemaIR.
+   *
+   * This is a pure schema discovery operation that queries the Postgres catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * Uses batched queries to minimize database round trips (7 queries instead of 5T+3).
+   *
+   * @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+   * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  introspect(driver: ControlDriverInstance<'sql', 'postgres'>, _contract?: unknown, schema?: string): Promise<SqlSchemaIR>;
+  /**
+   * Gets the Postgres version from the database.
+   */
+  private getPostgresVersion;
+}
+//#endregion
 //#region src/exports/control.d.ts
 declare const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>;
 //#endregion
-export { SqlEscapeError, postgresAdapterDescriptor as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
+export { PostgresControlAdapter, SqlEscapeError, postgresAdapterDescriptor as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;cAgBM,2BAA2B"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-adapter.ts","../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;AAiCa,cAAA,sBAAA,YAAkC,iBAAX,CAAA,UAAA,CAAA,CAAA;EAaR,SAAA,QAAA,EAAA,KAAA;EAQD,SAAA,QAAA,EAAA,UAAA;EAOG,iBAAA,WAAA;EAUjB;;;;;;;EAwEA,WAAA,CAAA,WAAA,CAAA,EAjGe,WAiGf;EAAR;;;;oCAzFsB;;AC/CqB;;;;uCDsDlB;;;;;;;;;aAUjB,sBAAsB,0BAA0B;;;;;;;;;qBAajD,2CACP,QAAQ;;;;;;;;;;;;;;;qBAuDD,iFAGP,QAAQ;;;;;;;;cC/HP,2BAA2B"}

package/dist/control.mjs

@@ -1,9 +1,11 @@
-import { t as renderLoweredSql } from "./sql-renderer-pEaSP82_.mjs";
-import { r as pgEnumControlHooks, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-RTDzyrae.mjs";
+import { n as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DLwYpnxz.mjs";
+import { r as pgEnumControlHooks, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-CpEka_0t.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
 import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
 import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
+import { timestampNowControlDescriptor } from "@prisma-next/family-sql/control";
 import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescriptor } from "@prisma-next/ids";
 
 //#region src/core/control-adapter.ts
@@ -14,6 +16,17 @@ import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescript
 var PostgresControlAdapter = class {
 	familyId = "sql";
 	targetId = "postgres";
+	codecLookup;
+	/**
+	* @param codecLookup - Codec lookup used by the SQL renderer to resolve
+	*   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
+	*   lookup when omitted. Stack-aware callers
+	*   (`SqlControlAdapterDescriptor.create(stack)`) supply
+	*   `stack.codecLookup` so extension codecs are visible to the renderer.
+	*/
+	constructor(codecLookup) {
+		this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
+	}
 	/**
 	* Target-specific normalizer for raw Postgres default expressions.
 	* Used by schema verification to normalize raw defaults before comparison.
@@ -34,7 +47,33 @@ var PostgresControlAdapter = class {
 	* without instantiating the runtime adapter.
 	*/
 	lower(ast, context) {
-		return renderLoweredSql(ast, context.contract);
+		return renderLoweredSql(ast, context.contract, this.codecLookup);
+	}
+	/**
+	* Reads the contract marker from `prisma_contract.marker`. Probes
+	* `information_schema.tables` first so a fresh database (where the
+	* `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+	* "relation does not exist" error — some Postgres wire-protocol clients
+	* (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+	* parse errors, so we probe before reading.
+	*/
+	async readMarker(driver) {
+		if ((await driver.query(`select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`, ["prisma_contract", "marker"])).rows.length === 0) return null;
+		const row = (await driver.query(`select
+         core_hash,
+         profile_hash,
+         contract_json,
+         canonical_version,
+         updated_at,
+         app_tag,
+         meta,
+         invariants
+       from prisma_contract.marker
+       where id = $1`, [1])).rows[0];
+		if (!row) return null;
+		return parseContractMarkerRow(row);
 	}
 	/**
 	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
@@ -566,7 +605,7 @@ function createPostgresDefaultFunctionRegistry() {
 	return new Map(postgresDefaultFunctionRegistryEntries);
 }
 function createPostgresMutationDefaultGeneratorDescriptors() {
-	return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
+	return [...builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
 		id,
 		applicableCodecIds,
 		resolveGeneratedColumnDescriptor: ({ generated }) => {
@@ -582,7 +621,7 @@ function createPostgresMutationDefaultGeneratorDescriptors() {
 				...descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}
 			};
 		}
-	}));
+	})), timestampNowControlDescriptor()];
 }
 function createPostgresScalarTypeDescriptors() {
 	return new Map(postgresScalarTypeDescriptors);
@@ -597,12 +636,12 @@ const postgresAdapterDescriptor = {
 		defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
 		generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors()
 	},
-	create(_stack) {
-		return new PostgresControlAdapter();
+	create(stack) {
+		return new PostgresControlAdapter(stack.codecLookup);
 	}
 };
 var control_default = postgresAdapterDescriptor;
 
 //#endregion
-export { SqlEscapeError, control_default as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
+export { PostgresControlAdapter, SqlEscapeError, control_default as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
 //# sourceMappingURL=control.mjs.map