@prisma-next/target-postgres 0.14.0-dev.59 → 0.14.0-dev.60

package/dist/control.mjs

@@ -5,7 +5,7 @@ import { i as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-BiS
 import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-BOsDnH64.mjs";
 import { r as renderDefaultLiteral } from "./planner-ddl-builders-B8Nn6nHN.mjs";
 import { n as PostgresContractSerializer } from "./postgres-contract-view-Dg-N7KA7.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-Bd-5WLzr.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-CNrc1Odu.mjs";
 import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";

package/dist/errors-DO-w0EUS.mjs

@@ -0,0 +1,35 @@
+import { CliStructuredError } from "@prisma-next/errors/control";
+//#region src/core/errors.ts
+/**
+* A `PostgresMigration` operation that needs the materialized control adapter
+* — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+* was invoked, but the migration was constructed without a `ControlStack`.
+* Concrete authoring usage always goes through the migration CLI entrypoint,
+* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+* error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+* with the no-arg form (legal for `operations` / `describe` introspection only).
+*
+* The `operation` argument is required so every throw site names the operation
+* that actually failed; a new operation cannot inherit a misattributed message.
+*
+* Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
+* (data-transform query plan against wrong contract) because the missing
+* input is the stack itself, not the per-operation contract.
+*
+* Lives in `@prisma-next/target-postgres/errors` rather than the shared
+* framework migration errors module because the failure is target-specific:
+* the contract it talks about (`PostgresMigration`, the Postgres control
+* adapter, the Postgres-target stack) only exists in this package.
+*/
+function errorPostgresMigrationStackMissing(operation) {
+	return new CliStructuredError("2007", `PostgresMigration.${operation} requires a control adapter`, {
+		domain: "MIG",
+		why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
+		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
+		meta: { operation }
+	});
+}
+//#endregion
+export { errorPostgresMigrationStackMissing as t };
+
+//# sourceMappingURL=errors-DO-w0EUS.mjs.map

package/dist/errors-DO-w0EUS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DO-w0EUS.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` operation that needs the materialized control adapter\n * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —\n * was invoked, but the migration was constructed without a `ControlStack`.\n * Concrete authoring usage always goes through the migration CLI entrypoint,\n * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection only).\n *\n * The `operation` argument is required so every throw site names the operation\n * that actually failed; a new operation cannot inherit a misattributed message.\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    `PostgresMigration.${operation} requires a control adapter`,\n    {\n      domain: 'MIG',\n      why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: { operation },\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,mCAAmC,WAAuC;CACxF,OAAO,IAAI,mBACT,QACA,qBAAqB,UAAU,8BAC/B;EACE,QAAQ;EACR,KAAK,qBAAqB,UAAU;EACpC,KAAK;EACL,MAAM,EAAE,UAAU;CACpB,CACF;AACF"}

package/dist/errors.d.mts

@@ -2,14 +2,16 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 
 //#region src/core/errors.d.ts
 /**
- * A `PostgresMigration` instance method that needs the materialized control
- * adapter (currently only `this.dataTransform(...)`) was invoked, but the
- * migration was constructed without a `ControlStack`. Concrete authoring
- * usage always goes through the migration CLI entrypoint, which assembles
- * a stack from the loaded `prisma-next.config.ts`; reaching this error
- * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
- * with the no-arg form (legal for `operations` / `describe` introspection
- * only).
+ * A `PostgresMigration` operation that needs the materialized control adapter
+ * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+ * was invoked, but the migration was constructed without a `ControlStack`.
+ * Concrete authoring usage always goes through the migration CLI entrypoint,
+ * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+ * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection only).
+ *
+ * The `operation` argument is required so every throw site names the operation
+ * that actually failed; a new operation cannot inherit a misattributed message.
  *
  * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
  * (data-transform query plan against wrong contract) because the missing
@@ -20,7 +22,7 @@ import { CliStructuredError } from "@prisma-next/errors/control";
  * the contract it talks about (`PostgresMigration`, the Postgres control
  * adapter, the Postgres-target stack) only exists in this package.
  */
-declare function errorPostgresMigrationStackMissing(): CliStructuredError;
+declare function errorPostgresMigrationStackMissing(operation: string): CliStructuredError;
 //#endregion
 export { errorPostgresMigrationStackMissing };
 //# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;AAAwE;;;;;;;;;;;;;iBAAxD,kCAAA,IAAsC,kBAAkB"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAuBA;;;;AAAyF;;;;;;;;;;;;;;;iBAAzE,kCAAA,CAAmC,SAAA,WAAoB,kBAAkB"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-DO-w0EUS.mjs";
 export { errorPostgresMigrationStackMissing };

package/dist/migration.d.mts

@@ -1,6 +1,6 @@
 import { n as DataTransformOptions, r as dataTransform, t as DataTransformClosure } from "./data-transform-DPzwBMhW.mjs";
 import { E as Op } from "./op-factory-call-D6_7-7Vc.mjs";
-import { t as PostgresMigration } from "./postgres-migration-cyBe2Ee0.mjs";
+import { t as PostgresMigration } from "./postgres-migration-Bzzi0Asr.mjs";
 import { checkExpression, col, fn, foreignKey, lit, primaryKey, unique } from "@prisma-next/sql-relational-core/contract-free";
 import { placeholder } from "@prisma-next/errors/migration";
 import { MigrationCLI } from "@prisma-next/cli/migration-cli";

package/dist/migration.mjs

@@ -1,6 +1,6 @@
 import { j as createExtension } from "./op-factory-call-DxNNKUeZ.mjs";
 import { t as dataTransform } from "./data-transform-BOWpliq8.mjs";
-import { t as PostgresMigration } from "./postgres-migration-BahMHTbj.mjs";
+import { t as PostgresMigration } from "./postgres-migration-ChyRsWvE.mjs";
 import { checkExpression, col, fn, foreignKey, lit, primaryKey, unique } from "@prisma-next/sql-relational-core/contract-free";
 import { placeholder } from "@prisma-next/errors/migration";
 import { MigrationCLI } from "@prisma-next/cli/migration-cli";

package/dist/{planner-Bd-5WLzr.mjs → planner-CNrc1Odu.mjs}

@@ -7,7 +7,7 @@ import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-C
 import { t as buildPostgresPlanDiff } from "./diff-database-schema-BOsDnH64.mjs";
 import { E as RenamePostgresRlsPolicyCall, S as DropPostgresRlsPolicyCall, d as CreatePostgresRlsPolicyCall } from "./op-factory-call-DxNNKUeZ.mjs";
 import { a as resolvePostgresNodeIssueCreationFactoryName, c as issueSchemaName, d as postgresPlannerStrategies, i as resolvePostgresNodeIssueControlPolicySubject, l as issueTableName, n as resolveNamespaceIdForDdlSchema, o as coalesceSubtreeIssues, r as resolvePostgresCallControlPolicySubject, s as issueNode, t as formatPostgresControlPolicySubjectLabel, u as planIssues } from "./control-policy-Co_13Hxa.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-BLJH1zIc.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-NI-oGKcw.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
@@ -419,4 +419,4 @@ function policyNodeToContractPolicy(node) {
 //#endregion
 export { createPostgresMigrationPlanner as t };
 
-//# sourceMappingURL=planner-Bd-5WLzr.mjs.map
+//# sourceMappingURL=planner-CNrc1Odu.mjs.map

package/dist/{planner-Bd-5WLzr.mjs.map → planner-CNrc1Odu.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-Bd-5WLzr.mjs","names":["#lowerer"],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaDiffIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\n\n/**\n * Resolves the live-database schema name for a given namespace\n * coordinate. Mirrors `resolveDdlSchemaForNamespace` in\n * `planner-strategies.ts` so the verifier's projection and the\n * planner's projection always agree — Postgres-aware namespaces (the\n * production path) dispatch to `ddlSchemaName(storage)`, and bare\n * object payloads (used by some tests) fall back to the coordinate\n * itself.\n */\nfunction resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string {\n  const namespace = storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/**\n * Reads the introspected list of schema names from the database-root schema\n * node. `existingSchemas` is database-level, so it lives on the\n * `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.\n *\n * Defaults to the always-present `public` schema when the node is not the\n * database root — a fresh Postgres database always carries `public` (unless an\n * operator dropped it manually), so any verifier path that runs without an\n * enriched introspection still suppresses the redundant `CREATE SCHEMA\n * \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and sets `existingSchemas`\n * on the returned root. Tests that want to assert against a richer initial\n * state construct a `PostgresDatabaseSchemaNode` explicitly.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {\n  if (PostgresDatabaseSchemaNode.is(schema)) {\n    return schema.existingSchemas;\n  }\n  return [DEFAULT_NAMESPACE_ID];\n}\n\n/**\n * Emits a `postgres-namespace` `not-found` diff issue for every\n * contract-declared Postgres namespace whose live container does not yet\n * exist. The planner prepends these (node-typed, synthesized) to the\n * relational diff issues so a multi-schema plan emits `CREATE SCHEMA`\n * before the tables that need it — a planner-only concern (verify already\n * rejects via the `not-found` table issues a missing schema already\n * produces), so this is not part of the shared diff.\n *\n * A namespace's live container is the schema returned by its\n * polymorphic `ddlSchemaName(storage)` method — named schemas resolve\n * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`\n * and is skipped explicitly (late-bound namespaces have no fixed DDL\n * schema). Issues are emitted only when the resolved name is a real,\n * creatable schema (not the unbound sentinel) and is missing from the\n * introspected list. `public` is suppressed implicitly because the\n * introspection (or its sensible default) always carries it.\n *\n * Each emitted issue's path is `['database', ddlName]` — an ancestor of\n * every table path under that schema, so it must never be run through\n * `coalesceSubtreeIssues` alongside the table diff (it would swallow the\n * table-level `not-found` issues that drive `CREATE TABLE`); the planner\n * adds these AFTER coalescing the relational issues, and they are not\n * subject to sibling-space ownership scoping (mirrors the retired\n * coordinate walk, which prepended namespace issues after that filter).\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n}): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaDiffIssue<SqlSchemaDiffNode>[] = [];\n  const namespaceIds = Object.keys(contract.storage.namespaces).sort();\n  for (const namespaceId of namespaceIds) {\n    if (namespaceId === UNBOUND_NAMESPACE_ID) continue;\n    const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);\n    if (ddlName === UNBOUND_NAMESPACE_ID) continue;\n    if (existing.has(ddlName)) continue;\n    const namespace = new PostgresNamespaceSchemaNode({\n      schemaName: ddlName,\n      tables: {},\n      nativeEnumTypeNames: [],\n    });\n    issues.push({\n      path: ['database', ddlName],\n      reason: 'not-found',\n      expected: namespace,\n    });\n  }\n  return issues;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerConflict,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\n  partitionCallsByControlPolicy,\n  partitionIssuesByControlPolicy,\n  planFieldEventOperations,\n  plannerFailure,\n} from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaDiffIssue,\n  SchemaOwnership,\n} from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport { parseRlsPolicyWireName } from '../rls/wire-name';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind, type SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\nimport {\n  formatPostgresControlPolicySubjectLabel,\n  resolveNamespaceIdForDdlSchema,\n  resolvePostgresCallControlPolicySubject,\n  resolvePostgresNodeIssueControlPolicySubject,\n  resolvePostgresNodeIssueCreationFactoryName,\n} from './control-policy';\nimport { buildPostgresPlanDiff } from './diff-database-schema';\nimport {\n  coalesceSubtreeIssues,\n  issueNode,\n  issueSchemaName,\n  issueTableName,\n  planIssues,\n} from './issue-planner';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport {\n  CreatePostgresRlsPolicyCall,\n  DropPostgresRlsPolicyCall,\n  RenamePostgresRlsPolicyCall,\n} from './op-factory-call';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\nimport { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(\n  lowerer: ExecuteRequestLowerer,\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner(lowerer);\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | {\n      readonly kind: 'success';\n      readonly plan: TypeScriptRenderablePostgresMigration;\n      readonly warnings?: readonly SqlPlannerConflict[];\n    }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` diffs the target contract against the live schema via the one\n * differ (`buildPostgresPlanDiff`, producing node-typed `SchemaDiffIssue[]`)\n * and delegates to `planIssues` with the unified `postgresPlannerStrategies`\n * list: NOT-NULL backfill, type-change, nullable-tightening, codec-hook\n * storage types, component-declared dependency installs, and\n * shared-temp-default / empty-table-guarded NOT-NULL add-column. The same\n * strategy list runs for `migration plan`, `db update`, and `db init`;\n * behavior diverges purely on `policy.allowedOperationClasses` (the\n * data-safe strategies short-circuit when `'data'` is excluded). The issue\n * planner applies operation-class policy gates and emits a single\n * `PostgresOpFactoryCall[]` that drives both the runtime-ops view (via\n * `renderOps`) and the `renderTypeScript()` authoring surface. RLS policy\n * drift (the structural half of the same one-differ tree) is handled\n * separately via `planPostgresSchemaDiff`.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n\n  constructor(lowerer?: ExecuteRequestLowerer) {\n    this.#lowerer = lowerer;\n  }\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n    /**\n     * Ownership oracle over the contract-space composition — see\n     * {@link SqlMigrationPlannerPlanOptions.ownership}.\n     */\n    readonly ownership?: SchemaOwnership;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(\n    context: MigrationScaffoldContext,\n    spaceId: string,\n  ): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration(\n      [],\n      {\n        from: context.fromHash,\n        to: context.toHash,\n      },\n      spaceId,\n      this.#lowerer,\n    );\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName =\n      options.schemaName ??\n      Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ??\n      UNBOUND_NAMESPACE_ID;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    // The one combined tree diff drives the whole plan: relational findings\n    // become structural DDL via `planIssues`, policy findings become RLS ops\n    // via `planPostgresSchemaDiff`. Verify runs its own full-tree node diff\n    // (`diffSchema`) over the same schema and rejects on a\n    // surviving failure.\n    PostgresDatabaseSchemaNode.assert(options.schema);\n    const { issues: rawIssues } = buildPostgresPlanDiff({\n      contract: options.contract,\n      actualSchema: options.schema,\n      frameworkComponents: options.frameworkComponents,\n    });\n    const policyDiffIssues = rawIssues.filter((issue) => isPolicyDiffIssue(issue));\n    const relationalDiffIssues = rawIssues.filter((issue) => !isPolicyDiffIssue(issue));\n\n    // The generic differ is total and un-gated: strict-mode extras filtering\n    // (dropping `not-expected` findings outside strict mode, mirroring the\n    // retired coordinate walk's `if (strict) { ...extra_* } }` guards),\n    // subtree coalescing (a missing/extra table also emits an issue for\n    // every child under it — redundant once the table-level Create/Drop call\n    // already accounts for the whole subtree), and ownership are all post-diff\n    // planner steps.\n    //\n    // Ownership: a live extra is only this plan's to drop when no contract\n    // space owns it. The differ ran against THIS space's contract, so a table\n    // a sibling space owns surfaces here as `not-expected`; the planner asks\n    // the ownership oracle (the passive aggregate) whether any space declares\n    // it and, if so, leaves it alone — it is a sibling's table, not an orphan.\n    // A table no space owns stays a genuine extra to drop under a destructive\n    // policy. Ownership lives in the aggregate; the planner only asks. Absent\n    // oracle (single-space, none handed) keeps every extra. Coalescing MUST\n    // run before this so a sibling-owned table's child issues have already\n    // collapsed into the one table-level issue that carries the table name.\n    const strict =\n      options.policy.allowedOperationClasses.includes('widening') ||\n      options.policy.allowedOperationClasses.includes('destructive');\n    const coalesced = coalesceSubtreeIssues(relationalDiffIssues);\n    const owned = retainUnownedExtras(coalesced, options.ownership, options.contract);\n    const gated = strict ? owned : owned.filter((issue) => issue.reason !== 'not-expected');\n\n    // Namespace presence (`CREATE SCHEMA`) is a planner-only op-generation\n    // concern stitched in here rather than inside the shared diff — verify\n    // never needs it (a missing schema already surfaces as a `not-found`\n    // table in the relational findings). These synthesized issues are added\n    // AFTER coalescing/scoping (never coalesced against the table diff —\n    // their path is an ancestor of every table path under that schema, so\n    // running them through the same coalesce would swallow the table-level\n    // `not-found` issues that drive `CREATE TABLE`) and are NOT subject to\n    // sibling-space scoping, matching the retired coordinate walk exactly.\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    const schemaIssues = [...namespaceIssues, ...gated];\n\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n    // The strategy layer reads the live schema by bare table name for existence\n    // checks (shared-temp-default safety, FK/unique probes), so it takes one\n    // per-schema namespace node — never the whole tree root, and never a flat\n    // merge of every namespace (which would collide same-named tables across\n    // schemas). Probing more than one namespace at once is future work.\n    const relationalSchema = relationalNamespaceNode(options.schema, schemaName);\n\n    // Input-side control-policy partition. `external` / `observed` subjects\n    // — and non-creation issues for `tolerated` subjects — are dropped from\n    // the planner's input entirely; the planner never observes them, never\n    // diffs them, never generates DDL for them. Suppression warnings are\n    // built directly from the suppressed partition (one per subject), so the\n    // user-visible message survives even when the planner would have failed\n    // to model the subject's live shape.\n    const issuePartition = partitionIssuesByControlPolicy({\n      issues: schemaIssues,\n      contract: options.contract,\n      resolveControlPolicySubject: (issue) =>\n        resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),\n      resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    const result = planIssues({\n      issues: issuePartition.plannable,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapNodeIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      ...ifDefined('schema', relationalSchema),\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    const schemaDiffCalls = this.planPostgresSchemaDiff(options, policyDiffIssues);\n    const schemaDiffPartition = partitionCallsByControlPolicy({\n      calls: schemaDiffCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed\n    // ordering is `structural → added → dropped → altered`, with\n    // within-group sorting by `(tableName, fieldName)` so re-emits are\n    // byte-stable. The hook fires only at the application emitter —\n    // extension-space planning never reaches this helper.\n    const fieldEventOps = planFieldEventOperations({\n      priorContract: options.fromContract,\n      newContract: options.contract,\n      codecHooks,\n    });\n    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning\n    // lifts them at this integration boundary (see field-event-planner JSDoc).\n    const fieldEventPostgresCalls = blindCast<\n      readonly PostgresOpFactoryCall[],\n      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'\n    >(fieldEventOps);\n    const fieldEventPartition = partitionCallsByControlPolicy({\n      calls: fieldEventPostgresCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];\n    const warnings: SqlPlannerConflict[] = [\n      ...issuePartition.warnings,\n      ...schemaDiffPartition.warnings,\n      ...fieldEventPartition.warnings,\n    ];\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(\n        calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        options.spaceId,\n        this.#lowerer,\n      ),\n      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),\n    });\n  }\n\n  /**\n   * Maps the RLS policy presence findings of the one combined tree diff\n   * (`buildPostgresPlanDiff`, already ownership-filtered) into\n   * `CREATE POLICY` / `DROP POLICY` / `ALTER POLICY … RENAME TO` ops. It\n   * does not re-diff — it consumes exactly the policy-node subset of the\n   * shared diff's issues. Enablement is NOT decided here: `ENABLE`/`DISABLE\n   * ROW LEVEL SECURITY` derive from the table's marker-driven `rlsEnabled`\n   * attribute diff on the relational side.\n   *\n   * Rename post-pass: a `not-found` and a `not-expected` policy on the SAME\n   * table whose wire-name content hashes match but prefixes differ are one\n   * prefix-only rename, collapsed into a single non-destructive\n   * `RenamePostgresRlsPolicyCall`. Multi-candidate hash groups pair\n   * deterministically by sorted wire name; leftovers proceed as\n   * create/drop. Unparseable wire names never pair.\n   *\n   * The pairing runs only when the policy allows `widening` (rename's\n   * class). Without it (db-init's additive-only set), pairing degrades\n   * deliberately to the additive half: the new name is CREATEd and the old\n   * policy survives live until a widening/destructive-allowed plan runs —\n   * emitting an ungated widening rename would only fail at the runner's\n   * class re-enforcement.\n   */\n  private planPostgresSchemaDiff(\n    options: PlannerOptionsWithComponents,\n    filteredDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ): readonly PostgresOpFactoryCall[] {\n    const allowsDestructive = options.policy.allowedOperationClasses.includes('destructive');\n    const allowsWidening = options.policy.allowedOperationClasses.includes('widening');\n\n    interface PolicyFinding {\n      readonly node: PostgresPolicySchemaNode;\n      readonly schemaForTable: string;\n    }\n    const missing: PolicyFinding[] = [];\n    const extra: PolicyFinding[] = [];\n\n    for (const issue of filteredDiffIssues) {\n      // 'not-equal' is unreachable for content-addressed policies: the wire name\n      // encodes the body hash, so two policies sharing a local key (same name)\n      // are always equal and isEqualTo never returns false.\n      if (issue.reason === 'not-found') {\n        const expected = issue.expected;\n        PostgresPolicySchemaNode.assert(expected);\n        // expected.namespaceId is the DDL schema name (resolved during projection);\n        // this re-resolution is a no-op as long as PostgresSchema.ddlSchemaName() returns this.id.\n        missing.push({\n          node: expected,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            expected.namespaceId,\n          ),\n        });\n      } else if (issue.reason === 'not-expected') {\n        const actual = issue.actual;\n        PostgresPolicySchemaNode.assert(actual);\n        extra.push({\n          node: actual,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            actual.namespaceId,\n          ),\n        });\n      }\n    }\n\n    const calls: PostgresOpFactoryCall[] = [];\n    const renamedExtras = new Set<PolicyFinding>();\n    const renamedMissing = new Set<PolicyFinding>();\n    const pairingKey = (finding: PolicyFinding, hash: string): string =>\n      JSON.stringify([finding.schemaForTable, finding.node.tableName, hash]);\n\n    if (allowsWidening) {\n      const extrasByGroup = new Map<string, PolicyFinding[]>();\n      for (const finding of extra) {\n        const parsed = parseRlsPolicyWireName(finding.node.name);\n        if (parsed === undefined) continue;\n        const key = pairingKey(finding, parsed.hash);\n        const group = extrasByGroup.get(key) ?? [];\n        group.push(finding);\n        extrasByGroup.set(key, group);\n      }\n      for (const group of extrasByGroup.values()) {\n        group.sort((a, b) => (a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0));\n      }\n\n      const sortedMissing = [...missing].sort((a, b) =>\n        a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0,\n      );\n      for (const missingFinding of sortedMissing) {\n        const parsed = parseRlsPolicyWireName(missingFinding.node.name);\n        if (parsed === undefined) continue;\n        const candidates = extrasByGroup.get(pairingKey(missingFinding, parsed.hash));\n        const candidate = candidates?.shift();\n        if (candidate === undefined) continue;\n        // Same name would never surface as missing+extra (the differ pairs by\n        // name), so a matched candidate always differs in prefix only.\n        renamedExtras.add(candidate);\n        renamedMissing.add(missingFinding);\n        calls.push(\n          new RenamePostgresRlsPolicyCall(\n            missingFinding.schemaForTable,\n            missingFinding.node.tableName,\n            candidate.node.name,\n            missingFinding.node.name,\n          ),\n        );\n      }\n    }\n\n    for (const finding of missing) {\n      if (renamedMissing.has(finding)) continue;\n      calls.push(\n        new CreatePostgresRlsPolicyCall(\n          finding.schemaForTable,\n          finding.node.tableName,\n          policyNodeToContractPolicy(finding.node),\n        ),\n      );\n    }\n    if (allowsDestructive) {\n      for (const finding of extra) {\n        if (renamedExtras.has(finding)) continue;\n        calls.push(\n          new DropPostgresRlsPolicyCall(\n            finding.schemaForTable,\n            finding.node.tableName,\n            finding.node.name,\n          ),\n        );\n      }\n    }\n\n    return calls;\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n}\n\n/**\n * A diff issue whose node is an RLS policy — the structural half of the one\n * combined tree diff, routed to `planPostgresSchemaDiff` instead of\n * `planIssues`.\n */\nfunction isPolicyDiffIssue(issue: SchemaDiffIssue<SqlSchemaDiffNode>): boolean {\n  const node = issue.expected ?? issue.actual;\n  return node !== undefined && PostgresPolicySchemaNode.is(node);\n}\n\n/**\n * Drops a `not-expected` issue when it is a whole extra TABLE that some\n * contract space owns, asking the ownership oracle per node.\n *\n * The consultation applies ONLY to table-level extras — a live table this\n * space's contract lacks — identified by asking the issue's own node\n * (`nodeKind === table`), never by counting path segments. `declaresEntity`\n * answers over the whole composition (self included), keyed on the schema-IR\n * entity coordinate so a genuine orphan in one namespace is never conflated\n * with a same-named table a sibling space declares in another, or with a\n * same-named non-table entity (an enum, an RLS policy) a sibling declares in\n * the SAME namespace: a positive answer means another space owns THIS table\n * in THIS namespace (a table this space owned would be in its expected tree,\n * never an extra) — leave it. A negative answer means no space owns it — a\n * genuine orphan to drop. `entityKind` is the literal `'table'` here: this\n * function only ever asks about a node already confirmed to be\n * `PostgresSchemaNodeKind.table` (checked just above), and the diff tree's\n * `nodeKind` vocabulary (`'postgres-table'`) is distinct from the storage\n * `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal\n * is that storage-entries spelling, not the node kind.\n *\n * The issue path carries the *resolved DDL schema* (e.g. `public`), but a\n * contract space's own declared namespace id can be the unbound sentinel\n * (`__unbound__`) that resolves to that schema — the two spellings would\n * never string-match. `resolveNamespaceIdForDdlSchema` recovers the raw\n * namespace id THIS space's own contract would use for that DDL schema, so\n * a table this space's own unbound namespace declares (and any sibling\n * whose own unbound namespace resolves the same way) is compared on the\n * same coordinate the aggregate's `elementCoordinates` walk yields.\n *\n * A DEEPER extra (an extra column/constraint on a table this space DOES own —\n * only the child drifted, so the table is in the expected tree) is this\n * space's own drift and is always kept for dropping; asking the oracle there\n * would wrongly suppress it, because the owned table answers `true`. Shallower\n * issues (namespace/root) are never ownership-scoped here. No oracle ⇒ every\n * extra is kept (single-space plan).\n */\nfunction retainUnownedExtras(\n  issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ownership: SchemaOwnership | undefined,\n  contract: Contract<SqlStorage>,\n): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  if (ownership === undefined) return issues;\n  return issues.filter((issue) => {\n    if (issue.reason !== 'not-expected') return true;\n    const node = issueNode(issue);\n    if (node === undefined || node.nodeKind !== PostgresSchemaNodeKind.table) return true;\n    const ddlSchemaName = issueSchemaName(issue);\n    const tableName = issueTableName(issue);\n    if (ddlSchemaName === undefined || tableName === undefined) return true;\n    const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);\n    return !ownership.declaresEntity({ namespaceId, entityKind: 'table', entityName: tableName });\n  });\n}\n\n/**\n * Returns the one namespace node the relational strategy layer probes for\n * live-table existence and reads codec-hook context off — the namespace\n * matching the planner's resolved schema name, or the first namespace when\n * none matches. `undefined` when the tree has no namespaces, so the strategy\n * context uses its empty-schema default.\n *\n * The relational strategies key tables by bare name, so they can only probe one\n * namespace at a time; probing across every namespace at once is future work.\n *\n * Returns the real `PostgresNamespaceSchemaNode` reference rather than a\n * projection: `storageTypePlanCallStrategy` hands this same value to codec\n * `planTypeOperations` hooks as `schema`, and hooks read the Postgres-specific\n * `nativeEnumTypeNames` field off it (via `PostgresNamespaceSchemaNode.is`) to\n * decide whether a native enum type already exists — a projection that only\n * copies `tables` would silently drop that signal. `StrategyContext.schema`'s\n * declared type (`SqlSchemaIR`, shared with SQLite's flat shape) doesn't\n * capture this, so the return is `blindCast` the same way `namespaceSchemaNodes`\n * in the family's relational walk already treats a namespace node as a\n * structurally-`SqlSchemaIR`-shaped value.\n */\nfunction relationalNamespaceNode(\n  schema: PostgresDatabaseSchemaNode,\n  schemaName: string,\n): SqlSchemaIR | undefined {\n  const namespaceNodes = Object.values(schema.namespaces);\n  const namespaceNode =\n    namespaceNodes.find((node) => node.schemaName === schemaName) ?? namespaceNodes[0];\n  if (namespaceNode === undefined) return undefined;\n  return blindCast<\n    SqlSchemaIR,\n    'PostgresNamespaceSchemaNode carries tables (+ nativeEnumTypeNames, read by codec hooks via PostgresNamespaceSchemaNode.is) structurally compatible with the SqlSchemaIR shape the strategy layer declares'\n  >(namespaceNode);\n}\n\n/**\n * Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`\n * carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole\n * entity, `namespaceId` included). This reconstructs rather than looking the\n * original up in the contract on purpose: the diff node's `namespaceId` is the\n * *resolved DDL schema* (set when the expected tree was built), which is the\n * value the emitted op must carry; the contract-stored entity holds the raw,\n * pre-resolution coordinate, so a lookup would change the migration output.\n */\nfunction policyNodeToContractPolicy(node: PostgresPolicySchemaNode): PostgresRlsPolicy {\n  return new PostgresRlsPolicy({\n    name: node.name,\n    prefix: node.prefix,\n    tableName: node.tableName,\n    namespaceId: node.namespaceId,\n    operation: node.operation,\n    roles: [...node.roles],\n    ...ifDefined('using', node.using),\n    ...ifDefined('withCheck', node.withCheck),\n    permissive: node.permissive,\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"planner-CNrc1Odu.mjs","names":["#lowerer"],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaDiffIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\n\n/**\n * Resolves the live-database schema name for a given namespace\n * coordinate. Mirrors `resolveDdlSchemaForNamespace` in\n * `planner-strategies.ts` so the verifier's projection and the\n * planner's projection always agree — Postgres-aware namespaces (the\n * production path) dispatch to `ddlSchemaName(storage)`, and bare\n * object payloads (used by some tests) fall back to the coordinate\n * itself.\n */\nfunction resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string {\n  const namespace = storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/**\n * Reads the introspected list of schema names from the database-root schema\n * node. `existingSchemas` is database-level, so it lives on the\n * `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.\n *\n * Defaults to the always-present `public` schema when the node is not the\n * database root — a fresh Postgres database always carries `public` (unless an\n * operator dropped it manually), so any verifier path that runs without an\n * enriched introspection still suppresses the redundant `CREATE SCHEMA\n * \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and sets `existingSchemas`\n * on the returned root. Tests that want to assert against a richer initial\n * state construct a `PostgresDatabaseSchemaNode` explicitly.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {\n  if (PostgresDatabaseSchemaNode.is(schema)) {\n    return schema.existingSchemas;\n  }\n  return [DEFAULT_NAMESPACE_ID];\n}\n\n/**\n * Emits a `postgres-namespace` `not-found` diff issue for every\n * contract-declared Postgres namespace whose live container does not yet\n * exist. The planner prepends these (node-typed, synthesized) to the\n * relational diff issues so a multi-schema plan emits `CREATE SCHEMA`\n * before the tables that need it — a planner-only concern (verify already\n * rejects via the `not-found` table issues a missing schema already\n * produces), so this is not part of the shared diff.\n *\n * A namespace's live container is the schema returned by its\n * polymorphic `ddlSchemaName(storage)` method — named schemas resolve\n * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`\n * and is skipped explicitly (late-bound namespaces have no fixed DDL\n * schema). Issues are emitted only when the resolved name is a real,\n * creatable schema (not the unbound sentinel) and is missing from the\n * introspected list. `public` is suppressed implicitly because the\n * introspection (or its sensible default) always carries it.\n *\n * Each emitted issue's path is `['database', ddlName]` — an ancestor of\n * every table path under that schema, so it must never be run through\n * `coalesceSubtreeIssues` alongside the table diff (it would swallow the\n * table-level `not-found` issues that drive `CREATE TABLE`); the planner\n * adds these AFTER coalescing the relational issues, and they are not\n * subject to sibling-space ownership scoping (mirrors the retired\n * coordinate walk, which prepended namespace issues after that filter).\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n}): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaDiffIssue<SqlSchemaDiffNode>[] = [];\n  const namespaceIds = Object.keys(contract.storage.namespaces).sort();\n  for (const namespaceId of namespaceIds) {\n    if (namespaceId === UNBOUND_NAMESPACE_ID) continue;\n    const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);\n    if (ddlName === UNBOUND_NAMESPACE_ID) continue;\n    if (existing.has(ddlName)) continue;\n    const namespace = new PostgresNamespaceSchemaNode({\n      schemaName: ddlName,\n      tables: {},\n      nativeEnumTypeNames: [],\n    });\n    issues.push({\n      path: ['database', ddlName],\n      reason: 'not-found',\n      expected: namespace,\n    });\n  }\n  return issues;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerConflict,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\n  partitionCallsByControlPolicy,\n  partitionIssuesByControlPolicy,\n  planFieldEventOperations,\n  plannerFailure,\n} from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaDiffIssue,\n  SchemaOwnership,\n} from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport { parseRlsPolicyWireName } from '../rls/wire-name';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind, type SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\nimport {\n  formatPostgresControlPolicySubjectLabel,\n  resolveNamespaceIdForDdlSchema,\n  resolvePostgresCallControlPolicySubject,\n  resolvePostgresNodeIssueControlPolicySubject,\n  resolvePostgresNodeIssueCreationFactoryName,\n} from './control-policy';\nimport { buildPostgresPlanDiff } from './diff-database-schema';\nimport {\n  coalesceSubtreeIssues,\n  issueNode,\n  issueSchemaName,\n  issueTableName,\n  planIssues,\n} from './issue-planner';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport {\n  CreatePostgresRlsPolicyCall,\n  DropPostgresRlsPolicyCall,\n  RenamePostgresRlsPolicyCall,\n} from './op-factory-call';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\nimport { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(\n  lowerer: ExecuteRequestLowerer,\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner(lowerer);\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | {\n      readonly kind: 'success';\n      readonly plan: TypeScriptRenderablePostgresMigration;\n      readonly warnings?: readonly SqlPlannerConflict[];\n    }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` diffs the target contract against the live schema via the one\n * differ (`buildPostgresPlanDiff`, producing node-typed `SchemaDiffIssue[]`)\n * and delegates to `planIssues` with the unified `postgresPlannerStrategies`\n * list: NOT-NULL backfill, type-change, nullable-tightening, codec-hook\n * storage types, component-declared dependency installs, and\n * shared-temp-default / empty-table-guarded NOT-NULL add-column. The same\n * strategy list runs for `migration plan`, `db update`, and `db init`;\n * behavior diverges purely on `policy.allowedOperationClasses` (the\n * data-safe strategies short-circuit when `'data'` is excluded). The issue\n * planner applies operation-class policy gates and emits a single\n * `PostgresOpFactoryCall[]` that drives both the runtime-ops view (via\n * `renderOps`) and the `renderTypeScript()` authoring surface. RLS policy\n * drift (the structural half of the same one-differ tree) is handled\n * separately via `planPostgresSchemaDiff`.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n\n  constructor(lowerer?: ExecuteRequestLowerer) {\n    this.#lowerer = lowerer;\n  }\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n    /**\n     * Ownership oracle over the contract-space composition — see\n     * {@link SqlMigrationPlannerPlanOptions.ownership}.\n     */\n    readonly ownership?: SchemaOwnership;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(\n    context: MigrationScaffoldContext,\n    spaceId: string,\n  ): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration(\n      [],\n      {\n        from: context.fromHash,\n        to: context.toHash,\n      },\n      spaceId,\n      this.#lowerer,\n    );\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName =\n      options.schemaName ??\n      Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ??\n      UNBOUND_NAMESPACE_ID;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    // The one combined tree diff drives the whole plan: relational findings\n    // become structural DDL via `planIssues`, policy findings become RLS ops\n    // via `planPostgresSchemaDiff`. Verify runs its own full-tree node diff\n    // (`diffSchema`) over the same schema and rejects on a\n    // surviving failure.\n    PostgresDatabaseSchemaNode.assert(options.schema);\n    const { issues: rawIssues } = buildPostgresPlanDiff({\n      contract: options.contract,\n      actualSchema: options.schema,\n      frameworkComponents: options.frameworkComponents,\n    });\n    const policyDiffIssues = rawIssues.filter((issue) => isPolicyDiffIssue(issue));\n    const relationalDiffIssues = rawIssues.filter((issue) => !isPolicyDiffIssue(issue));\n\n    // The generic differ is total and un-gated: strict-mode extras filtering\n    // (dropping `not-expected` findings outside strict mode, mirroring the\n    // retired coordinate walk's `if (strict) { ...extra_* } }` guards),\n    // subtree coalescing (a missing/extra table also emits an issue for\n    // every child under it — redundant once the table-level Create/Drop call\n    // already accounts for the whole subtree), and ownership are all post-diff\n    // planner steps.\n    //\n    // Ownership: a live extra is only this plan's to drop when no contract\n    // space owns it. The differ ran against THIS space's contract, so a table\n    // a sibling space owns surfaces here as `not-expected`; the planner asks\n    // the ownership oracle (the passive aggregate) whether any space declares\n    // it and, if so, leaves it alone — it is a sibling's table, not an orphan.\n    // A table no space owns stays a genuine extra to drop under a destructive\n    // policy. Ownership lives in the aggregate; the planner only asks. Absent\n    // oracle (single-space, none handed) keeps every extra. Coalescing MUST\n    // run before this so a sibling-owned table's child issues have already\n    // collapsed into the one table-level issue that carries the table name.\n    const strict =\n      options.policy.allowedOperationClasses.includes('widening') ||\n      options.policy.allowedOperationClasses.includes('destructive');\n    const coalesced = coalesceSubtreeIssues(relationalDiffIssues);\n    const owned = retainUnownedExtras(coalesced, options.ownership, options.contract);\n    const gated = strict ? owned : owned.filter((issue) => issue.reason !== 'not-expected');\n\n    // Namespace presence (`CREATE SCHEMA`) is a planner-only op-generation\n    // concern stitched in here rather than inside the shared diff — verify\n    // never needs it (a missing schema already surfaces as a `not-found`\n    // table in the relational findings). These synthesized issues are added\n    // AFTER coalescing/scoping (never coalesced against the table diff —\n    // their path is an ancestor of every table path under that schema, so\n    // running them through the same coalesce would swallow the table-level\n    // `not-found` issues that drive `CREATE TABLE`) and are NOT subject to\n    // sibling-space scoping, matching the retired coordinate walk exactly.\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    const schemaIssues = [...namespaceIssues, ...gated];\n\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n    // The strategy layer reads the live schema by bare table name for existence\n    // checks (shared-temp-default safety, FK/unique probes), so it takes one\n    // per-schema namespace node — never the whole tree root, and never a flat\n    // merge of every namespace (which would collide same-named tables across\n    // schemas). Probing more than one namespace at once is future work.\n    const relationalSchema = relationalNamespaceNode(options.schema, schemaName);\n\n    // Input-side control-policy partition. `external` / `observed` subjects\n    // — and non-creation issues for `tolerated` subjects — are dropped from\n    // the planner's input entirely; the planner never observes them, never\n    // diffs them, never generates DDL for them. Suppression warnings are\n    // built directly from the suppressed partition (one per subject), so the\n    // user-visible message survives even when the planner would have failed\n    // to model the subject's live shape.\n    const issuePartition = partitionIssuesByControlPolicy({\n      issues: schemaIssues,\n      contract: options.contract,\n      resolveControlPolicySubject: (issue) =>\n        resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),\n      resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    const result = planIssues({\n      issues: issuePartition.plannable,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapNodeIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      ...ifDefined('schema', relationalSchema),\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    const schemaDiffCalls = this.planPostgresSchemaDiff(options, policyDiffIssues);\n    const schemaDiffPartition = partitionCallsByControlPolicy({\n      calls: schemaDiffCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed\n    // ordering is `structural → added → dropped → altered`, with\n    // within-group sorting by `(tableName, fieldName)` so re-emits are\n    // byte-stable. The hook fires only at the application emitter —\n    // extension-space planning never reaches this helper.\n    const fieldEventOps = planFieldEventOperations({\n      priorContract: options.fromContract,\n      newContract: options.contract,\n      codecHooks,\n    });\n    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning\n    // lifts them at this integration boundary (see field-event-planner JSDoc).\n    const fieldEventPostgresCalls = blindCast<\n      readonly PostgresOpFactoryCall[],\n      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'\n    >(fieldEventOps);\n    const fieldEventPartition = partitionCallsByControlPolicy({\n      calls: fieldEventPostgresCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];\n    const warnings: SqlPlannerConflict[] = [\n      ...issuePartition.warnings,\n      ...schemaDiffPartition.warnings,\n      ...fieldEventPartition.warnings,\n    ];\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(\n        calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        options.spaceId,\n        this.#lowerer,\n      ),\n      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),\n    });\n  }\n\n  /**\n   * Maps the RLS policy presence findings of the one combined tree diff\n   * (`buildPostgresPlanDiff`, already ownership-filtered) into\n   * `CREATE POLICY` / `DROP POLICY` / `ALTER POLICY … RENAME TO` ops. It\n   * does not re-diff — it consumes exactly the policy-node subset of the\n   * shared diff's issues. Enablement is NOT decided here: `ENABLE`/`DISABLE\n   * ROW LEVEL SECURITY` derive from the table's marker-driven `rlsEnabled`\n   * attribute diff on the relational side.\n   *\n   * Rename post-pass: a `not-found` and a `not-expected` policy on the SAME\n   * table whose wire-name content hashes match but prefixes differ are one\n   * prefix-only rename, collapsed into a single non-destructive\n   * `RenamePostgresRlsPolicyCall`. Multi-candidate hash groups pair\n   * deterministically by sorted wire name; leftovers proceed as\n   * create/drop. Unparseable wire names never pair.\n   *\n   * The pairing runs only when the policy allows `widening` (rename's\n   * class). Without it (db-init's additive-only set), pairing degrades\n   * deliberately to the additive half: the new name is CREATEd and the old\n   * policy survives live until a widening/destructive-allowed plan runs —\n   * emitting an ungated widening rename would only fail at the runner's\n   * class re-enforcement.\n   */\n  private planPostgresSchemaDiff(\n    options: PlannerOptionsWithComponents,\n    filteredDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ): readonly PostgresOpFactoryCall[] {\n    const allowsDestructive = options.policy.allowedOperationClasses.includes('destructive');\n    const allowsWidening = options.policy.allowedOperationClasses.includes('widening');\n\n    interface PolicyFinding {\n      readonly node: PostgresPolicySchemaNode;\n      readonly schemaForTable: string;\n    }\n    const missing: PolicyFinding[] = [];\n    const extra: PolicyFinding[] = [];\n\n    for (const issue of filteredDiffIssues) {\n      // 'not-equal' is unreachable for content-addressed policies: the wire name\n      // encodes the body hash, so two policies sharing a local key (same name)\n      // are always equal and isEqualTo never returns false.\n      if (issue.reason === 'not-found') {\n        const expected = issue.expected;\n        PostgresPolicySchemaNode.assert(expected);\n        // expected.namespaceId is the DDL schema name (resolved during projection);\n        // this re-resolution is a no-op as long as PostgresSchema.ddlSchemaName() returns this.id.\n        missing.push({\n          node: expected,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            expected.namespaceId,\n          ),\n        });\n      } else if (issue.reason === 'not-expected') {\n        const actual = issue.actual;\n        PostgresPolicySchemaNode.assert(actual);\n        extra.push({\n          node: actual,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            actual.namespaceId,\n          ),\n        });\n      }\n    }\n\n    const calls: PostgresOpFactoryCall[] = [];\n    const renamedExtras = new Set<PolicyFinding>();\n    const renamedMissing = new Set<PolicyFinding>();\n    const pairingKey = (finding: PolicyFinding, hash: string): string =>\n      JSON.stringify([finding.schemaForTable, finding.node.tableName, hash]);\n\n    if (allowsWidening) {\n      const extrasByGroup = new Map<string, PolicyFinding[]>();\n      for (const finding of extra) {\n        const parsed = parseRlsPolicyWireName(finding.node.name);\n        if (parsed === undefined) continue;\n        const key = pairingKey(finding, parsed.hash);\n        const group = extrasByGroup.get(key) ?? [];\n        group.push(finding);\n        extrasByGroup.set(key, group);\n      }\n      for (const group of extrasByGroup.values()) {\n        group.sort((a, b) => (a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0));\n      }\n\n      const sortedMissing = [...missing].sort((a, b) =>\n        a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0,\n      );\n      for (const missingFinding of sortedMissing) {\n        const parsed = parseRlsPolicyWireName(missingFinding.node.name);\n        if (parsed === undefined) continue;\n        const candidates = extrasByGroup.get(pairingKey(missingFinding, parsed.hash));\n        const candidate = candidates?.shift();\n        if (candidate === undefined) continue;\n        // Same name would never surface as missing+extra (the differ pairs by\n        // name), so a matched candidate always differs in prefix only.\n        renamedExtras.add(candidate);\n        renamedMissing.add(missingFinding);\n        calls.push(\n          new RenamePostgresRlsPolicyCall(\n            missingFinding.schemaForTable,\n            missingFinding.node.tableName,\n            candidate.node.name,\n            missingFinding.node.name,\n          ),\n        );\n      }\n    }\n\n    for (const finding of missing) {\n      if (renamedMissing.has(finding)) continue;\n      calls.push(\n        new CreatePostgresRlsPolicyCall(\n          finding.schemaForTable,\n          finding.node.tableName,\n          policyNodeToContractPolicy(finding.node),\n        ),\n      );\n    }\n    if (allowsDestructive) {\n      for (const finding of extra) {\n        if (renamedExtras.has(finding)) continue;\n        calls.push(\n          new DropPostgresRlsPolicyCall(\n            finding.schemaForTable,\n            finding.node.tableName,\n            finding.node.name,\n          ),\n        );\n      }\n    }\n\n    return calls;\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n}\n\n/**\n * A diff issue whose node is an RLS policy — the structural half of the one\n * combined tree diff, routed to `planPostgresSchemaDiff` instead of\n * `planIssues`.\n */\nfunction isPolicyDiffIssue(issue: SchemaDiffIssue<SqlSchemaDiffNode>): boolean {\n  const node = issue.expected ?? issue.actual;\n  return node !== undefined && PostgresPolicySchemaNode.is(node);\n}\n\n/**\n * Drops a `not-expected` issue when it is a whole extra TABLE that some\n * contract space owns, asking the ownership oracle per node.\n *\n * The consultation applies ONLY to table-level extras — a live table this\n * space's contract lacks — identified by asking the issue's own node\n * (`nodeKind === table`), never by counting path segments. `declaresEntity`\n * answers over the whole composition (self included), keyed on the schema-IR\n * entity coordinate so a genuine orphan in one namespace is never conflated\n * with a same-named table a sibling space declares in another, or with a\n * same-named non-table entity (an enum, an RLS policy) a sibling declares in\n * the SAME namespace: a positive answer means another space owns THIS table\n * in THIS namespace (a table this space owned would be in its expected tree,\n * never an extra) — leave it. A negative answer means no space owns it — a\n * genuine orphan to drop. `entityKind` is the literal `'table'` here: this\n * function only ever asks about a node already confirmed to be\n * `PostgresSchemaNodeKind.table` (checked just above), and the diff tree's\n * `nodeKind` vocabulary (`'postgres-table'`) is distinct from the storage\n * `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal\n * is that storage-entries spelling, not the node kind.\n *\n * The issue path carries the *resolved DDL schema* (e.g. `public`), but a\n * contract space's own declared namespace id can be the unbound sentinel\n * (`__unbound__`) that resolves to that schema — the two spellings would\n * never string-match. `resolveNamespaceIdForDdlSchema` recovers the raw\n * namespace id THIS space's own contract would use for that DDL schema, so\n * a table this space's own unbound namespace declares (and any sibling\n * whose own unbound namespace resolves the same way) is compared on the\n * same coordinate the aggregate's `elementCoordinates` walk yields.\n *\n * A DEEPER extra (an extra column/constraint on a table this space DOES own —\n * only the child drifted, so the table is in the expected tree) is this\n * space's own drift and is always kept for dropping; asking the oracle there\n * would wrongly suppress it, because the owned table answers `true`. Shallower\n * issues (namespace/root) are never ownership-scoped here. No oracle ⇒ every\n * extra is kept (single-space plan).\n */\nfunction retainUnownedExtras(\n  issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ownership: SchemaOwnership | undefined,\n  contract: Contract<SqlStorage>,\n): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  if (ownership === undefined) return issues;\n  return issues.filter((issue) => {\n    if (issue.reason !== 'not-expected') return true;\n    const node = issueNode(issue);\n    if (node === undefined || node.nodeKind !== PostgresSchemaNodeKind.table) return true;\n    const ddlSchemaName = issueSchemaName(issue);\n    const tableName = issueTableName(issue);\n    if (ddlSchemaName === undefined || tableName === undefined) return true;\n    const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);\n    return !ownership.declaresEntity({ namespaceId, entityKind: 'table', entityName: tableName });\n  });\n}\n\n/**\n * Returns the one namespace node the relational strategy layer probes for\n * live-table existence and reads codec-hook context off — the namespace\n * matching the planner's resolved schema name, or the first namespace when\n * none matches. `undefined` when the tree has no namespaces, so the strategy\n * context uses its empty-schema default.\n *\n * The relational strategies key tables by bare name, so they can only probe one\n * namespace at a time; probing across every namespace at once is future work.\n *\n * Returns the real `PostgresNamespaceSchemaNode` reference rather than a\n * projection: `storageTypePlanCallStrategy` hands this same value to codec\n * `planTypeOperations` hooks as `schema`, and hooks read the Postgres-specific\n * `nativeEnumTypeNames` field off it (via `PostgresNamespaceSchemaNode.is`) to\n * decide whether a native enum type already exists — a projection that only\n * copies `tables` would silently drop that signal. `StrategyContext.schema`'s\n * declared type (`SqlSchemaIR`, shared with SQLite's flat shape) doesn't\n * capture this, so the return is `blindCast` the same way `namespaceSchemaNodes`\n * in the family's relational walk already treats a namespace node as a\n * structurally-`SqlSchemaIR`-shaped value.\n */\nfunction relationalNamespaceNode(\n  schema: PostgresDatabaseSchemaNode,\n  schemaName: string,\n): SqlSchemaIR | undefined {\n  const namespaceNodes = Object.values(schema.namespaces);\n  const namespaceNode =\n    namespaceNodes.find((node) => node.schemaName === schemaName) ?? namespaceNodes[0];\n  if (namespaceNode === undefined) return undefined;\n  return blindCast<\n    SqlSchemaIR,\n    'PostgresNamespaceSchemaNode carries tables (+ nativeEnumTypeNames, read by codec hooks via PostgresNamespaceSchemaNode.is) structurally compatible with the SqlSchemaIR shape the strategy layer declares'\n  >(namespaceNode);\n}\n\n/**\n * Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`\n * carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole\n * entity, `namespaceId` included). This reconstructs rather than looking the\n * original up in the contract on purpose: the diff node's `namespaceId` is the\n * *resolved DDL schema* (set when the expected tree was built), which is the\n * value the emitted op must carry; the contract-stored entity holds the raw,\n * pre-resolution coordinate, so a lookup would change the migration output.\n */\nfunction policyNodeToContractPolicy(node: PostgresPolicySchemaNode): PostgresRlsPolicy {\n  return new PostgresRlsPolicy({\n    name: node.name,\n    prefix: node.prefix,\n    tableName: node.tableName,\n    namespaceId: node.namespaceId,\n    operation: node.operation,\n    roles: [...node.roles],\n    ...ifDefined('using', node.using),\n    ...ifDefined('withCheck', node.withCheck),\n    permissive: node.permissive,\n  });\n}\n"],"mappings":"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"}

