@prisma-next/target-postgres 0.11.0-dev.6 → 0.11.0-dev.7

package/dist/{planner-DZG1dsSW.mjs.map → planner-DlhK35aV.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-DZG1dsSW.mjs","names":[],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["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 projects to `public` (sibling\n * present) or the framework sentinel (sibling absent). Issues are\n * emitted only when the resolved name is a real, creatable schema\n * (not the unbound sentinel) and is missing from the introspected\n * list. `public` is suppressed implicitly because the introspection\n * (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  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\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 { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { readExistingEnumValues } from './enum-planning';\nimport { planIssues } from './issue-planner';\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\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\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  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\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  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n  }): 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 = options.schemaName ?? this.config.defaultSchema;\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    const result = planIssues({\n      issues: schemaIssues,\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-emitted calls already conform to `OpFactoryCall` — render +\n    // toOp + importRequirements ride directly through the same emit path\n    // as structural ops, no `RawSqlCall` wrap.\n    const calls = [...result.value.calls, ...fieldEventOps];\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    });\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      resolveExistingEnumValues: (schema, enumType) =>\n        readExistingEnumValues(schema, enumType.nativeType),\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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"}
+{"version":3,"file":"planner-DlhK35aV.mjs","names":[],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["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 projects to `public` (sibling\n * present) or the framework sentinel (sibling absent). Issues are\n * emitted only when the resolved name is a real, creatable schema\n * (not the unbound sentinel) and is missing from the introspected\n * list. `public` is suppressed implicitly because the introspection\n * (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  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\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 { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { readExistingEnumValues } from './enum-planning';\nimport { planIssues } from './issue-planner';\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\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\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  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\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  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n  }): 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 = options.schemaName ?? this.config.defaultSchema;\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    const result = planIssues({\n      issues: schemaIssues,\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-emitted calls already conform to `OpFactoryCall` — render +\n    // toOp + importRequirements ride directly through the same emit path\n    // as structural ops, no `RawSqlCall` wrap.\n    const calls = [...result.value.calls, ...fieldEventOps];\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    });\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      resolveExistingEnumValues: (schema, enumType) =>\n        readExistingEnumValues(schema, enumType.nativeType),\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-DYMuN0w1.mjs → planner-ddl-builders--0TmW6Ey.mjs}

@@ -1,5 +1,5 @@
 import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-BewXAnsG.mjs";
-import { c as qualifyTableName, f as resolveColumnTypeMetadata } from "./planner-sql-checks-K-mTBJDi.mjs";
+import { c as qualifyTableName, f as resolveColumnTypeMetadata } from "./planner-sql-checks-BDtJQ9WD.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-DYMuN0w1.mjs.map
+//# sourceMappingURL=planner-ddl-builders--0TmW6Ey.mjs.map

package/dist/{planner-ddl-builders-DYMuN0w1.mjs.map → planner-ddl-builders--0TmW6Ey.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-ddl-builders-DYMuN0w1.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--0TmW6Ey.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.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-DYMuN0w1.mjs";
+import { a as buildForeignKeySql, i as buildCreateTableSql, n as buildColumnDefaultSql, o as renderDefaultLiteral, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders--0TmW6Ey.mjs";
 export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, buildForeignKeySql, renderDefaultLiteral };

package/dist/{planner-sql-checks-K-mTBJDi.mjs → planner-sql-checks-BDtJQ9WD.mjs}

@@ -1,5 +1,5 @@
 import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-BewXAnsG.mjs";
-import { i as postgresCreateNamespace } from "./postgres-schema-CK82EuWq.mjs";
+import { i as postgresCreateNamespace } from "./postgres-schema-BL0RAvew.mjs";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 //#region src/core/migrations/planner-type-resolution.ts
 function resolveColumnTypeMetadata(column, storageTypes) {
@@ -258,4 +258,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-K-mTBJDi.mjs.map
+//# sourceMappingURL=planner-sql-checks-BDtJQ9WD.mjs.map

package/dist/{planner-sql-checks-K-mTBJDi.mjs.map → planner-sql-checks-BDtJQ9WD.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-sql-checks-K-mTBJDi.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 }).qualifyTable(table);\n}\n\nexport function toRegclassLiteral(schema: string, name: string): string {\n  return postgresCreateNamespace({ id: schema }).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 });\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 });\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 });\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 });\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 });\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 });\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 });\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":"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"}
+{"version":3,"file":"planner-sql-checks-BDtJQ9WD.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 }).qualifyTable(table);\n}\n\nexport function toRegclassLiteral(schema: string, name: string): string {\n  return postgresCreateNamespace({ id: schema }).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 });\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 });\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 });\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 });\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 });\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 });\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 });\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":"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"}

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-K-mTBJDi.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-BDtJQ9WD.mjs";
 export { buildExpectedFormatType, columnExistsCheck, columnHasNoDefaultCheck, columnNullabilityCheck, constraintExistsCheck, qualifyTableName, tableHasPrimaryKeyCheck, tableIsEmptyCheck, toRegclassLiteral };

