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

package/src/core/descriptor-meta.ts

@@ -1,5 +1,5 @@
+import type { CodecTypes } from '../exports/codec-types';
 import { postgresAuthoringFieldPresets, postgresAuthoringTypes } from './authoring';
-import type { CodecTypes } from './codecs';
 
 const postgresTargetDescriptorMetaBase = {
   kind: 'target',

package/src/core/migrations/issue-planner.ts

@@ -15,6 +15,7 @@ import type {
   SqlPlannerConflict,
   SqlPlannerConflictLocation,
 } from '@prisma-next/family-sql/control';
+import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type {
@@ -32,9 +33,7 @@ import {
   AddUniqueCall,
   AlterColumnTypeCall,
   CreateEnumTypeCall,
-  CreateExtensionCall,
   CreateIndexCall,
-  CreateSchemaCall,
   CreateTableCall,
   DropColumnCall,
   DropConstraintCall,
@@ -62,8 +61,7 @@ export type { CallMigrationStrategy, StrategyContext };
 // ============================================================================
 
 const ISSUE_KIND_ORDER: Record<string, number> = {
-  // Dependencies and types first
-  dependency_missing: 1,
+  // Types first
   type_missing: 2,
   type_values_mismatch: 3,
   enum_values_changed: 3,
@@ -149,9 +147,8 @@ export interface IssuePlannerOptions {
    */
   readonly policy?: MigrationOperationPolicy;
   /**
-   * Framework components participating in this composition. Used by the
-   * dependency-install strategy to dispatch `databaseDependencies.init` at
-   * plan time.
+   * Framework components participating in this composition. Available to
+   * future strategies that may consult component metadata at plan time.
    */
   readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
   readonly strategies?: readonly CallMigrationStrategy[];
@@ -211,7 +208,12 @@ function mapIssueToCall(
       ];
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? `${issue.table}_${index.columns.join('_')}_idx`;
-        calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns]));
+        const extras: { type?: string; options?: Record<string, unknown> } = {};
+        if (index.type !== undefined) extras.type = index.type;
+        if (index.options !== undefined) extras.options = index.options;
+        calls.push(
+          new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns], extras),
+        );
       }
       const explicitIndexColumnSets = new Set(
         contractTable.indexes.map((idx) => idx.columns.join(',')),
@@ -446,8 +448,14 @@ function mapIssueToCall(
         return notOk(issueConflict('indexIncompatible', 'Index issue has no table name'));
       if (isMissing(issue) && issue.expected) {
         const columns = issue.expected.split(', ');
-        const indexName = `${issue.table}_${columns.join('_')}_idx`;
-        return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns)]);
+        const contractIndex = ctx.toContract.storage.tables[issue.table]?.indexes.find((idx) =>
+          arraysEqual(idx.columns, columns),
+        );
+        const indexName = contractIndex?.name ?? `${issue.table}_${columns.join('_')}_idx`;
+        const extras: { type?: string; options?: Record<string, unknown> } = {};
+        if (contractIndex?.type !== undefined) extras.type = contractIndex.type;
+        if (contractIndex?.options !== undefined) extras.options = contractIndex.options;
+        return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns, extras)]);
       }
       return notOk(
         issueConflict(
@@ -527,21 +535,6 @@ function mapIssueToCall(
         ),
       );
 
-    case 'dependency_missing':
-      if (!issue.dependencyId)
-        return notOk(
-          issueConflict('unsupportedOperation', 'Dependency missing issue has no dependencyId'),
-        );
-      if (issue.dependencyId.startsWith('ext:')) {
-        return ok([new CreateExtensionCall(issue.dependencyId.slice(4))]);
-      }
-      if (issue.dependencyId.startsWith('schema:')) {
-        return ok([new CreateSchemaCall(issue.dependencyId.slice(7))]);
-      }
-      return notOk(
-        issueConflict('unsupportedOperation', `Unknown dependency type: ${issue.dependencyId}`),
-      );
-
     default:
       return notOk(
         issueConflict(
@@ -605,24 +598,19 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
     case 'addForeignKey':
       return 'foreignKey';
     case 'rawSql': {
-      // Install ops (`dependencyInstallCallStrategy`) and type ops
-      // (`storageTypePlanCallStrategy`) both lift raw `SqlMigrationPlanOperation`s
-      // through `RawSqlCall` to preserve the component-declared label and
-      // precheck/postcheck. Classification falls back to inspecting the
-      // underlying op's target details (`objectType: 'type'`) and id prefix
-      // (`extension.*` / `schema.*`).
+      // Type ops lifted through `RawSqlCall` by `storageTypePlanCallStrategy`
+      // to preserve the codec-emitted label and precheck/postcheck.
+      // Classification falls back to inspecting the underlying op's target
+      // details (`objectType: 'type'`).
       const op = (
         call as {
           op?: {
-            id?: string;
             target?: { details?: { objectType?: string } };
           };
         }
       ).op;
       const objectType = op?.target?.details?.objectType;
       if (objectType === 'type') return 'dep';
-      const id = typeof op?.id === 'string' ? op.id : '';
-      if (id.startsWith('extension.') || id.startsWith('schema.')) return 'dep';
       return 'alter';
     }
     default:
@@ -651,7 +639,7 @@ const DEFAULT_POLICY: MigrationOperationPolicy = {
 };
 
 function emptySchemaIR(): SqlSchemaIR {
-  return { tables: {}, dependencies: [] };
+  return { tables: {} };
 }
 
 function conflictKindForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['kind'] {

package/src/core/migrations/op-factory-call.ts

@@ -506,6 +506,10 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly tableName: string;
   readonly indexName: string;
   readonly columns: readonly string[];
+  // Named indexType (not typeName) to avoid collision with CreateEnumTypeCall.typeName,
+  // which identifies a CREATE TYPE target and is read by `locationForCall` in issue-planner.ts.
+  readonly indexType: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
   readonly label: string;
 
   constructor(
@@ -513,22 +517,40 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
     tableName: string,
     indexName: string,
     columns: readonly string[],
+    extras?: { readonly type?: string; readonly options?: Record<string, unknown> },
   ) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
     this.indexName = indexName;
     this.columns = columns;
+    this.indexType = extras?.type;
+    this.options = extras?.options;
     this.label = `Create index "${indexName}" on "${tableName}"`;
     this.freeze();
   }
 
   toOp(): Op {
-    return createIndex(this.schemaName, this.tableName, this.indexName, this.columns);
+    const extras: { type?: string; options?: Record<string, unknown> } = {};
+    if (this.indexType !== undefined) extras.type = this.indexType;
+    if (this.options !== undefined) extras.options = this.options;
+    return createIndex(this.schemaName, this.tableName, this.indexName, this.columns, extras);
   }
 
   renderTypeScript(): string {
-    return `createIndex(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)}, ${jsonToTsSource(this.columns)})`;
+    const args = [
+      jsonToTsSource(this.schemaName),
+      jsonToTsSource(this.tableName),
+      jsonToTsSource(this.indexName),
+      jsonToTsSource(this.columns),
+    ];
+    if (this.indexType !== undefined || this.options !== undefined) {
+      const extrasParts: string[] = [];
+      if (this.indexType !== undefined) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
+      if (this.options !== undefined) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+      args.push(`{ ${extrasParts.join(', ')} }`);
+    }
+    return `createIndex(${args.join(', ')})`;
   }
 }
 
@@ -674,9 +696,8 @@ export class RenameTypeCall extends PostgresOpFactoryCallNode {
  * Laundered pre-built operation.
  *
  * Wraps an already-materialized `SqlMigrationPlanOperation` — typically one
- * produced by a SQL-family method, a codec control hook, or a component
- * `databaseDependencies.init` declaration — so the planner can carry it
- * alongside IR nodes without reverse-engineering it into a
+ * produced by a SQL-family method or a codec control hook — so the planner
+ * can carry it alongside IR nodes without reverse-engineering it into a
  * structured call class. Doubles as the user-facing escape hatch for raw
  * migrations: authors can pass a full op shape to `rawSql({...})`.
  *

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

@@ -11,7 +11,7 @@
  *   override get operations() {
  *     return [
  *       this.dataTransform(endContract, 'backfill emails', {
- *         check: () => db.users.count().where(({ email }) => email.isNull()),
+ *         check: () => db.users.select('id').where(({ email }) => email.isNull()).limit(1),
  *         run:   () => db.users.update({ email: '' }).where(({ email }) => email.isNull()),
  *       }),
  *     ];
@@ -23,20 +23,49 @@
  * invokes each one, asserts that its `meta.storageHash` matches the
  * `contract` it was handed (→ `PN-MIG-2005` on mismatch), and lowers the
  * plan via the supplied control adapter to a serialized `{sql, params}`
- * payload for `ops.json`. The free factory remains usable standalone
- * (tests, ad-hoc tooling, non-class contexts) by passing the adapter
- * explicitly as the fourth argument.
+ * payload.
+ *
+ * The factory then lowers the data transform to the unified migration-op
+ * shape `{ precheck, execute, postcheck }`. The user's `check` plan is
+ * wrapped twice with opposite truth values:
+ *
+ * - precheck `SELECT EXISTS (<check>) AS ok` asserts there is work to do
+ *   (precheck is short-circuited by the runner's pre-satisfied-skip path
+ *   when nothing remains to backfill).
+ * - postcheck `SELECT NOT EXISTS (<check>) AS ok` asserts the work is
+ *   complete after the run steps execute.
+ *
+ * The `check` plan is therefore expected to be a **rowset query whose
+ * presence of any row signals "work remains"** — typically `select('id')
+ * .where(<violation predicate>).limit(1)`. Scalar/aggregate shapes
+ * (`count(*)`, `bool_and(...)`) do not work under this contract: they
+ * always return exactly one row, so `EXISTS` is always true and
+ * `NOT EXISTS` is always false. (This is the same row-presence contract
+ * the pre-unification runner relied on; the wrapping is just lifting it
+ * into SQL.)
+ *
+ * Each `run` plan becomes an execute step. Because the `Step.params`
+ * field threads through `driver.query(sql, params)`, the user's bound
+ * values flow through the driver's parameter binder rather than being
+ * inlined into the SQL text.
+ *
+ * The free factory remains usable standalone (tests, ad-hoc tooling,
+ * non-class contexts) by passing the adapter explicitly as the fourth
+ * argument.
  */
 
 import type { Contract } from '@prisma-next/contract/types';
 import { errorDataTransformContractMismatch } from '@prisma-next/errors/migration';
-import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import type {
-  DataTransformOperation,
-  SerializedQueryPlan,
-} from '@prisma-next/framework-components/control';
+  SqlMigrationPlanOperation,
+  SqlMigrationPlanOperationStep,
+} from '@prisma-next/family-sql/control';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import type { SerializedQueryPlan } 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';
+import type { PostgresPlanTargetDetails } from '../planner-target-details';
 
 interface Buildable<R = unknown> {
   build(): SqlQueryPlan<R>;
@@ -49,36 +78,72 @@ interface Buildable<R = unknown> {
 export type DataTransformClosure = () => SqlQueryPlan | Buildable;
 
 export interface DataTransformOptions {
-  /** Optional pre-flight query. `undefined` means "no check". */
+  /**
+   * 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". When
+   * supplied, the closure must return a **rowset query** whose
+   * presence of any row signals "violations remain". Conventional
+   * shape: `db.<table>.select('id').where(<violation>).limit(1)`.
+   * Scalar/aggregate shapes do not satisfy this contract.
+   */
   readonly check?: DataTransformClosure;
   /** One or more mutation queries to execute. */
   readonly run: DataTransformClosure | readonly DataTransformClosure[];
 }
 
-/**
- * Concrete Postgres flavor of `DataTransformOperation`, re-exported so the
- * `PostgresMigration.dataTransform` instance method can name it without
- * leaking the framework-components symbol into call sites.
- */
-export type PostgresDataTransformOperation = DataTransformOperation;
-
 export function dataTransform<TContract extends Contract<SqlStorage>>(
   contract: TContract,
   name: string,
   options: DataTransformOptions,
   adapter: SqlControlAdapter<'postgres'>,
-): DataTransformOperation {
+): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
   const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)
     ? options.run
     : [options.run as DataTransformClosure];
+
+  const checkPlan = options.check ? invokeAndLower(options.check, contract, adapter, name) : null;
+  const runPlans = runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name));
+
+  const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
+    ? [
+        {
+          description: `Check ${name} has work to do`,
+          sql: `SELECT EXISTS (${checkPlan.sql}) AS ok`,
+          params: checkPlan.params,
+        },
+      ]
+    : [];
+
+  const execute: readonly SqlMigrationPlanOperationStep[] = runPlans.map((plan) => ({
+    description: `Run ${name}`,
+    sql: plan.sql,
+    params: plan.params,
+  }));
+
+  const postcheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
+    ? [
+        {
+          description: `Verify ${name} resolved all violations`,
+          sql: `SELECT NOT EXISTS (${checkPlan.sql}) AS ok`,
+          params: checkPlan.params,
+        },
+      ]
+    : [];
+
   return {
     id: `data_migration.${name}`,
     label: `Data transform: ${name}`,
     operationClass: 'data',
-    name,
-    source: 'migration.ts',
-    check: options.check ? invokeAndLower(options.check, contract, adapter, name) : null,
-    run: runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),
+    ...ifDefined('invariantId', options.invariantId),
+    target: { id: 'postgres' },
+    precheck,
+    execute,
+    postcheck,
   };
 }
 