package/dist/{planner-produced-postgres-migration-BLJH1zIc.mjs → planner-produced-postgres-migration-NI-oGKcw.mjs}

@@ -1,4 +1,4 @@
-import { t as PostgresMigration } from "./postgres-migration-BahMHTbj.mjs";
+import { t as PostgresMigration } from "./postgres-migration-ChyRsWvE.mjs";
 import { t as renderOps } from "./render-ops-BREh1kHe.mjs";
 import { t as renderCallsToTypeScript } from "./render-typescript-7yqILcwr.mjs";
 //#region src/core/migrations/planner-produced-postgres-migration.ts
@@ -40,4 +40,4 @@ var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
 
-//# sourceMappingURL=planner-produced-postgres-migration-BLJH1zIc.mjs.map
+//# sourceMappingURL=planner-produced-postgres-migration-NI-oGKcw.mjs.map

package/dist/{planner-produced-postgres-migration-BLJH1zIc.mjs.map → planner-produced-postgres-migration-NI-oGKcw.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-BLJH1zIc.mjs","names":["#calls","#meta","#spaceId","#lowerer","#operationsCache"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  MigrationPlanWithAuthoringSurface,\n  OpFactoryCall,\n} from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly OpFactoryCall[];\n  readonly #meta: MigrationMeta;\n  readonly #spaceId: string;\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n  #operationsCache:\n    | readonly (\n        | SqlMigrationPlanOperation<PostgresPlanTargetDetails>\n        | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>\n      )[]\n    | undefined;\n\n  constructor(\n    calls: readonly OpFactoryCall[],\n    meta: MigrationMeta,\n    spaceId: string,\n    lowerer?: ExecuteRequestLowerer,\n  ) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n    this.#spaceId = spaceId;\n    this.#lowerer = lowerer;\n  }\n\n  override get operations(): readonly (\n    | SqlMigrationPlanOperation<PostgresPlanTargetDetails>\n    | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>\n  )[] {\n    this.#operationsCache ??= renderOps(this.#calls, this.#lowerer);\n    return this.#operationsCache;\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  /**\n   * Contract space this planner-produced plan applies to. Threaded\n   * from the planner options so the runner keys the marker row by\n   * the right space when executing the plan.\n   */\n  get spaceId(): string {\n    return this.#spaceId;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, { from: this.#meta.from, to: this.#meta.to });\n  }\n}\n"],"mappings":";;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE;CACA;CACA;CACA;CACA;CAOA,YACE,OACA,MACA,SACA,SACA;EACA,MAAM;EACN,KAAKA,SAAS;EACd,KAAKC,QAAQ;EACb,KAAKC,WAAW;EAChB,KAAKC,WAAW;CAClB;CAEA,IAAa,aAGT;EACF,KAAKC,qBAAqB,UAAU,KAAKJ,QAAQ,KAAKG,QAAQ;EAC9D,OAAO,KAAKC;CACd;CAEA,WAAmC;EACjC,OAAO,KAAKH;CACd;;;;;;CAOA,IAAI,UAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,mBAA2B;EACzB,OAAO,wBAAwB,KAAKF,QAAQ;GAAE,MAAM,KAAKC,MAAM;GAAM,IAAI,KAAKA,MAAM;EAAG,CAAC;CAC1F;AACF"}
+{"version":3,"file":"planner-produced-postgres-migration-NI-oGKcw.mjs","names":["#calls","#meta","#spaceId","#lowerer","#operationsCache"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  MigrationPlanWithAuthoringSurface,\n  OpFactoryCall,\n} from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly OpFactoryCall[];\n  readonly #meta: MigrationMeta;\n  readonly #spaceId: string;\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n  #operationsCache:\n    | readonly (\n        | SqlMigrationPlanOperation<PostgresPlanTargetDetails>\n        | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>\n      )[]\n    | undefined;\n\n  constructor(\n    calls: readonly OpFactoryCall[],\n    meta: MigrationMeta,\n    spaceId: string,\n    lowerer?: ExecuteRequestLowerer,\n  ) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n    this.#spaceId = spaceId;\n    this.#lowerer = lowerer;\n  }\n\n  override get operations(): readonly (\n    | SqlMigrationPlanOperation<PostgresPlanTargetDetails>\n    | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>\n  )[] {\n    this.#operationsCache ??= renderOps(this.#calls, this.#lowerer);\n    return this.#operationsCache;\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  /**\n   * Contract space this planner-produced plan applies to. Threaded\n   * from the planner options so the runner keys the marker row by\n   * the right space when executing the plan.\n   */\n  get spaceId(): string {\n    return this.#spaceId;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, { from: this.#meta.from, to: this.#meta.to });\n  }\n}\n"],"mappings":";;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE;CACA;CACA;CACA;CACA;CAOA,YACE,OACA,MACA,SACA,SACA;EACA,MAAM;EACN,KAAKA,SAAS;EACd,KAAKC,QAAQ;EACb,KAAKC,WAAW;EAChB,KAAKC,WAAW;CAClB;CAEA,IAAa,aAGT;EACF,KAAKC,qBAAqB,UAAU,KAAKJ,QAAQ,KAAKG,QAAQ;EAC9D,OAAO,KAAKC;CACd;CAEA,WAAmC;EACjC,OAAO,KAAKH;CACd;;;;;;CAOA,IAAI,UAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,mBAA2B;EACzB,OAAO,wBAAwB,KAAKF,QAAQ;GAAE,MAAM,KAAKC,MAAM;GAAM,IAAI,KAAKA,MAAM;EAAG,CAAC;CAC1F;AACF"}

package/dist/{planner-produced-postgres-migration-CGifB6VH.d.mts → planner-produced-postgres-migration-a-tjfKsA.d.mts}

@@ -1,5 +1,5 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
-import { t as PostgresMigration } from "./postgres-migration-cyBe2Ee0.mjs";
+import { t as PostgresMigration } from "./postgres-migration-Bzzi0Asr.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface, OpFactoryCall } from "@prisma-next/framework-components/control";
 import { MigrationMeta } from "@prisma-next/migration-tools/migration";
@@ -21,4 +21,4 @@ declare class TypeScriptRenderablePostgresMigration extends PostgresMigration im
 }
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
-//# sourceMappingURL=planner-produced-postgres-migration-CGifB6VH.d.mts.map
+//# sourceMappingURL=planner-produced-postgres-migration-a-tjfKsA.d.mts.map

package/dist/{planner-produced-postgres-migration-CGifB6VH.d.mts.map → planner-produced-postgres-migration-a-tjfKsA.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-CGifB6VH.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;;cAqCa,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAcT,KAAA,WAAgB,aAAA,IAChB,IAAA,EAAM,aAAA,EACN,OAAA,UACA,OAAA,GAAU,qBAAA;EAAA,IASC,UAAA,cACT,yBAAA,CAA0B,yBAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,yBAAA;EAM7B,QAAA,IAAY,aAAA;EARR;;;;;EAAA,IAiBT,OAAA;EAIJ,gBAAA;AAAA"}
+{"version":3,"file":"planner-produced-postgres-migration-a-tjfKsA.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;;cAqCa,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAcT,KAAA,WAAgB,aAAA,IAChB,IAAA,EAAM,aAAA,EACN,OAAA,UACA,OAAA,GAAU,qBAAA;EAAA,IASC,UAAA,cACT,yBAAA,CAA0B,yBAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,yBAAA;EAM7B,QAAA,IAAY,aAAA;EARR;;;;;EAAA,IAiBT,OAAA;EAIJ,gBAAA;AAAA"}

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

@@ -1,2 +1,2 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CGifB6VH.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-a-tjfKsA.mjs";
 export { TypeScriptRenderablePostgresMigration };

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

@@ -1,2 +1,2 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-BLJH1zIc.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-NI-oGKcw.mjs";
 export { TypeScriptRenderablePostgresMigration };

package/dist/planner.d.mts

@@ -1,6 +1,6 @@
 import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-CfdTY-Qs.mjs";
 import { t as PostgresContract } from "./postgres-schema-CU4gF6QZ.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CGifB6VH.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-a-tjfKsA.mjs";
 import { ContractToSchemaIROptions, MigrationOperationPolicy, SqlPlannerConflict, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext, SchemaOwnership } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";

package/dist/planner.mjs

@@ -1,3 +1,3 @@
 import { r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-BOsDnH64.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-Bd-5WLzr.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-CNrc1Odu.mjs";
 export { contractToPostgresDatabaseSchemaNode, createPostgresMigrationPlanner };

package/dist/{postgres-migration-cyBe2Ee0.d.mts → postgres-migration-Bzzi0Asr.d.mts}

@@ -50,11 +50,17 @@ declare abstract class PostgresMigration<Start extends Contract<SqlStorage> = Co
   /**
    * Materialized Postgres control adapter, created once per migration
    * instance from the injected stack. `undefined` only when the migration
-   * was instantiated without a stack (test fixtures); `dataTransform`
-   * throws in that case to surface the misuse.
+   * was instantiated without a stack (test fixtures); `controlAdapterFor`
+   * throws a PN-MIG-2007 in that case to surface the misuse.
    */
   protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;
   constructor(stack?: ControlStack<'sql', 'postgres'>);
+  /**
+   * Returns the materialized control adapter, or throws a PN-MIG-2007 naming
+   * `operation` when the migration was constructed without a `ControlStack`.
+   * Single home for the null-check that every DDL/DML method shares.
+   */
+  private controlAdapterFor;
   /**
    * The typed, schema-qualified Postgres view over this migration's end-state
    * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws
@@ -191,4 +197,4 @@ declare abstract class PostgresMigration<Start extends Contract<SqlStorage> = Co
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-cyBe2Ee0.d.mts.map
+//# sourceMappingURL=postgres-migration-Bzzi0Asr.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-Bzzi0Asr.d.mts","names":[],"sources":["../src/core/migrations/operations/indexes.ts","../src/core/migrations/postgres-migration.ts"],"mappings":"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"}

package/dist/{postgres-migration-BahMHTbj.mjs → postgres-migration-ChyRsWvE.mjs}

@@ -1,5 +1,5 @@
 import { C as DropTableCall, D as SetDefaultCall, M as installExtension, O as SetNotNullCall, _ as DropColumnCall, b as DropIndexCall, c as AlterColumnTypeCall, f as CreateSchemaCall, g as DropCheckConstraintCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateTableCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropConstraintCall, x as DropNotNullCall, y as DropDefaultCall } from "./op-factory-call-DxNNKUeZ.mjs";
-import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-DO-w0EUS.mjs";
 import { t as PostgresContractView } from "./postgres-contract-view-Dg-N7KA7.mjs";
 import { t as dataTransform } from "./data-transform-BOWpliq8.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
@@ -37,8 +37,8 @@ var PostgresMigration = class extends Migration {
 	/**
 	* Materialized Postgres control adapter, created once per migration
 	* instance from the injected stack. `undefined` only when the migration
-	* was instantiated without a stack (test fixtures); `dataTransform`
-	* throws in that case to surface the misuse.
+	* was instantiated without a stack (test fixtures); `controlAdapterFor`
+	* throws a PN-MIG-2007 in that case to surface the misuse.
 	*/
 	controlAdapter;
 	#endView = new MigrationContractViews(this, "PostgresMigration", (json) => PostgresContractView.fromJson(json));
@@ -48,6 +48,15 @@ var PostgresMigration = class extends Migration {
 		this.controlAdapter = stack?.adapter ? stack.adapter.create(stack) : void 0;
 	}
 	/**
+	* Returns the materialized control adapter, or throws a PN-MIG-2007 naming
+	* `operation` when the migration was constructed without a `ControlStack`.
+	* Single home for the null-check that every DDL/DML method shares.
+	*/
+	controlAdapterFor(operation) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	/**
 	* The typed, schema-qualified Postgres view over this migration's end-state
 	* contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws
 	* if no `endContractJson` was provided.
@@ -68,8 +77,7 @@ var PostgresMigration = class extends Migration {
 	* `get operations()`; the adapter argument is hidden from the call site.
 	*/
 	dataTransform(contract, name, options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return dataTransform(contract, name, options, this.controlAdapter);
+		return dataTransform(contract, name, options, this.controlAdapterFor("dataTransform"));
 	}
 	/**
 	* Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
@@ -77,8 +85,7 @@ var PostgresMigration = class extends Migration {
 	* Throws if no adapter is present (i.e. migration instantiated without a stack).
 	*/
 	createTable(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new CreateTableCall(options.schema, options.table, options.columns, options.constraints).toOp(this.controlAdapter);
+		return new CreateTableCall(options.schema, options.table, options.columns, options.constraints).toOp(this.controlAdapterFor("createTable"));
 	}
 	/**
 	* Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
@@ -86,79 +93,61 @@ var PostgresMigration = class extends Migration {
 	* Throws if no adapter is present (i.e. migration instantiated without a stack).
 	*/
 	createSchema(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
+		return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor("createSchema"));
 	}
 	addColumn(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AddColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+		return new AddColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("addColumn"));
 	}
 	addPrimaryKey(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AddPrimaryKeyCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapter);
+		return new AddPrimaryKeyCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapterFor("addPrimaryKey"));
 	}
 	addUnique(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AddUniqueCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapter);
