@prisma-next/target-postgres 0.12.0-dev.4 → 0.12.0-dev.41

package/dist/planner-BRGVWfq4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-BRGVWfq4.mjs","names":[],"sources":["../src/core/migrations/control-policy.ts","../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { ControlPolicySubject } from '@prisma-next/family-sql/control';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  isPostgresEnumStorageEntry,\n  type SqlStorage,\n  storageTableAt,\n} from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { isPostgresSchema } from '../postgres-schema';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\n\n/**\n * Factory calls that create a whole, previously-absent top-level storage\n * object. Used to decide whether `tolerated` permits a call (it only allows\n * creating absent objects, never modifying existing ones).\n *\n * Deliberately an explicit, closed set rather than a `factoryName`\n * create/alter/drop classification: it answers exactly one yes/no question\n * and is fail-closed. Any call not listed here — including future or\n * extension-contributed factories — is treated as NOT object-creation, so it\n * is suppressed under `tolerated` rather than permissively emitted.\n */\nconst OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([\n  'createTable',\n  'createEnumType',\n  'createSchema',\n]);\n\nfunction createsNewTopLevelObject(call: PostgresOpFactoryCall): boolean {\n  return OBJECT_CREATION_FACTORIES.has(call.factoryName);\n}\n\nfunction ddlSchemaNameForNamespace(contract: Contract<SqlStorage>, namespaceId: string): string {\n  const namespace = contract.storage.namespaces[namespaceId];\n  return isPostgresSchema(namespace) ? namespace.ddlSchemaName(contract.storage) : namespaceId;\n}\n\nfunction resolveNamespaceIdForTable(\n  contract: Contract<SqlStorage>,\n  tableName: string,\n  ddlSchemaName: string | undefined,\n): string {\n  for (const namespaceId of Object.keys(contract.storage.namespaces)) {\n    const table = storageTableAt(contract.storage, namespaceId, tableName);\n    if (!table) continue;\n    if (\n      ddlSchemaName === undefined ||\n      ddlSchemaNameForNamespace(contract, namespaceId) === ddlSchemaName\n    ) {\n      return namespaceId;\n    }\n  }\n  return UNBOUND_NAMESPACE_ID;\n}\n\nfunction resolveNamespaceIdForDdlSchema(\n  contract: Contract<SqlStorage>,\n  ddlSchemaName: string,\n): string {\n  for (const namespaceId of Object.keys(contract.storage.namespaces)) {\n    const ns = contract.storage.namespaces[namespaceId];\n    if (isPostgresSchema(ns) && ns.ddlSchemaName(contract.storage) === ddlSchemaName) {\n      return namespaceId;\n    }\n    if (namespaceId === ddlSchemaName) {\n      return namespaceId;\n    }\n  }\n  return UNBOUND_NAMESPACE_ID;\n}\n\ninterface PostgresCallFields {\n  readonly schemaName?: string;\n  readonly tableName?: string;\n  readonly columnName?: string;\n  readonly typeName?: string;\n}\n\nfunction postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {\n  return {\n    ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),\n    ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),\n    ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),\n    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),\n  };\n}\n\nexport function formatPostgresControlPolicySubjectLabel(\n  factoryName: string,\n  subject: ControlPolicySubject | undefined,\n  contract: Contract<SqlStorage>,\n): string {\n  if (subject?.table) {\n    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);\n    return `${factoryName}(${ddlSchema}.${subject.table})`;\n  }\n  if (subject?.typeName) {\n    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);\n    return `${factoryName}(${ddlSchema}.${subject.typeName})`;\n  }\n  return factoryName;\n}\n\nexport function resolvePostgresCallControlPolicySubject(\n  call: PostgresOpFactoryCall,\n  contract: Contract<SqlStorage>,\n): ControlPolicySubject | undefined {\n  const callFields = postgresCallFields(call);\n  const createsNewObject = createsNewTopLevelObject(call);\n\n  if (call.factoryName === 'createSchema' && callFields.schemaName) {\n    return {\n      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),\n      createsNewObject,\n    };\n  }\n\n  if (callFields.typeName && call.factoryName !== 'addColumn') {\n    const namespaceId = callFields.schemaName\n      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)\n      : UNBOUND_NAMESPACE_ID;\n    const ns = contract.storage.namespaces[namespaceId];\n    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[callFields.typeName] : undefined;\n    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', controlPolicy),\n      typeName: callFields.typeName,\n      createsNewObject,\n    };\n  }\n\n  if (callFields.tableName) {\n    const namespaceId = resolveNamespaceIdForTable(\n      contract,\n      callFields.tableName,\n      callFields.schemaName,\n    );\n    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);\n    const tableControlPolicy = table?.control;\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),\n      table: callFields.tableName,\n      ...ifDefined('column', callFields.columnName),\n      createsNewObject,\n    };\n  }\n\n  if (callFields.schemaName) {\n    return {\n      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),\n      createsNewObject,\n    };\n  }\n\n  return undefined;\n}\n\n/**\n * Issue kinds that describe the absence of a whole, top-level Postgres\n * object — the same kinds `createsNewTopLevelObject` recognises for calls.\n * Used by {@link resolvePostgresIssueCreationFactoryName} to decide whether\n * a `tolerated` subject permits the issue to flow into the planner\n * (create-if-absent) and to seed the suppressed-subject warning's\n * `factoryName` when the planner is skipped.\n */\nconst POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({\n  missing_schema: 'createSchema',\n  missing_table: 'createTable',\n  type_missing: 'createEnumType',\n});\n\nexport function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {\n  return POSTGRES_ISSUE_CREATION_FACTORY[issue.kind];\n}\n\n/**\n * Resolve the control-policy subject coordinate for a single\n * {@link SchemaIssue}. Mirrors the resolution `resolvePostgresCallControlPolicySubject`\n * performs for a generated DDL call, but works *off the issue* — so the\n * planner can partition issues by effective policy before the diff engine\n * runs. `createsNewObject` is derived from the issue's kind: schema/table/\n * type-missing issues describe a brand-new top-level object; everything else\n * touches an existing object.\n *\n * An `extra_table` issue carries no contract namespace coordinate (the table\n * isn't in any contract namespace), so the subject's `namespaceId` falls\n * back to {@link UNBOUND_NAMESPACE_ID}; the call-side resolver does the same\n * for the `DropTableCall` it produces.\n */\nexport function resolvePostgresIssueControlPolicySubject(\n  issue: SchemaIssue,\n  contract: Contract<SqlStorage>,\n): ControlPolicySubject | undefined {\n  const createsNewObject = POSTGRES_ISSUE_CREATION_FACTORY[issue.kind] !== undefined;\n\n  if (issue.kind === 'missing_schema' && issue.namespaceId) {\n    return { namespaceId: issue.namespaceId, createsNewObject };\n  }\n\n  if ('typeName' in issue && issue.typeName) {\n    const namespaceId =\n      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;\n    const ns = contract.storage.namespaces[namespaceId];\n    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[issue.typeName] : undefined;\n    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', controlPolicy),\n      typeName: issue.typeName,\n      createsNewObject,\n    };\n  }\n\n  if ('table' in issue && issue.table) {\n    const namespaceId =\n      'namespaceId' in issue && issue.namespaceId\n        ? issue.namespaceId\n        : resolveNamespaceIdForTable(contract, issue.table, undefined);\n    const table = storageTableAt(contract.storage, namespaceId, issue.table);\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', table?.control),\n      table: issue.table,\n      ...ifDefined('column', 'column' in issue ? issue.column : undefined),\n      createsNewObject,\n    };\n  }\n\n  return undefined;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaIssue } 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 { isPostgresSchema } from '../postgres-schema';\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 Postgres-flavoured\n * annotations slot on the schema IR. Defaults to the always-present\n * `public` schema when introspection did not populate the slot — a fresh\n * Postgres database always carries `public` (unless an operator dropped\n * it manually), so any verifier path that runs without an enriched\n * introspection still suppresses the redundant `CREATE SCHEMA \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and writes every\n * non-system schema into `annotations.pg.existingSchemas`. Tests that\n * want to assert against a richer initial state pass the slot\n * explicitly via the schema IR.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {\n  const annotations = (schema as { annotations?: { pg?: { existingSchemas?: unknown } } })\n    .annotations;\n  const slot = annotations?.pg?.existingSchemas;\n  if (Array.isArray(slot)) {\n    return slot.filter((s): s is string => typeof s === 'string');\n  }\n  return ['public'];\n}\n\n/**\n * Emits a `missing_schema` issue for every contract-declared Postgres\n * namespace whose live container does not yet exist.\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 stamps `namespaceId` with the contract namespace\n * coordinate so the downstream `mapIssueToCall` re-resolves the DDL\n * schema name through the same polymorphic path — keeping the\n * coordinate, not the resolved name, as the issue's stable identity.\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIR;\n}): readonly SchemaIssue[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaIssue[] = [];\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    issues.push({\n      kind: 'missing_schema',\n      namespaceId,\n      message: `Schema \"${ddlName}\" is missing from database`,\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 { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { postgresColumnsCompatible } from '../column-type-compatibility';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport {\n  formatPostgresControlPolicySubjectLabel,\n  resolvePostgresCallControlPolicySubject,\n  resolvePostgresIssueControlPolicySubject,\n  resolvePostgresIssueCreationFactoryName,\n} from './control-policy';\nimport { createResolveExistingEnumValues } from './enum-planning';\nimport { planIssues } from './issue-planner';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\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\ntype VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner();\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()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\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  }): 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    );\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    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\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        resolvePostgresIssueControlPolicySubject(issue, options.contract),\n      resolveCreationFactoryName: resolvePostgresIssueCreationFactoryName,\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      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\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    // 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, ...fieldEventPartition.kept];\n    const warnings: SqlPlannerConflict[] = [\n      ...issuePartition.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      ),\n      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),\n    });\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  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {\n    // `db init` uses additive-only policy and intentionally ignores extra\n    // schema objects. Any reconciliation-capable policy (widening or\n    // destructive) must inspect extras to reconcile strict equality.\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parsePostgresDefault,\n      normalizeNativeType: normalizeSchemaNativeType,\n      columnsCompatible: postgresColumnsCompatible,\n      resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),\n    };\n    const verifyResult = verifySqlSchema(verifyOptions);\n    // Schema presence is a Postgres-specific concern (no equivalent in\n    // SQLite / Mongo), so the issue emission lives in the target layer\n    // rather than in the family verifier. Stitch it in here so a single\n    // `SchemaIssue[]` flows through `planIssues` and the planner emits\n    // CREATE SCHEMA in the dep bucket before any CreateTableCall.\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    if (namespaceIssues.length === 0) {\n      return verifyResult.schema.issues;\n    }\n    return [...namespaceIssues, ...verifyResult.schema.issues];\n  }\n}\n"],"mappings":"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"}

