@prisma-next/target-postgres 0.12.0-dev.6 → 0.12.0-dev.61

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

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

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

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

package/dist/planner-schema-lookup.mjs

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

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

@@ -1,22 +1,6 @@
-import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-CggjWNij.mjs";
-import { i as postgresCreateNamespace } from "./postgres-schema-BxAuNFX0.mjs";
-import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
-//#region src/core/migrations/planner-type-resolution.ts
-function resolveColumnTypeMetadata(column, storageTypes) {
-	if (!column.typeRef) return column;
-	const referencedType = storageTypes[column.typeRef];
-	if (!referencedType) return column;
-	if (isPostgresEnumStorageEntry(referencedType)) return {
-		codecId: referencedType.codecId,
-		nativeType: referencedType.nativeType
-	};
-	return {
-		codecId: referencedType.codecId,
-		nativeType: referencedType.nativeType,
-		typeParams: referencedType.typeParams
-	};
-}
-//#endregion
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
+import { i as postgresCreateNamespace } from "./postgres-schema-BuxCxbvB.mjs";
+import { t as resolveColumnTypeMetadata } from "./planner-type-resolution-836DExFN.mjs";
 //#region src/core/migrations/planner-sql-checks.ts
 /**
 * String-keyed entry points the migration ops use to render
@@ -30,10 +14,16 @@ function resolveColumnTypeMetadata(column, storageTypes) {
 * site.
 */
 function qualifyTableName(schema, table) {
-	return postgresCreateNamespace({ id: schema }).qualifyTable(table);
+	return postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).qualifyTable(table);
 }
 function toRegclassLiteral(schema, name) {
-	return postgresCreateNamespace({ id: schema }).regclassLiteral(name);
+	return postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).regclassLiteral(name);
 }
 /**
 * When `table` is omitted the check matches by name + schema across all tables.
@@ -41,7 +31,10 @@ function toRegclassLiteral(schema, name) {
 * identically-named constraints in different tables).
 */
 function constraintExistsCheck({ constraintName, schema, table, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const existsClause = exists ? "EXISTS" : "NOT EXISTS";
 	const tableFilter = table ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})` : "";
 	return `SELECT ${existsClause} (
@@ -53,7 +46,10 @@ function constraintExistsCheck({ constraintName, schema, table, exists = true })
 )`;
 }
 function columnExistsCheck({ schema, table, column, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	return `SELECT ${exists ? "" : "NOT "}EXISTS (
   SELECT 1
   FROM information_schema.columns
@@ -63,7 +59,10 @@ function columnExistsCheck({ schema, table, column, exists = true }) {
 )`;
 }
 function columnNullabilityCheck({ schema, table, column, nullable }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const expected = nullable ? "YES" : "NO";
 	return `SELECT EXISTS (
   SELECT 1
@@ -81,7 +80,10 @@ function columnHasNoDefaultCheck(opts) {
 	return `SELECT NOT EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = ${postgresCreateNamespace({ id: opts.schema }).schemaSqlExpression()}
+  WHERE table_schema = ${postgresCreateNamespace({
+		id: opts.schema,
+		entries: { table: {} }
+	}).schemaSqlExpression()}
     AND table_name = '${escapeLiteral(opts.table)}'
     AND column_name = '${escapeLiteral(opts.column)}'
     AND column_default IS NOT NULL
@@ -220,7 +222,10 @@ function columnTypeCheck({ schema, table, column, expectedType }) {
   FROM pg_attribute a
   JOIN pg_class c ON c.oid = a.attrelid
   JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = ${postgresCreateNamespace({ id: schema }).schemaSqlExpression()}
+  WHERE n.nspname = ${postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	}).schemaSqlExpression()}
     AND c.relname = '${escapeLiteral(table)}'
     AND a.attname = '${escapeLiteral(column)}'
     AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
@@ -228,7 +233,10 @@ function columnTypeCheck({ schema, table, column, expectedType }) {
 )`;
 }
 function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const nullCheck = exists ? "IS NOT NULL" : "IS NULL";
 	return `SELECT EXISTS (
   SELECT 1
@@ -240,7 +248,10 @@ function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
 )`;
 }
 function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
-	const namespace = postgresCreateNamespace({ id: schema });
+	const namespace = postgresCreateNamespace({
+		id: schema,
+		entries: { table: {} }
+	});
 	const comparison = exists ? "" : "NOT ";
 	const constraintFilter = constraintName ? `AND c2.relname = '${escapeLiteral(constraintName)}'` : "";
 	return `SELECT ${comparison}EXISTS (
@@ -256,6 +267,6 @@ function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
 )`;
 }
 //#endregion
-export { columnNullabilityCheck as a, qualifyTableName as c, toRegclassLiteral as d, resolveColumnTypeMetadata as f, columnHasNoDefaultCheck as i, tableHasPrimaryKeyCheck as l, columnDefaultExistsCheck as n, columnTypeCheck as o, columnExistsCheck as r, constraintExistsCheck as s, buildExpectedFormatType as t, tableIsEmptyCheck as u };
+export { columnNullabilityCheck as a, qualifyTableName as c, toRegclassLiteral as d, columnHasNoDefaultCheck as i, tableHasPrimaryKeyCheck as l, columnDefaultExistsCheck as n, columnTypeCheck as o, columnExistsCheck as r, constraintExistsCheck as s, buildExpectedFormatType as t, tableIsEmptyCheck as u };
 
