@prisma-next/target-postgres 0.5.0-dev.5 → 0.5.0-dev.50

package/dist/{planner-produced-postgres-migration-DSSPq8QS.mjs.map → planner-produced-postgres-migration-Bi-RWO4-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-DSSPq8QS.mjs","names":["#calls","#meta"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly PostgresOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n\n  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('kind', this.#meta.kind),\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE,CAASA;CACT,CAASC;CAET,YAAY,OAAyC,MAAqB;AACxE,SAAO;AACP,QAAKD,QAAS;AACd,QAAKC,OAAQ;;CAGf,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKD,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKD,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,QAAQ,MAAKA,KAAM,KAAK;GACrC,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}
+{"version":3,"file":"planner-produced-postgres-migration-Bi-RWO4-.mjs","names":["#calls","#meta"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly PostgresOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n\n  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE,CAASA;CACT,CAASC;CAET,YAAY,OAAyC,MAAqB;AACxE,SAAO;AACP,QAAKD,QAAS;AACd,QAAKC,OAAQ;;CAGf,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKD,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKD,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}

package/dist/{planner-produced-postgres-migration-CRRTno6Z.d.mts → planner-produced-postgres-migration-M3EfhWSS.d.mts}

@@ -1,6 +1,6 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
 import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
-import { t as PostgresMigration } from "./postgres-migration-BjA3Zmts.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BFjbb25b.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface } from "@prisma-next/framework-components/control";
 import { MigrationMeta } from "@prisma-next/migration-tools/migration";
@@ -17,4 +17,4 @@ declare class TypeScriptRenderablePostgresMigration extends PostgresMigration im
 }
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
-//# sourceMappingURL=planner-produced-postgres-migration-CRRTno6Z.d.mts.map
+//# sourceMappingURL=planner-produced-postgres-migration-M3EfhWSS.d.mts.map

package/dist/planner-produced-postgres-migration-M3EfhWSS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-postgres-migration-M3EfhWSS.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAmCK,EAAA,GAAK,0BAA0B;cAEvB,qCAAA,SACH,iBAAA,YACG;;8BAKiB,+BAA+B;6BAMvB;cAIf"}

package/dist/planner-produced-postgres-migration.d.mts

@@ -1,5 +1,6 @@
+import "./data-transform-CrpmG4uJ.mjs";
 import "./shared-Bxkt8pNO.mjs";
 import "./op-factory-call-C3bWXKSP.mjs";
-import "./postgres-migration-BjA3Zmts.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CRRTno6Z.mjs";
+import "./postgres-migration-BFjbb25b.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-M3EfhWSS.mjs";
 export { TypeScriptRenderablePostgresMigration };

package/dist/planner-produced-postgres-migration.mjs

@@ -1,3 +1,3 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-DSSPq8QS.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Bi-RWO4-.mjs";
 
 export { TypeScriptRenderablePostgresMigration };

package/dist/planner.d.mts

@@ -1,10 +1,12 @@
+import "./data-transform-CrpmG4uJ.mjs";
 import "./shared-Bxkt8pNO.mjs";
 import "./op-factory-call-C3bWXKSP.mjs";
-import "./postgres-migration-BjA3Zmts.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CRRTno6Z.mjs";
+import "./postgres-migration-BFjbb25b.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-M3EfhWSS.mjs";
 import { MigrationOperationPolicy, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
-import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
+import { Contract } from "@prisma-next/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 
 //#region src/core/migrations/planner.d.ts
 interface PlannerConfig {
@@ -45,16 +47,21 @@ declare class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postg
     readonly contract: unknown;
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
-    readonly fromHash?: string;
     /**
      * The "from" contract (state the planner assumes the database starts
-     * at). Only `migration plan` supplies this; `db update` / `db init`
-     * reconcile against the live schema with no old contract. When present
-     * alongside the `'data'` operation class, strategies that need from/to
-     * column shape comparisons (unsafe type change, nullability tightening)
-     * activate.
+     * at), or `null` for reconciliation flows. Only `migration plan` ever
+     * supplies a non-null value; `db update` / `db init` reconcile against
+     * the live schema and pass `null`. When present alongside the
+     * `'data'` operation class, strategies that need from/to column-shape
+     * comparisons (unsafe type change, nullability tightening) activate.
+     *
+     * Typed as the framework `Contract | null` to satisfy the
+     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL
+     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate
+     * `describe().from` on the produced plan as
+     * `fromContract?.storage.storageHash ?? null`.
      */
-    readonly fromContract?: unknown;
+    readonly fromContract: Contract | null;
     readonly schemaName?: string;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
   }): PostgresPlanResult;

package/dist/planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAkCU,aAAA;;;iBAQM,8BAAA,UACN,QAAQ,iBACf;;AA3B2F;AAyB9F;;;;;AAgBY,KAAA,kBAAA,GAAkB;EAoBjB,SAAA,IAAA,EAAA,SAAA;EAC0B,SAAA,IAAA,EApBQ,qCAoBR;CAKlB,GAxBjB,uBAwBiB;;;;;;;;;;;;;;;;;cANR,wBAAA,YAAoC;;sBACV;;;;qBAKlB;;;;;;;;;;;;kCAYa,cAAc;MAC1C;0BAIoB,2BAA2B"}
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;UAmCU,aAAA;;;iBAQM,8BAAA,UACN,QAAQ,iBACf;;;AA3B2F;AAyB9F;;;;AAE2B,KAcf,kBAAA,GAde;EAcf,SAAA,IAAA,EAAA,SAAkB;EAoBjB,SAAA,IAAA,EAnBkC,qCAmBT;CACC,GAnBnC,uBAmBmC;;;;;;;;;;;;;;;;;cAD1B,wBAAA,YAAoC;;sBACV;;;;qBAKlB;;;;;;;;;;;;;;;2BAeM;;kCAEO,cAAc;MAC1C;0BAIoB,2BAA2B"}

package/dist/planner.mjs

@@ -1,4 +1,4 @@
 import "./issue-planner-CFjB0_oO.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-CLUvVhUN.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-Cm-ZLutk.mjs";
 
 export { createPostgresMigrationPlanner };

package/dist/{postgres-migration-BjA3Zmts.d.mts → postgres-migration-BFjbb25b.d.mts}

@@ -1,5 +1,6 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
-import { n as DataTransformOptions, r as PostgresDataTransformOperation } from "./data-transform-CxFRBIUp.mjs";
+import { n as DataTransformOptions } from "./data-transform-CrpmG4uJ.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { Migration } from "@prisma-next/family-sql/migration";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
@@ -43,8 +44,8 @@ declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDet
    * supplies the stored control adapter. Authors call this from inside
    * `get operations()`; the adapter argument is hidden from the call site.
    */
-  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): PostgresDataTransformOperation;
+  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-BjA3Zmts.d.mts.map
+//# sourceMappingURL=postgres-migration-BFjbb25b.d.mts.map