+		return new AddUniqueCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapterFor("addUnique"));
 	}
 	addForeignKey(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(this.controlAdapter);
+		return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(this.controlAdapterFor("addForeignKey"));
 	}
 	addCheckConstraint(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.column, options.values).toOp(this.controlAdapter);
+		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.column, options.values).toOp(this.controlAdapterFor("addCheckConstraint"));
 	}
 	dropCheckConstraint(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(this.controlAdapter);
+		return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(this.controlAdapterFor("dropCheckConstraint"));
 	}
 	dropConstraint(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropConstraintCall(options.schema, options.table, options.constraint, options.kind ?? "unique").toOp(this.controlAdapter);
+		return new DropConstraintCall(options.schema, options.table, options.constraint, options.kind ?? "unique").toOp(this.controlAdapterFor("dropConstraint"));
 	}
 	dropTable(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);
+		return new DropTableCall(options.schema, options.table).toOp(this.controlAdapterFor("dropTable"));
 	}
 	dropColumn(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+		return new DropColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropColumn"));
 	}
 	alterColumnType(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new AlterColumnTypeCall(options.schema, options.table, options.column, options.options).toOp(this.controlAdapter);
+		return new AlterColumnTypeCall(options.schema, options.table, options.column, options.options).toOp(this.controlAdapterFor("alterColumnType"));
 	}
 	setNotNull(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new SetNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+		return new SetNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("setNotNull"));
 	}
 	dropNotNull(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+		return new DropNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropNotNull"));
 	}
 	setDefault(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new SetDefaultCall(options.schema, options.table, options.column, options.defaultSql, options.operationClass).toOp(this.controlAdapter);
+		return new SetDefaultCall(options.schema, options.table, options.column, options.defaultSql, options.operationClass).toOp(this.controlAdapterFor("setDefault"));
 	}
 	dropDefault(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropDefaultCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+		return new DropDefaultCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropDefault"));
 	}
 	createIndex(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new CreateIndexCall(options.schema, options.table, options.index, options.columns, options.extras).toOp(this.controlAdapter);
+		return new CreateIndexCall(options.schema, options.table, options.index, options.columns, options.extras).toOp(this.controlAdapterFor("createIndex"));
 	}
 	dropIndex(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return new DropIndexCall(options.schema, options.table, options.index).toOp(this.controlAdapter);
+		return new DropIndexCall(options.schema, options.table, options.index).toOp(this.controlAdapterFor("dropIndex"));
 	}
 	installExtension(options) {
-		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
-		return installExtension(options, this.controlAdapter);
+		return installExtension(options, this.controlAdapterFor("installExtension"));
 	}
 };
 //#endregion
 export { PostgresMigration as t };
 
