@prisma-next/target-postgres 0.4.2 → 0.4.3

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,25 +1,25 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
     "pathe": "^2.0.3",
-    "@prisma-next/cli": "0.4.2",
-    "@prisma-next/contract": "0.4.2",
-    "@prisma-next/errors": "0.4.2",
-    "@prisma-next/family-sql": "0.4.2",
-    "@prisma-next/framework-components": "0.4.2",
-    "@prisma-next/migration-tools": "0.4.2",
-    "@prisma-next/sql-contract": "0.4.2",
-    "@prisma-next/sql-errors": "0.4.2",
-    "@prisma-next/sql-operations": "0.4.2",
-    "@prisma-next/ts-render": "0.4.2",
-    "@prisma-next/sql-relational-core": "0.4.2",
-    "@prisma-next/utils": "0.4.2",
-    "@prisma-next/sql-schema-ir": "0.4.2"
+    "@prisma-next/errors": "0.4.3",
+    "@prisma-next/cli": "0.4.3",
+    "@prisma-next/contract": "0.4.3",
+    "@prisma-next/family-sql": "0.4.3",
+    "@prisma-next/framework-components": "0.4.3",
+    "@prisma-next/migration-tools": "0.4.3",
+    "@prisma-next/sql-contract": "0.4.3",
+    "@prisma-next/sql-errors": "0.4.3",
+    "@prisma-next/ts-render": "0.4.3",
+    "@prisma-next/sql-operations": "0.4.3",
+    "@prisma-next/sql-relational-core": "0.4.3",
+    "@prisma-next/sql-schema-ir": "0.4.3",
+    "@prisma-next/utils": "0.4.3"
   },
   "devDependencies": {
     "tsdown": "0.18.4",

package/src/core/codecs.ts

@@ -40,7 +40,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 +84,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 +332,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 +367,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}`);
@@ -576,7 +555,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 +573,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: {

package/src/core/migrations/operations/data-transform.ts

@@ -37,6 +37,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import { ifDefined } from '@prisma-next/utils/defined';
 
 interface Buildable<R = unknown> {
   build(): SqlQueryPlan<R>;
@@ -49,6 +50,12 @@ interface Buildable<R = unknown> {
 export type DataTransformClosure = () => SqlQueryPlan | Buildable;
 
 export interface DataTransformOptions {
+  /**
+   * Optional opt-in routing identity. Presence opts the transform into
+   * invariant-aware routing; absence means it is path-dependent and
+   * not referenceable from refs.
+   */
+  readonly invariantId?: string;
   /** Optional pre-flight query. `undefined` means "no check". */
   readonly check?: DataTransformClosure;
   /** One or more mutation queries to execute. */
@@ -76,6 +83,7 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
     label: `Data transform: ${name}`,
     operationClass: 'data',
     name,
+    ...ifDefined('invariantId', options.invariantId),
     source: 'migration.ts',
     check: options.check ? invokeAndLower(options.check, contract, adapter, name) : null,
     run: runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),

package/src/core/migrations/planner-produced-postgres-migration.ts

@@ -60,7 +60,6 @@ export class TypeScriptRenderablePostgresMigration
     return renderCallsToTypeScript(this.#calls, {
       from: this.#meta.from,
       to: this.#meta.to,
-      ...ifDefined('kind', this.#meta.kind),
       ...ifDefined('labels', this.#meta.labels),
     });
   }

package/src/core/migrations/planner.ts

@@ -1,3 +1,4 @@
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlMigrationPlannerPlanOptions,
@@ -83,20 +84,25 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     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 {
-    return this.planSql(options as SqlMigrationPlannerPlanOptions, options.fromHash ?? '');
+    return this.planSql(options as SqlMigrationPlannerPlanOptions);
   }
 
   emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {
@@ -106,7 +112,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
   }
 
-  private planSql(options: SqlMigrationPlannerPlanOptions, fromHash: string): PostgresPlanResult {
+  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
     const schemaName = options.schemaName ?? this.config.defaultSchema;
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) {
@@ -125,7 +131,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       // from/to comparisons (unsafe type change, nullable tightening) are
       // inapplicable there — reconciliation falls through to
       // `mapIssueToCall`'s direct destructive handlers.
-      fromContract: options.fromContract ?? null,
+      fromContract: options.fromContract,
       schemaName,
       codecHooks,
       storageTypes,
@@ -142,7 +148,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     return Object.freeze({
       kind: 'success' as const,
       plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {
-        from: fromHash,
+        from: options.fromContract?.storage.storageHash ?? null,
         to: options.contract.storage.storageHash,
       }),
     });

package/src/core/migrations/render-typescript.ts

@@ -14,9 +14,8 @@ import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-n
 import type { PostgresOpFactoryCall } from './op-factory-call';
 
 export interface RenderMigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: string;
   readonly labels?: readonly string[];
 }
 
@@ -84,9 +83,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   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)},`);
   }

