@prisma-next/target-postgres 0.5.0-dev.9 → 0.5.0

package/src/core/migrations/runner.ts

@@ -1,6 +1,7 @@
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
+  MultiSpaceRunnerResult,
   SqlControlFamilyInstance,
   SqlMigrationPlanContractInfo,
   SqlMigrationPlanOperation,
@@ -9,21 +10,22 @@ import type {
   SqlMigrationRunnerExecuteOptions,
   SqlMigrationRunnerFailure,
   SqlMigrationRunnerResult,
+  SqlMigrationRunnerSuccessValue,
 } from '@prisma-next/family-sql/control';
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
-import { readMarker } from '@prisma-next/family-sql/verify';
-import type { DataTransformOperation } from '@prisma-next/framework-components/control';
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
-import { ok, okVoid } from '@prisma-next/utils/result';
+import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
-  buildWriteMarkerStatements,
+  buildMergeMarkerStatements,
   ensureLedgerTableStatement,
   ensureMarkerTableStatement,
   ensurePrismaContractSchemaStatement,
@@ -45,18 +47,6 @@ const DEFAULT_CONFIG: RunnerConfig = {
 
 const LOCK_DOMAIN = 'prisma_next.contract.marker';
 
-function isDataTransformOperation(op: unknown): op is DataTransformOperation {
-  return (
-    typeof op === 'object' &&
-    op !== null &&
-    'operationClass' in op &&
-    (op as { operationClass: string }).operationClass === 'data' &&
-    'name' in op &&
-    'check' in op &&
-    'run' in op
-  );
-}
-
 /**
  * Deep clones and freezes a record object to prevent mutation.
  * Recursively clones nested objects and arrays to ensure complete isolation.
@@ -96,61 +86,98 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
   async execute(
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
   ): Promise<SqlMigrationRunnerResult> {
-    const schema = options.schemaName ?? this.config.defaultSchema;
     const driver = options.driver;
-    const lockKey = `${LOCK_DOMAIN}:${schema}`;
 
-    // Static checks - fail fast before transaction
+    // Static checks fail fast before any transaction work — no point
+    // burning a BEGIN/ROLLBACK round-trip on a destination-contract
+    // mismatch the caller can fix locally.
     const destinationCheck = this.ensurePlanMatchesDestinationContract(
       options.plan.destination,
       options.destinationContract,
     );
-    if (!destinationCheck.ok) {
-      return destinationCheck;
-    }
+    if (!destinationCheck.ok) return destinationCheck;
 
     const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
-    if (!policyCheck.ok) {
-      return policyCheck;
-    }
+    if (!policyCheck.ok) return policyCheck;
 
-    // Begin transaction for DB operations
     await this.beginTransaction(driver);
     let committed = false;
     try {
-      await this.acquireLock(driver, lockKey);
-      await this.ensureControlTables(driver);
-      const existingMarker = await readMarker(driver);
-
-      // Validate plan origin matches existing marker (needs marker from DB)
-      const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
-      if (!markerCheck.ok) {
-        return markerCheck;
+      const result = await this.executeOnConnection(options);
+      if (!result.ok) {
+        return result;
       }
-
-      // db update (origin: null) always applies; migration-apply (origin set) skips if marker matches.
-      const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-      const skipOperations = markerAtDestination && options.plan.origin != null;
-      let applyValue: ApplyPlanSuccessValue;
-
-      if (skipOperations) {
-        applyValue = { operationsExecuted: 0, executedOperations: [] };
-      } else {
-        const applyResult = await this.applyPlan(driver, options);
-        if (!applyResult.ok) {
-          return applyResult;
-        }
-        applyValue = applyResult.value;
+      await this.commitTransaction(driver);
+      committed = true;
+      return result;
+    } finally {
+      if (!committed) {
+        await this.rollbackTransaction(driver);
       }
+    }
+  }
+
+  /**
+   * Body of the migration runner without transaction management. The
+   * caller (single-space `execute(...)` above, or the multi-space
+   * outer-tx orchestrator at the SQL family level) owns the
+   * `BEGIN`/`COMMIT`/`ROLLBACK` lifecycle.
+   */
+  async executeOnConnection(
+    options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
+  ): Promise<SqlMigrationRunnerResult> {
+    const schema = options.schemaName ?? this.config.defaultSchema;
+    const driver = options.driver;
+    if (options.space !== undefined && options.space !== options.plan.spaceId) {
+      throw new Error(
+        `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`,
+      );
+    }
+    const space = options.plan.spaceId;
+    const lockKey = `${LOCK_DOMAIN}:${schema}:${space}`;
 
-      // Verify resulting schema matches contract
-      // Step 1: Introspect live schema (DB I/O, family-owned)
+    // Static checks (idempotent — safe to run again when the caller is
+    // `execute(...)` because the cost is a single object comparison).
+    const destinationCheck = this.ensurePlanMatchesDestinationContract(
+      options.plan.destination,
+      options.destinationContract,
+    );
+    if (!destinationCheck.ok) return destinationCheck;
+
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+    if (!policyCheck.ok) return policyCheck;
+
+    await this.acquireLock(driver, lockKey);
+    const ensureResult = await this.ensureControlTables(driver);
+    if (!ensureResult.ok) return ensureResult;
+    const existingMarker = await this.family.readMarker({ driver, space });
+
+    const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+    if (!markerCheck.ok) return markerCheck;
+
+    const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+    const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+    const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
+    let applyValue: ApplyPlanSuccessValue;
+
+    if (skipOperations) {
+      applyValue = { operationsExecuted: 0, executedOperations: [] };
+    } else {
+      const applyResult = await this.applyPlan(driver, options);
+      if (!applyResult.ok) return applyResult;
+      applyValue = applyResult.value;
+    }
+
+    // Schema verification on app-space only — extension spaces don't
+    // own user-facing tables in the live schema, and `verifySqlSchema`
+    // matches the destination contract against the database, which
+    // would flag every app-space table as "extra" when called against
+    // an extension contract.
+    if (space === APP_SPACE_ID) {
       const schemaIR = await this.family.introspect({
         driver,
         contract: options.destinationContract,
       });
-
-      // Step 2: Pure verification (no DB I/O)
       const schemaVerifyResult = verifySqlSchema({
         contract: options.destinationContract,
         schema: schemaIR,
@@ -164,22 +191,60 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
           why: 'The resulting database schema does not satisfy the destination contract.',
-          meta: {
-            issues: schemaVerifyResult.schema.issues,
-          },
+          meta: { issues: schemaVerifyResult.schema.issues },
         });
       }
+    }
 
-      // Record marker and ledger entries
-      await this.upsertMarker(driver, options, existingMarker);
+    const incomingInvariants = options.plan.providedInvariants ?? [];
+    const existingInvariants = new Set(existingMarker?.invariants ?? []);
+    const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
+    const isSelfEdgeNoOp =
+      isSelfEdge && applyValue.operationsExecuted === 0 && incomingIsSubsetOfExisting;
+
+    if (!isSelfEdgeNoOp) {
+      await this.upsertMarker(driver, options, existingMarker, space);
       await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+    }
+
+    return runnerSuccess({
+      operationsPlanned: options.plan.operations.length,
+      operationsExecuted: applyValue.operationsExecuted,
+    });
+  }
+
+  async executeAcrossSpaces(options: {
+    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly perSpaceOptions: ReadonlyArray<
+      SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>
+    >;
+  }): Promise<MultiSpaceRunnerResult> {
+    const driver = options.driver;
+    const perSpaceOptions = options.perSpaceOptions;
+
+    if (perSpaceOptions.length === 0) {
+      return ok({ perSpaceResults: [] });
+    }
+
+    await this.beginTransaction(driver);
+    let committed = false;
+    try {
+      const perSpaceResults: Array<{
+        space: string;
+        value: SqlMigrationRunnerSuccessValue;
+      }> = [];
+      for (const spaceOptions of perSpaceOptions) {
+        const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
+        const result = await this.executeOnConnection({ ...spaceOptions, driver, space });
+        if (!result.ok) {
+          return notOk({ ...result.failure, failingSpace: space });
+        }
+        perSpaceResults.push({ space, value: result.value });
+      }
 
       await this.commitTransaction(driver);
       committed = true;
-      return runnerSuccess({
-        operationsPlanned: options.plan.operations.length,
-        operationsExecuted: applyValue.operationsExecuted,
-      });
+      return ok({ perSpaceResults });
     } finally {
       if (!committed) {
         await this.rollbackTransaction(driver);
@@ -201,19 +266,6 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     for (const operation of options.plan.operations) {
       options.callbacks?.onOperationStart?.(operation);
       try {
-        // Data transform operations have a different execution lifecycle
-        if (operation.operationClass === 'data' && isDataTransformOperation(operation)) {
-          const dtResult = await this.executeDataTransform(driver, operation, {
-            runIdempotency,
-          });
-          if (!dtResult.ok) {
-            return dtResult;
-          }
-          executedOperations.push(operation);
-          operationsExecuted += 1;
-          continue;
-        }
-
         // Idempotency probe: only run if both postchecks and idempotency checks are enabled
         if (runPostchecks && runIdempotency) {
           const postcheckAlreadySatisfied = await this.expectationsAreSatisfied(
@@ -266,86 +318,51 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     return ok({ operationsExecuted, executedOperations });
   }
 
-  /**
-   * Executes a data transform operation with the check → (skip or run) → check lifecycle.
-   *
-   * 1. If check is a query AST: render to SQL, execute. Empty result = already applied (skip).
-   * 2. If check is `true`: always skip. If `false`: always run.
-   * 3. Execute run ASTs (rendered to SQL) sequentially.
-   * 4. Re-execute check as post-run validation. If violations remain, fail.
-   */
-  private async executeDataTransform(
+  private async ensureControlTables(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
-    op: DataTransformOperation,
-    options: { runIdempotency: boolean },
   ): Promise<Result<void, SqlMigrationRunnerFailure>> {
-    // Step 1: Check (skip guard)
-    if (op.check === true) {
-      // Always skip, regardless of idempotency setting
-      return okVoid();
-    }
-    if (options.runIdempotency && op.check !== null && op.check !== false) {
-      const checkResult = await driver.query(op.check.sql, op.check.params);
-      if (checkResult.rows.length === 0) {
-        // No violations — already applied, skip
-        return okVoid();
-      }
-    }
-
-    // Step 2: Execute run steps
-    if (op.run) {
-      for (const plan of op.run) {
-        try {
-          await driver.query(plan.sql, plan.params);
-        } catch (error: unknown) {
-          if (SqlQueryError.is(error)) {
-            return runnerFailure(
-              'EXECUTION_FAILED',
-              `Data transform "${op.name}" failed: ${error.message}`,
-              {
-                why: error.message,
-                meta: {
-                  operationId: op.id,
-                  dataTransformName: op.name,
-                  sql: plan.sql,
-                  sqlState: error.sqlState,
-                },
-              },
-            );
-          }
-          throw error;
-        }
-      }
-    }
-
-    // Step 3: Post-run validation (check again)
-    if (op.check !== null && op.check !== false) {
-      const checkResult = await driver.query(op.check.sql, op.check.params);
-      if (checkResult.rows.length > 0) {
-        return runnerFailure(
-          'POSTCHECK_FAILED',
-          `Data transform "${op.name}" did not resolve all violations (${checkResult.rows.length} remaining)`,
-          {
-            why: `After executing the data transform, the check query still returns ${checkResult.rows.length} violation(s).`,
-            meta: {
-              operationId: op.id,
-              dataTransformName: op.name,
-              remainingViolations: checkResult.rows.length,
-            },
-          },
-        );
-      }
+    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
+    // Pre-1.0 zero-range guardrail: detect a pre-cleanup single-row
+    // marker table (no `space` column) and surface a structured failure
+    // rather than silently auto-migrating it to the per-space shape.
+    // See `specs/framework-mechanism.spec.md § 2`.
+    const legacyDetection = await this.detectLegacyMarkerShape(driver);
+    if (!legacyDetection.ok) {
+      return legacyDetection;
     }
-
+    await this.executeStatement(driver, ensureMarkerTableStatement);
+    await this.executeStatement(driver, ensureLedgerTableStatement);
     return okVoid();
   }
 
-  private async ensureControlTables(
+  private async detectLegacyMarkerShape(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
-  ): Promise<void> {
-    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
-    await this.executeStatement(driver, ensureMarkerTableStatement);
-    await this.executeStatement(driver, ensureLedgerTableStatement);
+  ): Promise<Result<void, SqlMigrationRunnerFailure>> {
+    const result = await driver.query<{ column_name: string }>(
+      `select column_name
+         from information_schema.columns
+        where table_schema = 'prisma_contract'
+          and table_name = 'marker'`,
+    );
+    if (result.rows.length === 0) {
+      return okVoid();
+    }
+    const columns = new Set(result.rows.map((row) => row.column_name));
+    if (columns.has('space')) {
+      return okVoid();
+    }
+    return runnerFailure(
+      'LEGACY_MARKER_SHAPE',
+      'Legacy marker-table shape detected on prisma_contract.marker (no `space` column). ' +
+        'Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. ' +
+        'Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.',
+      {
+        meta: {
+          table: 'prisma_contract.marker',
+          columns: [...columns].sort(),
+        },
+      },
+    );
   }
 
   private async runExpectationSteps(
@@ -355,7 +372,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     phase: 'precheck' | 'postcheck',
   ): Promise<Result<void, SqlMigrationRunnerFailure>> {
     for (const step of steps) {
-      const result = await driver.query(step.sql);
+      const result = await driver.query(step.sql, step.params ?? []);
       if (!this.stepResultIsTrue(result.rows)) {
         const code = phase === 'precheck' ? 'PRECHECK_FAILED' : 'POSTCHECK_FAILED';
         return runnerFailure(
@@ -381,7 +398,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
   ): Promise<Result<void, SqlMigrationRunnerFailure>> {
     for (const step of steps) {
       try {
-        await driver.query(step.sql);
+        await driver.query(step.sql, step.params ?? []);
       } catch (error: unknown) {
         // Catch SqlQueryError and include normalized metadata
         if (SqlQueryError.is(error)) {
@@ -445,7 +462,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       return false;
     }
     for (const step of steps) {
-      const result = await driver.query(step.sql);
+      const result = await driver.query(step.sql, step.params ?? []);
       if (!this.stepResultIsTrue(result.rows)) {
         return false;
       }
@@ -616,8 +633,11 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
     existingMarker: ContractMarkerRecord | null,
+    space: string,
   ): Promise<void> {
-    const writeStatements = buildWriteMarkerStatements({
+    const incomingInvariants = options.plan.providedInvariants ?? [];
+    const writeStatements = buildMergeMarkerStatements({
+      space,
       storageHash: options.plan.destination.storageHash,
       profileHash:
         options.plan.destination.profileHash ??
@@ -626,6 +646,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       contractJson: options.destinationContract,
       canonicalVersion: null,
       meta: {},
+      invariants: incomingInvariants,
     });
     const statement = existingMarker ? writeStatements.update : writeStatements.insert;
     await this.executeStatement(driver, statement);

package/src/core/migrations/statement-builders.ts

@@ -1,3 +1,7 @@
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+
+export { APP_SPACE_ID };
+
 export interface SqlStatement {
   readonly sql: string;
   readonly params: readonly unknown[];
@@ -8,16 +12,26 @@ export const ensurePrismaContractSchemaStatement: SqlStatement = {
   params: [],
 };
 
+/**
+ * Schema for `prisma_contract.marker`. The `space text` primary key
+ * supports one row per loaded contract space (`'app'`,
+ * `'<extension-id>'`, …); on a brand-new database `CREATE TABLE IF NOT
+ * EXISTS` produces this shape directly. The migration runner detects
+ * pre-1.0 single-row markers (no `space` column) at boot and fails with
+ * a structured `LEGACY_MARKER_SHAPE` error rather than auto-migrating —
+ * see `specs/framework-mechanism.spec.md § 2`.
+ */
 export const ensureMarkerTableStatement: SqlStatement = {
   sql: `create table if not exists prisma_contract.marker (
-    id smallint primary key default 1,
+    space text not null primary key default '${APP_SPACE_ID}',
     core_hash text not null,
     profile_hash text not null,
     contract_json jsonb,
     canonical_version int,
     updated_at timestamptz not null default now(),
     app_tag text,
-    meta jsonb not null default '{}'
+    meta jsonb not null default '{}',
+    invariants text[] not null default '{}'
   )`,
   params: [],
 };
@@ -37,40 +51,59 @@ export const ensureLedgerTableStatement: SqlStatement = {
   params: [],
 };
 
-export interface WriteMarkerInput {
+export interface MergeMarkerInput {
+  /**
+   * Logical space identifier for this marker row. Required at every
+   * call site so the type system surfaces every place that needs to
+   * thread the value (rather than letting an `?? APP_SPACE_ID`
+   * fall-through silently collapse multi-space markers onto the
+   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}
+   * (`'app'`); per-extension callers (planner / runner / verifier
+   * extensions over contract spaces) pass the extension's space id.
+   */
+  readonly space: string;
   readonly storageHash: string;
   readonly profileHash: string;
   readonly contractJson?: unknown;
   readonly canonicalVersion?: number | null;
   readonly appTag?: string | null;
   readonly meta?: Record<string, unknown>;
+  /**
+   * Invariants to merge into `marker.invariants`. INSERT writes them as
+   * the initial value (callers are expected to pass a sorted, deduped
+   * array). UPDATE merges them with the existing column server-side via
+   * a single atomic SQL expression.
+   */
+  readonly invariants: readonly string[];
 }
 
-export function buildWriteMarkerStatements(input: WriteMarkerInput): {
+export function buildMergeMarkerStatements(input: MergeMarkerInput): {
   readonly insert: SqlStatement;
   readonly update: SqlStatement;
 } {
   const params: readonly unknown[] = [
-    1,
+    input.space,
     input.storageHash,
     input.profileHash,
     jsonParam(input.contractJson),
     input.canonicalVersion ?? null,
     input.appTag ?? null,
     jsonParam(input.meta ?? {}),
+    input.invariants,
   ];
 
   return {
     insert: {
       sql: `insert into prisma_contract.marker (
-        id,
+        space,
         core_hash,
         profile_hash,
         contract_json,
         canonical_version,
         updated_at,
         app_tag,
-        meta
+        meta,
+        invariants
       ) values (
         $1,
         $2,
@@ -79,11 +112,16 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
         $5,
         now(),
         $6,
-        $7::jsonb
+        $7::jsonb,
+        $8::text[]
       )`,
       params,
     },
     update: {
+      // `invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)`
+      // reads the current column value under the UPDATE's row lock, unions
+      // with the incoming array, dedupes, and sorts ascending — single
+      // statement, atomic, no read-then-write window.
       sql: `update prisma_contract.marker set
         core_hash = $2,
         profile_hash = $3,
@@ -91,8 +129,9 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
         canonical_version = $5,
         updated_at = now(),
         app_tag = $6,
-        meta = $7::jsonb
-      where id = $1`,
+        meta = $7::jsonb,
+        invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)
+      where space = $1`,
       params,
     },
   };

package/src/core/registry.ts

@@ -0,0 +1,11 @@
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
+import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { codecDescriptors } from './codecs';
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/target-postgres`.
+ *
+ * Public consumer surface for the postgres codec set: the postgres adapter and any other consumer that needs to enumerate or look up a postgres codec by id consumes this rather than the raw descriptor array. See ADR 208.
+ */
+export const postgresCodecRegistry: CodecDescriptorRegistry =
+  buildCodecDescriptorRegistry(codecDescriptors);

package/src/exports/codec-types.ts

@@ -1,26 +1,17 @@
 /**
  * Codec type definitions for the Postgres target.
  *
- * This file exports type-only definitions for codec input/output types.
- * These types are imported by generated `contract.d.ts` files for compile-time
- * type inference.
+ * This file is the public origin of `CodecTypes`. The `Resolve<...>` materialisation happens here (rather than in `core/codec-type-map.ts`) so the tsdown DTS bundler resolves consumer-side `.d.mts` references via this public entry point rather than a hash-named internal chunk (the `TS2742` family).
  *
- * Lives in `target-postgres` because codec types describe the target's value
- * space - both the control adapter (introspection / schema verification) and
- * the runtime adapter (encode/decode) share the same definitions, and the
- * target package is the natural home that both adapters depend on.
- *
- * Runtime codec implementations are provided by the runtime adapter's
- * codec registry, which is built from `core/codecs.ts`.
+ * Lives in `target-postgres` because codec types describe the target's value space — both the control adapter (introspection / schema verification) and the runtime adapter (encode/decode) share the same definitions, and the target package is the natural home that both adapters depend on.
  */
 
 import type { JsonValue } from '@prisma-next/contract/types';
-import type { CodecTypes as CoreCodecTypes } from '../core/codecs';
+import type { ExtractedCodecTypes, Resolve } from '../core/codec-type-map';
 
-export type CodecTypes = CoreCodecTypes;
+export type CodecTypes = Resolve<ExtractedCodecTypes>;
 
 export type { JsonValue };
-export { dataTypes } from '../core/codecs';
 
 type Branded<T, Shape extends Record<string, unknown>> = T & {
   readonly [K in keyof Shape]: Shape[K];

package/src/exports/codecs.ts

@@ -1,2 +1,49 @@
-export type { CodecTypes } from '../core/codecs';
-export { codecDefinitions, dataTypes } from '../core/codecs';
+export type {
+  PgBitDescriptor,
+  PgBoolDescriptor,
+  PgCharDescriptor,
+  PgEnumDescriptor,
+  PgFloat4Descriptor,
+  PgFloat8Descriptor,
+  PgFloatDescriptor,
+  PgInt2Descriptor,
+  PgInt4Descriptor,
+  PgInt8Descriptor,
+  PgIntDescriptor,
+  PgIntervalDescriptor,
+  PgJsonbDescriptor,
+  PgJsonDescriptor,
+  PgNumericDescriptor,
+  PgTextDescriptor,
+  PgTimeDescriptor,
+  PgTimestampDescriptor,
+  PgTimestamptzDescriptor,
+  PgTimetzDescriptor,
+  PgVarbitDescriptor,
+  PgVarcharDescriptor,
+} from '../core/codecs';
+export {
+  pgBitColumn,
+  pgBoolColumn,
+  pgCharColumn,
+  pgEnumColumn,
+  pgFloat4Column,
+  pgFloat8Column,
+  pgFloatColumn,
+  pgInt2Column,
+  pgInt4Column,
+  pgInt8Column,
+  pgIntColumn,
+  pgIntervalColumn,
+  pgJsonbColumn,
+  pgJsonColumn,
+  pgNumericColumn,
+  pgTextColumn,
+  pgTimeColumn,
+  pgTimestampColumn,
+  pgTimestamptzColumn,
+  pgTimetzColumn,
+  pgVarbitColumn,
+  pgVarcharColumn,
+} from '../core/codecs';
+export { postgresCodecRegistry } from '../core/registry';