-//# sourceMappingURL=postgres-migration-BahMHTbj.mjs.map
+//# sourceMappingURL=postgres-migration-ChyRsWvE.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-ChyRsWvE.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { PostgresContractView } from '../postgres-contract-view';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  type AlterColumnTypeOptions,\n  CreateIndexCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNotNullCall,\n  DropTableCall,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport { installExtension } from './operations/dependencies';\nimport type { CreateIndexExtras } from './operations/indexes';\nimport type { ForeignKeySpec } from './operations/shared';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n *\n * Every method requires an explicit `schema`. Postgres migrations name their\n * schema deliberately — there is no default and no `search_path`-relative\n * option. A migration that left the schema unspecified would resolve against\n * whatever `search_path` the connection happened to carry, and that ambiguity\n * is an antipattern in a migration. (The unbound/unspecified namespace concept\n * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)\n */\nexport abstract class PostgresMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<PostgresPlanTargetDetails, 'postgres', Start, End> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a PN-MIG-2007 in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  #endView = new MigrationContractViews<PostgresContractView<End>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<PostgresContractView<Start>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a PN-MIG-2007 naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'postgres'> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed, schema-qualified Postgres view over this migration's end-state\n   * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws\n   * if no `endContractJson` was provided.\n   */\n  get endContract(): PostgresContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed Postgres view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): PostgresContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return dataTransform(contract, name, options, this.controlAdapterFor('dataTransform'));\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateTableCall(\n      options.schema,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapterFor('createTable'));\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor('createSchema'));\n  }\n\n  protected addColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected addPrimaryKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddPrimaryKeyCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addPrimaryKey'));\n  }\n\n  protected addUnique(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddUniqueCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addUnique'));\n  }\n\n  protected addForeignKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly foreignKey: ForeignKeySpec;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(\n      this.controlAdapterFor('addForeignKey'),\n    );\n  }\n\n  protected addCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly column: string;\n    readonly values: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddCheckConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.column,\n      options.values,\n    ).toOp(this.controlAdapterFor('addCheckConstraint'));\n  }\n\n  protected dropCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(\n      this.controlAdapterFor('dropCheckConstraint'),\n    );\n  }\n\n  protected dropConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.kind ?? 'unique',\n    ).toOp(this.controlAdapterFor('dropConstraint'));\n  }\n\n  protected dropTable(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropTableCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('dropTable'),\n    );\n  }\n\n  protected dropColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected alterColumnType(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly options: AlterColumnTypeOptions;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AlterColumnTypeCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.options,\n    ).toOp(this.controlAdapterFor('alterColumnType'));\n  }\n\n  protected setNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('setNotNull'),\n    );\n  }\n\n  protected dropNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropNotNull'),\n    );\n  }\n\n  protected setDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly defaultSql: string;\n    readonly operationClass?: 'additive' | 'widening';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetDefaultCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.defaultSql,\n      options.operationClass,\n    ).toOp(this.controlAdapterFor('setDefault'));\n  }\n\n  protected dropDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropDefaultCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropDefault'),\n    );\n  }\n\n  protected createIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n    readonly extras?: CreateIndexExtras;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateIndexCall(\n      options.schema,\n      options.table,\n      options.index,\n      options.columns,\n      options.extras,\n    ).toOp(this.controlAdapterFor('createIndex'));\n  }\n\n  protected dropIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropIndexCall(options.schema, options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected installExtension(options: {\n    readonly extensionName: string;\n    readonly invariantId: string;\n    readonly id: string;\n    readonly label?: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return installExtension(options, this.controlAdapterFor('installExtension'));\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,35 +1,35 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.14.0-dev.59",
+  "version": "0.14.0-dev.60",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.14.0-dev.59",
-    "@prisma-next/contract": "0.14.0-dev.59",
-    "@prisma-next/errors": "0.14.0-dev.59",
-    "@prisma-next/family-sql": "0.14.0-dev.59",
-    "@prisma-next/framework-components": "0.14.0-dev.59",
-    "@prisma-next/migration-tools": "0.14.0-dev.59",
-    "@prisma-next/psl-parser": "0.14.0-dev.59",
-    "@prisma-next/sql-contract": "0.14.0-dev.59",
-    "@prisma-next/sql-errors": "0.14.0-dev.59",
-    "@prisma-next/sql-operations": "0.14.0-dev.59",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.59",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.59",
-    "@prisma-next/ts-render": "0.14.0-dev.59",
-    "@prisma-next/utils": "0.14.0-dev.59",
+    "@prisma-next/cli": "0.14.0-dev.60",
+    "@prisma-next/contract": "0.14.0-dev.60",
+    "@prisma-next/errors": "0.14.0-dev.60",
+    "@prisma-next/family-sql": "0.14.0-dev.60",
+    "@prisma-next/framework-components": "0.14.0-dev.60",
+    "@prisma-next/migration-tools": "0.14.0-dev.60",
+    "@prisma-next/psl-parser": "0.14.0-dev.60",
+    "@prisma-next/sql-contract": "0.14.0-dev.60",
+    "@prisma-next/sql-errors": "0.14.0-dev.60",
+    "@prisma-next/sql-operations": "0.14.0-dev.60",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.60",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.60",
+    "@prisma-next/ts-render": "0.14.0-dev.60",
+    "@prisma-next/utils": "0.14.0-dev.60",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/psl-printer": "0.14.0-dev.59",
-    "@prisma-next/sql-contract-psl": "0.14.0-dev.59",
-    "@prisma-next/test-utils": "0.14.0-dev.59",
-    "@prisma-next/tsconfig": "0.14.0-dev.59",
-    "@prisma-next/tsdown": "0.14.0-dev.59",
+    "@prisma-next/psl-printer": "0.14.0-dev.60",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.60",
+    "@prisma-next/test-utils": "0.14.0-dev.60",
+    "@prisma-next/tsconfig": "0.14.0-dev.60",
+    "@prisma-next/tsdown": "0.14.0-dev.60",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/core/errors.ts