-//# sourceMappingURL=planner-sql-checks-CfEiTXoQ.mjs.map
+//# sourceMappingURL=planner-sql-checks-DAdhnI2c.mjs.map

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

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

package/dist/planner-sql-checks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;;;AAqBA;;;;AAA8D;AAI9D;;;;iBAJgB,gBAAA,CAAiB,MAAA,UAAgB,KAAa;AAAA,iBAI9C,iBAAA,CAAkB,MAAA,UAAgB,IAAY;;;;;;iBAS9C,qBAAA,CAAA;EACd,cAAA;EACA,MAAA;EACA,KAAA;EACA;AAAA;EAEA,cAAA;EACA,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAgBc,iBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,MAAA;AAAA;AAAA,iBAac,sBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,iBAcc,iBAAA,CAAkB,kBAA0B;AAAA,iBAI5C,uBAAA,CAAwB,IAAA;EACtC,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAyIc,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,GAAA,SAAY,iBAAA,GACxB,YAAA,GAAc,MAAA,SAAe,mBAAA,GAAsB,wBAAA;AAAA,iBAsErC,uBAAA,CACd,MAAA,UACA,KAAA,UACA,MAAA,WACA,cAAA"}
+{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;;;AAqBA;;;;AAA8D;AAI9D;;;;iBAJgB,gBAAA,CAAiB,MAAA,UAAgB,KAAa;AAAA,iBAI9C,iBAAA,CAAkB,MAAA,UAAgB,IAAY;;;;;;iBAS9C,qBAAA;EACd,cAAA;EACA,MAAA;EACA,KAAA;EACA;AAAA;EAEA,cAAA;EACA,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAgBc,iBAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,MAAA;AAAA;AAAA,iBAac,sBAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,iBAcc,iBAAA,CAAkB,kBAA0B;AAAA,iBAI5C,uBAAA,CAAwB,IAAA;EACtC,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAyIc,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,GAAA,SAAY,iBAAA,GACxB,YAAA,GAAc,MAAA,SAAe,mBAAA,GAAsB,wBAAA;AAAA,iBAsErC,uBAAA,CACd,MAAA,UACA,KAAA,UACA,MAAA,WACA,cAAA"}

package/dist/planner-sql-checks.mjs

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

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

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

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

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

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

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

package/dist/planner-type-resolution-836DExFN.mjs

@@ -0,0 +1,20 @@
+import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
+//#region src/core/migrations/planner-type-resolution.ts
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referencedType = storageTypes[column.typeRef];
+	if (!referencedType) return column;
+	if (isPostgresEnumStorageEntry(referencedType)) return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType
+	};
+	return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType,
+		typeParams: referencedType.typeParams
+	};
+}
+//#endregion
+export { resolveColumnTypeMetadata as t };
+
+//# sourceMappingURL=planner-type-resolution-836DExFN.mjs.map