package/dist/postgres-migration-BFjbb25b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-BFjbb25b.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,UAC9C;;;;;;;;qCAWmC;sBAEf;;;;;;4CAesB,SAAS,uBACvC,kCAED,uBACR,0BAA0B"}

package/dist/{postgres-migration-qtmtbONe.mjs → postgres-migration-BS9vQW97.mjs}

@@ -1,5 +1,5 @@
 import { t as errorPostgresMigrationStackMissing } from "./errors-AFvEPZ1R.mjs";
-import { t as dataTransform } from "./data-transform-VfEGzXWt.mjs";
+import { t as dataTransform } from "./data-transform-Be_i_DBc.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 
 //#region src/core/migrations/postgres-migration.ts
@@ -49,4 +49,4 @@ var PostgresMigration = class extends Migration {
 
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-qtmtbONe.mjs.map
+//# sourceMappingURL=postgres-migration-BS9vQW97.mjs.map

package/dist/postgres-migration-BS9vQW97.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-BS9vQW97.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a target-specific re-export of this\n * class from `@prisma-next/target-postgres/migration`, keeping the\n * authoring surface target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,AAAS,WAAW;;;;;;;CAQpB,AAAmB;CAEnB,YAAY,OAAyC;AACnD,QAAM,MAAM;AAIZ,OAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,MAAM,GAC5B;;;;;;;CAQN,AAAU,cACR,UACA,MACA,SACsD;AACtD,MAAI,CAAC,KAAK,eACR,OAAM,oCAAoC;AAE5C,SAAO,cAAc,UAAU,MAAM,SAAS,KAAK,eAAe"}

package/dist/{render-typescript-1rF_SB4g.mjs → render-typescript-Co3Emwgz.mjs}

@@ -68,7 +68,6 @@ function buildDescribeMethod(meta) {
 	lines.push("    return {");
 	lines.push(`      from: ${JSON.stringify(meta.from)},`);
 	lines.push(`      to: ${JSON.stringify(meta.to)},`);
-	if (meta.kind) lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
 	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
 	lines.push("    };");
 	lines.push("  }");
@@ -82,4 +81,4 @@ function indent(text, spaces) {
 
 //#endregion
 export { renderCallsToTypeScript as t };
-//# sourceMappingURL=render-typescript-1rF_SB4g.mjs.map
+//# sourceMappingURL=render-typescript-Co3Emwgz.mjs.map

package/dist/render-typescript-Co3Emwgz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-Co3Emwgz.mjs","names":["BASE_IMPORTS: readonly ImportRequirement[]","requirements: ImportRequirement[]","lines: string[]"],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `PostgresOpFactoryCall` renders itself via `renderTypeScript()` and\n * declares its own `importRequirements()`; this file just composes the module\n * source around those contributions. The design mirrors the Mongo target's\n * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n * (different factory module specifiers, different base-class name) but the\n * shape is, so future consolidation to a framework-level helper is mechanical.\n */\n\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n  readonly labels?: readonly string[];\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/target-postgres/migration` so an authored Postgres\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint:\n *\n * - `Migration` — the target-owned re-export fixes the `SqlMigration`\n *   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n *   to `'postgres'`, so user-authored migrations don't need to thread\n *   target-details or redeclare `targetId`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n *   The migration file owns this dependency directly: pulling CLI\n *   machinery in at script run time is acceptable because the script's\n *   whole purpose is to be invoked from the project that owns the\n *   config.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<PostgresOpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction buildImports(calls: ReadonlyArray<PostgresOpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  if (meta.labels && meta.labels.length > 0) {\n    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);\n  }\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAMA,eAA6C,CACjD;CAAE,iBAAiB;CAA0C,QAAQ;CAAa,EAClF;CAAE,iBAAiB;CAA0C,QAAQ;CAAgB,CACtF;AAED,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,MAAM;CACnC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,kBAAkB,CAAC,CAAC,KAAK,MAAM;AAEzE,QAAO;EACL,eAAe,uBAAuB,CAAC;EACvC;EACA;EACA;EACA,oBAAoB,KAAK;EACzB;EACA;EACA,OAAO,gBAAgB,EAAE;EACzB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK;;AAGd,SAAS,aAAa,OAAqD;CACzE,MAAMC,eAAoC,CAAC,GAAG,aAAa;AAC3D,MAAK,MAAM,QAAQ,MACjB,MAAK,MAAM,OAAO,KAAK,oBAAoB,CACzC,cAAa,KAAK,IAAI;AAG1B,QAAO,cAAc,aAAa;;AAGpC,SAAS,oBAAoB,MAAmC;CAC9D,MAAMC,QAAkB,EAAE;AAC1B,OAAM,KAAK,0BAA0B;AACrC,OAAM,KAAK,eAAe;AAC1B,OAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;AACvD,OAAM,KAAK,aAAa,KAAK,UAAU,KAAK,GAAG,CAAC,GAAG;AACnD,KAAI,KAAK,UAAU,KAAK,OAAO,SAAS,EACtC,OAAM,KAAK,iBAAiB,eAAe,KAAK,OAAO,CAAC,GAAG;AAE7D,OAAM,KAAK,SAAS;AACpB,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AACd,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,OAAO;AAC9B,QAAO,KACJ,MAAM,KAAK,CACX,KAAK,SAAU,KAAK,MAAM,GAAG,GAAG,MAAM,SAAS,KAAM,CACrD,KAAK,KAAK"}

package/dist/render-typescript.d.mts

@@ -4,9 +4,8 @@ import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
 //#region src/core/migrations/render-typescript.d.ts
 
 interface RenderMigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: string;
   readonly labels?: readonly string[];
 }
 declare function renderCallsToTypeScript(calls: ReadonlyArray<PostgresOpFactoryCall>, meta: RenderMigrationMeta): string;

package/dist/render-typescript.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"render-typescript.d.mts","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":[],"mappings":";;;;;UAeiB,mBAAA;;;;;;iBA8BD,uBAAA,QACP,cAAc,8BACf"}
+{"version":3,"file":"render-typescript.d.mts","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":[],"mappings":";;;;;UAeiB,mBAAA;;;;;iBA6BD,uBAAA,QACP,cAAc,8BACf"}