package/src/core/migrations/operations/dependencies.ts

@@ -18,6 +18,58 @@ export function createExtension(extensionName: string): Op {
   };
 }
 
+/**
+ * Install a Postgres extension as the baseline op for an extension-pack
+ * contract space. Layered on top of {@link createExtension}: stamps an
+ * `invariantId` (required so the per-space marker records the install),
+ * scopes the op `id` under a caller-chosen namespace (e.g. `pgvector.`),
+ * and emits pre- and postcheck SQL probing `pg_extension`. The richer
+ * shape lets the runner's idempotency probe skip the install on re-run
+ * (postcheck-pre-satisfied) without firing the precheck.
+ *
+ * Use this for hand-rolled baseline migrations in contract-space
+ * extension packages (e.g. `extension-pgvector`, `extension-paradedb`);
+ * use the bare {@link createExtension} for planner-emitted ops where the
+ * caller already controls idempotency through the surrounding plan.
+ */
+export function installExtension(options: {
+  readonly extensionName: string;
+  readonly invariantId: string;
+  readonly id: string;
+  readonly label?: string;
+}): Op {
+  const { extensionName, invariantId, id } = options;
+  const label = options.label ?? `Enable extension "${extensionName}"`;
+  return {
+    id,
+    label,
+    operationClass: 'additive',
+    invariantId,
+    target: {
+      id: 'postgres',
+      details: { schema: 'public', objectType: 'dependency', name: extensionName },
+    },
+    precheck: [
+      step(
+        `verify extension "${extensionName}" is not already enabled`,
+        `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
+      ),
+    ],
+    execute: [
+      step(
+        `create extension "${extensionName}"`,
+        `CREATE EXTENSION IF NOT EXISTS ${extensionName}`,
+      ),
+    ],
+    postcheck: [
+      step(
+        `confirm extension "${extensionName}" is enabled`,
+        `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
+      ),
+    ],
+  };
+}
+
 export function createSchema(schemaName: string): Op {
   return {
     id: `schema.${schemaName}`,

package/src/core/migrations/operations/indexes.ts

@@ -1,15 +1,40 @@
-import { quoteIdentifier } from '../../sql-utils';
+import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
+export interface CreateIndexExtras {
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+
+function renderIndexOptionValue(key: string, value: unknown): string {
+  if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  throw new Error(
+    `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`,
+  );
+}
+
+function renderIndexOptions(options: Record<string, unknown>): string {
+  return Object.entries(options)
+    .map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`)
+    .join(', ');
+}
+
 export function createIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
   columns: readonly string[],
+  extras?: CreateIndexExtras,
 ): Op {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
+  const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : '';
+  const options = extras?.options;
+  const withClause =
+    options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : '';
   return {
     id: `index.${tableName}.${indexName}`,
     label: `Create index "${indexName}" on "${tableName}"`,
@@ -24,7 +49,7 @@ export function createIndex(
     execute: [
       step(
         `create index "${indexName}"`,
-        `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified} (${columnList})`,
+        `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`,
       ),
     ],
     postcheck: [

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

@@ -24,10 +24,12 @@
  */
 
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';
+import type {
+  MigrationPlanWithAuthoringSurface,
+  OpFactoryCall,
+} from '@prisma-next/framework-components/control';
 import type { MigrationMeta } from '@prisma-next/migration-tools/migration';
 import { ifDefined } from '@prisma-next/utils/defined';
-import type { PostgresOpFactoryCall } from './op-factory-call';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import { PostgresMigration } from './postgres-migration';
 import { renderOps } from './render-ops';
@@ -39,13 +41,15 @@ export class TypeScriptRenderablePostgresMigration
   extends PostgresMigration
   implements MigrationPlanWithAuthoringSurface
 {
-  readonly #calls: readonly PostgresOpFactoryCall[];
+  readonly #calls: readonly OpFactoryCall[];
   readonly #meta: MigrationMeta;
+  readonly #spaceId: string;
 
-  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {
+  constructor(calls: readonly OpFactoryCall[], meta: MigrationMeta, spaceId: string) {
     super();
     this.#calls = calls;
     this.#meta = meta;
+    this.#spaceId = spaceId;
   }
 
   override get operations(): readonly Op[] {
@@ -56,11 +60,19 @@ export class TypeScriptRenderablePostgresMigration
     return this.#meta;
   }
 
+  /**
+   * Contract space this planner-produced plan applies to. Threaded
+   * from the planner options so the runner keys the marker row by
+   * the right space when executing the plan.
+   */
+  get spaceId(): string {
+    return this.#spaceId;
+  }
+
   renderTypeScript(): string {
     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-strategies.ts

@@ -14,19 +14,16 @@
  *   nullability tightening, unsafe type changes, enum shrink/rebuild) emit
  *   `DataTransformCall` placeholders that the user fills in.
  * - When `'data'` is excluded, those strategies short-circuit so the
- *   downstream walk-schema strategies (codec-hook type ops, dependency
- *   installs, temp-default backfill) and `mapIssueToCall` defaults emit
- *   direct DDL instead.
+ *   downstream walk-schema strategies (codec-hook type ops and temp-default
+ *   backfill) and `mapIssueToCall` defaults emit direct DDL instead.
  */
 
 import type { Contract } from '@prisma-next/contract/types';
 import type {
   CodecControlHooks,
-  ComponentDatabaseDependency,
   MigrationOperationPolicy,
   SqlMigrationPlanOperation,
 } from '@prisma-next/family-sql/control';
-import { collectInitDependencies } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
@@ -428,47 +425,6 @@ export const storageTypePlanCallStrategy: CallMigrationStrategy = (issues, ctx)
   return { kind: 'match', issues: remaining, calls };
 };
 
-/**
- * Dispatches component-declared database dependencies. Replaces the
- * walk-schema `buildDatabaseDependencyOperations` path. Rather than consuming
- * `dependency_missing` issues (which only carry the id), this strategy
- * re-invokes `collectInitDependencies(frameworkComponents)` at plan time so
- * the handler has access to the structured `install` ops each component
- * declared — including arbitrary SQL launders — and dedupes by dependency id
- * plus per-op id.
- */
-export const dependencyInstallCallStrategy: CallMigrationStrategy = (issues, ctx) => {
-  const installedIds = new Set(ctx.schema.dependencies.map((d) => d.id));
-  const dependencies = sortDependencies(
-    collectInitDependencies(ctx.frameworkComponents).filter(isPostgresPlannerDependency),
-  );
-
-  const calls: PostgresOpFactoryCall[] = [];
-  const handledDependencyIds = new Set<string>();
-  const seenOperationIds = new Set<string>();
-
-  for (const dep of dependencies) {
-    handledDependencyIds.add(dep.id);
-    if (installedIds.has(dep.id)) continue;
-    for (const installOp of dep.install) {
-      if (seenOperationIds.has(installOp.id)) continue;
-      seenOperationIds.add(installOp.id);
-      calls.push(liftInstallOpToCall(installOp));
-    }
-  }
-
-  // Consume ALL `dependency_missing` issues — even non-postgres ones. The
-  // walk-schema predecessor silently skipped non-postgres deps; leaving those
-  // issues in the stream would let `mapIssueToCall` reject them as
-  // "Unknown dependency type".
-  const remaining = issues.filter((issue) => issue.kind !== 'dependency_missing');
-
-  if (calls.length === 0 && remaining.length === issues.length) {
-    return { kind: 'no_match' };
-  }
-  return { kind: 'match', issues: remaining, calls };
-};
-
 /**
  * Handles `missing_column` issues for NOT NULL columns without a contract
  * default. Replaces the walk-schema `buildAddColumnItem` non-default branches.
@@ -633,43 +589,6 @@ function canUseSharedTemporaryDefaultStrategy(options: {
   return true;
 }
 
-type PlannerDatabaseDependency = ComponentDatabaseDependency<unknown> & {
-  readonly install: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
-};
-
-function isPostgresPlannerDependency(
-  dependency: ComponentDatabaseDependency<unknown>,
-): dependency is PlannerDatabaseDependency {
-  return dependency.install.every((operation) => operation.target.id === 'postgres');
-}
-
-function sortDependencies(
-  dependencies: ReadonlyArray<PlannerDatabaseDependency>,
-): ReadonlyArray<PlannerDatabaseDependency> {
-  return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
-}
-
-/**
- * Lift a component install op into migration IR. Structured shapes — extension
- * and schema installs with predictable SQL — collapse to typed `*Call`
- * subclasses so the scaffolded migration authoring surface stays readable.
- * Everything else (arbitrary SQL) falls through to `RawSqlCall` as an escape
- * hatch.
- */
-/**
- * Component-declared install ops are wrapped as `RawSqlCall` so the
- * component's original `label`, `precheck`, `execute`, `postcheck`, and op
- * id are preserved verbatim. Structured conversion (to e.g.
- * `CreateExtensionCall`) would drop the precheck/postcheck pair and
- * change the DDL label, breaking walk-schema output parity. Classification
- * as `'dep'` happens in `classifyCall` via the underlying op's id prefix.
- */
-function liftInstallOpToCall(
-  op: SqlMigrationPlanOperation<PostgresPlanTargetDetails>,
-): PostgresOpFactoryCall {
-  return new RawSqlCall(op);
-}
-
 /**
  * Ordered list of Postgres planner strategies, shared by `migration plan`
  * and `db update` / `db init`. The issue planner runs each strategy in
@@ -685,8 +604,8 @@ function liftInstallOpToCall(
  * - When `'data'` is not allowed (`db update` / `db init`), each data-safe
  *   strategy short-circuits to `no_match`, leaving the issue for the
  *   downstream walk-schema strategies (`storageTypePlanCallStrategy`,
- *   `dependencyInstallCallStrategy`, `notNullAddColumnCallStrategy`) or the
- *   `mapIssueToCall` default to handle with direct DDL.
+ *   `notNullAddColumnCallStrategy`) or the `mapIssueToCall` default to handle
+ *   with direct DDL.
  *
  * Order matters: data-safe strategies must run before the walk-schema
  * strategies on overlapping issue kinds (e.g. `enum_values_changed`,
@@ -698,6 +617,5 @@ export const postgresPlannerStrategies: readonly CallMigrationStrategy[] = [
   typeChangeCallStrategy,
   nullableTighteningCallStrategy,
   storageTypePlanCallStrategy,
-  dependencyInstallCallStrategy,
   notNullAddColumnCallStrategy,
 ];