@@ -1,14 +1,16 @@
 import { CliStructuredError } from '@prisma-next/errors/control';
 
 /**
- * A `PostgresMigration` instance method that needs the materialized control
- * adapter (currently only `this.dataTransform(...)`) was invoked, but the
- * migration was constructed without a `ControlStack`. Concrete authoring
- * usage always goes through the migration CLI entrypoint, which assembles
- * a stack from the loaded `prisma-next.config.ts`; reaching this error
- * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
- * with the no-arg form (legal for `operations` / `describe` introspection
- * only).
+ * A `PostgresMigration` operation that needs the materialized control adapter
+ * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+ * was invoked, but the migration was constructed without a `ControlStack`.
+ * Concrete authoring usage always goes through the migration CLI entrypoint,
+ * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+ * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection only).
+ *
+ * The `operation` argument is required so every throw site names the operation
+ * that actually failed; a new operation cannot inherit a misattributed message.
  *
  * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
  * (data-transform query plan against wrong contract) because the missing
@@ -19,15 +21,15 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * the contract it talks about (`PostgresMigration`, the Postgres control
  * adapter, the Postgres-target stack) only exists in this package.
  */
-export function errorPostgresMigrationStackMissing(): CliStructuredError {
+export function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {
   return new CliStructuredError(
     '2007',
-    'PostgresMigration.dataTransform requires a control adapter',
+    `PostgresMigration.${operation} requires a control adapter`,
     {
       domain: 'MIG',
-      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',
+      why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
       fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',
-      meta: {},
+      meta: { operation },
     },
   );
 }

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

@@ -71,8 +71,8 @@ export abstract class PostgresMigration<
   /**
    * Materialized Postgres control adapter, created once per migration
    * instance from the injected stack. `undefined` only when the migration
-   * was instantiated without a stack (test fixtures); `dataTransform`
-   * throws in that case to surface the misuse.
+   * was instantiated without a stack (test fixtures); `controlAdapterFor`
+   * throws a PN-MIG-2007 in that case to surface the misuse.
    */
   protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;
 
@@ -97,6 +97,18 @@ export abstract class PostgresMigration<
       : undefined;
   }
 
