@prisma-next/target-postgres 0.1.0-pr.48.2 → 0.1.0-pr.49.2

package/README.md

@@ -4,36 +4,74 @@ Postgres target pack for Prisma Next.
 
 ## Package Classification
 
-- **Domain**: extensions
+- **Domain**: targets
 - **Layer**: targets
 - **Plane**: multi-plane (migration, runtime)
 
 ## Purpose
 
-Provides the Postgres target descriptor (`TargetDescriptor`) for CLI config. The target descriptor includes the target manifest with capabilities and type information.
+Provides the Postgres target descriptor (`SqlControlTargetDescriptor`) for CLI config. The target descriptor includes the target manifest with capabilities and type information, as well as factories for creating migration planners and runners.
 
 ## Responsibilities
 
-- **Target Descriptor Export**: Exports the Postgres `TargetDescriptor` for use in CLI configuration files
+- **Target Descriptor Export**: Exports the Postgres `SqlControlTargetDescriptor` for use in CLI configuration files
 - **Manifest Loading**: Loads the Postgres target manifest from `packs/manifest.json` with capabilities and type information
-- **Multi-Plane Support**: Provides both migration-plane (CLI) and runtime-plane entry points for the Postgres target
+- **Multi-Plane Support**: Provides both migration-plane (control) and runtime-plane entry points for the Postgres target
+- **Planner Factory**: Implements `createPlanner()` to create Postgres-specific migration planners
+- **Runner Factory**: Implements `createRunner()` to create Postgres-specific migration runners
 
 This package spans multiple planes:
-- **Migration plane** (`src/exports/cli.ts`): CLI entry point that exports `TargetDescriptor` for config files
+- **Migration plane** (`src/exports/control.ts`): Control plane entry point that exports `SqlControlTargetDescriptor` for config files
 - **Runtime plane** (`src/exports/runtime.ts`): Runtime entry point for target-specific runtime code (future)
 
 ## Usage
 
-### Migration Plane (CLI)
+### Control Plane (CLI)
 
 ```typescript
 import postgres from '@prisma-next/target-postgres/control';
+import sqlFamilyDescriptor from '@prisma-next/family-sql/control';
+import postgresAdapter from '@prisma-next/adapter-postgres/control';
+import postgresDriver from '@prisma-next/driver-postgres/control';
 
-// postgres is a TargetDescriptor with:
+// postgres is a SqlControlTargetDescriptor with:
 // - kind: 'target'
+// - familyId: 'sql'
+// - targetId: 'postgres'
 // - id: 'postgres'
-// - family: 'sql'
 // - manifest: ExtensionPackManifest
+// - createPlanner(): creates a Postgres migration planner
+// - createRunner(): creates a Postgres migration runner
+
+// Create family instance with target, adapter, and driver
+const family = sqlFamilyDescriptor.create({
+  target: postgres,
+  adapter: postgresAdapter,
+  driver: postgresDriver,
+  extensions: [],
+});
+
+// Create planner and runner from target descriptor
+const planner = postgres.createPlanner(family);
+const runner = postgres.createRunner(family);
+
+// Plan and execute migrations
+const planResult = planner.plan({ contract, schema, policy });
+if (planResult.kind === 'success') {
+  const executeResult = await runner.execute({
+    plan: planResult.plan,
+    driver,
+    destinationContract: contract,
+    policy,
+  });
+  if (!executeResult.ok) {
+    // Handle structured failure (e.g., EXECUTION_FAILED, PRECHECK_FAILED)
+    console.error(executeResult.failure.code, executeResult.failure.summary);
+  }
+} else {
+  // Handle planner failure (e.g., unsupportedExtension, unsupportedOperation)
+  console.error(planResult.conflicts);
+}
 ```
 
 ### Runtime Plane
@@ -45,11 +83,29 @@ import { ... } from '@prisma-next/target-postgres/runtime';
 
 ## Architecture
 
-This package provides both CLI and runtime entry points for the Postgres target. The CLI entry point loads the target manifest from `packs/manifest.json` and exports it as a `TargetDescriptor`. The runtime entry point will provide target-specific runtime functionality in the future.
+This package provides both control and runtime entry points for the Postgres target. The control entry point loads the target manifest from `packs/manifest.json` and exports it as a `SqlControlTargetDescriptor`. The runtime entry point will provide target-specific runtime functionality in the future.
+
+## Error Handling
+
+Both the planner and runner return structured results instead of throwing:
+
+**Planner** returns `PlannerResult` with either:
+- `kind: 'success'` with a `MigrationPlan`
+- `kind: 'failure'` with a list of `PlannerConflict` objects (e.g., `unsupportedExtension`, `unsupportedOperation`)
+
+**Runner** returns `MigrationRunnerResult` (`Result<MigrationRunnerSuccessValue, MigrationRunnerFailure>`) with either:
+- `ok: true` with operation counts
+- `ok: false` with a `MigrationRunnerFailure` containing error code, summary, and metadata
+
+Runner error codes include: `EXECUTION_FAILED`, `PRECHECK_FAILED`, `POSTCHECK_FAILED`, `SCHEMA_VERIFY_FAILED`, `POLICY_VIOLATION`, `MARKER_ORIGIN_MISMATCH`, `DESTINATION_CONTRACT_MISMATCH`.
+
+See `@prisma-next/family-sql/control` README for full error code documentation.
 
 ## Dependencies
 
-- **`@prisma-next/cli`**: CLI descriptor types (`TargetDescriptor`, `ExtensionPackManifest`)
+- **`@prisma-next/family-sql`**: SQL family types (`SqlControlTargetDescriptor`, `SqlControlFamilyInstance`)
+- **`@prisma-next/core-control-plane`**: Control plane types (`ControlTargetInstance`)
+- **`@prisma-next/contract`**: Manifest types (`ExtensionPackManifest`)
 - **`arktype`**: Runtime validation
 
 **Dependents:**
@@ -57,6 +113,18 @@ This package provides both CLI and runtime entry points for the Postgres target.
 
 ## Exports
 
-- `./cli`: Migration entry point for `TargetDescriptor`
+- `./control`: Control plane entry point for `SqlControlTargetDescriptor`
 - `./runtime`: Runtime entry point for target-specific runtime code (future)
 
+## Tests
+
+This package ships a mix of fast planner unit tests and slower runner integration tests that require a dev Postgres instance (via `@prisma/dev`).
+
+- **Default (`pnpm --filter @prisma-next/target-postgres test`)**: runs all tests including integration tests
+- **Test files**:
+  - `test/migrations/planner.case1.test.ts`: Planner unit tests
+  - `test/migrations/runner.*.integration.test.ts`: Runner integration tests (basic, errors, idempotency, policy)
+
+```bash
+pnpm --filter @prisma-next/target-postgres test
+```

package/dist/exports/control.d.ts