package/dist/planner-type-resolution-836DExFN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-type-resolution-836DExFN.mjs","names":[],"sources":["../src/core/migrations/planner-type-resolution.ts"],"sourcesContent":["import {\n  isPostgresEnumStorageEntry,\n  type PostgresEnumStorageEntry,\n  type StorageColumn,\n  type StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\n\nexport type ResolvedColumnTypeMetadata = Pick<\n  StorageColumn,\n  'nativeType' | 'codecId' | 'typeParams'\n>;\n\nexport function resolveColumnTypeMetadata(\n  column: StorageColumn,\n  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,\n): ResolvedColumnTypeMetadata {\n  if (!column.typeRef) {\n    return column;\n  }\n\n  const referencedType = storageTypes[column.typeRef];\n  if (!referencedType) {\n    return column;\n  }\n\n  if (isPostgresEnumStorageEntry(referencedType)) {\n    // Enum types are referenced by name (`quoteIdentifier(nativeType)`),\n    // not via parameterised codec expansion. The structural shape\n    // carries `codecId` as an enumerable property (mirroring the\n    // codec-typed view); `typeParams` is intentionally omitted here so\n    // `expandParameterizedTypeSql` does not try to look up a\n    // (deliberately absent) `expandNativeType` hook for `pg/enum@*`.\n    return {\n      codecId: referencedType.codecId,\n      nativeType: referencedType.nativeType,\n    };\n  }\n\n  return {\n    codecId: referencedType.codecId,\n    nativeType: referencedType.nativeType,\n    typeParams: referencedType.typeParams,\n  };\n}\n"],"mappings":";;AAYA,SAAgB,0BACd,QACA,cAC4B;CAC5B,IAAI,CAAC,OAAO,SACV,OAAO;CAGT,MAAM,iBAAiB,aAAa,OAAO;CAC3C,IAAI,CAAC,gBACH,OAAO;CAGT,IAAI,2BAA2B,cAAc,GAO3C,OAAO;EACL,SAAS,eAAe;EACxB,YAAY,eAAe;CAC7B;CAGF,OAAO;EACL,SAAS,eAAe;EACxB,YAAY,eAAe;EAC3B,YAAY,eAAe;CAC7B;AACF"}

package/dist/planner.d.mts

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

package/dist/planner.d.mts.map

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

package/dist/planner.mjs

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

package/dist/{postgres-contract-serializer-BnOboPWs.mjs → postgres-contract-serializer-DYTyXjPf.mjs}

@@ -1,6 +1,7 @@
-import { n as postgresAuthoringEntityTypes } from "./descriptor-meta-runtime-DMRX39kp.mjs";
-import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-BxAuNFX0.mjs";
+import { n as postgresAuthoringEntityTypes } from "./descriptor-meta-runtime-My8_s4cs.mjs";
+import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-BuxCxbvB.mjs";
 import { NamespaceBase, UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { isAuthoringEntityTypeDescriptor } from "@prisma-next/framework-components/authoring";
 //#region src/core/postgres-contract-serializer.ts
@@ -45,30 +46,36 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 	}
 	hydrateSqlNamespaceEntry(nsId, raw) {
 		if (raw instanceof NamespaceBase) return raw;
-		const { id, tables, enum: hydratedNsEnums } = super.hydrateSqlNamespaceEntry(nsId, raw);
-		const emptyTables = Object.keys(tables).length === 0;
-		const emptyEnums = !hydratedNsEnums || Object.keys(hydratedNsEnums).length === 0;
-		if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyEnums) return PostgresSchema.unbound;
+		const { id, entries } = blindCast(super.hydrateSqlNamespaceEntry(nsId, raw));
+		const rawEntries = raw["entries"];
+		let typeSlot;
+		if (rawEntries !== null && typeof rawEntries === "object" && !Array.isArray(rawEntries)) {
+			const rawTypeSlot = rawEntries["type"];
+			if (rawTypeSlot !== null && typeof rawTypeSlot === "object" && !Array.isArray(rawTypeSlot)) {
+				const enumFactory = this.entityTypeRegistry.get("postgres-enum");
+				typeSlot = Object.fromEntries(Object.entries(rawTypeSlot).map(([name, entry]) => [name, blindCast(enumFactory !== void 0 ? enumFactory(entry) : entry)]));
+			}
+		}
+		const emptyTables = Object.keys(entries.table).length === 0;
+		const emptyTypes = !typeSlot || Object.keys(typeSlot).length === 0;
+		if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) return PostgresSchema.unbound;
 		return new PostgresSchema({
 			id,
-			tables,
-			...hydratedNsEnums !== void 0 ? { enum: hydratedNsEnums } : {}
+			entries: {
+				table: entries.table,
+				type: typeSlot ?? {}
+			}
 		});
 	}
 	serializeContract(contract) {
 		const { storage, ...rest } = contract;
 		const namespacesJson = {};
 		for (const [nsId, ns] of Object.entries(storage.namespaces)) if (isPostgresSchema(ns)) namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
-		else {
-			const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
-			const nsEnums = ns.enum ?? {};
-			namespacesJson[nsId] = {
-				id: nsId,
-				kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
-				tables: Object.fromEntries(Object.entries(ns.tables).map(([tableName, table]) => [tableName, this.serializeJsonValue(table)])),
-				enum: Object.fromEntries(Object.entries(nsEnums).map(([typeName, entry]) => [typeName, this.serializeJsonValue(entry)]))
-			};
-		}
+		else namespacesJson[nsId] = {
+			id: nsId,
+			kind: nsId === UNBOUND_NAMESPACE_ID ? "postgres-unbound-schema" : "postgres-schema",
+			entries: { table: Object.fromEntries(Object.entries(ns.entries.table).map(([tableName, table]) => [tableName, this.serializeJsonValue(table)])) }
+		};
 		const storageOut = {
 			storageHash: String(storage.storageHash),
 			namespaces: namespacesJson
@@ -85,14 +92,16 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 	}
 	serializePostgresNamespace(ns, isUnboundSlot) {
 		const tablesOut = {};
-		for (const [tableName, table] of Object.entries(ns.tables)) tablesOut[tableName] = this.serializeJsonValue(table);
-		const enumOut = {};
-		for (const [typeName, ty] of Object.entries(ns.enum)) enumOut[typeName] = this.serializeJsonValue(ty);
+		for (const [tableName, table] of Object.entries(ns.entries.table)) tablesOut[tableName] = this.serializeJsonValue(table);
+		const typeOut = {};
+		for (const [typeName, ty] of Object.entries(ns.entries.type)) typeOut[typeName] = this.serializeJsonValue(ty);
 		return {
 			id: ns.id,
 			kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
-			tables: tablesOut,
-			enum: enumOut
+			entries: {
+				table: tablesOut,
+				type: typeOut
+			}
 		};
 	}
 	serializeJsonValue(value) {
@@ -102,4 +111,4 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 //#endregion
 export { PostgresContractSerializer as t };
 
-//# sourceMappingURL=postgres-contract-serializer-BnOboPWs.mjs.map
+//# sourceMappingURL=postgres-contract-serializer-DYTyXjPf.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-contract-serializer-DYTyXjPf.mjs","names":["rawRecord"],"sources":["../src/core/postgres-contract-serializer.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  SqlContractSerializerBase,\n  type SqlEntityHydrationFactory,\n} from '@prisma-next/family-sql/ir';\nimport {\n  type AuthoringEntityContext,\n  type AuthoringEntityTypeFactoryOutput,\n  type AuthoringEntityTypeNamespace,\n  isAuthoringEntityTypeDescriptor,\n} from '@prisma-next/framework-components/authoring';\nimport {\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport type { Type } from 'arktype';\nimport { postgresAuthoringEntityTypes } from './authoring';\nimport type { PostgresEnumType } from './postgres-enum-type';\nimport { isPostgresSchema, PostgresSchema } from './postgres-schema';\n\nconst POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {\n  family: 'sql',\n  target: 'postgres',\n};\n\nfunction isAuthoringEntityTypeFactoryOutput(\n  output: unknown,\n): output is AuthoringEntityTypeFactoryOutput<unknown, unknown> {\n  return (\n    typeof output === 'object' &&\n    output !== null &&\n    typeof (output as AuthoringEntityTypeFactoryOutput).factory === 'function'\n  );\n}\n\n/**\n * Walks a pack's entity-type namespace tree and emits the maps the\n * family base consumes — hydrators and validator-schema fragments, both\n * keyed by the descriptor's `discriminator`.\n */\nfunction collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamespace): {\n  readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>;\n  readonly validatorFragments: ReadonlyMap<string, Type<unknown>>;\n} {\n  const entityTypeRegistry = new Map<string, SqlEntityHydrationFactory>();\n  const validatorFragments = new Map<string, Type<unknown>>();\n  const walk = (node: AuthoringEntityTypeNamespace): void => {\n    for (const value of Object.values(node)) {\n      if (isAuthoringEntityTypeDescriptor(value)) {\n        if (isAuthoringEntityTypeFactoryOutput(value.output)) {\n          const { factory } = value.output;\n          entityTypeRegistry.set(value.discriminator, (raw) =>\n            factory(raw, POSTGRES_AUTHORING_CTX),\n          );\n        }\n        if (value.validatorSchema !== undefined) {\n          validatorFragments.set(value.discriminator, value.validatorSchema);\n        }\n        continue;\n      }\n      if (typeof value === 'object' && value !== null) {\n        walk(value);\n      }\n    }\n  };\n  walk(namespace);\n  return { entityTypeRegistry, validatorFragments };\n}\n\nexport class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    const { entityTypeRegistry, validatorFragments } = collectEntityRegistryContributions(\n      postgresAuthoringEntityTypes,\n    );\n    super(entityTypeRegistry, validatorFragments);\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const hydrated = blindCast<\n      SqlNamespaceTablesInput,\n      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    const { id, entries } = hydrated;\n\n    // Extract the postgres-specific `type` slot directly from raw input.\n    // The family base handles the `table` slot; the postgres target owns `type`.\n    const rawRecord = raw as Record<string, unknown>;\n    const rawEntries = rawRecord['entries'];\n    let typeSlot: Record<string, PostgresEnumType> | undefined;\n    if (rawEntries !== null && typeof rawEntries === 'object' && !Array.isArray(rawEntries)) {\n      const rawTypeSlot = (rawEntries as Record<string, unknown>)['type'];\n      if (rawTypeSlot !== null && typeof rawTypeSlot === 'object' && !Array.isArray(rawTypeSlot)) {\n        const enumFactory = this.entityTypeRegistry.get('postgres-enum');\n        typeSlot = Object.fromEntries(\n          Object.entries(rawTypeSlot as Record<string, unknown>).map(([name, entry]) => [\n            name,\n            blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(\n              enumFactory !== undefined ? enumFactory(entry) : entry,\n            ),\n          ]),\n        );\n      }\n    }\n\n    const emptyTables = Object.keys(entries.table).length === 0;\n    const emptyTypes = !typeSlot || Object.keys(typeSlot).length === 0;\n    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) {\n      return PostgresSchema.unbound;\n    }\n    return new PostgresSchema({\n      id,\n      entries: {\n        table: entries.table,\n        type: typeSlot ?? {},\n      },\n    });\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      if (isPostgresSchema(ns)) {\n        namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);\n      } else {\n        const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;\n        namespacesJson[nsId] = {\n          id: nsId,\n          kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n          entries: {\n            table: Object.fromEntries(\n              Object.entries(ns.entries.table).map(([tableName, table]) => [\n                tableName,\n                this.serializeJsonValue(table) as JsonObject,\n              ]),\n            ),\n          },\n        };\n      }\n    }\n    const storageOut: Record<string, unknown> = {\n      storageHash: String(storage.storageHash),\n      namespaces: namespacesJson,\n    };\n    if (storage.types !== undefined) {\n      const typesOut: Record<string, JsonObject> = {};\n      for (const [name, entry] of Object.entries(storage.types)) {\n        typesOut[name] = this.serializeJsonValue(entry) as JsonObject;\n      }\n      storageOut['types'] = typesOut;\n    }\n    return {\n      ...rest,\n      storage: storageOut,\n    } as unknown as JsonObject;\n  }\n\n  private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {\n    const tablesOut: Record<string, JsonObject> = {};\n    for (const [tableName, table] of Object.entries(ns.entries.table)) {\n      tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;\n    }\n    const typeOut: Record<string, JsonObject> = {};\n    for (const [typeName, ty] of Object.entries(ns.entries.type)) {\n      typeOut[typeName] = this.serializeJsonValue(ty) as JsonObject;\n    }\n    return {\n      id: ns.id,\n      kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n      entries: {\n        table: tablesOut,\n        type: typeOut,\n      },\n    };\n  }\n\n  private serializeJsonValue(value: unknown): unknown {\n    return JSON.parse(JSON.stringify(value)) as unknown;\n  }\n}\n"],"mappings":";;;;;;;AAwBA,MAAM,yBAAiD;CACrD,QAAQ;CACR,QAAQ;AACV;AAEA,SAAS,mCACP,QAC8D;CAC9D,OACE,OAAO,WAAW,YAClB,WAAW,QACX,OAAQ,OAA4C,YAAY;AAEpE;;;;;;AAOA,SAAS,mCAAmC,WAG1C;CACA,MAAM,qCAAqB,IAAI,IAAuC;CACtE,MAAM,qCAAqB,IAAI,IAA2B;CAC1D,MAAM,QAAQ,SAA6C;EACzD,KAAK,MAAM,SAAS,OAAO,OAAO,IAAI,GAAG;GACvC,IAAI,gCAAgC,KAAK,GAAG;IAC1C,IAAI,mCAAmC,MAAM,MAAM,GAAG;KACpD,MAAM,EAAE,YAAY,MAAM;KAC1B,mBAAmB,IAAI,MAAM,gBAAgB,QAC3C,QAAQ,KAAK,sBAAsB,CACrC;IACF;IACA,IAAI,MAAM,oBAAoB,KAAA,GAC5B,mBAAmB,IAAI,MAAM,eAAe,MAAM,eAAe;IAEnE;GACF;GACA,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,KAAK,KAAK;EAEd;CACF;CACA,KAAK,SAAS;CACd,OAAO;EAAE;EAAoB;CAAmB;AAClD;AAEA,IAAa,6BAAb,cAAgD,0BAAgD;CAC9F,cAAc;EACZ,MAAM,EAAE,oBAAoB,uBAAuB,mCACjD,4BACF;EACA,MAAM,oBAAoB,kBAAkB;CAC9C;CAEA,yBACE,MACA,KACqC;EACrC,IAAI,eAAe,eACjB,OAAO;EAMT,MAAM,EAAE,IAAI,YAJK,UAGf,MAAM,yBAAyB,MAAM,GAAG,CACX;EAK/B,MAAM,aAAaA,IAAU;EAC7B,IAAI;EACJ,IAAI,eAAe,QAAQ,OAAO,eAAe,YAAY,CAAC,MAAM,QAAQ,UAAU,GAAG;GACvF,MAAM,cAAe,WAAuC;GAC5D,IAAI,gBAAgB,QAAQ,OAAO,gBAAgB,YAAY,CAAC,MAAM,QAAQ,WAAW,GAAG;IAC1F,MAAM,cAAc,KAAK,mBAAmB,IAAI,eAAe;IAC/D,WAAW,OAAO,YAChB,OAAO,QAAQ,WAAsC,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAC5E,MACA,UACE,gBAAgB,KAAA,IAAY,YAAY,KAAK,IAAI,KACnD,CACF,CAAC,CACH;GACF;EACF;EAEA,MAAM,cAAc,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC,WAAW;EAC1D,MAAM,aAAa,CAAC,YAAY,OAAO,KAAK,QAAQ,CAAC,CAAC,WAAW;EACjE,IAAI,OAAO,wBAAwB,eAAe,YAChD,OAAO,eAAe;EAExB,OAAO,IAAI,eAAe;GACxB;GACA,SAAS;IACP,OAAO,QAAQ;IACf,MAAM,YAAY,CAAC;GACrB;EACF,CAAC;CACH;CAEA,kBAA2B,UAA4C;EACrE,MAAM,EAAE,SAAS,GAAG,SAAS;EAC7B,MAAM,iBAA6C,CAAC;EACpD,KAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,QAAQ,UAAU,GACxD,IAAI,iBAAiB,EAAE,GACrB,eAAe,QAAQ,KAAK,2BAA2B,IAAI,GAAG,OAAO,oBAAoB;OAGzF,eAAe,QAAQ;GACrB,IAAI;GACJ,MAHoB,SAAS,uBAGP,4BAA4B;GAClD,SAAS,EACP,OAAO,OAAO,YACZ,OAAO,QAAQ,GAAG,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,WAAW,WAAW,CAC3D,WACA,KAAK,mBAAmB,KAAK,CAC/B,CAAC,CACH,EACF;EACF;EAGJ,MAAM,aAAsC;GAC1C,aAAa,OAAO,QAAQ,WAAW;GACvC,YAAY;EACd;EACA,IAAI,QAAQ,UAAU,KAAA,GAAW;GAC/B,MAAM,WAAuC,CAAC;GAC9C,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,KAAK,GACtD,SAAS,QAAQ,KAAK,mBAAmB,KAAK;GAEhD,WAAW,WAAW;EACxB;EACA,OAAO;GACL,GAAG;GACH,SAAS;EACX;CACF;CAEA,2BAAmC,IAAoB,eAAoC;EACzF,MAAM,YAAwC,CAAC;EAC/C,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,QAAQ,KAAK,GAC9D,UAAU,aAAa,KAAK,mBAAmB,KAAK;EAEtD,MAAM,UAAsC,CAAC;EAC7C,KAAK,MAAM,CAAC,UAAU,OAAO,OAAO,QAAQ,GAAG,QAAQ,IAAI,GACzD,QAAQ,YAAY,KAAK,mBAAmB,EAAE;EAEhD,OAAO;GACL,IAAI,GAAG;GACP,MAAM,gBAAgB,4BAA4B;GAClD,SAAS;IACP,OAAO;IACP,MAAM;GACR;EACF;CACF;CAEA,mBAA2B,OAAyB;EAClD,OAAO,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;CACzC;AACF"}

package/dist/{postgres-enum-type-CSzsvXrO.d.mts → postgres-enum-type-BVn63a89.d.mts}

@@ -69,4 +69,4 @@ declare class PostgresEnumType<TName extends string = string, TValues extends re
 }
 //#endregion
 export { PostgresEnumTypeInput as n, PostgresEnumType as t };
-//# sourceMappingURL=postgres-enum-type-CSzsvXrO.d.mts.map
+//# sourceMappingURL=postgres-enum-type-BVn63a89.d.mts.map

package/dist/{postgres-enum-type-CSzsvXrO.d.mts.map → postgres-enum-type-BVn63a89.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-enum-type-CSzsvXrO.d.mts","names":[],"sources":["../src/core/postgres-enum-type.ts"],"mappings":";;;;UAIiB,qBAAA;;AAAjB;;;;WASW,IAAA,EAAM,KAAA;EAQI;;;;;EAAA,SAFV,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAAA,SACR,OAAA,GAAU,aAAA;AAAA;;cAIf,gBAAA;;;AAJ4B;AACjC;;;;AAGqB;AAyBtB;;;;;;;;;;;;;;;cAAa,gBAAA,+FAGH,OAAA;EAAA,SACU,IAAA;EAAA,SACT,IAAA,EAAM,KAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAFF;;;;;;;;;EAAA,SAYN,OAAA,SAAgB,gBAAA;EAAA,SACR,OAAA,GAAU,aAAA;cAEf,KAAA,EAAO,qBAAA,CAAsB,KAAA,EAAO,OAAA;EAAA,IAY5C,YAAA,CAAA;IAAA,SACO,OAAA,SAAgB,gBAAA;IAAA,SAChB,UAAA;MAAA,SAAuB,MAAA,EAAQ,OAAA;IAAA;EAAA;AAAA"}
+{"version":3,"file":"postgres-enum-type-BVn63a89.d.mts","names":[],"sources":["../src/core/postgres-enum-type.ts"],"mappings":";;;;UAIiB,qBAAA;;AAAjB;;;;WASW,IAAA,EAAM,KAAA;EAQI;;;;;EAAA,SAFV,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAAA,SACR,OAAA,GAAU,aAAA;AAAA;;cAIf,gBAAA;;;AAJ4B;AACjC;;;;AAGqB;AAyBtB;;;;;;;;;;;;;;;cAAa,gBAAA,+FAGH,OAAA;EAAA,SACU,IAAA;EAAA,SACT,IAAA,EAAM,KAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAFF;;;;;;;;;EAAA,SAYN,OAAA,SAAgB,gBAAA;EAAA,SACR,OAAA,GAAU,aAAA;cAEf,KAAA,EAAO,qBAAA,CAAsB,KAAA,EAAO,OAAA;EAAA,IAY5C,YAAA;IAAA,SACO,OAAA,SAAgB,gBAAA;IAAA,SAChB,UAAA;MAAA,SAAuB,MAAA,EAAQ,OAAA;IAAA;EAAA;AAAA"}

package/dist/{postgres-enum-type-BMgyxNyy.mjs → postgres-enum-type-DPKqCBem.mjs}

@@ -59,4 +59,4 @@ var PostgresEnumType = class extends SqlNode {
 //#endregion
 export { PostgresEnumType as t };
 
-//# sourceMappingURL=postgres-enum-type-BMgyxNyy.mjs.map
+//# sourceMappingURL=postgres-enum-type-DPKqCBem.mjs.map

package/dist/{postgres-enum-type-BMgyxNyy.mjs.map → postgres-enum-type-DPKqCBem.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-enum-type-BMgyxNyy.mjs","names":[],"sources":["../src/core/postgres-enum-type.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresEnumTypeInput<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> {\n  /**\n   * Contract-level enum name (e.g. `'Role'`). Used as the key in\n   * `SqlStorage.types` and as the contract-facing identifier in\n   * planner / verifier diagnostics.\n   */\n  readonly name: TName;\n  /**\n   * Postgres-side native type name created by `CREATE TYPE … AS ENUM`.\n   * Defaults to `name` when not overridden via PSL `@map(...)` or the\n   * TS authoring surface.\n   */\n  readonly nativeType?: string;\n  readonly values: TValues;\n  readonly control?: ControlPolicy;\n}\n\n/** Codec id used by Postgres enum-typed columns (text wire format). */\nconst PG_ENUM_CODEC_ID = 'pg/enum@1';\n\n/**\n * Postgres IR class for the `CREATE TYPE … AS ENUM` concept.\n *\n * Per Decision 18, enum is a target-only concept (Postgres alone today;\n * SQLite emulates via CHECK constraints). There is no family-layer\n * enum abstract — the abstract-earns-existence rule keeps the IR class\n * hierarchy minimal: this class extends `SqlNode` directly and is the\n * single concrete representation of the polymorphic `'postgres-enum'`\n * slot variant.\n *\n * Carries Postgres-specific resolution (`nativeType` defaults to\n * `name`; `values` is frozen at construction time). Constructor calls\n * `freezeNode(this)` per Decision 8 — the instance is fully immutable,\n * JSON-clean, and dispatchable on its enumerable `kind: 'postgres-enum'`\n * literal.\n *\n * The family-layer slot dispatch (verifier, planner, lowering, etc.)\n * narrows polymorphic `StorageType` entries via the `kind` literal\n * (e.g. `isPostgresEnumStorageEntry`) — SQL-domain code must not import\n * `target-postgres` directly (cross-domain layering rule). The\n * structural interface lives at the family layer for that purpose;\n * this class is the runtime concrete that satisfies it.\n */\nexport class PostgresEnumType<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> extends SqlNode {\n  override readonly kind = 'postgres-enum' as const;\n  readonly name: TName;\n  readonly nativeType: string;\n  readonly values: TValues;\n  /**\n   * Enumerable own property so the persisted JSON envelope carries\n   * `codecId: 'pg/enum@1'` alongside `kind: 'postgres-enum'`. The\n   * runtime path (`codecRefForStorageColumn`, `assertColumnCodecIntegrity`)\n   * receives JSON-shaped contracts (e.g. inside a user-written\n   * `migration.ts` that loads `endContract` from `end-contract.json`)\n   * and reads `codecId` directly from the envelope rather than\n   * dispatching through the prototype-only `codecBinding` accessor.\n   */\n  readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresEnumTypeInput<TName, TValues>) {\n    super();\n    this.name = input.name;\n    this.nativeType = input.nativeType ?? input.name;\n    // `Object.freeze` returns `Readonly<string[]>`, widening past the\n    // `TValues` literal tuple. Cast preserves the caller-supplied\n    // tuple shape so inferred contract types retain literal narrowing.\n    this.values = Object.freeze([...input.values] as unknown as TValues);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n\n  get codecBinding(): {\n    readonly codecId: typeof PG_ENUM_CODEC_ID;\n    readonly typeParams: { readonly values: TValues };\n  } {\n    return { codecId: PG_ENUM_CODEC_ID, typeParams: { values: this.values } };\n  }\n}\n"],"mappings":";;;;AAyBA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;AAyBzB,IAAa,mBAAb,cAGU,QAAQ;CAChB,OAAyB;CACzB;CACA;CACA;;;;;;;;;;CAUA,UAA4C;CAG5C,YAAY,OAA8C;EACxD,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM,cAAc,MAAM;EAI5C,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAuB;EACnE,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,WAAW,IAAI;CACjB;CAEA,IAAI,eAGF;EACA,OAAO;GAAE,SAAS;GAAkB,YAAY,EAAE,QAAQ,KAAK,OAAO;EAAE;CAC1E;AACF"}
+{"version":3,"file":"postgres-enum-type-DPKqCBem.mjs","names":[],"sources":["../src/core/postgres-enum-type.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresEnumTypeInput<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> {\n  /**\n   * Contract-level enum name (e.g. `'Role'`). Used as the key in\n   * `SqlStorage.types` and as the contract-facing identifier in\n   * planner / verifier diagnostics.\n   */\n  readonly name: TName;\n  /**\n   * Postgres-side native type name created by `CREATE TYPE … AS ENUM`.\n   * Defaults to `name` when not overridden via PSL `@map(...)` or the\n   * TS authoring surface.\n   */\n  readonly nativeType?: string;\n  readonly values: TValues;\n  readonly control?: ControlPolicy;\n}\n\n/** Codec id used by Postgres enum-typed columns (text wire format). */\nconst PG_ENUM_CODEC_ID = 'pg/enum@1';\n\n/**\n * Postgres IR class for the `CREATE TYPE … AS ENUM` concept.\n *\n * Per Decision 18, enum is a target-only concept (Postgres alone today;\n * SQLite emulates via CHECK constraints). There is no family-layer\n * enum abstract — the abstract-earns-existence rule keeps the IR class\n * hierarchy minimal: this class extends `SqlNode` directly and is the\n * single concrete representation of the polymorphic `'postgres-enum'`\n * slot variant.\n *\n * Carries Postgres-specific resolution (`nativeType` defaults to\n * `name`; `values` is frozen at construction time). Constructor calls\n * `freezeNode(this)` per Decision 8 — the instance is fully immutable,\n * JSON-clean, and dispatchable on its enumerable `kind: 'postgres-enum'`\n * literal.\n *\n * The family-layer slot dispatch (verifier, planner, lowering, etc.)\n * narrows polymorphic `StorageType` entries via the `kind` literal\n * (e.g. `isPostgresEnumStorageEntry`) — SQL-domain code must not import\n * `target-postgres` directly (cross-domain layering rule). The\n * structural interface lives at the family layer for that purpose;\n * this class is the runtime concrete that satisfies it.\n */\nexport class PostgresEnumType<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> extends SqlNode {\n  override readonly kind = 'postgres-enum' as const;\n  readonly name: TName;\n  readonly nativeType: string;\n  readonly values: TValues;\n  /**\n   * Enumerable own property so the persisted JSON envelope carries\n   * `codecId: 'pg/enum@1'` alongside `kind: 'postgres-enum'`. The\n   * runtime path (`codecRefForStorageColumn`, `assertColumnCodecIntegrity`)\n   * receives JSON-shaped contracts (e.g. inside a user-written\n   * `migration.ts` that loads `endContract` from `end-contract.json`)\n   * and reads `codecId` directly from the envelope rather than\n   * dispatching through the prototype-only `codecBinding` accessor.\n   */\n  readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresEnumTypeInput<TName, TValues>) {\n    super();\n    this.name = input.name;\n    this.nativeType = input.nativeType ?? input.name;\n    // `Object.freeze` returns `Readonly<string[]>`, widening past the\n    // `TValues` literal tuple. Cast preserves the caller-supplied\n    // tuple shape so inferred contract types retain literal narrowing.\n    this.values = Object.freeze([...input.values] as unknown as TValues);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n\n  get codecBinding(): {\n    readonly codecId: typeof PG_ENUM_CODEC_ID;\n    readonly typeParams: { readonly values: TValues };\n  } {\n    return { codecId: PG_ENUM_CODEC_ID, typeParams: { values: this.values } };\n  }\n}\n"],"mappings":";;;;AAyBA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;AAyBzB,IAAa,mBAAb,cAGU,QAAQ;CAChB,OAAyB;CACzB;CACA;CACA;;;;;;;;;;CAUA,UAA4C;CAG5C,YAAY,OAA8C;EACxD,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM,cAAc,MAAM;EAI5C,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAuB;EACnE,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,WAAW,IAAI;CACjB;CAEA,IAAI,eAGF;EACA,OAAO;GAAE,SAAS;GAAkB,YAAY,EAAE,QAAQ,KAAK,OAAO;EAAE;CAC1E;AACF"}

package/dist/{postgres-migration-DRY8V-bQ.d.mts → postgres-migration--iqDr7rB.d.mts}

@@ -1,5 +1,5 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-a_wuOiYf.mjs";
-import { n as DataTransformOptions } from "./data-transform-CAPmAdxS.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DyUHJ7MY.mjs";
+import { n as DataTransformOptions } from "./data-transform-lq3NGdIt.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/family-sql/migration";
@@ -47,4 +47,4 @@ declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDet
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-DRY8V-bQ.d.mts.map
+//# sourceMappingURL=postgres-migration--iqDr7rB.d.mts.map

package/dist/{postgres-migration-DRY8V-bQ.d.mts.map → postgres-migration--iqDr7rB.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration-DRY8V-bQ.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,SAAA,CAC9C,yBAAA;EAAA,SAGS,QAAA;;;;;;;qBAQU,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAgBlB;;;;;EAAA,UADQ,aAAA,mBAAgC,QAAA,CAAS,UAAA,EAAA,CACjD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,GACR,yBAAA,CAA0B,yBAAA;AAAA"}
+{"version":3,"file":"postgres-migration--iqDr7rB.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,SAAA,CAC9C,yBAAA;EAAA,SAGS,QAAA;;;;;;;qBAQU,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAgBlB;;;;;EAAA,UADQ,aAAA,mBAAgC,QAAA,CAAS,UAAA,GACjD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,GACR,yBAAA,CAA0B,yBAAA;AAAA"}

package/dist/{postgres-migration-BatbEvU6.mjs → postgres-migration-DcymFlMG.mjs}

@@ -1,5 +1,5 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-BbnITmAD.mjs";
-import { t as dataTransform } from "./data-transform-CRkv2T_U.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
+import { t as dataTransform } from "./data-transform-D25tLeYU.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 //#region src/core/migrations/postgres-migration.ts
 /**
@@ -48,4 +48,4 @@ var PostgresMigration = class extends Migration {
 //#endregion
 export { PostgresMigration as t };
 
-//# sourceMappingURL=postgres-migration-BatbEvU6.mjs.map
+//# sourceMappingURL=postgres-migration-DcymFlMG.mjs.map

package/dist/{postgres-migration-BatbEvU6.mjs.map → postgres-migration-DcymFlMG.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration-BatbEvU6.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 type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\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  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,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,SACsD;EACtD,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,cAAc;CACnE;AACF"}
+{"version":3,"file":"postgres-migration-DcymFlMG.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 type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\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  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,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,SACsD;EACtD,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,cAAc;CACnE;AACF"}

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

@@ -1,5 +1,5 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-BMgyxNyy.mjs";
-import { n as escapeLiteral } from "./sql-utils-CggjWNij.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.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";
 //#region src/core/postgres-schema.ts
@@ -9,9 +9,10 @@ import { StorageTable } from "@prisma-next/sql-contract/types";
 * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
 * the Postgres PSL interpreter from `namespace { … }` AST buckets.
 *
-* 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.
+* `entries` holds entity-kind slot maps (`table`, `type`). 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.
 * The unbound singleton below overrides these methods to elide the
 * prefix entirely — call sites stay polymorphic and never branch on
 * `id === UNBOUND_NAMESPACE_ID`.
@@ -26,13 +27,14 @@ var PostgresSchema = class extends NamespaceBase {
 	*/
 	static unbound;
 	id;
-	tables;
-	enum;
+	entries;
 	constructor(input) {
 		super();
 		this.id = input.id;
-		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables ?? {}).map(([name, t]) => [name, t instanceof StorageTable ? t : new StorageTable(t)])));
-		this.enum = Object.freeze(Object.fromEntries(Object.entries(input.enum ?? {}).map(([name, ty]) => [name, ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty)])));
+		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)])))
+		});
 		Object.defineProperty(this, "kind", {
 			value: "schema",
 			writable: false,
@@ -115,7 +117,13 @@ var PostgresSchema = class extends NamespaceBase {
 var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	static instance = new PostgresUnboundSchema();
 	constructor(input) {
-		super(input ?? { id: UNBOUND_NAMESPACE_ID });
+		super(input ?? {
+			id: UNBOUND_NAMESPACE_ID,
+			entries: {
+				table: {},
+				type: {}
+			}
+		});
 	}
 	qualifier() {
 		return "";
@@ -151,11 +159,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) {
-	if (input.id === UNBOUND_NAMESPACE_ID) return new PostgresUnboundSchema(input);
-	return new PostgresSchema(input);
+function postgresCreateNamespace(input, enumTypes) {
+	const schemaInput = {
+		id: input.id,
+		entries: {
+			table: input.entries.table,
+			type: enumTypes ?? {}
+		}
+	};
+	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 };
 
-//# sourceMappingURL=postgres-schema-BxAuNFX0.mjs.map
+//# sourceMappingURL=postgres-schema-BuxCxbvB.mjs.map