package/dist/render-typescript.mjs

@@ -1,3 +1,3 @@
-import { t as renderCallsToTypeScript } from "./render-typescript-1rF_SB4g.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-Co3Emwgz.mjs";
 
 export { renderCallsToTypeScript };

package/dist/{statement-builders-BPnmt6wx.mjs → statement-builders-CHqCtSfe.mjs}

@@ -12,7 +12,8 @@ const ensureMarkerTableStatement = {
     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: []
 };
@@ -30,7 +31,7 @@ const ensureLedgerTableStatement = {
   )`,
 	params: []
 };
-function buildWriteMarkerStatements(input) {
+function buildMergeMarkerStatements(input) {
 	const params = [
 		1,
 		input.storageHash,
@@ -38,7 +39,8 @@ function buildWriteMarkerStatements(input) {
 		jsonParam(input.contractJson),
 		input.canonicalVersion ?? null,
 		input.appTag ?? null,
-		jsonParam(input.meta ?? {})
+		jsonParam(input.meta ?? {}),
+		input.invariants
 	];
 	return {
 		insert: {
@@ -50,7 +52,8 @@ function buildWriteMarkerStatements(input) {
         canonical_version,
         updated_at,
         app_tag,
-        meta
+        meta,
+        invariants
       ) values (
         $1,
         $2,
@@ -59,7 +62,8 @@ function buildWriteMarkerStatements(input) {
         $5,
         now(),
         $6,
-        $7::jsonb
+        $7::jsonb,
+        $8::text[]
       )`,
 			params
 		},