@@ -1,8 +1,16 @@
-import { ControlTargetDescriptor, ControlTargetInstance } from '@prisma-next/core-control-plane/types';
+import { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
+
+type OperationClass = 'extension' | 'table' | 'unique' | 'index' | 'foreignKey';
+interface PostgresPlanTargetDetails {
+    readonly schema: string;
+    readonly objectType: OperationClass;
+    readonly name: string;
+    readonly table?: string;
+}
 
 /**
  * Postgres target descriptor for CLI config.
  */
-declare const postgresTargetDescriptor: ControlTargetDescriptor<'sql', 'postgres', ControlTargetInstance<'sql', 'postgres'>>;
+declare const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails>;
 
 export { postgresTargetDescriptor as default };

package/dist/exports/control.js

@@ -3,6 +3,898 @@ import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { type } from "arktype";
+
+// src/core/migrations/planner.ts
+import {
+  createMigrationPlan,
+  plannerFailure,
+  plannerSuccess
+} from "@prisma-next/family-sql/control";
+var DEFAULT_PLANNER_CONFIG = {
+  defaultSchema: "public"
+};
+var PG_EXTENSION_SQL = {
+  pgvector: "CREATE EXTENSION IF NOT EXISTS vector"
+};
+var ADAPTER_LEVEL_EXTENSIONS = /* @__PURE__ */ new Set(["pg", "postgres"]);
+function createPostgresMigrationPlanner(config = {}) {
+  return new PostgresMigrationPlanner({
+    ...DEFAULT_PLANNER_CONFIG,
+    ...config
+  });
+}
+var PostgresMigrationPlanner = class {
+  constructor(config) {
+    this.config = config;
+  }
+  plan(options) {
+    const schemaName = options.schemaName ?? this.config.defaultSchema;
+    const policyResult = this.ensureAdditivePolicy(options.policy);
+    if (policyResult) {
+      return policyResult;
+    }
+    const existingTables = Object.keys(options.schema.tables);
+    if (existingTables.length > 0) {
+      const tableList = existingTables.sort().join(", ");
+      return plannerFailure([
+        {
+          kind: "unsupportedOperation",
+          summary: `The Postgres migration planner currently supports only empty databases. Found ${existingTables.length} existing table(s): ${tableList}`,
+          why: "Remove existing tables or use a future planner mode that handles subsets/supersets."
+        }
+      ]);
+    }
+    const extensionResult = this.validateExtensions(options.contract);
+    if (extensionResult) {
+      return extensionResult;
+    }
+    const operations = [];
+    operations.push(
+      ...this.buildExtensionOperations(options.contract, schemaName),
+      ...this.buildTableOperations(options.contract.storage.tables, schemaName),
+      ...this.buildUniqueOperations(options.contract.storage.tables, schemaName),
+      ...this.buildIndexOperations(options.contract.storage.tables, schemaName),
+      ...this.buildForeignKeyOperations(options.contract.storage.tables, schemaName)
+    );
+    const plan = createMigrationPlan({
+      targetId: "postgres",
+      origin: null,
+      destination: {
+        coreHash: options.contract.coreHash,
+        ...options.contract.profileHash ? { profileHash: options.contract.profileHash } : {}
+      },
+      operations
+    });
+    return plannerSuccess(plan);
+  }
+  validateExtensions(contract) {
+    const extensions = contract.extensions ?? {};
+    const extensionNames = Object.keys(extensions);
+    const databaseExtensions = extensionNames.filter(
+      (extensionName) => !ADAPTER_LEVEL_EXTENSIONS.has(extensionName)
+    );
+    const unsupportedExtensions = databaseExtensions.filter(
+      (extensionName) => !PG_EXTENSION_SQL[extensionName]
+    );
+    if (unsupportedExtensions.length > 0) {
+      const supportedExtensions = Object.keys(PG_EXTENSION_SQL).join(", ");
+      const unsupportedList = unsupportedExtensions.join(", ");
+      return plannerFailure([
+        {
+          kind: "unsupportedExtension",
+          summary: `Unsupported PostgreSQL extensions in contract: ${unsupportedList}`,
+          why: `The Postgres migration planner currently only supports: ${supportedExtensions}. Extensions are defined in contract.extensions.`,
+          location: { extension: unsupportedList }
+        }
+      ]);
+    }
+    return null;
+  }
+  ensureAdditivePolicy(policy) {
+    if (!policy.allowedOperationClasses.includes("additive")) {
+      return plannerFailure([
+        {
+          kind: "unsupportedOperation",
+          summary: "Init planner requires additive operations be allowed",
+          why: 'The init planner only emits additive operations. Update the policy to include "additive".'
+        }
+      ]);
+    }
+    return null;
+  }
+  buildExtensionOperations(contract, schema) {
+    const extensions = contract.extensions ?? {};
+    const extensionNames = Object.keys(extensions);
+    const operations = [];
+    for (const extensionName of extensionNames) {
+      if (ADAPTER_LEVEL_EXTENSIONS.has(extensionName)) {
+        continue;
+      }
+      const sql = PG_EXTENSION_SQL[extensionName];
+      if (!sql) {
+        throw new Error(`Extension SQL not found for ${extensionName}`);
+      }
+      const details = this.buildTargetDetails("extension", extensionName, schema);
+      operations.push({
+        id: `extension.${extensionName}`,
+        label: `Enable extension "${extensionName}"`,
+        summary: `Ensures the ${extensionName} extension is available`,
+        operationClass: "additive",
+        target: { id: "postgres", details },
+        precheck: [
+          {
+            description: `verify extension "${extensionName}" is not already enabled`,
+            sql: `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${escapeLiteral(
+              this.extensionDatabaseName(extensionName)
+            )}')`
+          }
+        ],
+        execute: [
+          {
+            description: `create extension "${extensionName}"`,
+            sql
+          }
+        ],
+        postcheck: [
+          {
+            description: `confirm extension "${extensionName}" is enabled`,
+            sql: `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${escapeLiteral(
+              this.extensionDatabaseName(extensionName)
+            )}')`
+          }
+        ]
+      });
+    }
+    return operations;
+  }
+  extensionDatabaseName(extensionName) {
+    if (extensionName === "pgvector") {
+      return "vector";
+    }
+    return extensionName;
+  }
+  buildTableOperations(tables, schema) {
+    const operations = [];
+    for (const [tableName, table] of sortedEntries(tables)) {
+      const qualified = qualifyTableName(schema, tableName);
+      operations.push({
+        id: `table.${tableName}`,
+        label: `Create table ${tableName}`,
+        summary: `Creates table ${tableName} with required columns`,
+        operationClass: "additive",
+        target: {
+          id: "postgres",
+          details: this.buildTargetDetails("table", tableName, schema)
+        },
+        precheck: [
+          {
+            description: `ensure table "${tableName}" does not exist`,
+            sql: `SELECT to_regclass(${toRegclassLiteral(schema, tableName)}) IS NULL`
+          }
+        ],
+        execute: [
+          {
+            description: `create table "${tableName}"`,
+            sql: buildCreateTableSql(qualified, table)
+          }
+        ],
+        postcheck: [
+          {
+            description: `verify table "${tableName}" exists`,
+            sql: `SELECT to_regclass(${toRegclassLiteral(schema, tableName)}) IS NOT NULL`
+          }
+        ]
+      });
+    }
+    return operations;
+  }
+  buildUniqueOperations(tables, schema) {
+    const operations = [];
+    for (const [tableName, table] of sortedEntries(tables)) {
+      for (const unique of table.uniques) {
+        const constraintName = unique.name ?? `${tableName}_${unique.columns.join("_")}_key`;
+        operations.push({
+          id: `unique.${tableName}.${constraintName}`,
+          label: `Add unique constraint ${constraintName} on ${tableName}`,
+          summary: `Adds unique constraint ${constraintName} on ${tableName}`,
+          operationClass: "additive",
+          target: {
+            id: "postgres",
+            details: this.buildTargetDetails("unique", constraintName, schema, tableName)
+          },
+          precheck: [
+            {
+              description: `ensure unique constraint "${constraintName}" is missing`,
+              sql: constraintExistsCheck({ constraintName, schema, exists: false })
+            }
+          ],
+          execute: [
+            {
+              description: `add unique constraint "${constraintName}"`,
+              sql: `ALTER TABLE ${qualifyTableName(schema, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(constraintName)}
+UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
+            }
+          ],
+          postcheck: [
+            {
+              description: `verify unique constraint "${constraintName}" exists`,
+              sql: constraintExistsCheck({ constraintName, schema })
+            }
+          ]
+        });
+      }
+    }
+    return operations;
+  }
+  buildIndexOperations(tables, schema) {
+    const operations = [];
+    for (const [tableName, table] of sortedEntries(tables)) {
+      for (const index of table.indexes) {
+        const indexName = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
+        operations.push({
+          id: `index.${tableName}.${indexName}`,
+          label: `Create index ${indexName} on ${tableName}`,
+          summary: `Creates index ${indexName} on ${tableName}`,
+          operationClass: "additive",
+          target: {
+            id: "postgres",
+            details: this.buildTargetDetails("index", indexName, schema, tableName)
+          },
+          precheck: [
+            {
+              description: `ensure index "${indexName}" is missing`,
+              sql: `SELECT to_regclass(${toRegclassLiteral(schema, indexName)}) IS NULL`
+            }
+          ],
+          execute: [
+            {
+              description: `create index "${indexName}"`,
+              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(
+                schema,
+                tableName
+              )} (${index.columns.map(quoteIdentifier).join(", ")})`
+            }
+          ],
+          postcheck: [
+            {
+              description: `verify index "${indexName}" exists`,
+              sql: `SELECT to_regclass(${toRegclassLiteral(schema, indexName)}) IS NOT NULL`
+            }
+          ]
+        });
+      }
+    }
+    return operations;
+  }
+  buildForeignKeyOperations(tables, schema) {
+    const operations = [];
+    for (const [tableName, table] of sortedEntries(tables)) {
+      for (const foreignKey of table.foreignKeys) {
+        const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join("_")}_fkey`;
+        operations.push({
+          id: `foreignKey.${tableName}.${fkName}`,
+          label: `Add foreign key ${fkName} on ${tableName}`,
+          summary: `Adds foreign key ${fkName} referencing ${foreignKey.references.table}`,
+          operationClass: "additive",
+          target: {
+            id: "postgres",
+            details: this.buildTargetDetails("foreignKey", fkName, schema, tableName)
+          },
+          precheck: [
+            {
+              description: `ensure foreign key "${fkName}" is missing`,
+              sql: constraintExistsCheck({ constraintName: fkName, schema, exists: false })
+            }
+          ],
+          execute: [
+            {
+              description: `add foreign key "${fkName}"`,
+              sql: `ALTER TABLE ${qualifyTableName(schema, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fkName)}
+FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(", ")})
+REFERENCES ${qualifyTableName(schema, foreignKey.references.table)} (${foreignKey.references.columns.map(quoteIdentifier).join(", ")})`
+            }
+          ],
+          postcheck: [
+            {
+              description: `verify foreign key "${fkName}" exists`,
+              sql: constraintExistsCheck({ constraintName: fkName, schema })
+            }
+          ]
+        });
+      }
+    }
+    return operations;
+  }
+  buildTargetDetails(objectType, name, schema, table) {
+    return {
+      schema,
+      objectType,
+      name,
+      ...table ? { table } : {}
+    };
+  }
+};
+function buildCreateTableSql(qualifiedTableName, table) {
+  const columnDefinitions = Object.entries(table.columns).map(
+    ([columnName, column]) => {
+      const parts = [
+        quoteIdentifier(columnName),
+        column.nativeType,
+        column.nullable ? "" : "NOT NULL"
+      ].filter(Boolean);
+      return parts.join(" ");
+    }
+  );
+  const constraintDefinitions = [];
+  if (table.primaryKey) {
+    constraintDefinitions.push(
+      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
+    );
+  }
+  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];
+  return `CREATE TABLE ${qualifiedTableName} (
+  ${allDefinitions.join(",\n  ")}
+)`;
+}
+function qualifyTableName(schema, table) {
+  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+function toRegclassLiteral(schema, name) {
+  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+  return `'${escapeLiteral(regclass)}'`;
+}
+function quoteIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function escapeLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function sortedEntries(record) {
+  return Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
+}
+function constraintExistsCheck({
+  constraintName,
+  schema,
+  exists = true
+}) {
+  const existsClause = exists ? "EXISTS" : "NOT EXISTS";
+  return `SELECT ${existsClause} (
+  SELECT 1 FROM pg_constraint c
+  JOIN pg_namespace n ON c.connamespace = n.oid
+  WHERE c.conname = '${escapeLiteral(constraintName)}'
+  AND n.nspname = '${escapeLiteral(schema)}'
+)`;
+}
+
+// src/core/migrations/runner.ts
+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 { ok, okVoid } from "@prisma-next/utils/result";
+
+// src/core/migrations/statement-builders.ts
+var ensurePrismaContractSchemaStatement = {
+  sql: "create schema if not exists prisma_contract",
+  params: []
+};
+var ensureMarkerTableStatement = {
+  sql: `create table if not exists prisma_contract.marker (
+    id smallint primary key default 1,
+    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 '{}'
+  )`,
+  params: []
+};
+var ensureLedgerTableStatement = {
+  sql: `create table if not exists prisma_contract.ledger (
+    id bigserial primary key,
+    created_at timestamptz not null default now(),
+    origin_core_hash text,
+    origin_profile_hash text,
+    destination_core_hash text not null,
+    destination_profile_hash text,
+    contract_json_before jsonb,
+    contract_json_after jsonb,
+    operations jsonb not null
+  )`,
+  params: []
+};
+function buildWriteMarkerStatements(input) {
+  const params = [
+    1,
+    input.coreHash,
+    input.profileHash,
+    jsonParam(input.contractJson),
+    input.canonicalVersion ?? null,
+    input.appTag ?? null,
+    jsonParam(input.meta ?? {})
+  ];
+  return {
+    insert: {
+      sql: `insert into prisma_contract.marker (
+        id,
+        core_hash,
+        profile_hash,
+        contract_json,
+        canonical_version,
+        updated_at,
+        app_tag,
+        meta
+      ) values (
+        $1,
+        $2,
+        $3,
+        $4::jsonb,
+        $5,
+        now(),
+        $6,
+        $7::jsonb
+      )`,
+      params
+    },
+    update: {
+      sql: `update prisma_contract.marker set
+        core_hash = $2,
+        profile_hash = $3,
+        contract_json = $4::jsonb,
+        canonical_version = $5,
+        updated_at = now(),
+        app_tag = $6,
+        meta = $7::jsonb
+      where id = $1`,
+      params
+    }
+  };
+}
+function buildLedgerInsertStatement(input) {
+  return {
+    sql: `insert into prisma_contract.ledger (
+      origin_core_hash,
+      origin_profile_hash,
+      destination_core_hash,
+      destination_profile_hash,
+      contract_json_before,
+      contract_json_after,
+      operations
+    ) values (
+      $1,
+      $2,
+      $3,
+      $4,
+      $5::jsonb,
+      $6::jsonb,
+      $7::jsonb
+    )`,
+    params: [
+      input.originCoreHash ?? null,
+      input.originProfileHash ?? null,
+      input.destinationCoreHash,
+      input.destinationProfileHash ?? null,
+      jsonParam(input.contractJsonBefore),
+      jsonParam(input.contractJsonAfter),
+      jsonParam(input.operations)
+    ]
+  };
+}
+function jsonParam(value) {
+  return JSON.stringify(value ?? null);
+}
+
+// src/core/migrations/runner.ts
+var DEFAULT_CONFIG = {
+  defaultSchema: "public"
+};
+var LOCK_DOMAIN = "prisma_next.contract.marker";
+function cloneAndFreezeRecord(value) {
+  const cloned = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (val === null || val === void 0) {
+      cloned[key] = val;
+    } else if (Array.isArray(val)) {
+      cloned[key] = Object.freeze([...val]);
+    } else if (typeof val === "object") {
+      cloned[key] = cloneAndFreezeRecord(val);
+    } else {
+      cloned[key] = val;
+    }
+  }
+  return Object.freeze(cloned);
+}
+function createPostgresMigrationRunner(family, config = {}) {
+  return new PostgresMigrationRunner(family, { ...DEFAULT_CONFIG, ...config });
+}
+var PostgresMigrationRunner = class {
+  constructor(family, config) {
+    this.family = family;
+    this.config = config;
+  }
+  async execute(options) {
+    const schema = options.schemaName ?? this.config.defaultSchema;
+    const driver = options.driver;
+    const lockKey = `${LOCK_DOMAIN}:${schema}`;
+    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.beginTransaction(driver);
+    let committed = false;
+    try {
+      await this.acquireLock(driver, lockKey);
+      await this.ensureControlTables(driver);
+      const existingMarker = await readMarker(driver);
+      const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+      if (!markerCheck.ok) {
+        return markerCheck;
+      }
+      const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+      let applyValue;
+      if (markerAtDestination) {
+        applyValue = { operationsExecuted: 0, executedOperations: [] };
+      } else {
+        const applyResult = await this.applyPlan(driver, options);
+        if (!applyResult.ok) {
+          return applyResult;
+        }
+        applyValue = applyResult.value;
+      }
+      const schemaIR = await this.family.introspect({
+        driver,
+        contractIR: options.destinationContract
+      });
+      const schemaVerifyResult = verifySqlSchema({
+        contract: options.destinationContract,
+        schema: schemaIR,
+        strict: options.strictVerification ?? true,
+        context: options.context ?? {},
+        typeMetadataRegistry: this.family.typeMetadataRegistry
+      });
+      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
+          }
+        });
+      }
+      await this.upsertMarker(driver, options, existingMarker);
+      await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+      await this.commitTransaction(driver);
+      committed = true;
+      return runnerSuccess({
+        operationsPlanned: options.plan.operations.length,
+        operationsExecuted: applyValue.operationsExecuted
+      });
+    } finally {
+      if (!committed) {
+        await this.rollbackTransaction(driver);
+      }
+    }
+  }
+  async applyPlan(driver, options) {
+    let operationsExecuted = 0;
+    const executedOperations = [];
+    for (const operation of options.plan.operations) {
+      options.callbacks?.onOperationStart?.(operation);
+      try {
+        const postcheckAlreadySatisfied = await this.expectationsAreSatisfied(
+          driver,
+          operation.postcheck
+        );
+        if (postcheckAlreadySatisfied) {
+          executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));
+          continue;
+        }
+        const precheckResult = await this.runExpectationSteps(
+          driver,
+          operation.precheck,
+          operation,
+          "precheck"
+        );
+        if (!precheckResult.ok) {
+          return precheckResult;
+        }
+        const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);
+        if (!executeResult.ok) {
+          return executeResult;
+        }
+        const postcheckResult = await this.runExpectationSteps(
+          driver,
+          operation.postcheck,
+          operation,
+          "postcheck"
+        );
+        if (!postcheckResult.ok) {
+          return postcheckResult;
+        }
+        executedOperations.push(operation);
+        operationsExecuted += 1;
+      } finally {
+        options.callbacks?.onOperationComplete?.(operation);
+      }
+    }
+    return ok({ operationsExecuted, executedOperations });
+  }
+  async ensureControlTables(driver) {
+    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
+    await this.executeStatement(driver, ensureMarkerTableStatement);
+    await this.executeStatement(driver, ensureLedgerTableStatement);
+  }
+  async runExpectationSteps(driver, steps, operation, phase) {
+    for (const step of steps) {
+      const result = await driver.query(step.sql);
+      if (!this.stepResultIsTrue(result.rows)) {
+        const code = phase === "precheck" ? "PRECHECK_FAILED" : "POSTCHECK_FAILED";
+        return runnerFailure(
+          code,
+          `Operation ${operation.id} failed during ${phase}: ${step.description}`,
+          {
+            meta: {
+              operationId: operation.id,
+              phase,
+              stepDescription: step.description
+            }
+          }
+        );
+      }
+    }
+    return okVoid();
+  }
+  async runExecuteSteps(driver, steps, operation) {
+    for (const step of steps) {
+      try {
+        await driver.query(step.sql);
+      } catch (error) {
+        return runnerFailure(
+          "EXECUTION_FAILED",
+          `Operation ${operation.id} failed during execution: ${step.description}`,
+          {
+            why: error instanceof Error ? error.message : String(error),
+            meta: {
+              operationId: operation.id,
+              stepDescription: step.description,
+              sql: step.sql
+            }
+          }
+        );
+      }
+    }
+    return okVoid();
+  }
+  stepResultIsTrue(rows) {
+    if (!rows || rows.length === 0) {
+      return false;
+    }
+    const firstRow = rows[0];
+    const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
+    if (typeof firstValue === "boolean") {
+      return firstValue;
+    }
+    if (typeof firstValue === "number") {
+      return firstValue !== 0;
+    }
+    if (typeof firstValue === "string") {
+      const lower = firstValue.toLowerCase();
+      if (lower === "t" || lower === "true" || lower === "1") {
+        return true;
+      }
+      if (lower === "f" || lower === "false" || lower === "0") {
+        return false;
+      }
+      return firstValue.length > 0;
+    }
+    return Boolean(firstValue);
+  }
+  async expectationsAreSatisfied(driver, steps) {
+    if (steps.length === 0) {
+      return false;
+    }
+    for (const step of steps) {
+      const result = await driver.query(step.sql);
+      if (!this.stepResultIsTrue(result.rows)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  createPostcheckPreSatisfiedSkipRecord(operation) {
+    const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : void 0;
+    const runnerMeta = Object.freeze({
+      skipped: true,
+      reason: "postcheck_pre_satisfied"
+    });
+    const mergedMeta = Object.freeze({
+      ...clonedMeta ?? {},
+      runner: runnerMeta
+    });
+    const frozenPostcheck = Object.freeze([...operation.postcheck]);
+    return Object.freeze({
+      id: operation.id,
+      label: operation.label,
+      ...operation.summary ? { summary: operation.summary } : {},
+      operationClass: operation.operationClass,
+      target: operation.target,
+      // Already frozen from plan creation
+      precheck: Object.freeze([]),
+      execute: Object.freeze([]),
+      postcheck: frozenPostcheck,
+      ...operation.meta || mergedMeta ? { meta: mergedMeta } : {}
+    });
+  }
+  markerMatchesDestination(marker, plan) {
+    if (!marker) {
+      return false;
+    }
+    if (marker.coreHash !== plan.destination.coreHash) {
+      return false;
+    }
+    if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) {
+      return false;
+    }
+    return true;
+  }
+  enforcePolicyCompatibility(policy, operations) {
+    const allowedClasses = new Set(policy.allowedOperationClasses);
+    for (const operation of operations) {
+      if (!allowedClasses.has(operation.operationClass)) {
+        return runnerFailure(
+          "POLICY_VIOLATION",
+          `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`,
+          {
+            why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
+            meta: {
+              operationId: operation.id,
+              operationClass: operation.operationClass,
+              allowedClasses: policy.allowedOperationClasses
+            }
+          }
+        );
+      }
+    }
+    return okVoid();
+  }
+  ensureMarkerCompatibility(marker, plan) {
+    const origin = plan.origin ?? null;
+    if (!origin) {
+      if (!marker) {
+        return okVoid();
+      }
+      if (this.markerMatchesDestination(marker, plan)) {
+        return okVoid();
+      }
+      return runnerFailure(
+        "MARKER_ORIGIN_MISMATCH",
+        `Existing contract marker (${marker.coreHash}) does not match plan origin (no marker expected).`,
+        {
+          meta: {
+            markerCoreHash: marker.coreHash,
+            expectedOrigin: null
+          }
+        }
+      );
+    }
+    if (!marker) {
+      return runnerFailure(
+        "MARKER_ORIGIN_MISMATCH",
+        `Missing contract marker: expected origin core hash ${origin.coreHash}.`,
+        {
+          meta: {
+            expectedOriginCoreHash: origin.coreHash
+          }
+        }
+      );
+    }
+    if (marker.coreHash !== origin.coreHash) {
+      return runnerFailure(
+        "MARKER_ORIGIN_MISMATCH",
+        `Existing contract marker (${marker.coreHash}) does not match plan origin (${origin.coreHash}).`,
+        {
+          meta: {
+            markerCoreHash: marker.coreHash,
+            expectedOriginCoreHash: origin.coreHash
+          }
+        }
+      );
+    }
+    if (origin.profileHash && marker.profileHash !== origin.profileHash) {
+      return runnerFailure(
+        "MARKER_ORIGIN_MISMATCH",
+        `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`,
+        {
+          meta: {
+            markerProfileHash: marker.profileHash,
+            expectedOriginProfileHash: origin.profileHash
+          }
+        }
+      );
+    }
+    return okVoid();
+  }
+  ensurePlanMatchesDestinationContract(destination, contract) {
+    if (destination.coreHash !== contract.coreHash) {
+      return runnerFailure(
+        "DESTINATION_CONTRACT_MISMATCH",
+        `Plan destination core hash (${destination.coreHash}) does not match provided contract core hash (${contract.coreHash}).`,
+        {
+          meta: {
+            planCoreHash: destination.coreHash,
+            contractCoreHash: contract.coreHash
+          }
+        }
+      );
+    }
+    if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) {
+      return runnerFailure(
+        "DESTINATION_CONTRACT_MISMATCH",
+        `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`,
+        {
+          meta: {
+            planProfileHash: destination.profileHash,
+            contractProfileHash: contract.profileHash
+          }
+        }
+      );
+    }
+    return okVoid();
+  }
+  async upsertMarker(driver, options, existingMarker) {
+    const writeStatements = buildWriteMarkerStatements({
+      coreHash: options.plan.destination.coreHash,
+      profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.coreHash,
+      contractJson: options.destinationContract,
+      canonicalVersion: null,
+      meta: {}
+    });
+    const statement = existingMarker ? writeStatements.update : writeStatements.insert;
+    await this.executeStatement(driver, statement);
+  }
+  async recordLedgerEntry(driver, options, existingMarker, executedOperations) {
+    const ledgerStatement = buildLedgerInsertStatement({
+      originCoreHash: existingMarker?.coreHash ?? null,
+      originProfileHash: existingMarker?.profileHash ?? null,
+      destinationCoreHash: options.plan.destination.coreHash,
+      destinationProfileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.coreHash,
+      contractJsonBefore: existingMarker?.contractJson ?? null,
+      contractJsonAfter: options.destinationContract,
+      operations: executedOperations
+    });
+    await this.executeStatement(driver, ledgerStatement);
+  }
+  async acquireLock(driver, key) {
+    await driver.query("select pg_advisory_xact_lock(hashtext($1))", [key]);
+  }
+  async beginTransaction(driver) {
+    await driver.query("BEGIN");
+  }
+  async commitTransaction(driver) {
+    await driver.query("COMMIT");
+  }
+  async rollbackTransaction(driver) {
+    await driver.query("ROLLBACK");
+  }
+  async executeStatement(driver, statement) {
+    if (statement.params.length > 0) {
+      await driver.query(statement.sql, statement.params);
+      return;
+    }
+    await driver.query(statement.sql);
+  }
+};
+
+// src/exports/control.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 var TypesImportSpecSchema = type({
@@ -46,6 +938,12 @@ var postgresTargetDescriptor = {
       familyId: "sql",
       targetId: "postgres"
     };
+  },
+  createPlanner(_family) {
+    return createPostgresMigrationPlanner();
+  },
+  createRunner(family) {
+    return createPostgresMigrationRunner(family);
   }
 };
 var control_default = postgresTargetDescriptor;

package/dist/exports/control.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/control.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type {\n  ControlTargetDescriptor,\n  ControlTargetInstance,\n} from '@prisma-next/core-control-plane/types';\nimport { type } from 'arktype';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\nconst TypesImportSpecSchema = type({\n  package: 'string',\n  named: 'string',\n  alias: 'string',\n});\n\nconst ExtensionPackManifestSchema = type({\n  id: 'string',\n  version: 'string',\n  'targets?': type({ '[string]': type({ 'minVersion?': 'string' }) }),\n  'capabilities?': 'Record<string, unknown>',\n  'types?': type({\n    'codecTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n    'operationTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n  }),\n  'operations?': 'unknown[]',\n});\n\n/**\n * Loads the target manifest from packs/manifest.json.\n */\nfunction loadTargetManifest(): ExtensionPackManifest {\n  const manifestPath = join(__dirname, '../../packs/manifest.json');\n  const manifestJson = JSON.parse(readFileSync(manifestPath, 'utf-8'));\n\n  const result = ExtensionPackManifestSchema(manifestJson);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid target manifest structure at ${manifestPath}: ${messages}`);\n  }\n\n  return result as ExtensionPackManifest;\n}\n\n/**\n * Postgres target descriptor for CLI config.\n */\nconst postgresTargetDescriptor: ControlTargetDescriptor<\n  'sql',\n  'postgres',\n  ControlTargetInstance<'sql', 'postgres'>\n> = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  manifest: loadTargetManifest(),\n  create(): ControlTargetInstance<'sql', 'postgres'> {\n    return {\n      familyId: 'sql',\n      targetId: 'postgres',\n    };\n  },\n};\n\nexport default postgresTargetDescriptor;\n"],"mappings":";AAAA,SAAS,oBAAoB;AAC7B,SAAS,SAAS,YAAY;AAC9B,SAAS,qBAAqB;AAM9B,SAAS,YAAY;AAErB,IAAM,aAAa,cAAc,YAAY,GAAG;AAChD,IAAM,YAAY,QAAQ,UAAU;AAEpC,IAAM,wBAAwB,KAAK;AAAA,EACjC,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AACT,CAAC;AAED,IAAM,8BAA8B,KAAK;AAAA,EACvC,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,YAAY,KAAK,EAAE,YAAY,KAAK,EAAE,eAAe,SAAS,CAAC,EAAE,CAAC;AAAA,EAClE,iBAAiB;AAAA,EACjB,UAAU,KAAK;AAAA,IACb,eAAe,KAAK;AAAA,MAClB,QAAQ;AAAA,IACV,CAAC;AAAA,IACD,mBAAmB,KAAK;AAAA,MACtB,QAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AAAA,EACD,eAAe;AACjB,CAAC;AAKD,SAAS,qBAA4C;AACnD,QAAM,eAAe,KAAK,WAAW,2BAA2B;AAChE,QAAM,eAAe,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;AAEnE,QAAM,SAAS,4BAA4B,YAAY;AACvD,MAAI,kBAAkB,KAAK,QAAQ;AACjC,UAAM,WAAW,OAAO,IAAI,CAAC,MAA2B,EAAE,OAAO,EAAE,KAAK,IAAI;AAC5E,UAAM,IAAI,MAAM,wCAAwC,YAAY,KAAK,QAAQ,EAAE;AAAA,EACrF;AAEA,SAAO;AACT;AAKA,IAAM,2BAIF;AAAA,EACF,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA,EACV,IAAI;AAAA,EACJ,UAAU,mBAAmB;AAAA,EAC7B,SAAmD;AACjD,WAAO;AAAA,MACL,UAAU;AAAA,MACV,UAAU;AAAA,IACZ;AAAA,EACF;AACF;AAEA,IAAO,kBAAQ;","names":[]}
+{"version":3,"sources":["../../src/exports/control.ts","../../src/core/migrations/planner.ts","../../src/core/migrations/runner.ts","../../src/core/migrations/statement-builders.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type { ControlTargetInstance } from '@prisma-next/core-control-plane/types';\nimport type {\n  SqlControlFamilyInstance,\n  SqlControlTargetDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { type } from 'arktype';\nimport type { PostgresPlanTargetDetails } from '../core/migrations/planner';\nimport { createPostgresMigrationPlanner } from '../core/migrations/planner';\nimport { createPostgresMigrationRunner } from '../core/migrations/runner';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\nconst TypesImportSpecSchema = type({\n  package: 'string',\n  named: 'string',\n  alias: 'string',\n});\n\nconst ExtensionPackManifestSchema = type({\n  id: 'string',\n  version: 'string',\n  'targets?': type({ '[string]': type({ 'minVersion?': 'string' }) }),\n  'capabilities?': 'Record<string, unknown>',\n  'types?': type({\n    'codecTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n    'operationTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n  }),\n  'operations?': 'unknown[]',\n});\n\n/**\n * Loads the target manifest from packs/manifest.json.\n */\nfunction loadTargetManifest(): ExtensionPackManifest {\n  const manifestPath = join(__dirname, '../../packs/manifest.json');\n  const manifestJson = JSON.parse(readFileSync(manifestPath, 'utf-8'));\n\n  const result = ExtensionPackManifestSchema(manifestJson);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid target manifest structure at ${manifestPath}: ${messages}`);\n  }\n\n  return result as ExtensionPackManifest;\n}\n\n/**\n * Postgres target descriptor for CLI config.\n */\nconst postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails> =\n  {\n    kind: 'target',\n    familyId: 'sql',\n    targetId: 'postgres',\n    id: 'postgres',\n    manifest: loadTargetManifest(),\n    create(): ControlTargetInstance<'sql', 'postgres'> {\n      return {\n        familyId: 'sql',\n        targetId: 'postgres',\n      };\n    },\n    createPlanner(_family: SqlControlFamilyInstance) {\n      return createPostgresMigrationPlanner();\n    },\n    createRunner(family) {\n      return createPostgresMigrationRunner(family);\n    },\n  };\n\nexport default postgresTargetDescriptor;\n","import type {\n  MigrationOperationPolicy,\n  MigrationPlanner,\n  MigrationPlannerPlanOptions,\n  MigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport {\n  createMigrationPlan,\n  plannerFailure,\n  plannerSuccess,\n} from '@prisma-next/family-sql/control';\nimport type {\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n} from '@prisma-next/sql-contract/types';\n\ntype OperationClass = 'extension' | 'table' | 'unique' | 'index' | 'foreignKey';\n\nexport interface PostgresPlanTargetDetails {\n  readonly schema: string;\n  readonly objectType: OperationClass;\n  readonly name: string;\n  readonly table?: string;\n}\n\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nconst PG_EXTENSION_SQL: Record<string, string> = {\n  pgvector: 'CREATE EXTENSION IF NOT EXISTS vector',\n};\n\n/**\n * Adapter-level extensions that are NOT PostgreSQL database extensions.\n * These are metadata namespaces used by adapters for codec IDs (e.g., 'pg/int4@1').\n * The planner should skip these when validating extensions.\n */\nconst ADAPTER_LEVEL_EXTENSIONS = new Set(['pg', 'postgres']);\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): MigrationPlanner<PostgresPlanTargetDetails> {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\n}\n\nclass PostgresMigrationPlanner implements MigrationPlanner<PostgresPlanTargetDetails> {\n  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: MigrationPlannerPlanOptions) {\n    const schemaName = options.schemaName ?? this.config.defaultSchema;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    const existingTables = Object.keys(options.schema.tables);\n    if (existingTables.length > 0) {\n      const tableList = existingTables.sort().join(', ');\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: `The Postgres migration planner currently supports only empty databases. Found ${existingTables.length} existing table(s): ${tableList}`,\n          why: 'Remove existing tables or use a future planner mode that handles subsets/supersets.',\n        },\n      ]);\n    }\n\n    const extensionResult = this.validateExtensions(options.contract);\n    if (extensionResult) {\n      return extensionResult;\n    }\n\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n\n    operations.push(\n      ...this.buildExtensionOperations(options.contract, schemaName),\n      ...this.buildTableOperations(options.contract.storage.tables, schemaName),\n      ...this.buildUniqueOperations(options.contract.storage.tables, schemaName),\n      ...this.buildIndexOperations(options.contract.storage.tables, schemaName),\n      ...this.buildForeignKeyOperations(options.contract.storage.tables, schemaName),\n    );\n\n    const plan = createMigrationPlan<PostgresPlanTargetDetails>({\n      targetId: 'postgres',\n      origin: null,\n      destination: {\n        coreHash: options.contract.coreHash,\n        ...(options.contract.profileHash ? { profileHash: options.contract.profileHash } : {}),\n      },\n      operations,\n    });\n\n    return plannerSuccess(plan);\n  }\n\n  private validateExtensions(contract: SqlContract<SqlStorage>) {\n    const extensions = contract.extensions ?? {};\n    const extensionNames = Object.keys(extensions);\n    // Filter out adapter-level extensions (like 'pg', 'postgres') which are metadata namespaces\n    // used by adapters for codec IDs, not PostgreSQL database extensions\n    const databaseExtensions = extensionNames.filter(\n      (extensionName) => !ADAPTER_LEVEL_EXTENSIONS.has(extensionName),\n    );\n    const unsupportedExtensions = databaseExtensions.filter(\n      (extensionName) => !PG_EXTENSION_SQL[extensionName],\n    );\n    if (unsupportedExtensions.length > 0) {\n      const supportedExtensions = Object.keys(PG_EXTENSION_SQL).join(', ');\n      const unsupportedList = unsupportedExtensions.join(', ');\n      return plannerFailure([\n        {\n          kind: 'unsupportedExtension' as const,\n          summary: `Unsupported PostgreSQL extensions in contract: ${unsupportedList}`,\n          why: `The Postgres migration planner currently only supports: ${supportedExtensions}. Extensions are defined in contract.extensions.`,\n          location: { extension: unsupportedList },\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Init planner requires additive operations be allowed',\n          why: 'The init planner only emits additive operations. Update the policy to include \"additive\".',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private buildExtensionOperations(\n    contract: SqlContract<SqlStorage>,\n    schema: string,\n  ): readonly MigrationPlanOperation<PostgresPlanTargetDetails>[] {\n    const extensions = contract.extensions ?? {};\n    const extensionNames = Object.keys(extensions);\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n\n    // Extensions are validated in validateExtensions() before this method is called\n    for (const extensionName of extensionNames) {\n      // Skip adapter-level extensions (metadata namespaces, not database extensions)\n      if (ADAPTER_LEVEL_EXTENSIONS.has(extensionName)) {\n        continue;\n      }\n      const sql = PG_EXTENSION_SQL[extensionName];\n      if (!sql) {\n        // This should never happen since we validate extensions in validateExtensions(), but TypeScript requires this check\n        throw new Error(`Extension SQL not found for ${extensionName}`);\n      }\n      const details = this.buildTargetDetails('extension', extensionName, schema);\n      operations.push({\n        id: `extension.${extensionName}`,\n        label: `Enable extension \"${extensionName}\"`,\n        summary: `Ensures the ${extensionName} extension is available`,\n        operationClass: 'additive',\n        target: { id: 'postgres', details },\n        precheck: [\n          {\n            description: `verify extension \"${extensionName}\" is not already enabled`,\n            sql: `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${escapeLiteral(\n              this.extensionDatabaseName(extensionName),\n            )}')`,\n          },\n        ],\n        execute: [\n          {\n            description: `create extension \"${extensionName}\"`,\n            sql,\n          },\n        ],\n        postcheck: [\n          {\n            description: `confirm extension \"${extensionName}\" is enabled`,\n            sql: `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${escapeLiteral(\n              this.extensionDatabaseName(extensionName),\n            )}')`,\n          },\n        ],\n      });\n    }\n\n    return operations;\n  }\n\n  private extensionDatabaseName(extensionName: string): string {\n    if (extensionName === 'pgvector') {\n      return 'vector';\n    }\n    return extensionName;\n  }\n\n  private buildTableOperations(\n    tables: SqlContract<SqlStorage>['storage']['tables'],\n    schema: string,\n  ): readonly MigrationPlanOperation<PostgresPlanTargetDetails>[] {\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n    for (const [tableName, table] of sortedEntries(tables)) {\n      const qualified = qualifyTableName(schema, tableName);\n      operations.push({\n        id: `table.${tableName}`,\n        label: `Create table ${tableName}`,\n        summary: `Creates table ${tableName} with required columns`,\n        operationClass: 'additive',\n        target: {\n          id: 'postgres',\n          details: this.buildTargetDetails('table', tableName, schema),\n        },\n        precheck: [\n          {\n            description: `ensure table \"${tableName}\" does not exist`,\n            sql: `SELECT to_regclass(${toRegclassLiteral(schema, tableName)}) IS NULL`,\n          },\n        ],\n        execute: [\n          {\n            description: `create table \"${tableName}\"`,\n            sql: buildCreateTableSql(qualified, table),\n          },\n        ],\n        postcheck: [\n          {\n            description: `verify table \"${tableName}\" exists`,\n            sql: `SELECT to_regclass(${toRegclassLiteral(schema, tableName)}) IS NOT NULL`,\n          },\n        ],\n      });\n    }\n    return operations;\n  }\n\n  private buildUniqueOperations(\n    tables: SqlContract<SqlStorage>['storage']['tables'],\n    schema: string,\n  ): readonly MigrationPlanOperation<PostgresPlanTargetDetails>[] {\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n    for (const [tableName, table] of sortedEntries(tables)) {\n      for (const unique of table.uniques) {\n        const constraintName = unique.name ?? `${tableName}_${unique.columns.join('_')}_key`;\n        operations.push({\n          id: `unique.${tableName}.${constraintName}`,\n          label: `Add unique constraint ${constraintName} on ${tableName}`,\n          summary: `Adds unique constraint ${constraintName} on ${tableName}`,\n          operationClass: 'additive',\n          target: {\n            id: 'postgres',\n            details: this.buildTargetDetails('unique', constraintName, schema, tableName),\n          },\n          precheck: [\n            {\n              description: `ensure unique constraint \"${constraintName}\" is missing`,\n              sql: constraintExistsCheck({ constraintName, schema, exists: false }),\n            },\n          ],\n          execute: [\n            {\n              description: `add unique constraint \"${constraintName}\"`,\n              sql: `ALTER TABLE ${qualifyTableName(schema, tableName)}\nADD CONSTRAINT ${quoteIdentifier(constraintName)}\nUNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,\n            },\n          ],\n          postcheck: [\n            {\n              description: `verify unique constraint \"${constraintName}\" exists`,\n              sql: constraintExistsCheck({ constraintName, schema }),\n            },\n          ],\n        });\n      }\n    }\n    return operations;\n  }\n\n  private buildIndexOperations(\n    tables: SqlContract<SqlStorage>['storage']['tables'],\n    schema: string,\n  ): readonly MigrationPlanOperation<PostgresPlanTargetDetails>[] {\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n    for (const [tableName, table] of sortedEntries(tables)) {\n      for (const index of table.indexes) {\n        const indexName = index.name ?? `${tableName}_${index.columns.join('_')}_idx`;\n        operations.push({\n          id: `index.${tableName}.${indexName}`,\n          label: `Create index ${indexName} on ${tableName}`,\n          summary: `Creates index ${indexName} on ${tableName}`,\n          operationClass: 'additive',\n          target: {\n            id: 'postgres',\n            details: this.buildTargetDetails('index', indexName, schema, tableName),\n          },\n          precheck: [\n            {\n              description: `ensure index \"${indexName}\" is missing`,\n              sql: `SELECT to_regclass(${toRegclassLiteral(schema, indexName)}) IS NULL`,\n            },\n          ],\n          execute: [\n            {\n              description: `create index \"${indexName}\"`,\n              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(\n                schema,\n                tableName,\n              )} (${index.columns.map(quoteIdentifier).join(', ')})`,\n            },\n          ],\n          postcheck: [\n            {\n              description: `verify index \"${indexName}\" exists`,\n              sql: `SELECT to_regclass(${toRegclassLiteral(schema, indexName)}) IS NOT NULL`,\n            },\n          ],\n        });\n      }\n    }\n    return operations;\n  }\n\n  private buildForeignKeyOperations(\n    tables: SqlContract<SqlStorage>['storage']['tables'],\n    schema: string,\n  ): readonly MigrationPlanOperation<PostgresPlanTargetDetails>[] {\n    const operations: MigrationPlanOperation<PostgresPlanTargetDetails>[] = [];\n    for (const [tableName, table] of sortedEntries(tables)) {\n      for (const foreignKey of table.foreignKeys) {\n        const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join('_')}_fkey`;\n        operations.push({\n          id: `foreignKey.${tableName}.${fkName}`,\n          label: `Add foreign key ${fkName} on ${tableName}`,\n          summary: `Adds foreign key ${fkName} referencing ${foreignKey.references.table}`,\n          operationClass: 'additive',\n          target: {\n            id: 'postgres',\n            details: this.buildTargetDetails('foreignKey', fkName, schema, tableName),\n          },\n          precheck: [\n            {\n              description: `ensure foreign key \"${fkName}\" is missing`,\n              sql: constraintExistsCheck({ constraintName: fkName, schema, exists: false }),\n            },\n          ],\n          execute: [\n            {\n              description: `add foreign key \"${fkName}\"`,\n              sql: `ALTER TABLE ${qualifyTableName(schema, tableName)}\nADD CONSTRAINT ${quoteIdentifier(fkName)}\nFOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})\nREFERENCES ${qualifyTableName(schema, foreignKey.references.table)} (${foreignKey.references.columns\n                .map(quoteIdentifier)\n                .join(', ')})`,\n            },\n          ],\n          postcheck: [\n            {\n              description: `verify foreign key \"${fkName}\" exists`,\n              sql: constraintExistsCheck({ constraintName: fkName, schema }),\n            },\n          ],\n        });\n      }\n    }\n    return operations;\n  }\n\n  private buildTargetDetails(\n    objectType: OperationClass,\n    name: string,\n    schema: string,\n    table?: string,\n  ): PostgresPlanTargetDetails {\n    return {\n      schema,\n      objectType,\n      name,\n      ...(table ? { table } : {}),\n    };\n  }\n}\n\nfunction buildCreateTableSql(qualifiedTableName: string, table: StorageTable): string {\n  const columnDefinitions = Object.entries(table.columns).map(\n    ([columnName, column]: [string, StorageColumn]) => {\n      const parts = [\n        quoteIdentifier(columnName),\n        column.nativeType,\n        column.nullable ? '' : 'NOT NULL',\n      ].filter(Boolean);\n      return parts.join(' ');\n    },\n  );\n\n  const constraintDefinitions: string[] = [];\n  if (table.primaryKey) {\n    constraintDefinitions.push(\n      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,\n    );\n  }\n\n  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];\n  return `CREATE TABLE ${qualifiedTableName} (\\n  ${allDefinitions.join(',\\n  ')}\\n)`;\n}\n\nfunction qualifyTableName(schema: string, table: string): string {\n  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;\n}\n\nfunction toRegclassLiteral(schema: string, name: string): string {\n  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;\n  return `'${escapeLiteral(regclass)}'`;\n}\n\nfunction quoteIdentifier(identifier: string): string {\n  return `\"${identifier.replace(/\"/g, '\"\"')}\"`;\n}\n\nfunction escapeLiteral(value: string): string {\n  return value.replace(/'/g, \"''\");\n}\n\nfunction sortedEntries<V>(record: Readonly<Record<string, V>>): Array<[string, V]> {\n  return Object.entries(record).sort(([a], [b]) => a.localeCompare(b)) as Array<[string, V]>;\n}\n\nfunction constraintExistsCheck({\n  constraintName,\n  schema,\n  exists = true,\n}: {\n  constraintName: string;\n  schema: string;\n  exists?: boolean;\n}): string {\n  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';\n  return `SELECT ${existsClause} (\n  SELECT 1 FROM pg_constraint c\n  JOIN pg_namespace n ON c.connamespace = n.oid\n  WHERE c.conname = '${escapeLiteral(constraintName)}'\n  AND n.nspname = '${escapeLiteral(schema)}'\n)`;\n}\n","import type { ContractMarkerRecord } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  MigrationPlanContractInfo,\n  MigrationPlanOperation,\n  MigrationPlanOperationStep,\n  MigrationRunner,\n  MigrationRunnerExecuteOptions,\n  MigrationRunnerFailure,\n  MigrationRunnerResult,\n  SqlControlFamilyInstance,\n} from '@prisma-next/family-sql/control';\nimport { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport { readMarker } from '@prisma-next/family-sql/verify';\nimport type { Result } from '@prisma-next/utils/result';\nimport { ok, okVoid } from '@prisma-next/utils/result';\nimport type { PostgresPlanTargetDetails } from './planner';\nimport {\n  buildLedgerInsertStatement,\n  buildWriteMarkerStatements,\n  ensureLedgerTableStatement,\n  ensureMarkerTableStatement,\n  ensurePrismaContractSchemaStatement,\n  type SqlStatement,\n} from './statement-builders';\n\ninterface RunnerConfig {\n  readonly defaultSchema: string;\n}\n\ninterface ApplyPlanSuccessValue {\n  readonly operationsExecuted: number;\n  readonly executedOperations: readonly MigrationPlanOperation<PostgresPlanTargetDetails>[];\n}\n\nconst DEFAULT_CONFIG: RunnerConfig = {\n  defaultSchema: 'public',\n};\n\nconst LOCK_DOMAIN = 'prisma_next.contract.marker';\n\n/**\n * Deep clones and freezes a record object to prevent mutation.\n * Recursively clones nested objects and arrays to ensure complete isolation.\n */\nfunction cloneAndFreezeRecord<T extends Record<string, unknown>>(value: T): T {\n  const cloned: Record<string, unknown> = {};\n  for (const [key, val] of Object.entries(value)) {\n    if (val === null || val === undefined) {\n      cloned[key] = val;\n    } else if (Array.isArray(val)) {\n      // Clone array (shallow clone of array elements)\n      cloned[key] = Object.freeze([...val]);\n    } else if (typeof val === 'object') {\n      // Recursively clone nested objects\n      cloned[key] = cloneAndFreezeRecord(val as Record<string, unknown>);\n    } else {\n      // Primitives are copied as-is\n      cloned[key] = val;\n    }\n  }\n  return Object.freeze(cloned) as T;\n}\n\nexport function createPostgresMigrationRunner(\n  family: SqlControlFamilyInstance,\n  config: Partial<RunnerConfig> = {},\n): MigrationRunner<PostgresPlanTargetDetails> {\n  return new PostgresMigrationRunner(family, { ...DEFAULT_CONFIG, ...config });\n}\n\nclass PostgresMigrationRunner implements MigrationRunner<PostgresPlanTargetDetails> {\n  constructor(\n    private readonly family: SqlControlFamilyInstance,\n    private readonly config: RunnerConfig,\n  ) {}\n\n  async execute(\n    options: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,\n  ): Promise<MigrationRunnerResult> {\n    const schema = options.schemaName ?? this.config.defaultSchema;\n    const driver = options.driver;\n    const lockKey = `${LOCK_DOMAIN}:${schema}`;\n\n    // Static checks - fail fast before transaction\n    const destinationCheck = this.ensurePlanMatchesDestinationContract(\n      options.plan.destination,\n      options.destinationContract,\n    );\n    if (!destinationCheck.ok) {\n      return destinationCheck;\n    }\n\n    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);\n    if (!policyCheck.ok) {\n      return policyCheck;\n    }\n\n    // Begin transaction for DB operations\n    await this.beginTransaction(driver);\n    let committed = false;\n    try {\n      await this.acquireLock(driver, lockKey);\n      await this.ensureControlTables(driver);\n      const existingMarker = await readMarker(driver);\n\n      // Validate plan origin matches existing marker (needs marker from DB)\n      const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);\n      if (!markerCheck.ok) {\n        return markerCheck;\n      }\n\n      // Apply plan operations or skip if marker already at destination\n      const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);\n      let applyValue: ApplyPlanSuccessValue;\n\n      if (markerAtDestination) {\n        applyValue = { operationsExecuted: 0, executedOperations: [] };\n      } else {\n        const applyResult = await this.applyPlan(driver, options);\n        if (!applyResult.ok) {\n          return applyResult;\n        }\n        applyValue = applyResult.value;\n      }\n\n      // Verify resulting schema matches contract\n      // Step 1: Introspect live schema (DB I/O, family-owned)\n      const schemaIR = await this.family.introspect({\n        driver,\n        contractIR: options.destinationContract,\n      });\n\n      // Step 2: Pure verification (no DB I/O)\n      const schemaVerifyResult = verifySqlSchema({\n        contract: options.destinationContract,\n        schema: schemaIR,\n        strict: options.strictVerification ?? true,\n        context: options.context ?? {},\n        typeMetadataRegistry: this.family.typeMetadataRegistry,\n      });\n      if (!schemaVerifyResult.ok) {\n        return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {\n          why: 'The resulting database schema does not satisfy the destination contract.',\n          meta: {\n            issues: schemaVerifyResult.schema.issues,\n          },\n        });\n      }\n\n      // Record marker and ledger entries\n      await this.upsertMarker(driver, options, existingMarker);\n      await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);\n\n      await this.commitTransaction(driver);\n      committed = true;\n      return runnerSuccess({\n        operationsPlanned: options.plan.operations.length,\n        operationsExecuted: applyValue.operationsExecuted,\n      });\n    } finally {\n      if (!committed) {\n        await this.rollbackTransaction(driver);\n      }\n    }\n  }\n\n  private async applyPlan(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    options: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,\n  ): Promise<Result<ApplyPlanSuccessValue, MigrationRunnerFailure>> {\n    let operationsExecuted = 0;\n    const executedOperations: Array<MigrationPlanOperation<PostgresPlanTargetDetails>> = [];\n    for (const operation of options.plan.operations) {\n      options.callbacks?.onOperationStart?.(operation);\n      try {\n        const postcheckAlreadySatisfied = await this.expectationsAreSatisfied(\n          driver,\n          operation.postcheck,\n        );\n        if (postcheckAlreadySatisfied) {\n          executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));\n          continue;\n        }\n\n        const precheckResult = await this.runExpectationSteps(\n          driver,\n          operation.precheck,\n          operation,\n          'precheck',\n        );\n        if (!precheckResult.ok) {\n          return precheckResult;\n        }\n\n        const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);\n        if (!executeResult.ok) {\n          return executeResult;\n        }\n\n        const postcheckResult = await this.runExpectationSteps(\n          driver,\n          operation.postcheck,\n          operation,\n          'postcheck',\n        );\n        if (!postcheckResult.ok) {\n          return postcheckResult;\n        }\n\n        executedOperations.push(operation);\n        operationsExecuted += 1;\n      } finally {\n        options.callbacks?.onOperationComplete?.(operation);\n      }\n    }\n    return ok({ operationsExecuted, executedOperations });\n  }\n\n  private async ensureControlTables(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n  ): Promise<void> {\n    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);\n    await this.executeStatement(driver, ensureMarkerTableStatement);\n    await this.executeStatement(driver, ensureLedgerTableStatement);\n  }\n\n  private async runExpectationSteps(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    steps: readonly MigrationPlanOperationStep[],\n    operation: MigrationPlanOperation<PostgresPlanTargetDetails>,\n    phase: 'precheck' | 'postcheck',\n  ): Promise<Result<void, MigrationRunnerFailure>> {\n    for (const step of steps) {\n      const result = await driver.query(step.sql);\n      if (!this.stepResultIsTrue(result.rows)) {\n        const code = phase === 'precheck' ? 'PRECHECK_FAILED' : 'POSTCHECK_FAILED';\n        return runnerFailure(\n          code,\n          `Operation ${operation.id} failed during ${phase}: ${step.description}`,\n          {\n            meta: {\n              operationId: operation.id,\n              phase,\n              stepDescription: step.description,\n            },\n          },\n        );\n      }\n    }\n    return okVoid();\n  }\n\n  private async runExecuteSteps(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    steps: readonly MigrationPlanOperationStep[],\n    operation: MigrationPlanOperation<PostgresPlanTargetDetails>,\n  ): Promise<Result<void, MigrationRunnerFailure>> {\n    for (const step of steps) {\n      try {\n        await driver.query(step.sql);\n      } catch (error) {\n        return runnerFailure(\n          'EXECUTION_FAILED',\n          `Operation ${operation.id} failed during execution: ${step.description}`,\n          {\n            why: error instanceof Error ? error.message : String(error),\n            meta: {\n              operationId: operation.id,\n              stepDescription: step.description,\n              sql: step.sql,\n            },\n          },\n        );\n      }\n    }\n    return okVoid();\n  }\n\n  private stepResultIsTrue(rows: readonly Record<string, unknown>[]): boolean {\n    if (!rows || rows.length === 0) {\n      return false;\n    }\n    const firstRow = rows[0];\n    const firstValue = firstRow ? Object.values(firstRow)[0] : undefined;\n    if (typeof firstValue === 'boolean') {\n      return firstValue;\n    }\n    if (typeof firstValue === 'number') {\n      return firstValue !== 0;\n    }\n    if (typeof firstValue === 'string') {\n      const lower = firstValue.toLowerCase();\n      // PostgreSQL boolean representations: 't'/'f', 'true'/'false', '1'/'0'\n      if (lower === 't' || lower === 'true' || lower === '1') {\n        return true;\n      }\n      if (lower === 'f' || lower === 'false' || lower === '0') {\n        return false;\n      }\n      // For other strings, non-empty is truthy (though this case shouldn't occur for boolean checks)\n      return firstValue.length > 0;\n    }\n    return Boolean(firstValue);\n  }\n\n  private async expectationsAreSatisfied(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    steps: readonly MigrationPlanOperationStep[],\n  ): Promise<boolean> {\n    if (steps.length === 0) {\n      return false;\n    }\n    for (const step of steps) {\n      const result = await driver.query(step.sql);\n      if (!this.stepResultIsTrue(result.rows)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private createPostcheckPreSatisfiedSkipRecord(\n    operation: MigrationPlanOperation<PostgresPlanTargetDetails>,\n  ): MigrationPlanOperation<PostgresPlanTargetDetails> {\n    // Clone and freeze existing meta if present\n    const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : undefined;\n\n    // Create frozen runner metadata\n    const runnerMeta = Object.freeze({\n      skipped: true,\n      reason: 'postcheck_pre_satisfied',\n    });\n\n    // Merge and freeze the combined meta\n    const mergedMeta = Object.freeze({\n      ...(clonedMeta ?? {}),\n      runner: runnerMeta,\n    });\n\n    // Clone and freeze arrays to prevent mutation\n    const frozenPostcheck = Object.freeze([...operation.postcheck]);\n\n    return Object.freeze({\n      id: operation.id,\n      label: operation.label,\n      ...(operation.summary ? { summary: operation.summary } : {}),\n      operationClass: operation.operationClass,\n      target: operation.target, // Already frozen from plan creation\n      precheck: Object.freeze([]),\n      execute: Object.freeze([]),\n      postcheck: frozenPostcheck,\n      ...(operation.meta || mergedMeta ? { meta: mergedMeta } : {}),\n    });\n  }\n\n  private markerMatchesDestination(\n    marker: ContractMarkerRecord | null,\n    plan: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['plan'],\n  ): boolean {\n    if (!marker) {\n      return false;\n    }\n    if (marker.coreHash !== plan.destination.coreHash) {\n      return false;\n    }\n    if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) {\n      return false;\n    }\n    return true;\n  }\n\n  private enforcePolicyCompatibility(\n    policy: MigrationOperationPolicy,\n    operations: readonly MigrationPlanOperation<PostgresPlanTargetDetails>[],\n  ): Result<void, MigrationRunnerFailure> {\n    const allowedClasses = new Set(policy.allowedOperationClasses);\n    for (const operation of operations) {\n      if (!allowedClasses.has(operation.operationClass)) {\n        return runnerFailure(\n          'POLICY_VIOLATION',\n          `Operation ${operation.id} has class \"${operation.operationClass}\" which is not allowed by policy.`,\n          {\n            why: `Policy only allows: ${policy.allowedOperationClasses.join(', ')}.`,\n            meta: {\n              operationId: operation.id,\n              operationClass: operation.operationClass,\n              allowedClasses: policy.allowedOperationClasses,\n            },\n          },\n        );\n      }\n    }\n    return okVoid();\n  }\n\n  private ensureMarkerCompatibility(\n    marker: ContractMarkerRecord | null,\n    plan: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['plan'],\n  ): Result<void, MigrationRunnerFailure> {\n    const origin = plan.origin ?? null;\n    if (!origin) {\n      if (!marker) {\n        return okVoid();\n      }\n      if (this.markerMatchesDestination(marker, plan)) {\n        return okVoid();\n      }\n      return runnerFailure(\n        'MARKER_ORIGIN_MISMATCH',\n        `Existing contract marker (${marker.coreHash}) does not match plan origin (no marker expected).`,\n        {\n          meta: {\n            markerCoreHash: marker.coreHash,\n            expectedOrigin: null,\n          },\n        },\n      );\n    }\n\n    if (!marker) {\n      return runnerFailure(\n        'MARKER_ORIGIN_MISMATCH',\n        `Missing contract marker: expected origin core hash ${origin.coreHash}.`,\n        {\n          meta: {\n            expectedOriginCoreHash: origin.coreHash,\n          },\n        },\n      );\n    }\n    if (marker.coreHash !== origin.coreHash) {\n      return runnerFailure(\n        'MARKER_ORIGIN_MISMATCH',\n        `Existing contract marker (${marker.coreHash}) does not match plan origin (${origin.coreHash}).`,\n        {\n          meta: {\n            markerCoreHash: marker.coreHash,\n            expectedOriginCoreHash: origin.coreHash,\n          },\n        },\n      );\n    }\n    if (origin.profileHash && marker.profileHash !== origin.profileHash) {\n      return runnerFailure(\n        'MARKER_ORIGIN_MISMATCH',\n        `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`,\n        {\n          meta: {\n            markerProfileHash: marker.profileHash,\n            expectedOriginProfileHash: origin.profileHash,\n          },\n        },\n      );\n    }\n    return okVoid();\n  }\n\n  private ensurePlanMatchesDestinationContract(\n    destination: MigrationPlanContractInfo,\n    contract: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['destinationContract'],\n  ): Result<void, MigrationRunnerFailure> {\n    if (destination.coreHash !== contract.coreHash) {\n      return runnerFailure(\n        'DESTINATION_CONTRACT_MISMATCH',\n        `Plan destination core hash (${destination.coreHash}) does not match provided contract core hash (${contract.coreHash}).`,\n        {\n          meta: {\n            planCoreHash: destination.coreHash,\n            contractCoreHash: contract.coreHash,\n          },\n        },\n      );\n    }\n    if (\n      destination.profileHash &&\n      contract.profileHash &&\n      destination.profileHash !== contract.profileHash\n    ) {\n      return runnerFailure(\n        'DESTINATION_CONTRACT_MISMATCH',\n        `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`,\n        {\n          meta: {\n            planProfileHash: destination.profileHash,\n            contractProfileHash: contract.profileHash,\n          },\n        },\n      );\n    }\n    return okVoid();\n  }\n\n  private async upsertMarker(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    options: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,\n    existingMarker: ContractMarkerRecord | null,\n  ): Promise<void> {\n    const writeStatements = buildWriteMarkerStatements({\n      coreHash: options.plan.destination.coreHash,\n      profileHash:\n        options.plan.destination.profileHash ??\n        options.destinationContract.profileHash ??\n        options.plan.destination.coreHash,\n      contractJson: options.destinationContract,\n      canonicalVersion: null,\n      meta: {},\n    });\n    const statement = existingMarker ? writeStatements.update : writeStatements.insert;\n    await this.executeStatement(driver, statement);\n  }\n\n  private async recordLedgerEntry(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    options: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,\n    existingMarker: ContractMarkerRecord | null,\n    executedOperations: readonly MigrationPlanOperation<PostgresPlanTargetDetails>[],\n  ): Promise<void> {\n    const ledgerStatement = buildLedgerInsertStatement({\n      originCoreHash: existingMarker?.coreHash ?? null,\n      originProfileHash: existingMarker?.profileHash ?? null,\n      destinationCoreHash: options.plan.destination.coreHash,\n      destinationProfileHash:\n        options.plan.destination.profileHash ??\n        options.destinationContract.profileHash ??\n        options.plan.destination.coreHash,\n      contractJsonBefore: existingMarker?.contractJson ?? null,\n      contractJsonAfter: options.destinationContract,\n      operations: executedOperations,\n    });\n    await this.executeStatement(driver, ledgerStatement);\n  }\n\n  private async acquireLock(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    key: string,\n  ): Promise<void> {\n    await driver.query('select pg_advisory_xact_lock(hashtext($1))', [key]);\n  }\n\n  private async beginTransaction(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n  ): Promise<void> {\n    await driver.query('BEGIN');\n  }\n\n  private async commitTransaction(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n  ): Promise<void> {\n    await driver.query('COMMIT');\n  }\n\n  private async rollbackTransaction(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n  ): Promise<void> {\n    await driver.query('ROLLBACK');\n  }\n\n  private async executeStatement(\n    driver: MigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],\n    statement: SqlStatement,\n  ): Promise<void> {\n    if (statement.params.length > 0) {\n      await driver.query(statement.sql, statement.params);\n      return;\n    }\n    await driver.query(statement.sql);\n  }\n}\n","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  )`,\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 WriteMarkerInput {\n  readonly coreHash: 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\nexport function buildWriteMarkerStatements(input: WriteMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    1,\n    input.coreHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\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      ) values (\n        $1,\n        $2,\n        $3,\n        $4::jsonb,\n        $5,\n        now(),\n        $6,\n        $7::jsonb\n      )`,\n      params,\n    },\n    update: {\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      where id = $1`,\n      params,\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly originCoreHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationCoreHash: 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.originCoreHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationCoreHash,\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":"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","names":[]}

package/package.json

@@ -1,20 +1,27 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.1.0-pr.48.2",
+  "version": "0.1.0-pr.49.2",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/cli": "0.1.0-pr.48.2",
-    "@prisma-next/contract": "0.1.0-pr.48.2",
-    "@prisma-next/core-control-plane": "0.1.0-pr.48.2",
-    "@prisma-next/core-execution-plane": "0.1.0-pr.48.2"
+    "@prisma-next/family-sql": "0.1.0-pr.49.2",
+    "@prisma-next/cli": "0.1.0-pr.49.2",
+    "@prisma-next/contract": "0.1.0-pr.49.2",
+    "@prisma-next/sql-contract": "0.1.0-pr.49.2",
+    "@prisma-next/sql-schema-ir": "0.1.0-pr.49.2",
+    "@prisma-next/core-control-plane": "0.1.0-pr.49.2",
+    "@prisma-next/core-execution-plane": "0.1.0-pr.49.2",
+    "@prisma-next/utils": "0.1.0-pr.49.2"
   },
   "devDependencies": {
+    "vite-tsconfig-paths": "^5.1.4",
     "tsup": "^8.3.0",
     "typescript": "^5.9.3",
     "vitest": "^2.1.1",
+    "@prisma-next/adapter-postgres": "0.1.0-pr.49.2",
+    "@prisma-next/driver-postgres": "0.1.0-pr.49.2",
     "@prisma-next/test-utils": "0.0.1"
   },
   "files": [