package/dist/{planner-ddl-builders-BNMfSE9r.mjs → planner-ddl-builders-BfN5p8wr.mjs}

@@ -1,5 +1,5 @@
-import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-CggjWNij.mjs";
-import { c as qualifyTableName, f as resolveColumnTypeMetadata } from "./planner-sql-checks-CfEiTXoQ.mjs";
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DR_F9aHR.mjs";
+import { c as qualifyTableName, f as resolveColumnTypeMetadata } from "./planner-sql-checks-C43dcyOd.mjs";
 //#region src/core/migrations/planner-ddl-builders.ts
 function buildCreateTableSql(qualifiedTableName, table, codecHooks, storageTypes = {}) {
 	const columnDefinitions = Object.entries(table.columns).map(([columnName, column]) => {
@@ -128,4 +128,4 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.target.tableName)} (${forei
 //#endregion
 export { buildForeignKeySql as a, buildCreateTableSql as i, buildColumnDefaultSql as n, renderDefaultLiteral as o, buildColumnTypeSql as r, buildAddColumnSql as t };
 
-//# sourceMappingURL=planner-ddl-builders-BNMfSE9r.mjs.map
+//# sourceMappingURL=planner-ddl-builders-BfN5p8wr.mjs.map

package/dist/{planner-ddl-builders-BNMfSE9r.mjs.map → planner-ddl-builders-BfN5p8wr.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-ddl-builders-BNMfSE9r.mjs","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type {\n  ForeignKey,\n  PostgresEnumStorageEntry,\n  ReferentialAction,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { escapeLiteral, quoteIdentifier } from '../sql-utils';\nimport type { PostgresColumnDefault } from '../types';\nimport { qualifyTableName } from './planner-sql-checks';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\nexport function buildCreateTableSql(\n  qualifiedTableName: string,\n  table: StorageTable,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string {\n  const columnDefinitions = Object.entries(table.columns).map(\n    ([columnName, column]: [string, StorageColumn]) => {\n      const parts = [\n        quoteIdentifier(columnName),\n        buildColumnTypeSql(column, codecHooks, storageTypes),\n        buildColumnDefaultSql(column.default, column),\n        column.nullable ? '' : 'NOT NULL',\n      ].filter(Boolean);\n      return parts.join(' ');\n    },\n  );\n\n  const constraintDefinitions: string[] = [];\n  if (table.primaryKey) {\n    constraintDefinitions.push(\n      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,\n    );\n  }\n\n  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];\n  return `CREATE TABLE ${qualifiedTableName} (\\n  ${allDefinitions.join(',\\n  ')}\\n)`;\n}\n\n/**\n * Pattern for safe PostgreSQL type names.\n * Allows letters, digits, underscores, spaces (for \"double precision\", \"character varying\"),\n * and trailing [] for array types.\n */\nconst SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/;\n\nfunction assertSafeNativeType(nativeType: string): void {\n  if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {\n    throw new Error(\n      `Unsafe native type name in contract: \"${nativeType}\". ` +\n        'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\\\[\\\\])?$/',\n    );\n  }\n}\n\n/**\n * Sanity check against accidental SQL injection from malformed contract files.\n * Rejects semicolons, SQL comment tokens, and dollar-quoting.\n * Not a comprehensive security boundary — the contract is developer-authored.\n */\nfunction assertSafeDefaultExpression(expression: string): void {\n  if (expression.includes(';') || /--|\\/\\*|\\$\\$|\\bSELECT\\b/i.test(expression)) {\n    throw new Error(\n      `Unsafe default expression in contract: \"${expression}\". ` +\n        'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',\n    );\n  }\n}\n\n/**\n * Renders the SQL type for a column in DDL context.\n *\n * @param allowPseudoTypes - When true (default), autoincrement integer columns\n *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts\n *   like ALTER COLUMN TYPE where pseudo-types are invalid.\n */\nexport function buildColumnTypeSql(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n  allowPseudoTypes = true,\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (allowPseudoTypes) {\n    const columnDefault = column.default;\n    if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {\n      if (resolved.nativeType === 'int4' || resolved.nativeType === 'integer') {\n        return 'SERIAL';\n      }\n      if (resolved.nativeType === 'int8' || resolved.nativeType === 'bigint') {\n        return 'BIGSERIAL';\n      }\n      if (resolved.nativeType === 'int2' || resolved.nativeType === 'smallint') {\n        return 'SMALLSERIAL';\n      }\n    }\n  }\n\n  const expanded = expandParameterizedTypeSql(resolved, codecHooks);\n  if (expanded !== null) {\n    return expanded;\n  }\n\n  if (column.typeRef) {\n    return quoteIdentifier(resolved.nativeType);\n  }\n\n  assertSafeNativeType(resolved.nativeType);\n  return resolved.nativeType;\n}\n\nfunction expandParameterizedTypeSql(\n  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,\n  codecHooks: Map<string, CodecControlHooks>,\n): string | null {\n  if (!column.typeParams) {\n    return null;\n  }\n\n  if (!column.codecId) {\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" but has no codecId. ` +\n        'Ensure the column is associated with a codec.',\n    );\n  }\n\n  const hooks = codecHooks.get(column.codecId);\n  if (!hooks?.expandNativeType) {\n    if (hooks?.planTypeOperations) {\n      return null;\n    }\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" ` +\n        `but no expandNativeType hook is registered for codecId \"${column.codecId}\". ` +\n        'Ensure the extension providing this codec is included in extensionPacks.',\n    );\n  }\n\n  const expanded = hooks.expandNativeType({\n    nativeType: column.nativeType,\n    codecId: column.codecId,\n    typeParams: column.typeParams,\n  });\n\n  return expanded !== column.nativeType ? expanded : null;\n}\n\n/** Autoincrement columns use SERIAL types, so this returns empty for them. */\nexport function buildColumnDefaultSql(\n  columnDefault: PostgresColumnDefault | undefined,\n  column?: StorageColumn,\n): string {\n  if (!columnDefault) {\n    return '';\n  }\n\n  switch (columnDefault.kind) {\n    case 'literal':\n      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;\n    case 'function': {\n      if (columnDefault.expression === 'autoincrement()') {\n        return '';\n      }\n      assertSafeDefaultExpression(columnDefault.expression);\n      return `DEFAULT (${columnDefault.expression})`;\n    }\n    case 'sequence':\n      return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;\n  }\n}\n\nexport function renderDefaultLiteral(value: unknown, column?: StorageColumn): string {\n  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';\n\n  if (value instanceof Date) {\n    return `'${escapeLiteral(value.toISOString())}'`;\n  }\n  if (typeof value === 'string') {\n    return `'${escapeLiteral(value)}'`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (value === null) {\n    return 'NULL';\n  }\n  const json = JSON.stringify(value);\n  if (isJsonColumn) {\n    return `'${escapeLiteral(json)}'::${column.nativeType}`;\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nexport function buildAddColumnSql(\n  qualifiedTableName: string,\n  columnName: string,\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  temporaryDefault?: string | null,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string {\n  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);\n  const defaultSql =\n    buildColumnDefaultSql(column.default, column) ||\n    (temporaryDefault ? `DEFAULT ${temporaryDefault}` : '');\n  const parts = [\n    `ALTER TABLE ${qualifiedTableName}`,\n    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,\n    defaultSql,\n    column.nullable ? '' : 'NOT NULL',\n  ].filter(Boolean);\n  return parts.join(' ');\n}\n\nconst REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {\n  noAction: 'NO ACTION',\n  restrict: 'RESTRICT',\n  cascade: 'CASCADE',\n  setNull: 'SET NULL',\n  setDefault: 'SET DEFAULT',\n};\n\nexport function buildForeignKeySql(\n  schemaName: string,\n  tableName: string,\n  fkName: string,\n  foreignKey: ForeignKey,\n): string {\n  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}\nADD CONSTRAINT ${quoteIdentifier(fkName)}\nFOREIGN KEY (${foreignKey.source.columns.map(quoteIdentifier).join(', ')})\nREFERENCES ${qualifyTableName(schemaName, foreignKey.target.tableName)} (${foreignKey.target.columns\n    .map(quoteIdentifier)\n    .join(', ')})`;\n\n  if (foreignKey.onDelete !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];\n    if (!action) {\n      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);\n    }\n    sql += `\\nON DELETE ${action}`;\n  }\n  if (foreignKey.onUpdate !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];\n    if (!action) {\n      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);\n    }\n    sql += `\\nON UPDATE ${action}`;\n  }\n\n  return sql;\n}\n"],"mappings":"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"}
+{"version":3,"file":"planner-ddl-builders-BfN5p8wr.mjs","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type {\n  ForeignKey,\n  PostgresEnumStorageEntry,\n  ReferentialAction,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { escapeLiteral, quoteIdentifier } from '../sql-utils';\nimport type { PostgresColumnDefault } from '../types';\nimport { qualifyTableName } from './planner-sql-checks';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\nexport function buildCreateTableSql(\n  qualifiedTableName: string,\n  table: StorageTable,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string {\n  const columnDefinitions = Object.entries(table.columns).map(\n    ([columnName, column]: [string, StorageColumn]) => {\n      const parts = [\n        quoteIdentifier(columnName),\n        buildColumnTypeSql(column, codecHooks, storageTypes),\n        buildColumnDefaultSql(column.default, column),\n        column.nullable ? '' : 'NOT NULL',\n      ].filter(Boolean);\n      return parts.join(' ');\n    },\n  );\n\n  const constraintDefinitions: string[] = [];\n  if (table.primaryKey) {\n    constraintDefinitions.push(\n      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,\n    );\n  }\n\n  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];\n  return `CREATE TABLE ${qualifiedTableName} (\\n  ${allDefinitions.join(',\\n  ')}\\n)`;\n}\n\n/**\n * Pattern for safe PostgreSQL type names.\n * Allows letters, digits, underscores, spaces (for \"double precision\", \"character varying\"),\n * and trailing [] for array types.\n */\nconst SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/;\n\nfunction assertSafeNativeType(nativeType: string): void {\n  if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {\n    throw new Error(\n      `Unsafe native type name in contract: \"${nativeType}\". ` +\n        'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\\\[\\\\])?$/',\n    );\n  }\n}\n\n/**\n * Sanity check against accidental SQL injection from malformed contract files.\n * Rejects semicolons, SQL comment tokens, and dollar-quoting.\n * Not a comprehensive security boundary — the contract is developer-authored.\n */\nfunction assertSafeDefaultExpression(expression: string): void {\n  if (expression.includes(';') || /--|\\/\\*|\\$\\$|\\bSELECT\\b/i.test(expression)) {\n    throw new Error(\n      `Unsafe default expression in contract: \"${expression}\". ` +\n        'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',\n    );\n  }\n}\n\n/**\n * Renders the SQL type for a column in DDL context.\n *\n * @param allowPseudoTypes - When true (default), autoincrement integer columns\n *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts\n *   like ALTER COLUMN TYPE where pseudo-types are invalid.\n */\nexport function buildColumnTypeSql(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n  allowPseudoTypes = true,\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (allowPseudoTypes) {\n    const columnDefault = column.default;\n    if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {\n      if (resolved.nativeType === 'int4' || resolved.nativeType === 'integer') {\n        return 'SERIAL';\n      }\n      if (resolved.nativeType === 'int8' || resolved.nativeType === 'bigint') {\n        return 'BIGSERIAL';\n      }\n      if (resolved.nativeType === 'int2' || resolved.nativeType === 'smallint') {\n        return 'SMALLSERIAL';\n      }\n    }\n  }\n\n  const expanded = expandParameterizedTypeSql(resolved, codecHooks);\n  if (expanded !== null) {\n    return expanded;\n  }\n\n  if (column.typeRef) {\n    return quoteIdentifier(resolved.nativeType);\n  }\n\n  assertSafeNativeType(resolved.nativeType);\n  return resolved.nativeType;\n}\n\nfunction expandParameterizedTypeSql(\n  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,\n  codecHooks: Map<string, CodecControlHooks>,\n): string | null {\n  if (!column.typeParams) {\n    return null;\n  }\n\n  if (!column.codecId) {\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" but has no codecId. ` +\n        'Ensure the column is associated with a codec.',\n    );\n  }\n\n  const hooks = codecHooks.get(column.codecId);\n  if (!hooks?.expandNativeType) {\n    if (hooks?.planTypeOperations) {\n      return null;\n    }\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" ` +\n        `but no expandNativeType hook is registered for codecId \"${column.codecId}\". ` +\n        'Ensure the extension providing this codec is included in extensionPacks.',\n    );\n  }\n\n  const expanded = hooks.expandNativeType({\n    nativeType: column.nativeType,\n    codecId: column.codecId,\n    typeParams: column.typeParams,\n  });\n\n  return expanded !== column.nativeType ? expanded : null;\n}\n\n/** Autoincrement columns use SERIAL types, so this returns empty for them. */\nexport function buildColumnDefaultSql(\n  columnDefault: PostgresColumnDefault | undefined,\n  column?: StorageColumn,\n): string {\n  if (!columnDefault) {\n    return '';\n  }\n\n  switch (columnDefault.kind) {\n    case 'literal':\n      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;\n    case 'function': {\n      if (columnDefault.expression === 'autoincrement()') {\n        return '';\n      }\n      assertSafeDefaultExpression(columnDefault.expression);\n      return `DEFAULT (${columnDefault.expression})`;\n    }\n    case 'sequence':\n      return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;\n  }\n}\n\nexport function renderDefaultLiteral(value: unknown, column?: StorageColumn): string {\n  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';\n\n  if (value instanceof Date) {\n    return `'${escapeLiteral(value.toISOString())}'`;\n  }\n  if (typeof value === 'string') {\n    return `'${escapeLiteral(value)}'`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (value === null) {\n    return 'NULL';\n  }\n  const json = JSON.stringify(value);\n  if (isJsonColumn) {\n    return `'${escapeLiteral(json)}'::${column.nativeType}`;\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nexport function buildAddColumnSql(\n  qualifiedTableName: string,\n  columnName: string,\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  temporaryDefault?: string | null,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string {\n  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);\n  const defaultSql =\n    buildColumnDefaultSql(column.default, column) ||\n    (temporaryDefault ? `DEFAULT ${temporaryDefault}` : '');\n  const parts = [\n    `ALTER TABLE ${qualifiedTableName}`,\n    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,\n    defaultSql,\n    column.nullable ? '' : 'NOT NULL',\n  ].filter(Boolean);\n  return parts.join(' ');\n}\n\nconst REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {\n  noAction: 'NO ACTION',\n  restrict: 'RESTRICT',\n  cascade: 'CASCADE',\n  setNull: 'SET NULL',\n  setDefault: 'SET DEFAULT',\n};\n\nexport function buildForeignKeySql(\n  schemaName: string,\n  tableName: string,\n  fkName: string,\n  foreignKey: ForeignKey,\n): string {\n  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}\nADD CONSTRAINT ${quoteIdentifier(fkName)}\nFOREIGN KEY (${foreignKey.source.columns.map(quoteIdentifier).join(', ')})\nREFERENCES ${qualifyTableName(schemaName, foreignKey.target.tableName)} (${foreignKey.target.columns\n    .map(quoteIdentifier)\n    .join(', ')})`;\n\n  if (foreignKey.onDelete !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];\n    if (!action) {\n      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);\n    }\n    sql += `\\nON DELETE ${action}`;\n  }\n  if (foreignKey.onUpdate !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];\n    if (!action) {\n      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);\n    }\n    sql += `\\nON UPDATE ${action}`;\n  }\n\n  return sql;\n}\n"],"mappings":"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"}

package/dist/planner-ddl-builders.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresColumnDefault } from "./types-O40IcFV9.mjs";
+import { t as PostgresColumnDefault } from "./types-kggVJs6C.mjs";
 import { CodecControlHooks } from "@prisma-next/family-sql/control";
 import { ForeignKey, PostgresEnumStorageEntry, StorageColumn, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 

package/dist/planner-ddl-builders.mjs

@@ -1,2 +1,2 @@
-import { a as buildForeignKeySql, i as buildCreateTableSql, n as buildColumnDefaultSql, o as renderDefaultLiteral, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-BNMfSE9r.mjs";
+import { a as buildForeignKeySql, i as buildCreateTableSql, n as buildColumnDefaultSql, o as renderDefaultLiteral, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-BfN5p8wr.mjs";
 export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, buildForeignKeySql, renderDefaultLiteral };

package/dist/{planner-identity-values-nhVj0hp-.mjs → planner-identity-values-DmwlJe_z.mjs}

@@ -93,4 +93,4 @@ function buildBitIdentityValue(typeParams) {
 //#endregion
 export { resolveIdentityValue as n, buildBuiltinIdentityValue as t };
 
-//# sourceMappingURL=planner-identity-values-nhVj0hp-.mjs.map
+//# sourceMappingURL=planner-identity-values-DmwlJe_z.mjs.map

package/dist/{planner-identity-values-nhVj0hp-.mjs.map → planner-identity-values-DmwlJe_z.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-identity-values-nhVj0hp-.mjs","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport {\n  isPostgresEnumStorageEntry,\n  type PostgresEnumStorageEntry,\n  type StorageColumn,\n  type StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresEnumType } from '../postgres-enum-type';\n\n/**\n * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.\n * Checks codec hooks first (extensions can provide type-specific identity values),\n * then falls back to the built-in map.\n */\nexport function resolveIdentityValue(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string | null {\n  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;\n  const referencedIsEnum =\n    referencedType !== undefined && isPostgresEnumStorageEntry(referencedType);\n  const referencedBinding = referencedIsEnum\n    ? ((referencedType as PostgresEnumType).codecBinding ?? {\n        codecId: (referencedType as PostgresEnumStorageEntry).codecId,\n        typeParams: { values: (referencedType as PostgresEnumStorageEntry).values },\n      })\n    : undefined;\n  const codecId =\n    referencedBinding?.codecId ??\n    (referencedType && !referencedIsEnum\n      ? (referencedType as StorageTypeInstance).codecId\n      : undefined) ??\n    column.codecId;\n  const nativeType = referencedType?.nativeType ?? column.nativeType;\n  const typeParams =\n    (referencedBinding?.typeParams as Record<string, unknown> | undefined) ??\n    (referencedType && !referencedIsEnum\n      ? (referencedType as StorageTypeInstance).typeParams\n      : undefined) ??\n    column.typeParams;\n\n  if (codecId) {\n    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({\n      nativeType,\n      codecId,\n      ...ifDefined('typeParams', typeParams),\n    });\n    if (hookDefault !== undefined) {\n      return hookDefault;\n    }\n  }\n\n  return buildBuiltinIdentityValue(nativeType, typeParams);\n}\n\n/**\n * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given\n * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.\n *\n * This is the planner's fallback when no codec hook provides a type-specific identity value.\n *\n * Returns null for unrecognized types (for example enums and extension-owned types without a\n * hook), which causes the planner to fall back to the empty-table precheck.\n *\n * @internal Exported for testing only.\n */\nexport function buildBuiltinIdentityValue(\n  nativeType: string,\n  typeParams?: Record<string, unknown>,\n): string | null {\n  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);\n\n  if (normalizedNativeType.endsWith('[]')) {\n    return \"'{}'\";\n  }\n\n  switch (normalizedNativeType) {\n    case 'text':\n    case 'character':\n    case 'bpchar':\n    case 'character varying':\n    case 'varchar':\n      return \"''\";\n\n    case 'int2':\n    case 'int4':\n    case 'int8':\n    case 'integer':\n    case 'bigint':\n    case 'smallint':\n    case 'float4':\n    case 'float8':\n    case 'real':\n    case 'double precision':\n    case 'numeric':\n    case 'decimal':\n      return '0';\n\n    case 'bool':\n    case 'boolean':\n      return 'false';\n\n    case 'uuid':\n      return \"'00000000-0000-0000-0000-000000000000'\";\n\n    case 'json':\n      return \"'{}'::json\";\n    case 'jsonb':\n      return \"'{}'::jsonb\";\n\n    case 'date':\n    case 'timestamp':\n    case 'timestamptz':\n    case 'timestamp with time zone':\n    case 'timestamp without time zone':\n      return \"'epoch'\";\n\n    case 'time':\n    case 'time without time zone':\n      return \"'00:00:00'\";\n    case 'timetz':\n    case 'time with time zone':\n      return \"'00:00:00+00'\";\n\n    case 'interval':\n      return \"'0'\";\n\n    case 'bytea':\n      return \"''::bytea\";\n    case 'tsvector':\n      return \"''::tsvector\";\n\n    case 'bit':\n      return buildBitIdentityValue(typeParams);\n    case 'bit varying':\n    case 'varbit':\n      return \"B''\";\n\n    default:\n      return null;\n  }\n}\n\nfunction normalizeIdentityValueNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase().replace(/\\s+/g, ' ');\n}\n\nfunction buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {\n  const length = typeParams?.['length'];\n  if (length === undefined) {\n    return \"B'0'\";\n  }\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n  return `B'${'0'.repeat(length)}'`;\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,qBACd,QACA,YACA,eAA+E,CAAC,GACjE;CACf,MAAM,iBAAiB,OAAO,UAAU,aAAa,OAAO,WAAW,KAAA;CACvE,MAAM,mBACJ,mBAAmB,KAAA,KAAa,2BAA2B,cAAc;CAC3E,MAAM,oBAAoB,mBACpB,eAAoC,gBAAgB;EACpD,SAAU,eAA4C;EACtD,YAAY,EAAE,QAAS,eAA4C,OAAO;CAC5E,IACA,KAAA;CACJ,MAAM,UACJ,mBAAmB,YAClB,kBAAkB,CAAC,mBACf,eAAuC,UACxC,KAAA,MACJ,OAAO;CACT,MAAM,aAAa,gBAAgB,cAAc,OAAO;CACxD,MAAM,aACH,mBAAmB,eACnB,kBAAkB,CAAC,mBACf,eAAuC,aACxC,KAAA,MACJ,OAAO;CAET,IAAI,SAAS;EACX,MAAM,cAAc,WAAW,IAAI,OAAO,GAAG,uBAAuB;GAClE;GACA;GACA,GAAG,UAAU,cAAc,UAAU;EACvC,CAAC;EACD,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAEX;CAEA,OAAO,0BAA0B,YAAY,UAAU;AACzD;;;;;;;;;;;;AAaA,SAAgB,0BACd,YACA,YACe;CACf,MAAM,uBAAuB,iCAAiC,UAAU;CAExE,IAAI,qBAAqB,SAAS,IAAI,GACpC,OAAO;CAGT,QAAQ,sBAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EACT,KAAK,SACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,+BACH,OAAO;EAET,KAAK;EACL,KAAK,0BACH,OAAO;EACT,KAAK;EACL,KAAK,uBACH,OAAO;EAET,KAAK,YACH,OAAO;EAET,KAAK,SACH,OAAO;EACT,KAAK,YACH,OAAO;EAET,KAAK,OACH,OAAO,sBAAsB,UAAU;EACzC,KAAK;EACL,KAAK,UACH,OAAO;EAET,SACE,OAAO;CACX;AACF;AAEA,SAAS,iCAAiC,YAA4B;CACpE,OAAO,WAAW,KAAK,EAAE,YAAY,EAAE,QAAQ,QAAQ,GAAG;AAC5D;AAEA,SAAS,sBAAsB,YAAqD;CAClF,MAAM,SAAS,aAAa;CAC5B,IAAI,WAAW,KAAA,GACb,OAAO;CAET,IAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvE,OAAO;CAET,OAAO,KAAK,IAAI,OAAO,MAAM,EAAE;AACjC"}
+{"version":3,"file":"planner-identity-values-DmwlJe_z.mjs","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport {\n  isPostgresEnumStorageEntry,\n  type PostgresEnumStorageEntry,\n  type StorageColumn,\n  type StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresEnumType } from '../postgres-enum-type';\n\n/**\n * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.\n * Checks codec hooks first (extensions can provide type-specific identity values),\n * then falls back to the built-in map.\n */\nexport function resolveIdentityValue(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string | null {\n  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;\n  const referencedIsEnum =\n    referencedType !== undefined && isPostgresEnumStorageEntry(referencedType);\n  const referencedBinding = referencedIsEnum\n    ? ((referencedType as PostgresEnumType).codecBinding ?? {\n        codecId: (referencedType as PostgresEnumStorageEntry).codecId,\n        typeParams: { values: (referencedType as PostgresEnumStorageEntry).values },\n      })\n    : undefined;\n  const codecId =\n    referencedBinding?.codecId ??\n    (referencedType && !referencedIsEnum\n      ? (referencedType as StorageTypeInstance).codecId\n      : undefined) ??\n    column.codecId;\n  const nativeType = referencedType?.nativeType ?? column.nativeType;\n  const typeParams =\n    (referencedBinding?.typeParams as Record<string, unknown> | undefined) ??\n    (referencedType && !referencedIsEnum\n      ? (referencedType as StorageTypeInstance).typeParams\n      : undefined) ??\n    column.typeParams;\n\n  if (codecId) {\n    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({\n      nativeType,\n      codecId,\n      ...ifDefined('typeParams', typeParams),\n    });\n    if (hookDefault !== undefined) {\n      return hookDefault;\n    }\n  }\n\n  return buildBuiltinIdentityValue(nativeType, typeParams);\n}\n\n/**\n * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given\n * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.\n *\n * This is the planner's fallback when no codec hook provides a type-specific identity value.\n *\n * Returns null for unrecognized types (for example enums and extension-owned types without a\n * hook), which causes the planner to fall back to the empty-table precheck.\n *\n * @internal Exported for testing only.\n */\nexport function buildBuiltinIdentityValue(\n  nativeType: string,\n  typeParams?: Record<string, unknown>,\n): string | null {\n  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);\n\n  if (normalizedNativeType.endsWith('[]')) {\n    return \"'{}'\";\n  }\n\n  switch (normalizedNativeType) {\n    case 'text':\n    case 'character':\n    case 'bpchar':\n    case 'character varying':\n    case 'varchar':\n      return \"''\";\n\n    case 'int2':\n    case 'int4':\n    case 'int8':\n    case 'integer':\n    case 'bigint':\n    case 'smallint':\n    case 'float4':\n    case 'float8':\n    case 'real':\n    case 'double precision':\n    case 'numeric':\n    case 'decimal':\n      return '0';\n\n    case 'bool':\n    case 'boolean':\n      return 'false';\n\n    case 'uuid':\n      return \"'00000000-0000-0000-0000-000000000000'\";\n\n    case 'json':\n      return \"'{}'::json\";\n    case 'jsonb':\n      return \"'{}'::jsonb\";\n\n    case 'date':\n    case 'timestamp':\n    case 'timestamptz':\n    case 'timestamp with time zone':\n    case 'timestamp without time zone':\n      return \"'epoch'\";\n\n    case 'time':\n    case 'time without time zone':\n      return \"'00:00:00'\";\n    case 'timetz':\n    case 'time with time zone':\n      return \"'00:00:00+00'\";\n\n    case 'interval':\n      return \"'0'\";\n\n    case 'bytea':\n      return \"''::bytea\";\n    case 'tsvector':\n      return \"''::tsvector\";\n\n    case 'bit':\n      return buildBitIdentityValue(typeParams);\n    case 'bit varying':\n    case 'varbit':\n      return \"B''\";\n\n    default:\n      return null;\n  }\n}\n\nfunction normalizeIdentityValueNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase().replace(/\\s+/g, ' ');\n}\n\nfunction buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {\n  const length = typeParams?.['length'];\n  if (length === undefined) {\n    return \"B'0'\";\n  }\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n  return `B'${'0'.repeat(length)}'`;\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,qBACd,QACA,YACA,eAA+E,CAAC,GACjE;CACf,MAAM,iBAAiB,OAAO,UAAU,aAAa,OAAO,WAAW,KAAA;CACvE,MAAM,mBACJ,mBAAmB,KAAA,KAAa,2BAA2B,cAAc;CAC3E,MAAM,oBAAoB,mBACpB,eAAoC,gBAAgB;EACpD,SAAU,eAA4C;EACtD,YAAY,EAAE,QAAS,eAA4C,OAAO;CAC5E,IACA,KAAA;CACJ,MAAM,UACJ,mBAAmB,YAClB,kBAAkB,CAAC,mBACf,eAAuC,UACxC,KAAA,MACJ,OAAO;CACT,MAAM,aAAa,gBAAgB,cAAc,OAAO;CACxD,MAAM,aACH,mBAAmB,eACnB,kBAAkB,CAAC,mBACf,eAAuC,aACxC,KAAA,MACJ,OAAO;CAET,IAAI,SAAS;EACX,MAAM,cAAc,WAAW,IAAI,OAAO,GAAG,uBAAuB;GAClE;GACA;GACA,GAAG,UAAU,cAAc,UAAU;EACvC,CAAC;EACD,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAEX;CAEA,OAAO,0BAA0B,YAAY,UAAU;AACzD;;;;;;;;;;;;AAaA,SAAgB,0BACd,YACA,YACe;CACf,MAAM,uBAAuB,iCAAiC,UAAU;CAExE,IAAI,qBAAqB,SAAS,IAAI,GACpC,OAAO;CAGT,QAAQ,sBAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EACT,KAAK,SACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,+BACH,OAAO;EAET,KAAK;EACL,KAAK,0BACH,OAAO;EACT,KAAK;EACL,KAAK,uBACH,OAAO;EAET,KAAK,YACH,OAAO;EAET,KAAK,SACH,OAAO;EACT,KAAK,YACH,OAAO;EAET,KAAK,OACH,OAAO,sBAAsB,UAAU;EACzC,KAAK;EACL,KAAK,UACH,OAAO;EAET,SACE,OAAO;CACX;AACF;AAEA,SAAS,iCAAiC,YAA4B;CACpE,OAAO,WAAW,KAAK,EAAE,YAAY,EAAE,QAAQ,QAAQ,GAAG;AAC5D;AAEA,SAAS,sBAAsB,YAAqD;CAClF,MAAM,SAAS,aAAa;CAC5B,IAAI,WAAW,KAAA,GACb,OAAO;CAET,IAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvE,OAAO;CAET,OAAO,KAAK,IAAI,OAAO,MAAM,EAAE;AACjC"}

package/dist/planner-identity-values.mjs

@@ -1,2 +1,2 @@
-import { t as buildBuiltinIdentityValue } from "./planner-identity-values-nhVj0hp-.mjs";
+import { t as buildBuiltinIdentityValue } from "./planner-identity-values-DmwlJe_z.mjs";
 export { buildBuiltinIdentityValue };

package/dist/{planner-produced-postgres-migration-D02NOhVQ.d.mts → planner-produced-postgres-migration-Co71_VbU.d.mts}

@@ -1,5 +1,5 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-a_wuOiYf.mjs";
-import { t as PostgresMigration } from "./postgres-migration-DRY8V-bQ.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-Dv5N6x6k.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BcKS2Lqq.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-D02NOhVQ.d.mts.map
+//# sourceMappingURL=planner-produced-postgres-migration-Co71_VbU.d.mts.map

package/dist/{planner-produced-postgres-migration-D02NOhVQ.d.mts.map → planner-produced-postgres-migration-Co71_VbU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-D02NOhVQ.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;KAoCK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,cAEvB,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAMC,KAAA,WAAgB,aAAA,IAAiB,IAAA,EAAM,aAAA,EAAe,OAAA;EAAA,IAOrD,UAAA,CAAA,YAAuB,EAAA;EAI3B,QAAA,CAAA,GAAY,aAAA;EAAA;;;;AAaL;EAbK,IASjB,OAAA,CAAA;EAIJ,gBAAA,CAAA;AAAA"}
+{"version":3,"file":"planner-produced-postgres-migration-Co71_VbU.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;KAoCK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,cAEvB,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAMC,KAAA,WAAgB,aAAA,IAAiB,IAAA,EAAM,aAAA,EAAe,OAAA;EAAA,IAOrD,UAAA,CAAA,YAAuB,EAAA;EAI3B,QAAA,CAAA,GAAY,aAAA;EAAA;;;;AAaL;EAbK,IASjB,OAAA,CAAA;EAIJ,gBAAA,CAAA;AAAA"}

package/dist/{planner-produced-postgres-migration-D_nsXbhl.mjs → planner-produced-postgres-migration-D6KXC2DH.mjs}

@@ -1,6 +1,6 @@
-import { t as PostgresMigration } from "./postgres-migration-BatbEvU6.mjs";
-import { t as renderOps } from "./render-ops-XhICjX_P.mjs";
-import { t as renderCallsToTypeScript } from "./render-typescript-K125n-RZ.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BnDg_Nj0.mjs";
+import { t as renderOps } from "./render-ops-BpU-Qv06.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-D9O7aOS_.mjs";
 //#region src/core/migrations/planner-produced-postgres-migration.ts
 var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
 	#calls;
@@ -36,4 +36,4 @@ var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
 
-//# sourceMappingURL=planner-produced-postgres-migration-D_nsXbhl.mjs.map
+//# sourceMappingURL=planner-produced-postgres-migration-D6KXC2DH.mjs.map

package/dist/{planner-produced-postgres-migration-D_nsXbhl.mjs.map → planner-produced-postgres-migration-D6KXC2DH.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-D_nsXbhl.mjs","names":["#calls","#meta","#spaceId"],"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 {\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\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\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\n  constructor(calls: readonly OpFactoryCall[], meta: MigrationMeta, spaceId: string) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n    this.#spaceId = spaceId;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  /**\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, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n    });\n  }\n}\n"],"mappings":";;;;AAsCA,IAAa,wCAAb,cACU,kBAEV;CACE;CACA;CACA;CAEA,YAAY,OAAiC,MAAqB,SAAiB;EACjF,MAAM;EACN,KAAKA,SAAS;EACd,KAAKC,QAAQ;EACb,KAAKC,WAAW;CAClB;CAEA,IAAa,aAA4B;EACvC,OAAO,UAAU,KAAKF,MAAM;CAC9B;CAEA,WAAmC;EACjC,OAAO,KAAKC;CACd;;;;;;CAOA,IAAI,UAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,mBAA2B;EACzB,OAAO,wBAAwB,KAAKF,QAAQ;GAC1C,MAAM,KAAKC,MAAM;GACjB,IAAI,KAAKA,MAAM;EACjB,CAAC;CACH;AACF"}
+{"version":3,"file":"planner-produced-postgres-migration-D6KXC2DH.mjs","names":["#calls","#meta","#spaceId"],"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 {\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\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\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\n  constructor(calls: readonly OpFactoryCall[], meta: MigrationMeta, spaceId: string) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n    this.#spaceId = spaceId;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  /**\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, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n    });\n  }\n}\n"],"mappings":";;;;AAsCA,IAAa,wCAAb,cACU,kBAEV;CACE;CACA;CACA;CAEA,YAAY,OAAiC,MAAqB,SAAiB;EACjF,MAAM;EACN,KAAKA,SAAS;EACd,KAAKC,QAAQ;EACb,KAAKC,WAAW;CAClB;CAEA,IAAa,aAA4B;EACvC,OAAO,UAAU,KAAKF,MAAM;CAC9B;CAEA,WAAmC;EACjC,OAAO,KAAKC;CACd;;;;;;CAOA,IAAI,UAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,mBAA2B;EACzB,OAAO,wBAAwB,KAAKF,QAAQ;GAC1C,MAAM,KAAKC,MAAM;GACjB,IAAI,KAAKA,MAAM;EACjB,CAAC;CACH;AACF"}

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

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

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

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

package/dist/{planner-schema-lookup-CGxxYfnD.mjs → planner-schema-lookup-Bm4S3LvB.mjs}

@@ -54,4 +54,4 @@ function hasForeignKey(lookup, fk) {
 //#endregion
 export { hasUniqueConstraint as i, hasForeignKey as n, hasIndex as r, buildSchemaLookupMap as t };
 
-//# sourceMappingURL=planner-schema-lookup-CGxxYfnD.mjs.map
+//# sourceMappingURL=planner-schema-lookup-Bm4S3LvB.mjs.map

package/dist/{planner-schema-lookup-CGxxYfnD.mjs.map → planner-schema-lookup-Bm4S3LvB.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-schema-lookup-CGxxYfnD.mjs","names":[],"sources":["../src/core/migrations/planner-schema-lookup.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { ForeignKey } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * Pre-computed lookup sets for a schema table's constraints.\n * Converts O(n*m) linear scans to O(1) Set lookups per constraint check.\n */\nexport interface SchemaTableLookup {\n  readonly uniqueKeys: Set<string>;\n  readonly indexKeys: Set<string>;\n  readonly uniqueIndexKeys: Set<string>;\n  readonly fkKeys: Set<string>;\n}\n\nexport function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, SchemaTableLookup> {\n  const map = new Map<string, SchemaTableLookup>();\n  for (const [tableName, table] of Object.entries(schema.tables)) {\n    map.set(tableName, buildSchemaTableLookup(table));\n  }\n  return map;\n}\n\nfunction buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {\n  const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));\n  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));\n  const uniqueIndexKeys = new Set(\n    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),\n  );\n  const fkKeys = new Set<string>();\n  for (const fk of table.foreignKeys) {\n    // Keys are JSON-encoded tuples so identifiers containing any character\n    // (including the column-list comma or pipe characters) cannot collide\n    // across structurally-distinct FKs. Unqualified keys are 3-tuples\n    // (cols, table, refCols); qualified keys are 4-tuples\n    // (cols, schema, table, refCols) — the arity difference makes the two\n    // key shapes fundamentally non-collidable.\n    fkKeys.add(JSON.stringify([fk.columns, fk.referencedTable, fk.referencedColumns]));\n    if (fk.referencedSchema !== undefined) {\n      fkKeys.add(\n        JSON.stringify([fk.columns, fk.referencedSchema, fk.referencedTable, fk.referencedColumns]),\n      );\n    }\n  }\n  return { uniqueKeys, indexKeys, uniqueIndexKeys, fkKeys };\n}\n\nexport function hasUniqueConstraint(\n  lookup: SchemaTableLookup,\n  columns: readonly string[],\n): boolean {\n  const key = columns.join(',');\n  return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);\n}\n\nexport function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]): boolean {\n  const key = columns.join(',');\n  return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);\n}\n\nexport function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean {\n  // Mirror the encoding produced by buildSchemaTableLookup exactly:\n  // unqualified 3-tuple for unbound-namespace FKs, qualified 4-tuple for\n  // bound-namespace FKs.\n  if (fk.target.namespaceId === UNBOUND_NAMESPACE_ID) {\n    return lookup.fkKeys.has(\n      JSON.stringify([fk.source.columns, fk.target.tableName, fk.target.columns]),\n    );\n  }\n  return lookup.fkKeys.has(\n    JSON.stringify([\n      fk.source.columns,\n      fk.target.namespaceId,\n      fk.target.tableName,\n      fk.target.columns,\n    ]),\n  );\n}\n"],"mappings":";;AAeA,SAAgB,qBAAqB,QAA6D;CAChG,MAAM,sBAAM,IAAI,IAA+B;CAC/C,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,OAAO,MAAM,GAC3D,IAAI,IAAI,WAAW,uBAAuB,KAAK,CAAC;CAElD,OAAO;AACT;AAEA,SAAS,uBAAuB,OAAyD;CACvF,MAAM,aAAa,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CAAC;CACxE,MAAM,YAAY,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CAAC;CACvE,MAAM,kBAAkB,IAAI,IAC1B,MAAM,QAAQ,QAAQ,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CACtE;CACA,MAAM,yBAAS,IAAI,IAAY;CAC/B,KAAK,MAAM,MAAM,MAAM,aAAa;EAOlC,OAAO,IAAI,KAAK,UAAU;GAAC,GAAG;GAAS,GAAG;GAAiB,GAAG;EAAiB,CAAC,CAAC;EACjF,IAAI,GAAG,qBAAqB,KAAA,GAC1B,OAAO,IACL,KAAK,UAAU;GAAC,GAAG;GAAS,GAAG;GAAkB,GAAG;GAAiB,GAAG;EAAiB,CAAC,CAC5F;CAEJ;CACA,OAAO;EAAE;EAAY;EAAW;EAAiB;CAAO;AAC1D;AAEA,SAAgB,oBACd,QACA,SACS;CACT,MAAM,MAAM,QAAQ,KAAK,GAAG;CAC5B,OAAO,OAAO,WAAW,IAAI,GAAG,KAAK,OAAO,gBAAgB,IAAI,GAAG;AACrE;AAEA,SAAgB,SAAS,QAA2B,SAAqC;CACvF,MAAM,MAAM,QAAQ,KAAK,GAAG;CAC5B,OAAO,OAAO,UAAU,IAAI,GAAG,KAAK,OAAO,WAAW,IAAI,GAAG;AAC/D;AAEA,SAAgB,cAAc,QAA2B,IAAyB;CAIhF,IAAI,GAAG,OAAO,gBAAgB,sBAC5B,OAAO,OAAO,OAAO,IACnB,KAAK,UAAU;EAAC,GAAG,OAAO;EAAS,GAAG,OAAO;EAAW,GAAG,OAAO;CAAO,CAAC,CAC5E;CAEF,OAAO,OAAO,OAAO,IACnB,KAAK,UAAU;EACb,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;CACZ,CAAC,CACH;AACF"}
+{"version":3,"file":"planner-schema-lookup-Bm4S3LvB.mjs","names":[],"sources":["../src/core/migrations/planner-schema-lookup.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { ForeignKey } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * Pre-computed lookup sets for a schema table's constraints.\n * Converts O(n*m) linear scans to O(1) Set lookups per constraint check.\n */\nexport interface SchemaTableLookup {\n  readonly uniqueKeys: Set<string>;\n  readonly indexKeys: Set<string>;\n  readonly uniqueIndexKeys: Set<string>;\n  readonly fkKeys: Set<string>;\n}\n\nexport function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, SchemaTableLookup> {\n  const map = new Map<string, SchemaTableLookup>();\n  for (const [tableName, table] of Object.entries(schema.tables)) {\n    map.set(tableName, buildSchemaTableLookup(table));\n  }\n  return map;\n}\n\nfunction buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {\n  const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));\n  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));\n  const uniqueIndexKeys = new Set(\n    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),\n  );\n  const fkKeys = new Set<string>();\n  for (const fk of table.foreignKeys) {\n    // Keys are JSON-encoded tuples so identifiers containing any character\n    // (including the column-list comma or pipe characters) cannot collide\n    // across structurally-distinct FKs. Unqualified keys are 3-tuples\n    // (cols, table, refCols); qualified keys are 4-tuples\n    // (cols, schema, table, refCols) — the arity difference makes the two\n    // key shapes fundamentally non-collidable.\n    fkKeys.add(JSON.stringify([fk.columns, fk.referencedTable, fk.referencedColumns]));\n    if (fk.referencedSchema !== undefined) {\n      fkKeys.add(\n        JSON.stringify([fk.columns, fk.referencedSchema, fk.referencedTable, fk.referencedColumns]),\n      );\n    }\n  }\n  return { uniqueKeys, indexKeys, uniqueIndexKeys, fkKeys };\n}\n\nexport function hasUniqueConstraint(\n  lookup: SchemaTableLookup,\n  columns: readonly string[],\n): boolean {\n  const key = columns.join(',');\n  return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);\n}\n\nexport function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]): boolean {\n  const key = columns.join(',');\n  return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);\n}\n\nexport function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean {\n  // Mirror the encoding produced by buildSchemaTableLookup exactly:\n  // unqualified 3-tuple for unbound-namespace FKs, qualified 4-tuple for\n  // bound-namespace FKs.\n  if (fk.target.namespaceId === UNBOUND_NAMESPACE_ID) {\n    return lookup.fkKeys.has(\n      JSON.stringify([fk.source.columns, fk.target.tableName, fk.target.columns]),\n    );\n  }\n  return lookup.fkKeys.has(\n    JSON.stringify([\n      fk.source.columns,\n      fk.target.namespaceId,\n      fk.target.tableName,\n      fk.target.columns,\n    ]),\n  );\n}\n"],"mappings":";;AAeA,SAAgB,qBAAqB,QAA6D;CAChG,MAAM,sBAAM,IAAI,IAA+B;CAC/C,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,OAAO,MAAM,GAC3D,IAAI,IAAI,WAAW,uBAAuB,KAAK,CAAC;CAElD,OAAO;AACT;AAEA,SAAS,uBAAuB,OAAyD;CACvF,MAAM,aAAa,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CAAC;CACxE,MAAM,YAAY,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CAAC;CACvE,MAAM,kBAAkB,IAAI,IAC1B,MAAM,QAAQ,QAAQ,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,CACtE;CACA,MAAM,yBAAS,IAAI,IAAY;CAC/B,KAAK,MAAM,MAAM,MAAM,aAAa;EAOlC,OAAO,IAAI,KAAK,UAAU;GAAC,GAAG;GAAS,GAAG;GAAiB,GAAG;EAAiB,CAAC,CAAC;EACjF,IAAI,GAAG,qBAAqB,KAAA,GAC1B,OAAO,IACL,KAAK,UAAU;GAAC,GAAG;GAAS,GAAG;GAAkB,GAAG;GAAiB,GAAG;EAAiB,CAAC,CAC5F;CAEJ;CACA,OAAO;EAAE;EAAY;EAAW;EAAiB;CAAO;AAC1D;AAEA,SAAgB,oBACd,QACA,SACS;CACT,MAAM,MAAM,QAAQ,KAAK,GAAG;CAC5B,OAAO,OAAO,WAAW,IAAI,GAAG,KAAK,OAAO,gBAAgB,IAAI,GAAG;AACrE;AAEA,SAAgB,SAAS,QAA2B,SAAqC;CACvF,MAAM,MAAM,QAAQ,KAAK,GAAG;CAC5B,OAAO,OAAO,UAAU,IAAI,GAAG,KAAK,OAAO,WAAW,IAAI,GAAG;AAC/D;AAEA,SAAgB,cAAc,QAA2B,IAAyB;CAIhF,IAAI,GAAG,OAAO,gBAAgB,sBAC5B,OAAO,OAAO,OAAO,IACnB,KAAK,UAAU;EAAC,GAAG,OAAO;EAAS,GAAG,OAAO;EAAW,GAAG,OAAO;CAAO,CAAC,CAC5E;CAEF,OAAO,OAAO,OAAO,IACnB,KAAK,UAAU;EACb,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;CACZ,CAAC,CACH;AACF"}

package/dist/planner-schema-lookup.mjs

@@ -1,2 +1,2 @@
-import { i as hasUniqueConstraint, n as hasForeignKey, r as hasIndex, t as buildSchemaLookupMap } from "./planner-schema-lookup-CGxxYfnD.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, r as hasIndex, t as buildSchemaLookupMap } from "./planner-schema-lookup-Bm4S3LvB.mjs";
 export { buildSchemaLookupMap, hasForeignKey, hasIndex, hasUniqueConstraint };

package/dist/{planner-sql-checks-CfEiTXoQ.mjs → planner-sql-checks-C43dcyOd.mjs}

@@ -1,5 +1,5 @@
-import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-CggjWNij.mjs";
-import { i as postgresCreateNamespace } from "./postgres-schema-BxAuNFX0.mjs";
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DR_F9aHR.mjs";
+import { i as postgresCreateNamespace } from "./postgres-schema-BQG4laaB.mjs";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 //#region src/core/migrations/planner-type-resolution.ts
 function resolveColumnTypeMetadata(column, storageTypes) {
@@ -30,10 +30,16 @@ function resolveColumnTypeMetadata(column, storageTypes) {
 * site.
 */
 function qualifyTableName(schema, table) {
-	return postgresCreateNamespace({ id: schema }).qualifyTable(table);
+	return postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).qualifyTable(table);
 }
 function toRegclassLiteral(schema, name) {
-	return postgresCreateNamespace({ id: schema }).regclassLiteral(name);
+	return postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).regclassLiteral(name);
 }
 /**
 * When `table` is omitted the check matches by name + schema across all tables.
@@ -41,7 +47,10 @@ function toRegclassLiteral(schema, name) {
 * identically-named constraints in different tables).
 */
 function constraintExistsCheck({ constraintName, schema, table, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const existsClause = exists ? "EXISTS" : "NOT EXISTS";
 	const tableFilter = table ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})` : "";
 	return `SELECT ${existsClause} (
@@ -53,7 +62,10 @@ function constraintExistsCheck({ constraintName, schema, table, exists = true })
 )`;
 }
 function columnExistsCheck({ schema, table, column, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	return `SELECT ${exists ? "" : "NOT "}EXISTS (
   SELECT 1
   FROM information_schema.columns
@@ -63,7 +75,10 @@ function columnExistsCheck({ schema, table, column, exists = true }) {
 )`;
 }
 function columnNullabilityCheck({ schema, table, column, nullable }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const expected = nullable ? "YES" : "NO";
 	return `SELECT EXISTS (
   SELECT 1
@@ -81,7 +96,10 @@ function columnHasNoDefaultCheck(opts) {
 	return `SELECT NOT EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = ${postgresCreateNamespace({ id: opts.schema }).schemaSqlExpression()}
+  WHERE table_schema = ${postgresCreateNamespace({
+		id: opts.schema,
+		entries: { table: {} }
+	}).schemaSqlExpression()}
     AND table_name = '${escapeLiteral(opts.table)}'
     AND column_name = '${escapeLiteral(opts.column)}'
     AND column_default IS NOT NULL
@@ -220,7 +238,10 @@ function columnTypeCheck({ schema, table, column, expectedType }) {
   FROM pg_attribute a
   JOIN pg_class c ON c.oid = a.attrelid
   JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = ${postgresCreateNamespace({ id: schema }).schemaSqlExpression()}
+  WHERE n.nspname = ${postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).schemaSqlExpression()}
     AND c.relname = '${escapeLiteral(table)}'
     AND a.attname = '${escapeLiteral(column)}'
     AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
@@ -228,7 +249,10 @@ function columnTypeCheck({ schema, table, column, expectedType }) {
 )`;
 }
 function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const nullCheck = exists ? "IS NOT NULL" : "IS NULL";
 	return `SELECT EXISTS (
   SELECT 1
@@ -240,7 +264,10 @@ function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
 )`;
 }
 function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const comparison = exists ? "" : "NOT ";
 	const constraintFilter = constraintName ? `AND c2.relname = '${escapeLiteral(constraintName)}'` : "";
 	return `SELECT ${comparison}EXISTS (
@@ -258,4 +285,4 @@ function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
 //#endregion
 export { columnNullabilityCheck as a, qualifyTableName as c, toRegclassLiteral as d, resolveColumnTypeMetadata as f, columnHasNoDefaultCheck as i, tableHasPrimaryKeyCheck as l, columnDefaultExistsCheck as n, columnTypeCheck as o, columnExistsCheck as r, constraintExistsCheck as s, buildExpectedFormatType as t, tableIsEmptyCheck as u };
 
-//# sourceMappingURL=planner-sql-checks-CfEiTXoQ.mjs.map
+//# sourceMappingURL=planner-sql-checks-C43dcyOd.mjs.map

package/dist/planner-sql-checks-C43dcyOd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-sql-checks-C43dcyOd.mjs","names":[],"sources":["../src/core/migrations/planner-type-resolution.ts","../src/core/migrations/planner-sql-checks.ts"],"sourcesContent":["import {\n  isPostgresEnumStorageEntry,\n  type PostgresEnumStorageEntry,\n  type StorageColumn,\n  type StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\n\nexport type ResolvedColumnTypeMetadata = Pick<\n  StorageColumn,\n  'nativeType' | 'codecId' | 'typeParams'\n>;\n\nexport function resolveColumnTypeMetadata(\n  column: StorageColumn,\n  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,\n): ResolvedColumnTypeMetadata {\n  if (!column.typeRef) {\n    return column;\n  }\n\n  const referencedType = storageTypes[column.typeRef];\n  if (!referencedType) {\n    return column;\n  }\n\n  if (isPostgresEnumStorageEntry(referencedType)) {\n    // Enum types are referenced by name (`quoteIdentifier(nativeType)`),\n    // not via parameterised codec expansion. The structural shape\n    // carries `codecId` as an enumerable property (mirroring the\n    // codec-typed view); `typeParams` is intentionally omitted here so\n    // `expandParameterizedTypeSql` does not try to look up a\n    // (deliberately absent) `expandNativeType` hook for `pg/enum@*`.\n    return {\n      codecId: referencedType.codecId,\n      nativeType: referencedType.nativeType,\n    };\n  }\n\n  return {\n    codecId: referencedType.codecId,\n    nativeType: referencedType.nativeType,\n    typeParams: referencedType.typeParams,\n  };\n}\n","import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type {\n  PostgresEnumStorageEntry,\n  StorageColumn,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { postgresCreateNamespace } from '../postgres-schema';\nimport { escapeLiteral, quoteIdentifier } from '../sql-utils';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\n/**\n * String-keyed entry points the migration ops use to render\n * schema-qualified DDL and catalog checks. The `schema` argument is\n * interpreted as a namespace coordinate: the framework `__unbound__`\n * sentinel resolves to the late-bound `PostgresUnboundSchema` singleton\n * (which elides the qualifier so `search_path` decides at runtime); any\n * other id materialises a `PostgresSchema(id)` whose qualifier is the\n * named schema. Helpers route through these `Namespace` concretions so\n * the unbound branch lives in the polymorphic override, not the call\n * site.\n */\nexport function qualifyTableName(schema: string, table: string): string {\n  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(table);\n}\n\nexport function toRegclassLiteral(schema: string, name: string): string {\n  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).regclassLiteral(name);\n}\n\n/**\n * When `table` is omitted the check matches by name + schema across all tables.\n * Pass `table` to scope the check to a single table (prevents false matches on\n * identically-named constraints in different tables).\n */\nexport function constraintExistsCheck({\n  constraintName,\n  schema,\n  table,\n  exists = true,\n}: {\n  constraintName: string;\n  schema: string;\n  table?: string;\n  exists?: boolean;\n}): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';\n  const tableFilter = table\n    ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})`\n    : '';\n  return `SELECT ${existsClause} (\n  SELECT 1 FROM pg_constraint c\n  JOIN pg_namespace n ON c.connamespace = n.oid\n  WHERE c.conname = '${escapeLiteral(constraintName)}'\n  AND n.nspname = ${namespace.schemaSqlExpression()}\n  ${tableFilter}\n)`;\n}\n\nexport function columnExistsCheck({\n  schema,\n  table,\n  column,\n  exists = true,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  exists?: boolean;\n}): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  const existsClause = exists ? '' : 'NOT ';\n  return `SELECT ${existsClause}EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = ${namespace.schemaSqlExpression()}\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n)`;\n}\n\nexport function columnNullabilityCheck({\n  schema,\n  table,\n  column,\n  nullable,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  nullable: boolean;\n}): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  const expected = nullable ? 'YES' : 'NO';\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = ${namespace.schemaSqlExpression()}\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n    AND is_nullable = '${expected}'\n)`;\n}\n\nexport function tableIsEmptyCheck(qualifiedTableName: string): string {\n  return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;\n}\n\nexport function columnHasNoDefaultCheck(opts: {\n  schema: string;\n  table: string;\n  column: string;\n}): string {\n  const namespace = postgresCreateNamespace({ id: opts.schema, entries: { table: {} } });\n  return `SELECT NOT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = ${namespace.schemaSqlExpression()}\n    AND table_name = '${escapeLiteral(opts.table)}'\n    AND column_name = '${escapeLiteral(opts.column)}'\n    AND column_default IS NOT NULL\n)`;\n}\n\nconst FORMAT_TYPE_DISPLAY: ReadonlyMap<string, string> = new Map([\n  ['int2', 'smallint'],\n  ['int4', 'integer'],\n  ['int8', 'bigint'],\n  ['float4', 'real'],\n  ['float8', 'double precision'],\n  ['bool', 'boolean'],\n  ['timestamp', 'timestamp without time zone'],\n  ['timestamptz', 'timestamp with time zone'],\n  ['time', 'time without time zone'],\n  ['timetz', 'time with time zone'],\n]);\n\nconst UNQUOTED_POSTGRES_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/;\n\nconst POSTGRES_RESERVED_IDENTIFIER_WORDS = new Set([\n  'all',\n  'analyse',\n  'analyze',\n  'and',\n  'any',\n  'array',\n  'as',\n  'asc',\n  'asymmetric',\n  'authorization',\n  'between',\n  'binary',\n  'both',\n  'case',\n  'cast',\n  'check',\n  'collate',\n  'column',\n  'constraint',\n  'create',\n  'current_catalog',\n  'current_date',\n  'current_role',\n  'current_time',\n  'current_timestamp',\n  'current_user',\n  'default',\n  'deferrable',\n  'desc',\n  'distinct',\n  'do',\n  'else',\n  'end',\n  'except',\n  'false',\n  'fetch',\n  'for',\n  'foreign',\n  'freeze',\n  'from',\n  'full',\n  'grant',\n  'group',\n  'having',\n  'ilike',\n  'in',\n  'initially',\n  'inner',\n  'intersect',\n  'into',\n  'is',\n  'isnull',\n  'join',\n  'lateral',\n  'leading',\n  'left',\n  'like',\n  'limit',\n  'localtime',\n  'localtimestamp',\n  'natural',\n  'not',\n  'notnull',\n  'null',\n  'offset',\n  'on',\n  'only',\n  'or',\n  'order',\n  'outer',\n  'overlaps',\n  'placing',\n  'primary',\n  'references',\n  'right',\n  'select',\n  'session_user',\n  'similar',\n  'some',\n  'symmetric',\n  'table',\n  'then',\n  'to',\n  'trailing',\n  'true',\n  'union',\n  'unique',\n  'user',\n  'using',\n  'variadic',\n  'verbose',\n  'when',\n  'where',\n  'window',\n  'with',\n]);\n\nfunction formatUserDefinedTypeName(identifier: string): string {\n  if (\n    UNQUOTED_POSTGRES_IDENTIFIER_PATTERN.test(identifier) &&\n    !POSTGRES_RESERVED_IDENTIFIER_WORDS.has(identifier)\n  ) {\n    return identifier;\n  }\n\n  return quoteIdentifier(identifier);\n}\n\nexport function buildExpectedFormatType(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (resolved.typeParams && resolved.codecId) {\n    const hooks = codecHooks.get(resolved.codecId);\n    if (hooks?.expandNativeType) {\n      return hooks.expandNativeType({\n        nativeType: resolved.nativeType,\n        codecId: resolved.codecId,\n        typeParams: resolved.typeParams,\n      });\n    }\n  }\n\n  if (column.typeRef) {\n    return formatUserDefinedTypeName(resolved.nativeType);\n  }\n\n  return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;\n}\n\nexport function columnTypeCheck({\n  schema,\n  table,\n  column,\n  expectedType,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  expectedType: string;\n}): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM pg_attribute a\n  JOIN pg_class c ON c.oid = a.attrelid\n  JOIN pg_namespace n ON n.oid = c.relnamespace\n  WHERE n.nspname = ${namespace.schemaSqlExpression()}\n    AND c.relname = '${escapeLiteral(table)}'\n    AND a.attname = '${escapeLiteral(column)}'\n    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'\n    AND NOT a.attisdropped\n)`;\n}\n\nexport function columnDefaultExistsCheck({\n  schema,\n  table,\n  column,\n  exists = true,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  exists?: boolean;\n}): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = ${namespace.schemaSqlExpression()}\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n    AND column_default ${nullCheck}\n)`;\n}\n\nexport function tableHasPrimaryKeyCheck(\n  schema: string,\n  table: string,\n  exists: boolean,\n  constraintName?: string,\n): string {\n  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });\n  const comparison = exists ? '' : 'NOT ';\n  const constraintFilter = constraintName\n    ? `AND c2.relname = '${escapeLiteral(constraintName)}'`\n    : '';\n  return `SELECT ${comparison}EXISTS (\n  SELECT 1\n  FROM pg_index i\n  JOIN pg_class c ON c.oid = i.indrelid\n  JOIN pg_namespace n ON n.oid = c.relnamespace\n  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid\n  WHERE n.nspname = ${namespace.schemaSqlExpression()}\n    AND c.relname = '${escapeLiteral(table)}'\n    AND i.indisprimary\n    ${constraintFilter}\n)`;\n}\n"],"mappings":";;;;AAYA,SAAgB,0BACd,QACA,cAC4B;CAC5B,IAAI,CAAC,OAAO,SACV,OAAO;CAGT,MAAM,iBAAiB,aAAa,OAAO;CAC3C,IAAI,CAAC,gBACH,OAAO;CAGT,IAAI,2BAA2B,cAAc,GAO3C,OAAO;EACL,SAAS,eAAe;EACxB,YAAY,eAAe;CAC7B;CAGF,OAAO;EACL,SAAS,eAAe;EACxB,YAAY,eAAe;EAC3B,YAAY,eAAe;CAC7B;AACF;;;;;;;;;;;;;;ACtBA,SAAgB,iBAAiB,QAAgB,OAAuB;CACtE,OAAO,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC,EAAE,aAAa,KAAK;AAC3F;AAEA,SAAgB,kBAAkB,QAAgB,MAAsB;CACtE,OAAO,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC,EAAE,gBAAgB,IAAI;AAC7F;;;;;;AAOA,SAAgB,sBAAsB,EACpC,gBACA,QACA,OACA,SAAS,QAMA;CACT,MAAM,YAAY,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC;CAChF,MAAM,eAAe,SAAS,WAAW;CACzC,MAAM,cAAc,QAChB,gCAAgC,UAAU,gBAAgB,KAAK,EAAE,KACjE;CACJ,OAAO,UAAU,aAAa;;;uBAGT,cAAc,cAAc,EAAE;oBACjC,UAAU,oBAAoB,EAAE;IAChD,YAAY;;AAEhB;AAEA,SAAgB,kBAAkB,EAChC,QACA,OACA,QACA,SAAS,QAMA;CACT,MAAM,YAAY,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC;CAEhF,OAAO,UADc,SAAS,KAAK,OACL;;;yBAGP,UAAU,oBAAoB,EAAE;wBACjC,cAAc,KAAK,EAAE;yBACpB,cAAc,MAAM,EAAE;;AAE/C;AAEA,SAAgB,uBAAuB,EACrC,QACA,OACA,QACA,YAMS;CACT,MAAM,YAAY,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC;CAChF,MAAM,WAAW,WAAW,QAAQ;CACpC,OAAO;;;yBAGgB,UAAU,oBAAoB,EAAE;wBACjC,cAAc,KAAK,EAAE;yBACpB,cAAc,MAAM,EAAE;yBACtB,SAAS;;AAElC;AAEA,SAAgB,kBAAkB,oBAAoC;CACpE,OAAO,oCAAoC,mBAAmB;AAChE;AAEA,SAAgB,wBAAwB,MAI7B;CAET,OAAO;;;yBADW,wBAAwB;EAAE,IAAI,KAAK;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAIrD,EAAE,oBAAoB,EAAE;wBACjC,cAAc,KAAK,KAAK,EAAE;yBACzB,cAAc,KAAK,MAAM,EAAE;;;AAGpD;AAEA,MAAM,sBAAmD,IAAI,IAAI;CAC/D,CAAC,QAAQ,UAAU;CACnB,CAAC,QAAQ,SAAS;CAClB,CAAC,QAAQ,QAAQ;CACjB,CAAC,UAAU,MAAM;CACjB,CAAC,UAAU,kBAAkB;CAC7B,CAAC,QAAQ,SAAS;CAClB,CAAC,aAAa,6BAA6B;CAC3C,CAAC,eAAe,0BAA0B;CAC1C,CAAC,QAAQ,wBAAwB;CACjC,CAAC,UAAU,qBAAqB;AAClC,CAAC;AAED,MAAM,uCAAuC;AAE7C,MAAM,qCAAqC,IAAI,IAAI;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,0BAA0B,YAA4B;CAC7D,IACE,qCAAqC,KAAK,UAAU,KACpD,CAAC,mCAAmC,IAAI,UAAU,GAElD,OAAO;CAGT,OAAO,gBAAgB,UAAU;AACnC;AAEA,SAAgB,wBACd,QACA,YACA,eAA+E,CAAC,GACxE;CACR,MAAM,WAAW,0BAA0B,QAAQ,YAAY;CAE/D,IAAI,SAAS,cAAc,SAAS,SAAS;EAC3C,MAAM,QAAQ,WAAW,IAAI,SAAS,OAAO;EAC7C,IAAI,OAAO,kBACT,OAAO,MAAM,iBAAiB;GAC5B,YAAY,SAAS;GACrB,SAAS,SAAS;GAClB,YAAY,SAAS;EACvB,CAAC;CAEL;CAEA,IAAI,OAAO,SACT,OAAO,0BAA0B,SAAS,UAAU;CAGtD,OAAO,oBAAoB,IAAI,SAAS,UAAU,KAAK,SAAS;AAClE;AAEA,SAAgB,gBAAgB,EAC9B,QACA,OACA,QACA,gBAMS;CAET,OAAO;;;;;sBADW,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAMnD,EAAE,oBAAoB,EAAE;uBAC/B,cAAc,KAAK,EAAE;uBACrB,cAAc,MAAM,EAAE;kDACK,cAAc,YAAY,EAAE;;;AAG9E;AAEA,SAAgB,yBAAyB,EACvC,QACA,OACA,QACA,SAAS,QAMA;CACT,MAAM,YAAY,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC;CAChF,MAAM,YAAY,SAAS,gBAAgB;CAC3C,OAAO;;;yBAGgB,UAAU,oBAAoB,EAAE;wBACjC,cAAc,KAAK,EAAE;yBACpB,cAAc,MAAM,EAAE;yBACtB,UAAU;;AAEnC;AAEA,SAAgB,wBACd,QACA,OACA,QACA,gBACQ;CACR,MAAM,YAAY,wBAAwB;EAAE,IAAI;EAAQ,SAAS,EAAE,OAAO,CAAC,EAAE;CAAE,CAAC;CAChF,MAAM,aAAa,SAAS,KAAK;CACjC,MAAM,mBAAmB,iBACrB,qBAAqB,cAAc,cAAc,EAAE,KACnD;CACJ,OAAO,UAAU,WAAW;;;;;;sBAMR,UAAU,oBAAoB,EAAE;uBAC/B,cAAc,KAAK,EAAE;;MAEtC,iBAAiB;;AAEvB"}

package/dist/planner-sql-checks.mjs

@@ -1,2 +1,2 @@
-import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, i as columnHasNoDefaultCheck, l as tableHasPrimaryKeyCheck, r as columnExistsCheck, s as constraintExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-CfEiTXoQ.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, i as columnHasNoDefaultCheck, l as tableHasPrimaryKeyCheck, r as columnExistsCheck, s as constraintExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-C43dcyOd.mjs";
 export { buildExpectedFormatType, columnExistsCheck, columnHasNoDefaultCheck, columnNullabilityCheck, constraintExistsCheck, qualifyTableName, tableHasPrimaryKeyCheck, tableIsEmptyCheck, toRegclassLiteral };

package/dist/{planner-target-details-a_wuOiYf.d.mts → planner-target-details-Dv5N6x6k.d.mts}

@@ -8,4 +8,4 @@ interface PostgresPlanTargetDetails {
 }
 //#endregion
 export { PostgresPlanTargetDetails as t };
-//# sourceMappingURL=planner-target-details-a_wuOiYf.d.mts.map
+//# sourceMappingURL=planner-target-details-Dv5N6x6k.d.mts.map

package/dist/{planner-target-details-a_wuOiYf.d.mts.map → planner-target-details-Dv5N6x6k.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-target-details-a_wuOiYf.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"mappings":";KAEY,cAAA;AAAA,UAUK,yBAAA;EAAA,SACN,MAAA;EAAA,SACA,UAAA,EAAY,cAAc;EAAA,SAC1B,IAAA;EAAA,SACA,KAAA;AAAA"}
+{"version":3,"file":"planner-target-details-Dv5N6x6k.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"mappings":";KAEY,cAAA;AAAA,UAUK,yBAAA;EAAA,SACN,MAAA;EAAA,SACA,UAAA,EAAY,cAAc;EAAA,SAC1B,IAAA;EAAA,SACA,KAAA;AAAA"}

package/dist/planner-target-details.d.mts

@@ -1,2 +1,2 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-a_wuOiYf.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-Dv5N6x6k.mjs";
 export { type PostgresPlanTargetDetails };

package/dist/planner.d.mts

@@ -1,5 +1,5 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-D02NOhVQ.mjs";
-import { MigrationOperationPolicy, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Co71_VbU.mjs";
+import { MigrationOperationPolicy, SqlPlannerConflict, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
@@ -16,6 +16,7 @@ declare function createPostgresMigrationPlanner(): PostgresMigrationPlanner;
 type PostgresPlanResult = {
   readonly kind: 'success';
   readonly plan: TypeScriptRenderablePostgresMigration;
+  readonly warnings?: readonly SqlPlannerConflict[];
 } | SqlPlannerFailureResult;
 /**
  * Postgres migration planner — a thin wrapper over `planIssues`.

package/dist/planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"mappings":";;;;;;;iBA0CgB,8BAAA,CAAA,GAAkC,wBAAwB;;AAA1E;;;;AAA0E;AAW1E;KAAY,kBAAA;EAAA,SACG,IAAA;EAAA,SAA0B,IAAA,EAAM,qCAAA;AAAA,IAC3C,uBAAuB;;;;;AAAA;AAkB3B;;;;;;;;;;;cAAa,wBAAA,YAAoC,gBAAA;EAC/C,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IADR;;;;;;;;;;;;;;IAAA,SAgBA,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IAyBtC;;;;AA6EmB;IA7EnB,SAnBG,OAAA;EAAA,IACP,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAWK,OAAA;EAAA,QAgEA,oBAAA;EAAA,QAaA,mBAAA;AAAA"}
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"mappings":";;;;;;;iBAsDgB,8BAAA,CAAA,GAAkC,wBAAwB;;AAA1E;;;;AAA0E;AAW1E;KAAY,kBAAA;EAAA,SAEG,IAAA;EAAA,SACA,IAAA,EAAM,qCAAA;EAAA,SACN,QAAA,YAAoB,kBAAA;AAAA,IAE/B,uBAAA;;;;;;;;;;AAAuB;AAkB3B;;;;;;cAAa,wBAAA,YAAoC,gBAAA;EAC/C,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IAJ4C;;;;;;;;;;;;;;IAAA,SAmBpD,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IAW9C;;;;;IAAA,SALW,OAAA;EAAA,IACP,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAWK,OAAA;EAAA,QAkGA,oBAAA;EAAA,QAaA,mBAAA;AAAA"}

package/dist/planner.mjs

@@ -1,2 +1,2 @@
-import { t as createPostgresMigrationPlanner } from "./planner-Bjz5pnLa.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-BRGVWfq4.mjs";
 export { createPostgresMigrationPlanner };