+  /**
+   * Returns the materialized control adapter, or throws a PN-MIG-2007 naming
+   * `operation` when the migration was constructed without a `ControlStack`.
+   * Single home for the null-check that every DDL/DML method shares.
+   */
+  private controlAdapterFor(operation: string): SqlControlAdapter<'postgres'> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing(operation);
+    }
+    return this.controlAdapter;
+  }
+
   /**
    * The typed, schema-qualified Postgres view over this migration's end-state
    * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws
@@ -124,10 +136,7 @@ export abstract class PostgresMigration<
     name: string,
     options: DataTransformOptions,
   ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
-    return dataTransform(contract, name, options, this.controlAdapter);
+    return dataTransform(contract, name, options, this.controlAdapterFor('dataTransform'));
   }
 
   /**
@@ -142,15 +151,12 @@ export abstract class PostgresMigration<
     readonly columns: readonly DdlColumn[];
     readonly constraints?: readonly DdlTableConstraint[];
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new CreateTableCall(
       options.schema,
       options.table,
       options.columns,
       options.constraints,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('createTable'));
   }
 
   /**
@@ -162,10 +168,7 @@ export abstract class PostgresMigration<
     readonly schema: string;
     readonly ifNotExists?: boolean;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
-    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
+    return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor('createSchema'));
   }
 
   protected addColumn(options: {
@@ -173,11 +176,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly column: DdlColumn;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AddColumnCall(options.schema, options.table, options.column).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('addColumn'),
     );
   }
 
@@ -187,15 +187,12 @@ export abstract class PostgresMigration<
     readonly constraint: string;
     readonly columns: readonly string[];
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AddPrimaryKeyCall(
       options.schema,
       options.table,
       options.constraint,
       options.columns,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('addPrimaryKey'));
   }
 
   protected addUnique(options: {
@@ -204,15 +201,12 @@ export abstract class PostgresMigration<
     readonly constraint: string;
     readonly columns: readonly string[];
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AddUniqueCall(
       options.schema,
       options.table,
       options.constraint,
       options.columns,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('addUnique'));
   }
 
   protected addForeignKey(options: {
@@ -220,11 +214,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly foreignKey: ForeignKeySpec;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('addForeignKey'),
     );
   }
 
@@ -235,16 +226,13 @@ export abstract class PostgresMigration<
     readonly column: string;
     readonly values: readonly string[];
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AddCheckConstraintCall(
       options.schema,
       options.table,
       options.constraint,
       options.column,
       options.values,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('addCheckConstraint'));
   }
 
   protected dropCheckConstraint(options: {
@@ -252,11 +240,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly constraint: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('dropCheckConstraint'),
     );
   }
 
@@ -266,25 +251,21 @@ export abstract class PostgresMigration<
     readonly constraint: string;
     readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropConstraintCall(
       options.schema,
       options.table,
       options.constraint,
       options.kind ?? 'unique',
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('dropConstraint'));
   }
 
   protected dropTable(options: {
     readonly schema: string;
     readonly table: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
-    return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);
+    return new DropTableCall(options.schema, options.table).toOp(
+      this.controlAdapterFor('dropTable'),
+    );
   }
 
   protected dropColumn(options: {
@@ -292,11 +273,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly column: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropColumnCall(options.schema, options.table, options.column).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('dropColumn'),
     );
   }
 
@@ -306,15 +284,12 @@ export abstract class PostgresMigration<
     readonly column: string;
     readonly options: AlterColumnTypeOptions;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new AlterColumnTypeCall(
       options.schema,
       options.table,
       options.column,
       options.options,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('alterColumnType'));
   }
 
   protected setNotNull(options: {
@@ -322,11 +297,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly column: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new SetNotNullCall(options.schema, options.table, options.column).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('setNotNull'),
     );
   }
 
@@ -335,11 +307,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly column: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropNotNullCall(options.schema, options.table, options.column).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('dropNotNull'),
     );
   }
 
@@ -350,16 +319,13 @@ export abstract class PostgresMigration<
     readonly defaultSql: string;
     readonly operationClass?: 'additive' | 'widening';
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new SetDefaultCall(
       options.schema,
       options.table,
       options.column,
       options.defaultSql,
       options.operationClass,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('setDefault'));
   }
 
   protected dropDefault(options: {
@@ -367,11 +333,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly column: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropDefaultCall(options.schema, options.table, options.column).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('dropDefault'),
     );
   }
 
@@ -382,16 +345,13 @@ export abstract class PostgresMigration<
     readonly columns: readonly string[];
     readonly extras?: CreateIndexExtras;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new CreateIndexCall(
       options.schema,
       options.table,
       options.index,
       options.columns,
       options.extras,
-    ).toOp(this.controlAdapter);
+    ).toOp(this.controlAdapterFor('createIndex'));
   }
 
   protected dropIndex(options: {
@@ -399,11 +359,8 @@ export abstract class PostgresMigration<
     readonly table: string;
     readonly index: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
     return new DropIndexCall(options.schema, options.table, options.index).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('dropIndex'),
     );
   }
 
@@ -413,9 +370,6 @@ export abstract class PostgresMigration<
     readonly id: string;
     readonly label?: string;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
-    if (!this.controlAdapter) {
-      throw errorPostgresMigrationStackMissing();
-    }
-    return installExtension(options, this.controlAdapter);
+    return installExtension(options, this.controlAdapterFor('installExtension'));
   }
 }

package/dist/errors-CUk87ByX.mjs

@@ -1,33 +0,0 @@
-import { CliStructuredError } from "@prisma-next/errors/control";
-//#region src/core/errors.ts
-/**
-* A `PostgresMigration` instance method that needs the materialized control
-* adapter (currently only `this.dataTransform(...)`) was invoked, but the
-* migration was constructed without a `ControlStack`. Concrete authoring
-* usage always goes through the migration CLI entrypoint, which assembles
-* a stack from the loaded `prisma-next.config.ts`; reaching this error
-* means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
-* with the no-arg form (legal for `operations` / `describe` introspection
-* only).
-*
-* Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
-* (data-transform query plan against wrong contract) because the missing
-* input is the stack itself, not the per-operation contract.
-*
-* Lives in `@prisma-next/target-postgres/errors` rather than the shared
-* framework migration errors module because the failure is target-specific:
-* the contract it talks about (`PostgresMigration`, the Postgres control
-* adapter, the Postgres-target stack) only exists in this package.
-*/
-function errorPostgresMigrationStackMissing() {
-	return new CliStructuredError("2007", "PostgresMigration.dataTransform requires a control adapter", {
-		domain: "MIG",
-		why: "PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.",
-		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
-		meta: {}
-	});
-}
-//#endregion
-export { errorPostgresMigrationStackMissing as t };
-
-//# sourceMappingURL=errors-CUk87ByX.mjs.map