package/dist/planner.mjs

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

package/dist/{postgres-contract-serializer-CrET5Ov0.mjs → postgres-contract-serializer-CYct4Y7O.mjs}

@@ -1,5 +1,5 @@
 import { n as postgresAuthoringEntityTypes } from "./descriptor-meta-DLA2xV6B.mjs";
-import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-CK82EuWq.mjs";
+import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-BL0RAvew.mjs";
 import { NamespaceBase, UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { isAuthoringEntityTypeDescriptor } from "@prisma-next/framework-components/authoring";
@@ -45,14 +45,14 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 	}
 	hydrateSqlNamespaceEntry(nsId, raw) {
 		if (raw instanceof NamespaceBase) return raw;
-		const { id, tables, types: hydratedNsTypes } = super.hydrateSqlNamespaceEntry(nsId, raw);
+		const { id, tables, enum: hydratedNsEnums } = super.hydrateSqlNamespaceEntry(nsId, raw);
 		const emptyTables = Object.keys(tables).length === 0;
-		const emptyTypes = !hydratedNsTypes || Object.keys(hydratedNsTypes).length === 0;
-		if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) return PostgresSchema.unbound;
+		const emptyEnums = !hydratedNsEnums || Object.keys(hydratedNsEnums).length === 0;
+		if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyEnums) return PostgresSchema.unbound;
 		return new PostgresSchema({
 			id,
 			tables,
-			...hydratedNsTypes !== void 0 ? { types: hydratedNsTypes } : {}
+			...hydratedNsEnums !== void 0 ? { enum: hydratedNsEnums } : {}
 		});
 	}
 	serializeContract(contract) {
@@ -61,12 +61,12 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 		for (const [nsId, ns] of Object.entries(storage.namespaces)) if (isPostgresSchema(ns)) namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
 		else {
 			const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
-			const nsTypes = ns.types ?? {};
+			const nsEnums = ns.enum ?? {};
 			namespacesJson[nsId] = {
 				id: nsId,
 				kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
 				tables: Object.fromEntries(Object.entries(ns.tables).map(([tableName, table]) => [tableName, this.serializeJsonValue(table)])),
-				types: Object.fromEntries(Object.entries(nsTypes).map(([typeName, entry]) => [typeName, this.serializeJsonValue(entry)]))
+				enum: Object.fromEntries(Object.entries(nsEnums).map(([typeName, entry]) => [typeName, this.serializeJsonValue(entry)]))
 			};
 		}
 		const storageOut = {
@@ -86,13 +86,13 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 	serializePostgresNamespace(ns, isUnboundSlot) {
 		const tablesOut = {};
 		for (const [tableName, table] of Object.entries(ns.tables)) tablesOut[tableName] = this.serializeJsonValue(table);
-		const typesOut = {};
-		for (const [typeName, ty] of Object.entries(ns.types)) typesOut[typeName] = this.serializeJsonValue(ty);
+		const enumOut = {};
+		for (const [typeName, ty] of Object.entries(ns.enum)) enumOut[typeName] = this.serializeJsonValue(ty);
 		return {
 			id: ns.id,
 			kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
 			tables: tablesOut,
-			types: typesOut
+			enum: enumOut
 		};
 	}
 	serializeJsonValue(value) {
@@ -102,4 +102,4 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 //#endregion
 export { PostgresContractSerializer as t };
 
-//# sourceMappingURL=postgres-contract-serializer-CrET5Ov0.mjs.map
+//# sourceMappingURL=postgres-contract-serializer-CYct4Y7O.mjs.map

package/dist/postgres-contract-serializer-CYct4Y7O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-contract-serializer-CYct4Y7O.mjs","names":[],"sources":["../src/core/postgres-contract-serializer.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  SqlContractSerializerBase,\n  type SqlEntityHydrationFactory,\n} from '@prisma-next/family-sql/ir';\nimport {\n  type AuthoringEntityContext,\n  type AuthoringEntityTypeFactoryOutput,\n  type AuthoringEntityTypeNamespace,\n  isAuthoringEntityTypeDescriptor,\n} from '@prisma-next/framework-components/authoring';\nimport {\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type {\n  SqlNamespaceTablesInput,\n  SqlStorage,\n  SqlStorageTypeEntry,\n  StorageTable,\n} from '@prisma-next/sql-contract/types';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport type { Type } from 'arktype';\nimport { postgresAuthoringEntityTypes } from './authoring';\nimport type { PostgresEnumType } from './postgres-enum-type';\nimport { isPostgresSchema, PostgresSchema } from './postgres-schema';\n\nconst POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {\n  family: 'sql',\n  target: 'postgres',\n};\n\nfunction isAuthoringEntityTypeFactoryOutput(\n  output: unknown,\n): output is AuthoringEntityTypeFactoryOutput<unknown, unknown> {\n  return (\n    typeof output === 'object' &&\n    output !== null &&\n    typeof (output as AuthoringEntityTypeFactoryOutput).factory === 'function'\n  );\n}\n\n/**\n * Walks a pack's entity-type namespace tree and emits the maps the\n * family base consumes — hydrators and validator-schema fragments, both\n * keyed by the descriptor's `discriminator`.\n */\nfunction collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamespace): {\n  readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>;\n  readonly validatorFragments: ReadonlyMap<string, Type<unknown>>;\n} {\n  const entityTypeRegistry = new Map<string, SqlEntityHydrationFactory>();\n  const validatorFragments = new Map<string, Type<unknown>>();\n  const walk = (node: AuthoringEntityTypeNamespace): void => {\n    for (const value of Object.values(node)) {\n      if (isAuthoringEntityTypeDescriptor(value)) {\n        if (isAuthoringEntityTypeFactoryOutput(value.output)) {\n          const { factory } = value.output;\n          entityTypeRegistry.set(\n            value.discriminator,\n            (raw) => factory(raw, POSTGRES_AUTHORING_CTX) as SqlStorageTypeEntry,\n          );\n        }\n        if (value.validatorSchema !== undefined) {\n          validatorFragments.set(value.discriminator, value.validatorSchema);\n        }\n        continue;\n      }\n      if (typeof value === 'object' && value !== null) {\n        walk(value);\n      }\n    }\n  };\n  walk(namespace);\n  return { entityTypeRegistry, validatorFragments };\n}\n\nexport class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    const { entityTypeRegistry, validatorFragments } = collectEntityRegistryContributions(\n      postgresAuthoringEntityTypes,\n    );\n    super(entityTypeRegistry, validatorFragments);\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const hydrated = super.hydrateSqlNamespaceEntry(nsId, raw) as {\n      id: string;\n      tables: Readonly<Record<string, StorageTable>>;\n      enum?: Readonly<Record<string, PostgresEnumType>>;\n    };\n    const { id, tables, enum: hydratedNsEnums } = hydrated;\n\n    const emptyTables = Object.keys(tables).length === 0;\n    const emptyEnums = !hydratedNsEnums || Object.keys(hydratedNsEnums).length === 0;\n    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyEnums) {\n      return PostgresSchema.unbound;\n    }\n    return new PostgresSchema({\n      id,\n      tables,\n      ...(hydratedNsEnums !== undefined ? { enum: hydratedNsEnums } : {}),\n    });\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      if (isPostgresSchema(ns)) {\n        namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);\n      } else {\n        // Family-level SqlNamespacePayload / SqlUnboundNamespace haven't\n        // been promoted to a PostgresSchema instance yet (e.g. they came\n        // straight from the TS builder, which uses the family-shared\n        // SqlStorage constructor). Serialise them as postgres-schema /\n        // postgres-unbound-schema so the round-trip through\n        // deserializeContract hydrates them back into PostgresSchema\n        // instances.\n        const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;\n        const nsEnums = (ns as { readonly enum?: Readonly<Record<string, unknown>> }).enum ?? {};\n        namespacesJson[nsId] = {\n          id: nsId,\n          kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n          tables: Object.fromEntries(\n            Object.entries(ns.tables).map(([tableName, table]) => [\n              tableName,\n              this.serializeJsonValue(table) as JsonObject,\n            ]),\n          ),\n          enum: Object.fromEntries(\n            Object.entries(nsEnums).map(([typeName, entry]) => [\n              typeName,\n              this.serializeJsonValue(entry) as JsonObject,\n            ]),\n          ),\n        };\n      }\n    }\n    const storageOut: Record<string, unknown> = {\n      storageHash: String(storage.storageHash),\n      namespaces: namespacesJson,\n    };\n    if (storage.types !== undefined) {\n      const typesOut: Record<string, JsonObject> = {};\n      for (const [name, entry] of Object.entries(storage.types)) {\n        typesOut[name] = this.serializeJsonValue(entry) as JsonObject;\n      }\n      storageOut['types'] = typesOut;\n    }\n    return {\n      ...rest,\n      storage: storageOut,\n    } as unknown as JsonObject;\n  }\n\n  private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {\n    const tablesOut: Record<string, JsonObject> = {};\n    for (const [tableName, table] of Object.entries(ns.tables)) {\n      tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;\n    }\n    const enumOut: Record<string, JsonObject> = {};\n    for (const [typeName, ty] of Object.entries(ns.enum)) {\n      enumOut[typeName] = this.serializeJsonValue(ty) as JsonObject;\n    }\n    return {\n      id: ns.id,\n      kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n      tables: tablesOut,\n      enum: enumOut,\n    };\n  }\n\n  private serializeJsonValue(value: unknown): unknown {\n    return JSON.parse(JSON.stringify(value)) as unknown;\n  }\n}\n"],"mappings":"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"}

package/dist/{postgres-schema-CK82EuWq.mjs → postgres-schema-BL0RAvew.mjs}

@@ -27,12 +27,12 @@ var PostgresSchema = class extends NamespaceBase {
 	static unbound;
 	id;
 	tables;
-	types;
+	enum;
 	constructor(input) {
 		super();
 		this.id = input.id;
 		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables ?? {}).map(([name, t]) => [name, t instanceof StorageTable ? t : new StorageTable(t)])));