@@ -71,7 +75,8 @@ function buildWriteMarkerStatements(input) {
         canonical_version = $5,
         updated_at = now(),
         app_tag = $6,
-        meta = $7::jsonb
+        meta = $7::jsonb,
+        invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)
       where id = $1`,
 			params
 		}
@@ -112,5 +117,5 @@ function jsonParam(value) {
 }
 
 //#endregion
-export { ensurePrismaContractSchemaStatement as a, ensureMarkerTableStatement as i, buildWriteMarkerStatements as n, ensureLedgerTableStatement as r, buildLedgerInsertStatement as t };
-//# sourceMappingURL=statement-builders-BPnmt6wx.mjs.map
+export { ensurePrismaContractSchemaStatement as a, ensureMarkerTableStatement as i, buildMergeMarkerStatements as n, ensureLedgerTableStatement as r, buildLedgerInsertStatement as t };
+//# sourceMappingURL=statement-builders-CHqCtSfe.mjs.map

package/dist/statement-builders-CHqCtSfe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-builders-CHqCtSfe.mjs","names":["ensurePrismaContractSchemaStatement: SqlStatement","ensureMarkerTableStatement: SqlStatement","ensureLedgerTableStatement: SqlStatement","params: readonly unknown[]"],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["export interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const ensurePrismaContractSchemaStatement: SqlStatement = {\n  sql: 'create schema if not exists prisma_contract',\n  params: [],\n};\n\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.marker (\n    id smallint primary key default 1,\n    core_hash text not null,\n    profile_hash text not null,\n    contract_json jsonb,\n    canonical_version int,\n    updated_at timestamptz not null default now(),\n    app_tag text,\n    meta jsonb not null default '{}',\n    invariants text[] not null default '{}'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.ledger (\n    id bigserial primary key,\n    created_at timestamptz not null default now(),\n    origin_core_hash text,\n    origin_profile_hash text,\n    destination_core_hash text not null,\n    destination_profile_hash text,\n    contract_json_before jsonb,\n    contract_json_after jsonb,\n    operations jsonb not null\n  )`,\n  params: [],\n};\n\nexport interface MergeMarkerInput {\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to merge into `marker.invariants`. INSERT writes them as\n   * the initial value (callers are expected to pass a sorted, deduped\n   * array). UPDATE merges them with the existing column server-side via\n   * a single atomic SQL expression.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildMergeMarkerStatements(input: MergeMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    1,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    input.invariants,\n  ];\n\n  return {\n    insert: {\n      sql: `insert into prisma_contract.marker (\n        id,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) values (\n        $1,\n        $2,\n        $3,\n        $4::jsonb,\n        $5,\n        now(),\n        $6,\n        $7::jsonb,\n        $8::text[]\n      )`,\n      params,\n    },\n    update: {\n      // `invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)`\n      // reads the current column value under the UPDATE's row lock, unions\n      // with the incoming array, dedupes, and sorts ascending — single\n      // statement, atomic, no read-then-write window.\n      sql: `update prisma_contract.marker set\n        core_hash = $2,\n        profile_hash = $3,\n        contract_json = $4::jsonb,\n        canonical_version = $5,\n        updated_at = now(),\n        app_tag = $6,\n        meta = $7::jsonb,\n        invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)\n      where id = $1`,\n      params,\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `insert into prisma_contract.ledger (\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) values (\n      $1,\n      $2,\n      $3,\n      $4,\n      $5::jsonb,\n      $6::jsonb,\n      $7::jsonb\n    )`,\n    params: [\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";AAKA,MAAaA,sCAAoD;CAC/D,KAAK;CACL,QAAQ,EAAE;CACX;AAED,MAAaC,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,EAAE;CACX;AAED,MAAaC,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,EAAE;CACX;AAkBD,SAAgB,2BAA2B,OAGzC;CACA,MAAMC,SAA6B;EACjC;EACA,MAAM;EACN,MAAM;EACN,UAAU,MAAM,aAAa;EAC7B,MAAM,oBAAoB;EAC1B,MAAM,UAAU;EAChB,UAAU,MAAM,QAAQ,EAAE,CAAC;EAC3B,MAAM;EACP;AAED,QAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL;GACD;EACD,QAAQ;GAKN,KAAK;;;;;;;;;;GAUL;GACD;EACF;;AAaH,SAAgB,2BAA2B,OAAwC;AACjF,QAAO;EACL,KAAK;;;;;;;;;;;;;;;;;EAiBL,QAAQ;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,mBAAmB;GACnC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,WAAW;GAC5B;EACF;;AAGH,SAAS,UAAU,OAAwB;AACzC,QAAO,KAAK,UAAU,SAAS,KAAK"}

package/dist/statement-builders.d.mts

@@ -6,18 +6,25 @@ interface SqlStatement {
 declare const ensurePrismaContractSchemaStatement: SqlStatement;
 declare const ensureMarkerTableStatement: SqlStatement;
 declare const ensureLedgerTableStatement: SqlStatement;
-interface WriteMarkerInput {
+interface MergeMarkerInput {
   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[];
 }
-declare function buildWriteMarkerStatements(input: WriteMarkerInput): {
+declare function buildMergeMarkerStatements(input: MergeMarkerInput): {
   readonly insert: SqlStatement;
   readonly update: SqlStatement;
 };
 //#endregion
-export { type SqlStatement, buildWriteMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };
+export { type SqlStatement, buildMergeMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };
 //# sourceMappingURL=statement-builders.d.mts.map

package/dist/statement-builders.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":[],"mappings":";UAAiB,YAAA;EAAA,SAAA,GAAA,EAAA,MAAY;EAKhB,SAAA,MAAA,EAAA,SAAA,OAAA,EAAA;AAKb;AAca,cAnBA,mCAmB4B,EAnBS,YAgCjD;AAEgB,cA7BJ,0BAmCW,EAnCiB,YAmCjB;AAGR,cAxBH,0BAwB6B,EAxBD,YAwBC;AAAQ,UATjC,gBAAA,CASiC;EAC/B,SAAA,WAAA,EAAA,MAAA;EACA,SAAA,WAAA,EAAA,MAAA;EAAY,SAAA,YAAA,CAAA,EAAA,OAAA;;;kBALb;;iBAGF,0BAAA,QAAkC;mBAC/B;mBACA"}
+{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":[],"mappings":";UAAiB,YAAA;EAAA,SAAA,GAAA,EAAA,MAAY;EAKhB,SAAA,MAAA,EAAA,SAAA,OAAA,EAAA;AAKb;AAea,cApBA,mCAoB4B,EApBS,YAiCjD;AAEgB,cA9BJ,0BAoCW,EApCiB,YAoCjB;AAUR,cA/BH,0BA+B6B,EA/BD,YA+BC;AAAQ,UAhBjC,gBAAA,CAgBiC;EAC/B,SAAA,WAAA,EAAA,MAAA;EACA,SAAA,WAAA,EAAA,MAAA;EAAY,SAAA,YAAA,CAAA,EAAA,OAAA;;;kBAZb;;;;;;;;;iBAUF,0BAAA,QAAkC;mBAC/B;mBACA"}

package/dist/statement-builders.mjs

@@ -1,3 +1,3 @@
-import { a as ensurePrismaContractSchemaStatement, i as ensureMarkerTableStatement, n as buildWriteMarkerStatements, r as ensureLedgerTableStatement } from "./statement-builders-BPnmt6wx.mjs";
+import { a as ensurePrismaContractSchemaStatement, i as ensureMarkerTableStatement, n as buildMergeMarkerStatements, r as ensureLedgerTableStatement } from "./statement-builders-CHqCtSfe.mjs";
 
-export { buildWriteMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };
+export { buildMergeMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.5.0-dev.5",
+  "version": "0.5.0-dev.50",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
     "pathe": "^2.0.3",
-    "@prisma-next/cli": "0.5.0-dev.5",
-    "@prisma-next/contract": "0.5.0-dev.5",
-    "@prisma-next/errors": "0.5.0-dev.5",
-    "@prisma-next/framework-components": "0.5.0-dev.5",
-    "@prisma-next/migration-tools": "0.5.0-dev.5",
-    "@prisma-next/ts-render": "0.5.0-dev.5",
-    "@prisma-next/sql-errors": "0.5.0-dev.5",
-    "@prisma-next/family-sql": "0.5.0-dev.5",
-    "@prisma-next/sql-operations": "0.5.0-dev.5",
-    "@prisma-next/sql-contract": "0.5.0-dev.5",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.5",
-    "@prisma-next/utils": "0.5.0-dev.5",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.5"
+    "@prisma-next/contract": "0.5.0-dev.50",
+    "@prisma-next/errors": "0.5.0-dev.50",
+    "@prisma-next/migration-tools": "0.5.0-dev.50",
+    "@prisma-next/family-sql": "0.5.0-dev.50",
+    "@prisma-next/cli": "0.5.0-dev.50",
+    "@prisma-next/framework-components": "0.5.0-dev.50",
+    "@prisma-next/ts-render": "0.5.0-dev.50",
+    "@prisma-next/sql-contract": "0.5.0-dev.50",
+    "@prisma-next/sql-errors": "0.5.0-dev.50",
+    "@prisma-next/sql-operations": "0.5.0-dev.50",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.50",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.50",
+    "@prisma-next/utils": "0.5.0-dev.50"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",

package/src/core/codec-ids.ts

@@ -28,3 +28,4 @@ export const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;
 export const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;
 export const PG_JSON_CODEC_ID = 'pg/json@1' as const;
 export const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;
+export const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;

package/src/core/codecs.ts

@@ -19,6 +19,7 @@ import { type as arktype } from 'arktype';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
+  PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
@@ -40,7 +41,6 @@ import {
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
 } from './codec-ids';
-import { renderTypeScriptTypeFromJsonSchema } from './json-schema-type-expression';
 
 const lengthParamsSchema = arktype({
   length: 'number.integer > 0',
@@ -85,19 +85,13 @@ function renderPrecision(typeName: string, typeParams: Record<string, unknown>):
   return `${typeName}<${precision}>`;
 }
 
-function renderJsonOutputType(typeParams: Record<string, unknown>): string {
-  const typeName = typeParams['type'];
-  if (typeof typeName === 'string' && typeName.trim().length > 0) {
-    return typeName.trim();
-  }
-  const schema = typeParams['schemaJson'];
-  if (schema && typeof schema === 'object') {
-    return renderTypeScriptTypeFromJsonSchema(schema);
-  }
-  throw new Error(
-    `renderOutputType: JSON codec typeParams must contain "type" (string) or "schemaJson" (object), got keys: ${Object.keys(typeParams).join(', ')}`,
-  );
-}
+// Phase C: postgres' raw json/jsonb codecs no longer carry a
+// `renderOutputType` slot — the schema-typed JSON surface that drove
+// `typeParams: { schemaJson, type? }` retired in favor of the per-library
+// extension package (`@prisma-next/extension-arktype-json`). Untyped
+// json/jsonb columns have no typeParams; the framework emit path falls
+// through to the generic `CodecTypes['pg/jsonb@1']['output']` accessor
+// (which resolves to `JsonValue` via the codec-types map).
 
 function aliasCodec<
   Id extends string,
@@ -339,22 +333,15 @@ const pgFloat8Codec = codec({
 const pgTimestampCodec = codec<
   typeof PG_TIMESTAMP_CODEC_ID,
   readonly ['equality', 'order'],
-  string | Date,
-  string | Date
+  Date,
+  Date
 >({
   typeId: PG_TIMESTAMP_CODEC_ID,
   targetTypes: ['timestamp'],
   traits: ['equality', 'order'],
-  encode: (value: string | Date): string => {
-    if (value instanceof Date) return value.toISOString();
-    if (typeof value === 'string') return value;
-    return String(value);
-  },
-  decode: (wire: string | Date): string => {
-    if (wire instanceof Date) return wire.toISOString();
-    return wire;
-  },
-  encodeJson: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),
+  encode: (value: Date): Date => value,
+  decode: (wire: Date): Date => wire,
+  encodeJson: (value: Date) => value.toISOString(),
   decodeJson: (json) => {
     if (typeof json !== 'string') {
       throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
@@ -381,22 +368,15 @@ const pgTimestampCodec = codec<
 const pgTimestamptzCodec = codec<
   typeof PG_TIMESTAMPTZ_CODEC_ID,
   readonly ['equality', 'order'],
-  string | Date,
-  string | Date
+  Date,
+  Date
 >({
   typeId: PG_TIMESTAMPTZ_CODEC_ID,
   targetTypes: ['timestamptz'],
   traits: ['equality', 'order'],
-  encode: (value: string | Date): string => {
-    if (value instanceof Date) return value.toISOString();
-    if (typeof value === 'string') return value;
-    return String(value);
-  },
-  decode: (wire: string | Date): string => {
-    if (wire instanceof Date) return wire.toISOString();
-    return wire;
-  },
-  encodeJson: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),
+  encode: (value: Date): Date => value,
+  decode: (wire: Date): Date => wire,
+  encodeJson: (value: Date) => value.toISOString(),
   decodeJson: (json) => {
     if (typeof json !== 'string') {
       throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
@@ -523,6 +503,40 @@ const pgVarbitCodec = codec<
   },
 });
 
+const pgByteaCodec = codec({
+  typeId: PG_BYTEA_CODEC_ID,
+  targetTypes: ['bytea'],
+  traits: ['equality'],
+  encode: (value: Uint8Array): Uint8Array => value,
+  decode: (wire: Uint8Array): Uint8Array =>
+    // Postgres node drivers commonly return Buffer instances (which extend
+    // Uint8Array) — normalize to a plain Uint8Array view so engine-agnostic
+    // consumers don't accidentally observe Buffer-specific APIs.
+    wire instanceof Uint8Array && wire.constructor === Uint8Array
+      ? wire
+      : new Uint8Array(wire.buffer, wire.byteOffset, wire.byteLength),
+  encodeJson: (value: Uint8Array): string => Buffer.from(value).toString('base64'),
+  decodeJson: (json): Uint8Array => {
+    if (typeof json !== 'string') {
+      throw new Error(`Expected base64 string for pg/bytea@1, got ${typeof json}`);
+    }
+    const decoded = Buffer.from(json, 'base64');
+    if (decoded.toString('base64') !== json) {
+      throw new Error(`Invalid base64 string for pg/bytea@1 (length: ${json.length})`);
+    }
+    return new Uint8Array(decoded);
+  },
+  meta: {
+    db: {
+      sql: {
+        postgres: {
+          nativeType: 'bytea',
+        },
+      },
+    },
+  },
+});
+
 const pgEnumCodec = codec({
   typeId: PG_ENUM_CODEC_ID,
   targetTypes: ['enum'],
@@ -576,7 +590,6 @@ const pgJsonCodec = codec({
   encode: (value: string | JsonValue): string => JSON.stringify(value),
   decode: (wire: string | JsonValue): JsonValue =>
     typeof wire === 'string' ? JSON.parse(wire) : wire,
-  renderOutputType: renderJsonOutputType,
   meta: {
     db: {
       sql: {
@@ -595,7 +608,6 @@ const pgJsonbCodec = codec({
   encode: (value: string | JsonValue): string => JSON.stringify(value),
   decode: (wire: string | JsonValue): JsonValue =>
     typeof wire === 'string' ? JSON.parse(wire) : wire,
-  renderOutputType: renderJsonOutputType,
   meta: {
     db: {
       sql: {
@@ -633,6 +645,7 @@ const codecs = defineCodecs()
   .add('bool', pgBoolCodec)
   .add('bit', pgBitCodec)
   .add('bit varying', pgVarbitCodec)
+  .add('bytea', pgByteaCodec)
   .add('interval', pgIntervalCodec)
   .add('enum', pgEnumCodec)
   .add('json', pgJsonCodec)