package/dist/errors-CUk87ByX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-CUk87ByX.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,CAAC;CACT,CACF;AACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-migration-BahMHTbj.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { PostgresContractView } from '../postgres-contract-view';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  type AlterColumnTypeOptions,\n  CreateIndexCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNotNullCall,\n  DropTableCall,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport { installExtension } from './operations/dependencies';\nimport type { CreateIndexExtras } from './operations/indexes';\nimport type { ForeignKeySpec } from './operations/shared';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n *\n * Every method requires an explicit `schema`. Postgres migrations name their\n * schema deliberately — there is no default and no `search_path`-relative\n * option. A migration that left the schema unspecified would resolve against\n * whatever `search_path` the connection happened to carry, and that ambiguity\n * is an antipattern in a migration. (The unbound/unspecified namespace concept\n * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)\n */\nexport abstract class PostgresMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<PostgresPlanTargetDetails, 'postgres', Start, End> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  #endView = new MigrationContractViews<PostgresContractView<End>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<PostgresContractView<Start>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * The typed, schema-qualified Postgres view over this migration's end-state\n   * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws\n   * if no `endContractJson` was provided.\n   */\n  get endContract(): PostgresContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed Postgres view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): PostgresContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateTableCall(\n      options.schema,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);\n  }\n\n  protected addColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected addPrimaryKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddPrimaryKeyCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected addUnique(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddUniqueCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected addForeignKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly foreignKey: ForeignKeySpec;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected addCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly column: string;\n    readonly values: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddCheckConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.column,\n      options.values,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected dropConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.kind ?? 'unique',\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropTable(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);\n  }\n\n  protected dropColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected alterColumnType(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly options: AlterColumnTypeOptions;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AlterColumnTypeCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.options,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected setNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new SetNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected dropNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected setDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly defaultSql: string;\n    readonly operationClass?: 'additive' | 'widening';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new SetDefaultCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.defaultSql,\n      options.operationClass,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropDefaultCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected createIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n    readonly extras?: CreateIndexExtras;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateIndexCall(\n      options.schema,\n      options.table,\n      options.index,\n      options.columns,\n      options.extras,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropIndexCall(options.schema, options.table, options.index).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected installExtension(options: {\n    readonly extensionName: string;\n    readonly invariantId: string;\n    readonly id: string;\n    readonly label?: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return installExtension(options, this.controlAdapter);\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-migration-cyBe2Ee0.d.mts","names":[],"sources":["../src/core/migrations/operations/indexes.ts","../src/core/migrations/postgres-migration.ts"],"mappings":"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"}