@prisma-next/target-postgres 0.13.0-dev.28 → 0.13.0-dev.29

package/dist/{postgres-migration-DF5ApLqQ.mjs → postgres-migration-dG-J0aI8.mjs}

@@ -1,4 +1,4 @@
-import { d as CreateSchemaCall, f as CreateTableCall, n as AddColumnCall } from "./op-factory-call-CHvtj70z.mjs";
+import { l as CreateSchemaCall, n as AddColumnCall, u as CreateTableCall } from "./op-factory-call-CjR846f7.mjs";
 import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
 import { t as dataTransform } from "./data-transform-BOWpliq8.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
@@ -72,4 +72,4 @@ var PostgresMigration = class extends Migration {
 //#endregion
 export { PostgresMigration as t };
 
-//# sourceMappingURL=postgres-migration-DF5ApLqQ.mjs.map
+//# sourceMappingURL=postgres-migration-dG-J0aI8.mjs.map

package/dist/{postgres-migration-DF5ApLqQ.mjs.map → postgres-migration-dG-J0aI8.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration-DF5ApLqQ.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { AddColumnCall, CreateSchemaCall, CreateTableCall } from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema?: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateTableCall(\n      options.schema ?? UNBOUND_NAMESPACE_ID,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);\n  }\n\n  protected addColumn(options: {\n    readonly schema?: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddColumnCall(\n      options.schema ?? UNBOUND_NAMESPACE_ID,\n      options.table,\n      options.column,\n    ).toOp(this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAyC;EACnD,MAAM,KAAK;EAIX,KAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,KAAK,IAC3B,KAAA;CACN;;;;;;CAOA,cACE,UACA,MACA,SAC+D;EAC/D,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,cAAc;CACnE;;;;;;CAOA,YAAsB,SAM4C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,gBACT,QAAQ,UAAU,sBAClB,QAAQ,OACR,QAAQ,SACR,QAAQ,WACV,CAAC,CAAC,KAAK,KAAK,cAAc;CAC5B;;;;;;CAOA,aAAuB,SAG2C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,iBAAiB,QAAQ,MAAM,CAAC,CAAC,KAAK,KAAK,cAAc;CACtE;CAEA,UAAoB,SAI8C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,cACT,QAAQ,UAAU,sBAClB,QAAQ,OACR,QAAQ,MACV,CAAC,CAAC,KAAK,KAAK,cAAc;CAC5B;AACF"}
+{"version":3,"file":"postgres-migration-dG-J0aI8.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { AddColumnCall, CreateSchemaCall, CreateTableCall } from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema?: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateTableCall(\n      options.schema ?? UNBOUND_NAMESPACE_ID,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);\n  }\n\n  protected addColumn(options: {\n    readonly schema?: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddColumnCall(\n      options.schema ?? UNBOUND_NAMESPACE_ID,\n      options.table,\n      options.column,\n    ).toOp(this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAyC;EACnD,MAAM,KAAK;EAIX,KAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,KAAK,IAC3B,KAAA;CACN;;;;;;CAOA,cACE,UACA,MACA,SAC+D;EAC/D,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,cAAc;CACnE;;;;;;CAOA,YAAsB,SAM4C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,gBACT,QAAQ,UAAU,sBAClB,QAAQ,OACR,QAAQ,SACR,QAAQ,WACV,CAAC,CAAC,KAAK,KAAK,cAAc;CAC5B;;;;;;CAOA,aAAuB,SAG2C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,iBAAiB,QAAQ,MAAM,CAAC,CAAC,KAAK,KAAK,cAAc;CACtE;CAEA,UAAoB,SAI8C;EAChE,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,cACT,QAAQ,UAAU,sBAClB,QAAQ,OACR,QAAQ,MACV,CAAC,CAAC,KAAK,KAAK,cAAc;CAC5B;AACF"}

package/dist/{postgres-schema-C7c9rhGk.mjs → postgres-schema-CTKYiTHu.mjs}

@@ -1,4 +1,3 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
 import { n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -11,7 +10,7 @@ import { StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
 * the Postgres PSL interpreter from `namespace { … }` AST buckets.
 *
-* `entries` holds entity-kind maps (`table`, `type`). Qualifier
+* `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
 * emission is the rendering seam: DDL / SQL emission asks the namespace
 * for its qualifier (`"<schema>"`) or for a qualified table name
 * (`"<schema>"."<table>"`) and consumes the result polymorphically.
@@ -35,16 +34,11 @@ var PostgresSchema = class extends NamespaceBase {
 		this.id = input.id;
 		const carried = {};
 		let table = Object.freeze({});
-		let type = Object.freeze({});
 		let valueSet;
 		for (const [kind, rawMap] of Object.entries(input.entries)) if (kind === "table") {
 			const tableMap = {};
 			for (const [name, v] of Object.entries(blindCast(rawMap))) tableMap[name] = new StorageTable(v);
 			table = Object.freeze(tableMap);
-		} else if (kind === "type") {
-			const typeMap = {};
-			for (const [name, v] of Object.entries(blindCast(rawMap))) typeMap[name] = new PostgresEnumType(v);
-			type = Object.freeze(typeMap);
 		} else if (kind === "valueSet") {
 			const vsMap = {};
 			for (const [name, v] of Object.entries(blindCast(rawMap))) vsMap[name] = new StorageValueSet(v);
@@ -53,7 +47,6 @@ var PostgresSchema = class extends NamespaceBase {
 		this.entries = Object.freeze({
 			...carried,
 			table,
-			type,
 			...ifDefined("valueSet", valueSet)
 		});
 		Object.defineProperty(this, "kind", {
@@ -65,13 +58,10 @@ var PostgresSchema = class extends NamespaceBase {
 		freezeNode(this);
 	}
 	get table() {
-		return this.entries.table ?? Object.freeze({});
-	}
-	get type() {
-		return this.entries.type ?? Object.freeze({});
+		return this.entries["table"] ?? Object.freeze({});
 	}
 	get valueSet() {
-		return this.entries.valueSet;
+		return this.entries["valueSet"];
 	}
 	/**
 	* The bare schema qualifier as it would appear in a rendered SQL
@@ -149,10 +139,7 @@ var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	constructor(input) {
 		super(input ?? {
 			id: UNBOUND_NAMESPACE_ID,
-			entries: {
-				table: {},
-				type: {}
-			}
+			entries: { table: {} }
 		});
 	}
 	qualifier() {
@@ -189,13 +176,12 @@ function isPostgresSchema(ns) {
 * by reference and trust the resulting `SqlStorage.namespaces` map to
 * be value-stable for a given input set.
 */
-function postgresCreateNamespace(input, enumTypes) {
+function postgresCreateNamespace(input) {
 	const schemaInput = {
 		id: input.id,
 		entries: {
 			...input.entries,
-			table: input.entries["table"] ?? {},
-			type: blindCast(enumTypes ?? {})
+			table: input.entries["table"] ?? {}
 		}
 	};
 	if (input.id === UNBOUND_NAMESPACE_ID) return new PostgresUnboundSchema(schemaInput);
@@ -204,4 +190,4 @@ function postgresCreateNamespace(input, enumTypes) {
 //#endregion
 export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
 
-//# sourceMappingURL=postgres-schema-C7c9rhGk.mjs.map
+//# sourceMappingURL=postgres-schema-CTKYiTHu.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-CTKYiTHu.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  StorageValueSet,\n  type StorageValueSetInput,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { escapeLiteral } from './sql-utils';\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\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 * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier\n * emission is the rendering seam: DDL / SQL emission asks the namespace\n * for its qualifier (`\"<schema>\"`) or for a qualified table name\n * (`\"<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 entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const carried: Record<string, Readonly<Record<string, unknown>>> = {};\n    let table: Readonly<Record<string, StorageTable>> = Object.freeze({});\n    let valueSet: Readonly<Record<string, StorageValueSet>> | undefined;\n    for (const [kind, rawMap] of Object.entries(input.entries)) {\n      if (kind === 'table') {\n        const tableMap: Record<string, StorageTable> = {};\n        for (const [name, v] of Object.entries(\n          blindCast<\n            Record<string, StorageTableInput>,\n            'entries[table] holds StorageTableInput by construction'\n          >(rawMap),\n        )) {\n          tableMap[name] = new StorageTable(v);\n        }\n        table = Object.freeze(tableMap);\n      } else if (kind === 'valueSet') {\n        const vsMap: Record<string, StorageValueSet> = {};\n        for (const [name, v] of Object.entries(\n          blindCast<\n            Record<string, StorageValueSetInput>,\n            'entries[valueSet] holds StorageValueSetInput by construction'\n          >(rawMap),\n        )) {\n          vsMap[name] = new StorageValueSet(v);\n        }\n        if (Object.keys(vsMap).length > 0) {\n          valueSet = Object.freeze(vsMap);\n        }\n      } else {\n        carried[kind] = Object.freeze(rawMap);\n      }\n    }\n\n    this.entries = Object.freeze({\n      ...carried,\n      table,\n      ...ifDefined('valueSet', valueSet),\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  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries['table'] ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries['valueSet'] as Readonly<Record<string, StorageValueSet>> | undefined;\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 `PostgresUnboundSchema` singleton inherits\n   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch\n   * through `qualifyTableName` / `toRegclassLiteral` route through the\n   * polymorphic `PostgresUnboundSchema` overrides and produce\n   * unqualified (search-path-resolved) output automatically.\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 *\n * `ddlSchemaName` is inherited from `PostgresSchema` and returns\n * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,\n * `toRegclassLiteral`) route through the polymorphic factory and\n * produce unqualified output automatically.\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, entries: { table: {} } });\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\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  const schemaInput: PostgresSchemaInput = {\n    id: input.id,\n    entries: {\n      ...input.entries,\n      table: input.entries['table'] ?? {},\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAGP;CACA;CAEA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAEhB,MAAM,UAA6D,CAAC;EACpE,IAAI,QAAgD,OAAO,OAAO,CAAC,CAAC;EACpE,IAAI;EACJ,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,MAAM,OAAO,GACvD,IAAI,SAAS,SAAS;GACpB,MAAM,WAAyC,CAAC;GAChD,KAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAC7B,UAGE,MAAM,CACV,GACE,SAAS,QAAQ,IAAI,aAAa,CAAC;GAErC,QAAQ,OAAO,OAAO,QAAQ;EAChC,OAAO,IAAI,SAAS,YAAY;GAC9B,MAAM,QAAyC,CAAC;GAChD,KAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAC7B,UAGE,MAAM,CACV,GACE,MAAM,QAAQ,IAAI,gBAAgB,CAAC;GAErC,IAAI,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,GAC9B,WAAW,OAAO,OAAO,KAAK;EAElC,OACE,QAAQ,QAAQ,OAAO,OAAO,MAAM;EAIxC,KAAK,UAAU,OAAO,OAAO;GAC3B,GAAG;GACH;GACA,GAAG,UAAU,YAAY,QAAQ;EACnC,CAAC;EACD,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;CAEA,IAAI,QAAgD;EAClD,OAAO,KAAK,QAAQ,YAAY,OAAO,OAAO,CAAC,CAAC;CAClD;CAEA,IAAI,WAAkE;EACpE,OAAO,KAAK,QAAQ;CACtB;;;;;;CAOA,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;CACrB;;;;;;;CAQA,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;CACpC;;;;;;;CAQA,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,IAAI,CAAC,EAAE;CACpD;;;;;;;;;CAUA,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,EAAE,EAAE;CACpC;;;;;;;;;;;;CAaA,cAAc,UAA8B;EAC1C,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,YAAY,OAA6B;EACvC,MAAM,SAAS;GAAE,IAAI;GAAsB,SAAS,EAAE,OAAO,CAAC,EAAE;EAAE,CAAC;CACrE;CAEA,YAA6B;EAC3B,OAAO;CACT;CAEA,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;CACvB;CAEA,sBAAuC;EACrC,OAAO;CACT;AACF;AAEA,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;AACjE;;;;;;;;;;;;AAaA,SAAgB,wBAAwB,OAAgD;CACtF,MAAM,cAAmC;EACvC,IAAI,MAAM;EACV,SAAS;GACP,GAAG,MAAM;GACT,OAAO,MAAM,QAAQ,YAAY,CAAC;EACpC;CACF;CACA,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,WAAW;CAE9C,OAAO,IAAI,eAAe,WAAW;AACvC"}

package/dist/runtime.d.mts

@@ -8,9 +8,7 @@ import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  private readonly enumFactory;
   constructor();
-  protected hydrateEntriesKind(key: string, innerMap: unknown): Record<string, unknown> | undefined;
   protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
   serializeContract(contract: Contract<SqlStorage>): JsonObject;
   private serializePostgresNamespace;

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cA6Ea,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;EAAA,iBAChE,WAAA;;YAQE,kBAAA,CACjB,GAAA,UACA,QAAA,YACC,MAAA;EAAA,UAmBgB,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA0CN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAuCpD,0BAAA;EAAA,QA8BA,kBAAA;AAAA;;;UCrNO,6BAAA,SAAsC,qBAAqB;;;;;ADoE5E;;cC5DM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAiEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;YAM9D,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA0BN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAuCpD,0BAAA;EAAA,QAyBA,kBAAA;AAAA;;;UC3JO,6BAAA,SAAsC,qBAAqB;;;;;ADwD5E;;cChDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-BToWdas9.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CTxVcCVW.mjs";
+import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-e5f2tscJ.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CyAe8ZFv.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/types.d.mts

@@ -1,27 +1,8 @@
-import { n as PostgresEnumTypeInput, t as PostgresEnumType } from "./postgres-enum-type-BVn63a89.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
 import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { PostgresEnumStorageEntry, SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
+import { SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 
-//#region src/core/postgres-enum-type-schema.d.ts
-/**
- * Arktype validator for a `postgres-enum` entry under
- * `storage.namespaces[id].entries.type[name]`. Registered by the Postgres
- * target pack against the `'type'` entries key so the family-layer namespace
- * validator accepts (and rejects) entries of this kind.
- */
-declare const PostgresEnumTypeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-  kind: "postgres-enum";
-  values: readonly string[];
-  name?: string;
-  nativeType?: string;
-  control?: "managed" | "tolerated" | "external" | "observed";
-}, {}>;
-//#endregion
 //#region src/core/postgres-schema.d.ts
-type PostgresNamespaceEntries = SqlNamespaceEntries & {
-  readonly type?: Readonly<Record<string, PostgresEnumType>>;
-};
 interface PostgresSchemaInput {
   readonly id: string;
   readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -32,7 +13,7 @@ interface PostgresSchemaInput {
  * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
  * the Postgres PSL interpreter from `namespace { … }` AST buckets.
  *
- * `entries` holds entity-kind maps (`table`, `type`). Qualifier
+ * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
  * emission is the rendering seam: DDL / SQL emission asks the namespace
  * for its qualifier (`"<schema>"`) or for a qualified table name
  * (`"<schema>"."<table>"`) and consumes the result polymorphically.
@@ -51,10 +32,9 @@ declare class PostgresSchema extends NamespaceBase {
   static unbound: PostgresUnboundSchema;
   readonly kind: 'schema';
   readonly id: string;
-  readonly entries: PostgresNamespaceEntries;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
   constructor(input: PostgresSchemaInput);
   get table(): Readonly<Record<string, StorageTable>>;
-  get type(): Readonly<Record<string, PostgresEnumType>>;
   get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
@@ -135,7 +115,7 @@ declare class PostgresUnboundSchema extends PostgresSchema {
  * by reference and trust the resulting `SqlStorage.namespaces` map to
  * be value-stable for a given input set.
  */
-declare function postgresCreateNamespace(input: SqlNamespaceTablesInput, enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>): PostgresSchema;
+declare function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema;
 //#endregion
-export { type PostgresColumnDefault, PostgresEnumType, type PostgresEnumTypeInput, PostgresEnumTypeSchema, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+export { type PostgresColumnDefault, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-enum-type-schema.ts","../src/core/postgres-schema.ts"],"mappings":";;;;;;;;;;;;cAUa,sBAAA,gDAAsB,UAAA;;;;;;;;;KCUvB,wBAAA,GAA2B,mBAAA;EAAA,SAC5B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,gBAAA;AAAA;AAAA,UAGzB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;AANrD;;;cAuBa,cAAA,SAAuB,aAAA;EAtBM;;;;;;;EAAA,OA8BjC,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,wBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IAgEf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,IAAA,IAAQ,QAAA,CAAS,MAAA,SAAe,gBAAA;EAAA,IAIhC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAvGW;;;;;EAgHnD,SAAA;EAjHS;;;;;;EA2HT,YAAA,CAAa,SAAA;EA1H4C;AAiB3D;;;;;EAmHE,eAAA,CAAgB,IAAA;EArCqB;;;;;;;;EAiDrC,mBAAA;EAewB;;;;;;;;;;;EAAxB,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAwBb,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;;AAAmB;AA+B9B;;;iBAAgB,uBAAA,CACd,KAAA,EAAO,uBAAA,EACP,SAAA,GAAY,QAAA,CAAS,MAAA,SAAe,wBAAA,KACnC,cAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;UAiBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAjBuB;AAiB3D;;;;;;EAjB2D,OAyBlD,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;cAEvC,KAAA,EAAO,mBAAA;EAAA,IAmDf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAAf;;;;;EASzB,SAAA;EA9EkC;;;;;;EAwFlC,YAAA,CAAa,SAAA;EA5Ec;;;;;;EAsF3B,eAAA,CAAgB,IAAA;EAjCH;;;;;;;;EA6Cb,mBAAA;EAtBa;;;;;;;;AAqCqB;AAwBpC;;EAxBE,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;;;;;AAuCI;AA+B9B;;;cA9Ca,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;;;;;;iBA+BK,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/types.mjs

@@ -1,4 +1,2 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
-import { t as PostgresEnumTypeSchema } from "./postgres-enum-type-schema-DZBTtvBF.mjs";
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-C7c9rhGk.mjs";
-export { PostgresEnumType, PostgresEnumTypeSchema, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-CTKYiTHu.mjs";
+export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.13.0-dev.28",
+  "version": "0.13.0-dev.29",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.28",
-    "@prisma-next/contract": "0.13.0-dev.28",
-    "@prisma-next/errors": "0.13.0-dev.28",
-    "@prisma-next/family-sql": "0.13.0-dev.28",
-    "@prisma-next/framework-components": "0.13.0-dev.28",
-    "@prisma-next/migration-tools": "0.13.0-dev.28",
-    "@prisma-next/ts-render": "0.13.0-dev.28",
-    "@prisma-next/sql-contract": "0.13.0-dev.28",
-    "@prisma-next/sql-errors": "0.13.0-dev.28",
-    "@prisma-next/sql-operations": "0.13.0-dev.28",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.28",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.28",
-    "@prisma-next/utils": "0.13.0-dev.28",
+    "@prisma-next/cli": "0.13.0-dev.29",
+    "@prisma-next/contract": "0.13.0-dev.29",
+    "@prisma-next/errors": "0.13.0-dev.29",
+    "@prisma-next/family-sql": "0.13.0-dev.29",
+    "@prisma-next/framework-components": "0.13.0-dev.29",
+    "@prisma-next/migration-tools": "0.13.0-dev.29",
+    "@prisma-next/ts-render": "0.13.0-dev.29",
+    "@prisma-next/sql-contract": "0.13.0-dev.29",
+    "@prisma-next/sql-errors": "0.13.0-dev.29",
+    "@prisma-next/sql-operations": "0.13.0-dev.29",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.29",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.29",
+    "@prisma-next/utils": "0.13.0-dev.29",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.28",
-    "@prisma-next/tsconfig": "0.13.0-dev.28",
-    "@prisma-next/tsdown": "0.13.0-dev.28",
+    "@prisma-next/test-utils": "0.13.0-dev.29",
+    "@prisma-next/tsconfig": "0.13.0-dev.29",
+    "@prisma-next/tsdown": "0.13.0-dev.29",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -53,7 +53,6 @@
     "./data-transform": "./dist/data-transform.mjs",
     "./ddl": "./dist/ddl.mjs",
     "./default-normalizer": "./dist/default-normalizer.mjs",
-    "./enum-planning": "./dist/enum-planning.mjs",
     "./errors": "./dist/errors.mjs",
     "./issue-planner": "./dist/issue-planner.mjs",
     "./migration": "./dist/migration.mjs",

package/src/core/authoring.ts

@@ -4,53 +4,10 @@ import type {
   AuthoringFieldNamespace,
   AuthoringTypeNamespace,
 } from '@prisma-next/framework-components/authoring';
-import type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';
-import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
-import { PostgresEnumTypeSchema } from './postgres-enum-type-schema';
 
 export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
 
-/**
- * Entity type contributions surface as top-level helpers on the
- * composed-helpers shape (e.g. `helpers.enum({...})`), flattened
- * alongside the built-in `model` / `rel` helpers. Pack contributions
- * still ship via the contribution data structure
- * `authoring.entityTypes.<name>`; the composed-helpers template
- * performs the rename in the type system.
- *
- * `enum` is the first real consumer of the entities-namespace mechanism:
- * the factory constructs a `PostgresEnumType` IR-class instance from
- * the user-supplied input. Both authoring runtimes (TS DSL and PSL)
- * dispatch through this single contribution — PSL `enum Status { … }`
- * declarations are lowered by the interpreter into a factory call
- * with the parsed name + value list; TS DSL `helpers.enum({...})`
- * resolves through the same path. Removing this contribution makes
- * both surfaces fail with a "no entity helper named `enum`" type
- * error at the contract-definition site.
- */
-/**
- * The factory constructs a `PostgresEnumType` instance natively — the
- * `SqlStorage.types` slot accepts polymorphic IR (the framework
- * `StorageType` alphabet), so no cast is needed at the contribution
- * surface. The declared return type is the structural
- * `PostgresEnumStorageEntry` so the inferred contract type stays
- * portable (it names a type exported from
- * `@prisma-next/sql-contract/types`, a public surface every consumer
- * already imports). Sharpening the inferred contract type to surface
- * enum-specific narrowing through `EntityHelperFunction` is a
- * separable refinement and lives outside this PR.
- */
-export const postgresAuthoringEntityTypes = {
-  enum: {
-    kind: 'entity',
-    discriminator: 'postgres-enum',
-    validatorSchema: PostgresEnumTypeSchema,
-    output: {
-      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>
-        new PostgresEnumType(input),
-    },
-  },
-} as const satisfies AuthoringEntityTypeNamespace;
+export const postgresAuthoringEntityTypes = {} as const satisfies AuthoringEntityTypeNamespace;
 
 /**
  * Field presets contributed by the Postgres target pack.

package/src/core/codec-helpers.ts

@@ -109,23 +109,6 @@ export const pgIntervalDecode = (wire: string | Record<string, unknown>): string
   return JSON.stringify(wire);
 };
 
-export const pgEnumRenderOutputType = (typeParams: {
-  readonly values?: readonly unknown[];
-}): string => {
-  const values = typeParams.values;
-  if (!Array.isArray(values)) {
-    throw new Error(
-      `renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`,
-    );
-  }
-  if (!values.every((v): v is string => typeof v === 'string')) {
-    throw new Error(`renderOutputType: expected string[] "values" in typeParams for enum`);
-  }
-  return values
-    .map((value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
-    .join(' | ');
-};
-
 export const pgJsonEncode = (value: string | JsonValue): string => JSON.stringify(value);
 export const pgJsonDecode = (wire: string | JsonValue): JsonValue =>
   typeof wire === 'string' ? JSON.parse(wire) : wire;

package/src/core/codec-ids.ts

@@ -8,7 +8,6 @@ export {
 } from '@prisma-next/sql-relational-core/ast';
 export const PG_TEXT_CODEC_ID = 'pg/text@1' as const;
 export const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;
-export const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;
 export const PG_CHAR_CODEC_ID = 'pg/char@1' as const;
 export const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;
 export const PG_INT_CODEC_ID = 'pg/int@1' as const;

package/src/core/codec-type-map.ts

@@ -21,7 +21,6 @@ import {
   pgBoolDescriptor,
   pgByteaDescriptor,
   pgCharDescriptor,
-  pgEnumDescriptor,
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgFloatDescriptor,
@@ -71,7 +70,6 @@ export const codecDescriptorMap = {
   bytea: pgByteaDescriptor,
   uuid: pgUuidDescriptor,
   interval: pgIntervalDescriptor,
-  enum: pgEnumDescriptor,
   json: pgJsonDescriptor,
   jsonb: pgJsonbDescriptor,
 } as const;

package/src/core/codecs.ts

@@ -40,7 +40,6 @@ import { blindCast } from '@prisma-next/utils/casts';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type as arktype } from 'arktype';
 import {
-  pgEnumRenderOutputType,
   pgIntervalDecode,
   pgJsonbDecode,
   pgJsonbEncode,
@@ -60,7 +59,6 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
-  PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -86,7 +84,6 @@ import {
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
 type NumericParams = { readonly precision: number; readonly scale?: number };
-type EnumParams = { readonly values?: readonly string[] };
 
 const lengthParamsSchema = arktype({
   'length?': 'number.integer > 0',
@@ -875,51 +872,6 @@ export const pgIntervalColumn = (params: PrecisionParams = {}) =>
 pgIntervalColumn satisfies ColumnHelperFor<PgIntervalDescriptor>;
 pgIntervalColumn satisfies ColumnHelperForStrict<PgIntervalDescriptor>;
 
-const enumParamsSchema = arktype({
-  'values?': 'string[]',
-});
-
-export class PgEnumCodec extends CodecImpl<
-  typeof PG_ENUM_CODEC_ID,
-  readonly ['equality', 'order'],
-  string,
-  string
-> {
-  async encode(value: string, _ctx: CodecCallContext): Promise<string> {
-    return value;
-  }
-  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
-    return wire;
-  }
-  encodeJson(value: string): JsonValue {
-    return value;
-  }
-  decodeJson(json: JsonValue): string {
-    return json as string;
-  }
-}
-
-export class PgEnumDescriptor extends CodecDescriptorImpl<EnumParams> {
-  override readonly codecId = PG_ENUM_CODEC_ID;
-  override readonly traits = ['equality', 'order'] as const;
-  override readonly targetTypes = ['enum'] as const;
-  override readonly paramsSchema = enumParamsSchema satisfies StandardSchemaV1<EnumParams>;
-  override renderOutputType(params: EnumParams): string | undefined {
-    return pgEnumRenderOutputType(params);
-  }
-  override factory(_params: EnumParams): (ctx: CodecInstanceContext) => PgEnumCodec {
-    return () => new PgEnumCodec(this);
-  }
-}
-
-export const pgEnumDescriptor = new PgEnumDescriptor();
-
-export const pgEnumColumn = (params: EnumParams = {}) =>
-  column(pgEnumDescriptor.factory(params), pgEnumDescriptor.codecId, params, 'enum');
-
-pgEnumColumn satisfies ColumnHelperFor<PgEnumDescriptor>;
-pgEnumColumn satisfies ColumnHelperForStrict<PgEnumDescriptor>;
-
 export class PgJsonCodec extends CodecImpl<
   typeof PG_JSON_CODEC_ID,
   readonly [],
@@ -1120,7 +1072,6 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgByteaDescriptor,
   pgUuidDescriptor,
   pgIntervalDescriptor,
-  pgEnumDescriptor,
   pgJsonDescriptor,
   pgJsonbDescriptor,
   pgTextArrayDescriptor,

package/src/core/migrations/control-policy.ts

@@ -2,11 +2,7 @@ import type { Contract } from '@prisma-next/contract/types';
 import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import {
-  isPostgresEnumStorageEntry,
-  type SqlStorage,
-  type StorageTable,
-} from '@prisma-next/sql-contract/types';
+import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPostgresSchema } from '../postgres-schema';
 import type { PostgresOpFactoryCall } from './op-factory-call';
@@ -24,7 +20,6 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
  */
 const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
   'createTable',
-  'createEnumType',
   'createSchema',
 ]);
 
@@ -79,7 +74,6 @@ interface PostgresCallFields {
   readonly schemaName?: string;
   readonly tableName?: string;
   readonly columnName?: string;
-  readonly typeName?: string;
 }
 
 function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
@@ -87,7 +81,6 @@ function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
     ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),
     ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),
     ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),
-    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),
   };
 }
 
@@ -100,10 +93,6 @@ export function formatPostgresControlPolicySubjectLabel(
     const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
     return `${factoryName}(${ddlSchema}.${subject.table})`;
   }
-  if (subject?.typeName) {
-    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
-    return `${factoryName}(${ddlSchema}.${subject.typeName})`;
-  }
   return factoryName;
 }
 
@@ -121,33 +110,17 @@ export function resolvePostgresCallControlPolicySubject(
     };
   }
 
-  if (callFields.typeName && call.factoryName !== 'addColumn') {
-    const namespaceId = callFields.schemaName
-      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
-      : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.type[callFields.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: callFields.typeName,
-      createsNewObject,
-    };
-  }
-
   if (callFields.tableName) {
     const namespaceId = resolveNamespaceIdForTable(
       contract,
       callFields.tableName,
       callFields.schemaName,
     );
-    const table = entityAt<StorageTable>(contract.storage, {
+    const tableControlPolicy = entityAt<StorageTable>(contract.storage, {
       namespaceId,
       entityKind: 'table',
       entityName: callFields.tableName,
-    });
-    const tableControlPolicy = table?.control;
+    })?.control;
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),
@@ -178,7 +151,6 @@ export function resolvePostgresCallControlPolicySubject(
 const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
   missing_schema: 'createSchema',
   missing_table: 'createTable',
-  type_missing: 'createEnumType',
 });
 
 export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
@@ -209,20 +181,6 @@ export function resolvePostgresIssueControlPolicySubject(
     return { namespaceId: issue.namespaceId, createsNewObject };
   }
 
-  if ('typeName' in issue && issue.typeName) {
-    const namespaceId =
-      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.type[issue.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: issue.typeName,
-      createsNewObject,
-    };
-  }
-
   if ('table' in issue && issue.table) {
     const namespaceId =
       'namespaceId' in issue && issue.namespaceId