package/src/core/migrations/runner.ts

@@ -12,7 +12,6 @@ import type {
 } 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 { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
@@ -23,7 +22,7 @@ import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
-  buildWriteMarkerStatements,
+  buildMergeMarkerStatements,
   ensureLedgerTableStatement,
   ensureMarkerTableStatement,
   ensurePrismaContractSchemaStatement,
@@ -120,7 +119,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     try {
       await this.acquireLock(driver, lockKey);
       await this.ensureControlTables(driver);
-      const existingMarker = await readMarker(driver);
+      const existingMarker = await this.family.readMarker({ driver });
 
       // Validate plan origin matches existing marker (needs marker from DB)
       const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
@@ -128,9 +127,14 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         return markerCheck;
       }
 
-      // db update (origin: null) always applies; migration-apply (origin set) skips if marker matches.
+      // db update (origin: null) always applies; migration-apply (origin set,
+      // origin !== destination) skips if marker already matches destination.
+      // Self-edges (origin === destination) intentionally bypass the skip:
+      // the migration is data-only, and the data transform's own check
+      // decides whether `run` fires.
       const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-      const skipOperations = markerAtDestination && options.plan.origin != null;
+      const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+      const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
       let applyValue: ApplyPlanSuccessValue;
 
       if (skipOperations) {
@@ -170,9 +174,39 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         });
       }
 
-      // Record marker and ledger entries
-      await this.upsertMarker(driver, options, existingMarker);
-      await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+      // Self-edge no-op detection: a self-edge migration with zero ops in
+      // the plan that brings no new invariants produced no observable
+      // change. Skip the marker + ledger writes so an idempotent re-apply
+      // of a self-edge data transform doesn't churn updatedAt or pile up
+      // empty ledger entries. db update no-ops still write a ledger entry
+      // as audit trail.
+      //
+      // TODO(invariant-routing follow-up): `executeDataTransform` always
+      // counts every op it visits (including self-skips via `check === true`
+      // or empty idempotency probe), so `operationsExecuted === 0` here
+      // means "the plan had zero ops" rather than "every op self-skipped".
+      // The CLI is unaffected today because `migration-apply.ts` marker-
+      // subtraction empties `effectiveRequired` first and short-circuits
+      // before we run; the non-CLI re-apply path needs a per-op `executed`
+      // flag threaded through `executeDataTransform` to recover the
+      // intended check. See review thread A13 / future M5 ADR draft.
+      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);
+        await this.recordLedgerEntry(
+          driver,
+          options,
+          existingMarker,
+          applyValue.executedOperations,
+        );
+      }
 
       await this.commitTransaction(driver);
       committed = true;
@@ -617,7 +651,8 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
     existingMarker: ContractMarkerRecord | null,
   ): Promise<void> {
-    const writeStatements = buildWriteMarkerStatements({
+    const incomingInvariants = options.plan.providedInvariants;
+    const writeStatements = buildMergeMarkerStatements({
       storageHash: options.plan.destination.storageHash,
       profileHash:
         options.plan.destination.profileHash ??
@@ -626,6 +661,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

@@ -17,7 +17,8 @@ export const ensureMarkerTableStatement: SqlStatement = {
     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,16 +38,23 @@ export const ensureLedgerTableStatement: SqlStatement = {
   params: [],
 };
 
-export interface WriteMarkerInput {
+export 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[];
 }
 
-export function buildWriteMarkerStatements(input: WriteMarkerInput): {
+export function buildMergeMarkerStatements(input: MergeMarkerInput): {
   readonly insert: SqlStatement;
   readonly update: SqlStatement;
 } {
@@ -58,6 +66,7 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
     input.canonicalVersion ?? null,
     input.appTag ?? null,
     jsonParam(input.meta ?? {}),
+    input.invariants,
   ];
 
   return {
@@ -70,7 +79,8 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
         canonical_version,
         updated_at,
         app_tag,
-        meta
+        meta,
+        invariants
       ) values (
         $1,
         $2,
@@ -79,11 +89,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,7 +106,8 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
         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,
     },

package/src/exports/statement-builders.ts

@@ -1,6 +1,6 @@
 export type { SqlStatement } from '../core/migrations/statement-builders';
 export {
-  buildWriteMarkerStatements,
+  buildMergeMarkerStatements,
   ensureLedgerTableStatement,
   ensureMarkerTableStatement,
   ensurePrismaContractSchemaStatement,