-		this.types = Object.freeze(Object.fromEntries(Object.entries(input.types ?? {}).map(([name, ty]) => [name, ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty)])));
+		this.enum = Object.freeze(Object.fromEntries(Object.entries(input.enum ?? {}).map(([name, ty]) => [name, ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty)])));
 		Object.defineProperty(this, "kind", {
 			value: "schema",
 			writable: false,
@@ -165,4 +165,4 @@ function postgresCreateNamespace(input) {
 //#endregion
 export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
 
-//# sourceMappingURL=postgres-schema-CK82EuWq.mjs.map
+//# sourceMappingURL=postgres-schema-BL0RAvew.mjs.map

package/dist/postgres-schema-BL0RAvew.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-BL0RAvew.mjs","names":[],"sources":["../src/core/postgres-schema.ts"],"sourcesContent":["import {\n  freezeNode,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  type SqlStorage,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { escapeLiteral } from './sql-utils';\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly tables?: Record<string, StorageTable | StorageTableInput>;\n  readonly enum?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * Qualifier emission is the rendering seam: DDL / SQL emission asks the\n * namespace for its qualifier (`\"<schema>\"`) or for a qualified table\n * name (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends NamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  declare readonly kind: 'schema';\n  readonly id: string;\n  readonly tables: Readonly<Record<string, StorageTable>>;\n  readonly enum: Readonly<Record<string, PostgresEnumType>>;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables ?? {}).map(([name, t]) => [\n          name,\n          t instanceof StorageTable ? t : new StorageTable(t),\n        ]),\n      ),\n    );\n    this.enum = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.enum ?? {}).map(([name, ty]) => [\n          name,\n          ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty),\n        ]),\n      ),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: 'schema',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id; the unbound singleton overrides this to project\n   * to `'public'` when a sibling public namespace exists in the same\n   * contract — and falls back to the framework sentinel otherwise so\n   * the planner can detect the missing-projection case explicitly.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n\n  /**\n   * The unbound slot has no schema name of its own, so DDL emission\n   * projects it onto a sibling when one is available: if the contract\n   * carries a `public` namespace, the late-bound slot resolves to\n   * `'public'` (the default Postgres landing schema); otherwise it\n   * resolves to the framework sentinel `UNBOUND_NAMESPACE_ID` so the\n   * planner can recognise the unprojected case and route accordingly\n   * (e.g. emit a conflict instead of silently picking a schema).\n   */\n  override ddlSchemaName(storage: SqlStorage): string {\n    if (storage.namespaces['public'] !== undefined) {\n      return 'public';\n    }\n    return UNBOUND_NAMESPACE_ID;\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set.\n */\nexport function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(input);\n  }\n  return new PostgresSchema(input);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiCA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAGP;CACA;CACA;CAEA,YAAY,OAA4B;EACtC,OAAO;EACP,KAAK,KAAK,MAAM;EAChB,KAAK,SAAS,OAAO,OACnB,OAAO,YACL,OAAO,QAAQ,MAAM,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,OAAO,CACpD,MACA,aAAa,eAAe,IAAI,IAAI,aAAa,EAAE,CACpD,CAAC,CACH,CACF;EACD,KAAK,OAAO,OAAO,OACjB,OAAO,YACL,OAAO,QAAQ,MAAM,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,QAAQ,CACnD,MACA,cAAc,mBAAmB,KAAK,IAAI,iBAAiB,GAAG,CAC/D,CAAC,CACH,CACF;EACD,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;GACf,CAAC;EACF,WAAW,KAAK;;;;;;;CAQlB,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;;;;;;;;CASrB,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;;;;;;;;CASpC,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,KAAK,CAAC,CAAC;;;;;;;;;;CAWpD,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,GAAG,CAAC;;;;;;;;;;;;CAapC,cAAc,UAA8B;EAC1C,OAAO,KAAK;;;;;;;;;;;;;;;;;AAkBhB,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,uBAAuB;CAE7E,YAAY,OAA6B;EACvC,MAAM,SAAS,EAAE,IAAI,sBAAsB,CAAC;;CAG9C,YAA6B;EAC3B,OAAO;;CAGT,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;;CAGvB,sBAAuC;EACrC,OAAO;;;;;;;;;;;CAYT,cAAuB,SAA6B;EAClD,IAAI,QAAQ,WAAW,cAAc,KAAA,GACnC,OAAO;EAET,OAAO;;;AAIX,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;;;;;;;;;;;;;AAcjE,SAAgB,wBAAwB,OAAgD;CACtF,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,MAAM;CAEzC,OAAO,IAAI,eAAe,MAAM"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DLA2xV6B.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CrET5Ov0.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CYct4Y7O.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/{tables-CWxZgD0H.mjs → tables-Vhh4k5yz.mjs}

@@ -1,5 +1,5 @@
 import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName } from "./sql-utils-BewXAnsG.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, n as columnDefaultExistsCheck, o as columnTypeCheck, r as columnExistsCheck, s as constraintExistsCheck } from "./planner-sql-checks-K-mTBJDi.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, n as columnDefaultExistsCheck, o as columnTypeCheck, r as columnExistsCheck, s as constraintExistsCheck } from "./planner-sql-checks-BDtJQ9WD.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 //#region src/core/migrations/operations/shared.ts
 function step(description, sql) {
@@ -513,4 +513,4 @@ function dropTable(schemaName, tableName) {
 //#endregion
 export { setNotNull as S, alterColumnType as _, addEnumValues as a, dropNotNull as b, renameType as c, installExtension as d, addForeignKey as f, addColumn as g, dropConstraint as h, dropIndex as i, createExtension as l, addUnique as m, dropTable as n, createEnumType as o, addPrimaryKey as p, createIndex as r, dropEnumType as s, createTable as t, createSchema as u, dropColumn as v, setDefault as x, dropDefault as y };
 
-//# sourceMappingURL=tables-CWxZgD0H.mjs.map
+//# sourceMappingURL=tables-Vhh4k5yz.mjs.map