@prisma-next/target-postgres 0.13.0 → 0.14.0

package/dist/{postgres-schema-BuxCxbvB.mjs → postgres-schema-COGZ1ark.mjs}

@@ -1,7 +1,24 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
+import { _ as PG_TEXT_CODEC_ID } from "./codec-ids-BvytN2P8.mjs";
 import { n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode } from "@prisma-next/framework-components/ir";
-import { StorageTable } from "@prisma-next/sql-contract/types";
+import { TableSource } from "@prisma-next/sql-relational-core/ast";
+import { blindCast } from "@prisma-next/utils/casts";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
+import { composeSqlEntityKinds } from "@prisma-next/sql-contract/entity-kinds";
+import { cfExpr } from "@prisma-next/sql-relational-core/contract-free";
+//#region src/core/ast/table-source.ts
+var PostgresTableSource = class extends TableSource {
+	schema;
+	constructor(options) {
+		super(options.name, options.alias);
+		this.schema = options.schema;
+		this.freeze();
+	}
+	rewrite(rewriter) {
+		return rewriter.tableSource ? rewriter.tableSource(this) : this;
+	}
+};
+//#endregion
 //#region src/core/postgres-schema.ts
 /**
 * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -9,7 +26,7 @@ import { StorageTable } 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 slot 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.
@@ -31,10 +48,13 @@ var PostgresSchema = class extends NamespaceBase {
 	constructor(input) {
 		super();
 		this.id = input.id;
-		this.entries = Object.freeze({
-			table: Object.freeze(Object.fromEntries(Object.entries(input.entries.table).map(([k, v]) => [k, v instanceof StorageTable ? v : new StorageTable(v)]))),
-			type: Object.freeze(Object.fromEntries(Object.entries(input.entries.type).map(([k, v]) => [k, v instanceof PostgresEnumType ? v : new PostgresEnumType(v)])))
-		});
+		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), "carry");
+		const valueSetRaw = dispatched["valueSet"];
+		const withPresence = valueSetRaw !== void 0 && Object.keys(valueSetRaw).length === 0 ? {
+			...dispatched,
+			valueSet: void 0
+		} : dispatched;
+		this.entries = Object.freeze(blindCast(withPresence));
 		Object.defineProperty(this, "kind", {
 			value: "schema",
 			writable: false,
@@ -43,6 +63,12 @@ var PostgresSchema = class extends NamespaceBase {
 		});
 		freezeNode(this);
 	}
+	get table() {
+		return this.entries.table ?? Object.freeze({});
+	}
+	get valueSet() {
+		return this.entries.valueSet;
+	}
 	/**
 	* The bare schema qualifier as it would appear in a rendered SQL
 	* fragment (already quoted). The unbound-schema singleton overrides
@@ -81,15 +107,39 @@ var PostgresSchema = class extends NamespaceBase {
 		return `'${escapeLiteral(this.id)}'`;
 	}
 	/**
+	* Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+	* builder-built catalog check compares `n.nspname` / `table_schema`
+	* against. Named schemas bind the schema name as a text parameter; the
+	* unbound singleton overrides this to the opaque `current_schema()`
+	* expression so the live connection's `search_path` decides at runtime.
+	*/
+	schemaFilterExpression() {
+		return cfExpr.param(this.id, PG_TEXT_CODEC_ID);
+	}
+	/**
+	* Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+	* builder-built check uses to address a user table in this namespace.
+	* Named schemas qualify (`"schema"."table"`); the unbound singleton
+	* overrides this to leave the table unqualified so `search_path`
+	* resolves it at runtime.
+	*/
+	tableSource(tableName, alias) {
+		return new PostgresTableSource({
+			name: tableName,
+			schema: this.id,
+			...ifDefined("alias", alias)
+		});
+	}
+	/**
 	* The bare schema name a DDL planner should target when emitting
 	* statements that need to identify this namespace in the live
 	* database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
 	* catalog filters, planner conflict lookups). Named schemas resolve
 	* to their own id. The `PostgresUnboundSchema` singleton inherits
 	* this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-	* through `qualifyTableName` / `toRegclassLiteral` route through the
-	* polymorphic `PostgresUnboundSchema` overrides and produce
-	* unqualified (search-path-resolved) output automatically.
+	* through `qualifyTableName` route through the polymorphic
+	* `PostgresUnboundSchema` overrides and produce unqualified
+	* (search-path-resolved) output automatically.
 	*/
 	ddlSchemaName(_storage) {
 		return this.id;
@@ -110,19 +160,16 @@ var PostgresSchema = class extends NamespaceBase {
 * `search_path`).
 *
 * `ddlSchemaName` is inherited from `PostgresSchema` and returns
-* `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
-* `toRegclassLiteral`) route through the polymorphic factory and
-* produce unqualified output automatically.
+* `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+* route through the polymorphic factory and produce unqualified output
+* automatically.
 */
 var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	static instance = new PostgresUnboundSchema();
 	constructor(input) {
 		super(input ?? {
 			id: UNBOUND_NAMESPACE_ID,
-			entries: {
-				table: {},
-				type: {}
-			}
+			entries: { table: {} }
 		});
 	}
 	qualifier() {
@@ -134,6 +181,18 @@ var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	schemaSqlExpression() {
 		return "current_schema()";
 	}
+	schemaFilterExpression() {
+		return cfExpr.raw("current_schema()", {
+			codecId: PG_TEXT_CODEC_ID,
+			nullable: false
+		});
+	}
+	tableSource(tableName, alias) {
+		return new PostgresTableSource({
+			name: tableName,
+			...ifDefined("alias", alias)
+		});
+	}
 };
 PostgresSchema.unbound = PostgresUnboundSchema.instance;
 /**
@@ -159,18 +218,18 @@ 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: {
-			table: input.entries.table,
-			type: enumTypes ?? {}
+			...input.entries,
+			table: input.entries["table"] ?? {}
 		}
 	};
 	if (input.id === UNBOUND_NAMESPACE_ID) return new PostgresUnboundSchema(schemaInput);
 	return new PostgresSchema(schemaInput);
 }
 //#endregion
-export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+export { PostgresTableSource as a, postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
 
-//# sourceMappingURL=postgres-schema-BuxCxbvB.mjs.map
+//# sourceMappingURL=postgres-schema-COGZ1ark.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-COGZ1ark.mjs","names":[],"sources":["../src/core/ast/table-source.ts","../src/core/postgres-schema.ts"],"sourcesContent":["import {\n  type AnyFromSource,\n  type AstRewriter,\n  TableSource,\n} from '@prisma-next/sql-relational-core/ast';\n\nexport class PostgresTableSource extends TableSource {\n  readonly schema: string | undefined;\n\n  constructor(options: {\n    readonly name: string;\n    readonly schema?: string;\n    readonly alias?: string;\n  }) {\n    super(options.name, options.alias);\n    this.schema = options.schema;\n    this.freeze();\n  }\n\n  override rewrite(rewriter: AstRewriter): AnyFromSource {\n    return rewriter.tableSource ? rewriter.tableSource(this) : this;\n  }\n}\n","import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport type {\n  SqlNamespaceEntries,\n  SqlNamespaceTablesInput,\n  SqlStorage,\n  StorageTable,\n  StorageValueSet,\n} from '@prisma-next/sql-contract/types';\nimport { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresTableSource } from './ast/table-source';\nimport { PG_TEXT_CODEC_ID } from './codec-ids';\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: SqlNamespaceEntries;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');\n\n    // Drop an empty valueSet so presence signals non-emptiness.\n    const valueSetRaw = dispatched['valueSet'];\n    const withPresence =\n      valueSetRaw !== undefined && Object.keys(valueSetRaw).length === 0\n        ? { ...dispatched, valueSet: undefined }\n        : dispatched;\n\n    this.entries = Object.freeze(\n      blindCast<\n        SqlNamespaceEntries,\n        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'\n      >(withPresence),\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;\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   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a\n   * builder-built catalog check compares `n.nspname` / `table_schema`\n   * against. Named schemas bind the schema name as a text parameter; the\n   * unbound singleton overrides this to the opaque `current_schema()`\n   * expression so the live connection's `search_path` decides at runtime.\n   */\n  schemaFilterExpression(): CfExpr {\n    return cfExpr.param(this.id, PG_TEXT_CODEC_ID);\n  }\n\n  /**\n   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a\n   * builder-built check uses to address a user table in this namespace.\n   * Named schemas qualify (`\"schema\".\"table\"`); the unbound singleton\n   * overrides this to leave the table unqualified so `search_path`\n   * resolves it at runtime.\n   */\n  tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      schema: this.id,\n      ...ifDefined('alias', alias),\n    });\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` route through the polymorphic\n   * `PostgresUnboundSchema` overrides and produce unqualified\n   * (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 such as `qualifyTableName`\n * route through the polymorphic factory and produce unqualified output\n * 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  override schemaFilterExpression(): CfExpr {\n    return cfExpr.raw('current_schema()', { codecId: PG_TEXT_CODEC_ID, nullable: false });\n  }\n\n  override tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      ...ifDefined('alias', alias),\n    });\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":";;;;;;;;;AAMA,IAAa,sBAAb,cAAyC,YAAY;CACnD;CAEA,YAAY,SAIT;EACD,MAAM,QAAQ,MAAM,QAAQ,KAAK;EACjC,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO;CACd;CAEA,QAAiB,UAAsC;EACrD,OAAO,SAAS,cAAc,SAAS,YAAY,IAAI,IAAI;CAC7D;AACF;;;;;;;;;;;;;;;;;ACkBA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAGP;CACA;CAEA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAEhB,MAAM,aAAa,yBAAyB,MAAM,SAAS,sBAAsB,GAAG,OAAO;EAG3F,MAAM,cAAc,WAAW;EAC/B,MAAM,eACJ,gBAAgB,KAAA,KAAa,OAAO,KAAK,WAAW,CAAC,CAAC,WAAW,IAC7D;GAAE,GAAG;GAAY,UAAU,KAAA;EAAU,IACrC;EAEN,KAAK,UAAU,OAAO,OACpB,UAGE,YAAY,CAChB;EACA,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,SAAS,OAAO,OAAO,CAAC,CAAC;CAC/C;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;;;;;;;;CASA,yBAAiC;EAC/B,OAAO,OAAO,MAAM,KAAK,IAAI,gBAAgB;CAC/C;;;;;;;;CASA,YAAY,WAAmB,OAAqC;EAClE,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,QAAQ,KAAK;GACb,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;;;;;;;;;;;;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;CAEA,yBAA0C;EACxC,OAAO,OAAO,IAAI,oBAAoB;GAAE,SAAS;GAAkB,UAAU;EAAM,CAAC;CACtF;CAEA,YAAqB,WAAmB,OAAqC;EAC3E,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;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/{render-ops-BpjstrKQ.mjs → render-ops-BREh1kHe.mjs}

@@ -1,4 +1,5 @@
 import { blindCast } from "@prisma-next/utils/casts";
+import { isThenable } from "@prisma-next/utils/promise";
 //#region src/core/migrations/render-ops.ts
 /**
 * Asserts an op materialised by an `OpFactoryCall` targets postgres. The
@@ -8,17 +9,21 @@ import { blindCast } from "@prisma-next/utils/casts";
 * place to fail loudly with op metadata (`id` + `target.id`).
 */
 function assertPostgresOp(op, callFactoryName) {
-	const targetId = op.target?.id;
+	const targetId = blindCast(op).target?.id;
 	if (targetId !== "postgres") throw new Error(`renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`);
 }
 function renderOps(calls, lowerer) {
 	return calls.map((c) => {
-		const op = blindCast(c).toOp(lowerer);
-		assertPostgresOp(op, c.factoryName);
-		return op;
+		const opOrPromise = blindCast(c).toOp(lowerer);
+		if (isThenable(opOrPromise)) return opOrPromise.then((op) => {
+			assertPostgresOp(op, c.factoryName);
+			return op;
+		});
+		assertPostgresOp(opOrPromise, c.factoryName);
+		return opOrPromise;
 	});
 }
 //#endregion
 export { renderOps as t };
 
-//# sourceMappingURL=render-ops-BpjstrKQ.mjs.map
+//# sourceMappingURL=render-ops-BREh1kHe.mjs.map

package/dist/render-ops-BREh1kHe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-BREh1kHe.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  MigrationPlanOperation,\n  OpFactoryCall,\n} from '@prisma-next/framework-components/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {\n  const targetId = blindCast<\n    { target?: { id?: string } },\n    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'\n  >(op).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(\n  calls: readonly OpFactoryCall[],\n  lowerer?: ExecuteRequestLowerer,\n): (Op | Promise<Op>)[] {\n  return calls.map((c) => {\n    const opOrPromise = blindCast<\n      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },\n      'PG OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'\n    >(c).toOp(lowerer);\n    if (isThenable(opOrPromise)) {\n      return opOrPromise.then((op) => {\n        assertPostgresOp(op, c.factoryName);\n        return op;\n      });\n    }\n    assertPostgresOp(opOrPromise, c.factoryName);\n    return opOrPromise;\n  });\n}\n"],"mappings":";;;;;;;;;;AAmBA,SAAS,iBAAiB,IAA4B,iBAA2C;CAC/F,MAAM,WAAW,UAGf,EAAE,CAAC,CAAC,QAAQ;CACd,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,0HAChI;AAEJ;AAEA,SAAgB,UACd,OACA,SACsB;CACtB,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,cAAc,UAGlB,CAAC,CAAC,CAAC,KAAK,OAAO;EACjB,IAAI,WAAW,WAAW,GACxB,OAAO,YAAY,MAAM,OAAO;GAC9B,iBAAiB,IAAI,EAAE,WAAW;GAClC,OAAO;EACT,CAAC;EAEH,iBAAiB,aAAa,EAAE,WAAW;EAC3C,OAAO;CACT,CAAC;AACH"}

package/dist/render-ops.d.mts

@@ -1,11 +1,11 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
-import { Lowerer } from "@prisma-next/family-sql/control-adapter";
+import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";
 
 //#region src/core/migrations/render-ops.d.ts
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
-declare function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[];
+declare function renderOps(calls: readonly OpFactoryCall[], lowerer?: ExecuteRequestLowerer): (Op | Promise<Op>)[];
 //#endregion
 export { renderOps };
 //# sourceMappingURL=render-ops.d.mts.map

package/dist/render-ops.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"mappings":";;;;;;KAMK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,iBAqBpB,SAAA,CAAU,KAAA,WAAgB,aAAA,IAAiB,OAAA,GAAU,OAAA,GAAU,EAAA"}
+{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"mappings":";;;;;;KAUK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,iBAqBpB,SAAA,CACd,KAAA,WAAgB,aAAA,IAChB,OAAA,GAAU,qBAAA,IACR,EAAA,GAAK,OAAA,CAAQ,EAAA"}

package/dist/render-ops.mjs

@@ -1,2 +1,2 @@
-import { t as renderOps } from "./render-ops-BpjstrKQ.mjs";
+import { t as renderOps } from "./render-ops-BREh1kHe.mjs";
 export { renderOps };

package/dist/runtime.d.mts

@@ -9,6 +9,7 @@ import { JsonObject } from "@prisma-next/utils/json";
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor();
+  protected get defaultNamespaceId(): string;
   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":";;;;;;;;;cAyEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;YAQ9D,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA4CN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAuCpD,0BAAA;EAAA,QAmBA,kBAAA;AAAA;;;UCjLO,6BAAA,SAAsC,qBAAqB;;;;;ADgE5E;;cCxDM,+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":";;;;;;;;;cAkEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;gBAM1D,kBAAA;EAAA,UAIJ,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;;;UChKO,6BAAA,SAAsC,qBAAqB;;;;;ADyD5E;;cCjDM,+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-My8_s4cs.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-DYTyXjPf.mjs";
+import { n as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-CpGygXpI.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k3TAcPMY.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/table-source-BvFo7gVs.d.mts

@@ -0,0 +1,15 @@
+import { AnyFromSource, AstRewriter, TableSource } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/ast/table-source.d.ts
+declare class PostgresTableSource extends TableSource {
+  readonly schema: string | undefined;
+  constructor(options: {
+    readonly name: string;
+    readonly schema?: string;
+    readonly alias?: string;
+  });
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+}
+//#endregion
+export { PostgresTableSource as t };
+//# sourceMappingURL=table-source-BvFo7gVs.d.mts.map

package/dist/table-source-BvFo7gVs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-source-BvFo7gVs.d.mts","names":[],"sources":["../src/core/ast/table-source.ts"],"mappings":";;;cAMa,mBAAA,SAA4B,WAAA;EAAA,SAC9B,MAAA;cAEG,OAAA;IAAA,SACD,IAAA;IAAA,SACA,MAAA;IAAA,SACA,KAAA;EAAA;EAOF,OAAA,CAAQ,QAAA,EAAU,WAAA,GAAc,aAAA;AAAA"}

package/dist/types.d.mts

@@ -1,15 +1,13 @@
-import { n as PostgresEnumTypeInput, t as PostgresEnumType } from "./postgres-enum-type-BVn63a89.mjs";
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
 import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { PostgresEnumStorageEntry, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageTableInput } from "@prisma-next/sql-contract/types";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
+import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 
 //#region src/core/postgres-schema.d.ts
 interface PostgresSchemaInput {
   readonly id: string;
-  readonly entries: {
-    readonly table: Record<string, StorageTable | StorageTableInput>;
-    readonly type: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
-  };
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 /**
  * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -17,7 +15,7 @@ interface PostgresSchemaInput {
  * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
  * the Postgres PSL interpreter from `namespace { … }` AST buckets.
  *
- * `entries` holds entity-kind slot 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.
@@ -36,11 +34,10 @@ declare class PostgresSchema extends NamespaceBase {
   static unbound: PostgresUnboundSchema;
   readonly kind: 'schema';
   readonly id: string;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-    readonly type: Readonly<Record<string, PostgresEnumType>>;
-  }>;
+  readonly entries: SqlNamespaceEntries;
   constructor(input: PostgresSchemaInput);
+  get table(): Readonly<Record<string, StorageTable>>;
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides
@@ -70,6 +67,22 @@ declare class PostgresSchema extends NamespaceBase {
    * connection's `search_path` resolved at runtime.
    */
   schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
   /**
    * The bare schema name a DDL planner should target when emitting
    * statements that need to identify this namespace in the live
@@ -77,9 +90,9 @@ declare class PostgresSchema extends NamespaceBase {
    * catalog filters, planner conflict lookups). Named schemas resolve
    * to their own id. The `PostgresUnboundSchema` singleton inherits
    * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-   * through `qualifyTableName` / `toRegclassLiteral` route through the
-   * polymorphic `PostgresUnboundSchema` overrides and produce
-   * unqualified (search-path-resolved) output automatically.
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
    */
   ddlSchemaName(_storage: SqlStorage): string;
 }
@@ -98,9 +111,9 @@ declare class PostgresSchema extends NamespaceBase {
  * `search_path`).
  *
  * `ddlSchemaName` is inherited from `PostgresSchema` and returns
- * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
- * `toRegclassLiteral`) route through the polymorphic factory and
- * produce unqualified output automatically.
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
  */
 declare class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema;
@@ -108,6 +121,8 @@ declare class PostgresUnboundSchema extends PostgresSchema {
   qualifier(): string;
   qualifyTable(tableName: string): string;
   schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
 }
 /**
  * Target-supplied `Namespace` factory the Postgres target plumbs
@@ -120,7 +135,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, 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-schema.ts"],"mappings":";;;;;;UAeiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;IAAA,SACE,KAAA,EAAO,MAAA,SAAe,YAAA,GAAe,iBAAA;IAAA,SACrC,IAAA,EAAM,MAAA,SAAe,gBAAA,GAAmB,qBAAA;EAAA;AAAA;;;;;;;;;;;;;;;cAkBxC,cAAA,SAAuB,aAAA;EAlBF;;;AAAwC;AAkB1E;;;EAlBkC,OA0BzB,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,QAAA;IAAA,SACP,KAAA,EAAO,QAAA,CAAS,MAAA,SAAe,YAAA;IAAA,SAC/B,IAAA,EAAM,QAAA,CAAS,MAAA,SAAe,gBAAA;EAAA;cAG7B,KAAA,EAAO,mBAAA;EAAA;;;;;EAmCnB,SAAA;EA5CO;;;;;;EAsDP,YAAA,CAAa,SAAA;EAjDK;;;;;;EA2DlB,eAAA,CAAgB,IAAA;;;;;;;;;EAYhB,mBAAA;EAeA;;;;AAAkC;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,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":";;;;;;;UAqBiB,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,mBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IA4Bf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EA+DQ;;;;;EAtDhD,SAAA;EA/CO;;;;;;EAyDP,YAAA,CAAa,SAAA;EAnDM;;;;;;EA6DnB,eAAA,CAAgB,IAAA;EA7BA;;;;;;;;EAyChB,mBAAA;EAWA;;;;;;;EAAA,sBAAA,IAA0B,MAAA;EA8BZ;;AAAoB;AAwBpC;;;;EA3CE,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EA8Db;;;;;;;;;;;EA3CnC,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;AA+CoD;AAkC9E;;;;;;;;AAAuF;cAzD1E,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;;;iBAkC3C,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/types.mjs

@@ -1,3 +1,2 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-BuxCxbvB.mjs";
-export { PostgresEnumType, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
+export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.13.0",
-    "@prisma-next/contract": "0.13.0",
-    "@prisma-next/errors": "0.13.0",
-    "@prisma-next/family-sql": "0.13.0",
-    "@prisma-next/framework-components": "0.13.0",
-    "@prisma-next/migration-tools": "0.13.0",
-    "@prisma-next/ts-render": "0.13.0",
-    "@prisma-next/sql-contract": "0.13.0",
-    "@prisma-next/sql-errors": "0.13.0",
-    "@prisma-next/sql-operations": "0.13.0",
-    "@prisma-next/sql-relational-core": "0.13.0",
-    "@prisma-next/sql-schema-ir": "0.13.0",
-    "@prisma-next/utils": "0.13.0",
+    "@prisma-next/cli": "0.14.0",
+    "@prisma-next/contract": "0.14.0",
+    "@prisma-next/errors": "0.14.0",
+    "@prisma-next/family-sql": "0.14.0",
+    "@prisma-next/framework-components": "0.14.0",
+    "@prisma-next/migration-tools": "0.14.0",
+    "@prisma-next/ts-render": "0.14.0",
+    "@prisma-next/sql-contract": "0.14.0",
+    "@prisma-next/sql-errors": "0.14.0",
+    "@prisma-next/sql-operations": "0.14.0",
+    "@prisma-next/sql-relational-core": "0.14.0",
+    "@prisma-next/sql-schema-ir": "0.14.0",
+    "@prisma-next/utils": "0.14.0",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0",
-    "@prisma-next/tsconfig": "0.13.0",
-    "@prisma-next/tsdown": "0.13.0",
+    "@prisma-next/test-utils": "0.14.0",
+    "@prisma-next/tsconfig": "0.14.0",
+    "@prisma-next/tsdown": "0.14.0",
     "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",