@prisma-next/target-postgres 0.12.0 → 0.13.0-dev.2

package/dist/{descriptor-meta-DLA2xV6B.mjs → descriptor-meta-runtime-My8_s4cs.mjs}

@@ -1,4 +1,4 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
 import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
 import { PostgresEnumTypeSchema } from "@prisma-next/sql-contract/validators";
 //#region src/core/authoring.ts
@@ -39,88 +39,92 @@ const postgresAuthoringEntityTypes = { enum: {
 	validatorSchema: PostgresEnumTypeSchema,
 	output: { factory: (input) => new PostgresEnumType(input) }
 } };
-const postgresTargetDescriptorMeta = {
+/**
+* Field presets contributed by the Postgres target pack.
+*
+* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
+* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
+* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
+* surface (e.g. `Int`) lowers to byte-identical contracts.
+*/
+const postgresAuthoringFieldPresets = {
+	text: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/text@1",
+			nativeType: "text"
+		}
+	},
+	int: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int4@1",
+			nativeType: "int4"
+		}
+	},
+	bigint: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int8@1",
+			nativeType: "int8"
+		}
+	},
+	float: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/float8@1",
+			nativeType: "float8"
+		}
+	},
+	decimal: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric"
+		}
+	},
+	boolean: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bool@1",
+			nativeType: "bool"
+		}
+	},
+	json: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/jsonb@1",
+			nativeType: "jsonb"
+		}
+	},
+	bytes: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bytea@1",
+			nativeType: "bytea"
+		}
+	},
+	dateTime: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/timestamptz@1",
+			nativeType: "timestamptz"
+		}
+	},
+	temporal: /* @__PURE__ */ temporalAuthoringPresets({
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	})
+};
+const postgresTargetDescriptorMetaRuntime = {
 	kind: "target",
 	familyId: "sql",
 	targetId: "postgres",
 	id: "postgres",
 	version: "0.0.1",
-	capabilities: {},
-	authoring: {
-		type: postgresAuthoringTypes,
-		field: {
-			text: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/text@1",
-					nativeType: "text"
-				}
-			},
-			int: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/int4@1",
-					nativeType: "int4"
-				}
-			},
-			bigint: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/int8@1",
-					nativeType: "int8"
-				}
-			},
-			float: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/float8@1",
-					nativeType: "float8"
-				}
-			},
-			decimal: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/numeric@1",
-					nativeType: "numeric"
-				}
-			},
-			boolean: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/bool@1",
-					nativeType: "bool"
-				}
-			},
-			json: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/jsonb@1",
-					nativeType: "jsonb"
-				}
-			},
-			bytes: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/bytea@1",
-					nativeType: "bytea"
-				}
-			},
-			dateTime: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/timestamptz@1",
-					nativeType: "timestamptz"
-				}
-			},
-			temporal: temporalAuthoringPresets({
-				codecId: "pg/timestamptz@1",
-				nativeType: "timestamptz"
-			})
-		},
-		entityTypes: postgresAuthoringEntityTypes
-	}
+	capabilities: {}
 };
 //#endregion
-export { postgresAuthoringEntityTypes as n, postgresTargetDescriptorMeta as t };
+export { postgresAuthoringTypes as i, postgresAuthoringEntityTypes as n, postgresAuthoringFieldPresets as r, postgresTargetDescriptorMetaRuntime as t };
 
-//# sourceMappingURL=descriptor-meta-DLA2xV6B.mjs.map
+//# sourceMappingURL=descriptor-meta-runtime-My8_s4cs.mjs.map

package/dist/descriptor-meta-runtime-My8_s4cs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-runtime-My8_s4cs.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta-runtime.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\nimport type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';\nimport { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\n/**\n * Entity type contributions surface as top-level helpers on the\n * composed-helpers shape (e.g. `helpers.enum({...})`), flattened\n * alongside the built-in `model` / `rel` helpers. Pack contributions\n * still ship via the contribution data structure\n * `authoring.entityTypes.<name>`; the composed-helpers template\n * performs the rename in the type system.\n *\n * `enum` is the first real consumer of the entities-namespace mechanism:\n * the factory constructs a `PostgresEnumType` IR-class instance from\n * the user-supplied input. Both authoring runtimes (TS DSL and PSL)\n * dispatch through this single contribution — PSL `enum Status { … }`\n * declarations are lowered by the interpreter into a factory call\n * with the parsed name + value list; TS DSL `helpers.enum({...})`\n * resolves through the same path. Removing this contribution makes\n * both surfaces fail with a \"no entity helper named `enum`\" type\n * error at the contract-definition site.\n */\n/**\n * The factory constructs a `PostgresEnumType` instance natively — the\n * `SqlStorage.types` slot accepts polymorphic IR (the framework\n * `StorageType` alphabet), so no cast is needed at the contribution\n * surface. The declared return type is the structural\n * `PostgresEnumStorageEntry` so the inferred contract type stays\n * portable (it names a type exported from\n * `@prisma-next/sql-contract/types`, a public surface every consumer\n * already imports). Sharpening the inferred contract type to surface\n * enum-specific narrowing through `EntityHelperFunction` is a\n * separable refinement and lives outside this PR.\n */\nexport const postgresAuthoringEntityTypes = {\n  enum: {\n    kind: 'entity',\n    discriminator: 'postgres-enum',\n    validatorSchema: PostgresEnumTypeSchema,\n    output: {\n      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>\n        new PostgresEnumType(input),\n    },\n  },\n} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n */\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: /* @__PURE__ */ temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n} as const satisfies AuthoringFieldNamespace;\n","// Runtime-safe slice of the postgres target descriptor metadata.\n//\n// This file exists separately from ./descriptor-meta on purpose: the runtime\n// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the\n// `__codecTypes` phantom). The `authoring` slot lives on the pack/control\n// descriptor only, because authoring contributions are consumed at\n// contract-construction time by `assembleAuthoringContributions` (control\n// plane) and the PSL interpreter — never at runtime.\n//\n// Keeping the runtime closure free of the `./authoring` import is what lets\n// the bundler tree-shake `@prisma-next/family-sql/control` (and its\n// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not\n// add an `authoring` field here — if you need to, the pack/control meta in\n// `./descriptor-meta` is the right place. See TML-2766 for context.\nimport type { CodecTypes } from '../exports/codec-types';\n\nconst postgresTargetDescriptorMetaRuntimeBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaRuntimeBase;\n"],"mappings":";;;;AAUA,MAAa,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCvC,MAAa,+BAA+B,EAC1C,MAAM;CACJ,MAAM;CACN,eAAe;CACf,iBAAiB;CACjB,QAAQ,EACN,UAAU,UACR,IAAI,iBAAiB,KAAK,EAC9B;AACF,EACF;;;;;;;;;AAUA,MAAa,gCAAgC;CAC3C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,KAAK;EACH,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,QAAQ;EACN,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAA0B,yCAAyB;EACjD,SAAS;EACT,YAAY;CACd,CAAC;AACH;ACzGA,MAAa,sCAET;CAVF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,CAAC;AAKb"}

package/dist/{enum-planning-Dz0Ye3Lb.mjs.map → enum-planning-BCyvlFHk.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"enum-planning-Dz0Ye3Lb.mjs","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"sourcesContent":["/**\n * Pure planning helpers for Postgres enum types: the diff/rebuild logic\n * that the verifier and planner use to walk `PostgresEnumType` instances\n * natively. Op builders live in `./operations/enums.ts`.\n */\n\nimport { arraysEqual } from '@prisma-next/family-sql/schema-verify';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { PG_ENUM_CODEC_ID } from '../codec-ids';\nimport type { PostgresEnumType } from '../postgres-enum-type';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Codec-typed enum entry shape stored under\n * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.\n */\ninterface PgStorageTypeEntry {\n  readonly codecId?: string;\n  readonly typeParams?: { readonly values?: unknown };\n}\n\n/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */\nexport interface PostgresSchemaIrAnnotations {\n  readonly schema?: string;\n  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;\n}\n\nfunction readOptionalString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nfunction readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const codecId = Reflect.get(value, 'codecId');\n  const typeParamsRaw = Reflect.get(value, 'typeParams');\n  const typeParams =\n    typeParamsRaw !== undefined &&\n    typeParamsRaw !== null &&\n    typeof typeParamsRaw === 'object' &&\n    !Array.isArray(typeParamsRaw)\n      ? { values: Reflect.get(typeParamsRaw, 'values') }\n      : undefined;\n  return {\n    ...(typeof codecId === 'string' ? { codecId } : {}),\n    ...(typeParams !== undefined ? { typeParams } : {}),\n  };\n}\n\nfunction readPgStorageTypesMap(\n  value: unknown,\n): Readonly<Record<string, PgStorageTypeEntry>> | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const entries: Record<string, PgStorageTypeEntry> = {};\n  for (const [key, entryValue] of Object.entries(value)) {\n    const entry = readPgStorageTypeEntry(entryValue);\n    if (entry !== undefined) {\n      entries[key] = entry;\n    }\n  }\n  return Object.keys(entries).length > 0 ? entries : undefined;\n}\n\n/**\n * Reads the Postgres annotation envelope (`schema.annotations.pg`) from\n * family Schema IR. `SqlAnnotations` is an open target-pack extensibility\n * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at\n * runtime so Postgres code can read introspection fields without casts.\n */\nexport function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {\n  const raw = schema.annotations?.['pg'];\n  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {\n    return {};\n  }\n  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));\n  const storageTypes = readPgStorageTypesMap(Reflect.get(raw, 'storageTypes'));\n  return {\n    ...(schemaField !== undefined ? { schema: schemaField } : {}),\n    ...(storageTypes !== undefined ? { storageTypes } : {}),\n  };\n}\n\n/**\n * Separator for `(schemaName, nativeType)` keys in introspected\n * `schema.annotations.pg.storageTypes`. NUL cannot appear in Postgres\n * identifiers, so the pair is unambiguous.\n */\nexport const ENUM_STORAGE_KEY_SEP = '\\u0000';\n\n/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */\nexport function enumStorageCompoundKey(schemaName: string, nativeType: string): string {\n  return `${schemaName}${ENUM_STORAGE_KEY_SEP}${nativeType}`;\n}\n\n/**\n * Resolves the live-schema name a namespace's enums are introspected under,\n * for keying `readExistingEnumValues` lookups. The unbound namespace's\n * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a\n * real schema, so for the unbound coordinate we read the *introspected* schema\n * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter\n * walked) — that is the schema the enum's `storageTypes` entry is keyed under.\n * Named namespaces resolve to their own DDL schema, which matches the\n * per-schema introspection key directly.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/** Contract-scoped bridge for the family verifier's enum value resolver. */\nexport function createResolveExistingEnumValues(\n  storage: SqlStorage,\n): (\n  schema: SqlSchemaIR,\n  enumType: PostgresEnumStorageEntry,\n  namespaceId: string,\n) => readonly string[] | null {\n  return (schema, enumType, namespaceId) =>\n    readExistingEnumValues(\n      schema,\n      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),\n      enumType.nativeType,\n    );\n}\n\n/**\n * Categorisation of how an existing enum type's values relate to the\n * desired set in the contract.\n */\nexport type EnumDiff =\n  | { readonly kind: 'unchanged' }\n  | { readonly kind: 'add_values'; readonly values: readonly string[] }\n  | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };\n\n/**\n * Reads existing enum values for `(schemaName, nativeType)` from the\n * Postgres-introspected `schema.annotations.pg.storageTypes` map.\n *\n * Schema IR's `storageTypes` slots are always codec-typed\n * (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector\n * writes that shape, and the Contract→Schema IR projector resolves\n * `PostgresEnumType` instances down to the same codec-typed triple before\n * they ever land in Schema IR. There is no second on-disk shape to\n * accept here.\n *\n * Returns `null` when no enum entry exists for the given native type.\n */\nexport function readExistingEnumValues(\n  schema: SqlSchemaIR,\n  schemaName: string,\n  nativeType: string,\n): readonly string[] | null {\n  const storageTypes = readPostgresSchemaIrAnnotations(schema).storageTypes;\n  const existing = storageTypes?.[enumStorageCompoundKey(schemaName, nativeType)];\n  if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {\n    return null;\n  }\n  const enumValues = existing.typeParams?.values;\n  if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {\n    return null;\n  }\n  return enumValues;\n}\n\n/**\n * Determines what changes are needed to transform existing enum values to\n * desired values.\n *\n * Postgres enums can only have values added (not removed or reordered)\n * without a full type rebuild involving temp type creation and column\n * migration; `'rebuild'` covers the value-removal and reorder cases.\n */\nexport function determineEnumDiff(\n  existing: readonly string[],\n  desired: readonly string[],\n): EnumDiff {\n  if (arraysEqual(existing, desired)) {\n    return { kind: 'unchanged' };\n  }\n  const existingSet = new Set(existing);\n  const desiredSet = new Set(desired);\n  const missingValues = desired.filter((value) => !existingSet.has(value));\n  const removedValues = existing.filter((value) => !desiredSet.has(value));\n  const orderMismatch =\n    missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);\n  if (removedValues.length > 0 || orderMismatch) {\n    return { kind: 'rebuild', removedValues };\n  }\n  return { kind: 'add_values', values: missingValues };\n}\n\n/**\n * Convenience accessor — returns the enum's desired values from a\n * `PostgresEnumType` IR instance.\n */\nexport function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[] {\n  return typeInstance.values;\n}\n"],"mappings":";;;;;;;;;;AA6BA,SAAS,mBAAmB,OAAoC;CAC9D,OAAO,OAAO,UAAU,WAAW,QAAQ,KAAA;AAC7C;AAEA,SAAS,uBAAuB,OAAgD;CAC9E,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GACpE;CAEF,MAAM,UAAU,QAAQ,IAAI,OAAO,SAAS;CAC5C,MAAM,gBAAgB,QAAQ,IAAI,OAAO,YAAY;CACrD,MAAM,aACJ,kBAAkB,KAAA,KAClB,kBAAkB,QAClB,OAAO,kBAAkB,YACzB,CAAC,MAAM,QAAQ,aAAa,IACxB,EAAE,QAAQ,QAAQ,IAAI,eAAe,QAAQ,EAAE,IAC/C,KAAA;CACN,OAAO;EACL,GAAI,OAAO,YAAY,WAAW,EAAE,QAAQ,IAAI,CAAC;EACjD,GAAI,eAAe,KAAA,IAAY,EAAE,WAAW,IAAI,CAAC;CACnD;AACF;AAEA,SAAS,sBACP,OAC0D;CAC1D,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GACpE;CAEF,MAAM,UAA8C,CAAC;CACrD,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,KAAK,GAAG;EACrD,MAAM,QAAQ,uBAAuB,UAAU;EAC/C,IAAI,UAAU,KAAA,GACZ,QAAQ,OAAO;CAEnB;CACA,OAAO,OAAO,KAAK,OAAO,EAAE,SAAS,IAAI,UAAU,KAAA;AACrD;;;;;;;AAQA,SAAgB,gCAAgC,QAAkD;CAChG,MAAM,MAAM,OAAO,cAAc;CACjC,IAAI,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO,QAAQ,YAAY,MAAM,QAAQ,GAAG,GACnF,OAAO,CAAC;CAEV,MAAM,cAAc,mBAAmB,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACjE,MAAM,eAAe,sBAAsB,QAAQ,IAAI,KAAK,cAAc,CAAC;CAC3E,OAAO;EACL,GAAI,gBAAgB,KAAA,IAAY,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC3D,GAAI,iBAAiB,KAAA,IAAY,EAAE,aAAa,IAAI,CAAC;CACvD;AACF;;AAUA,SAAgB,uBAAuB,YAAoB,YAA4B;CACrF,OAAO,GAAG,cAAoC;AAChD;;;;;;;;;;;AAYA,SAAgB,oCACd,SACA,aACA,UACQ;CACR,IAAI,gBAAgB,sBAClB,QAAQ,WAAW,gCAAgC,QAAQ,EAAE,SAAS,KAAA,MAAc;CAEtF,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT;;AAGA,SAAgB,gCACd,SAK4B;CAC5B,QAAQ,QAAQ,UAAU,gBACxB,uBACE,QACA,oCAAoC,SAAS,aAAa,MAAM,GAChE,SAAS,UACX;AACJ;;;;;;;;;;;;;;AAwBA,SAAgB,uBACd,QACA,YACA,YAC0B;CAE1B,MAAM,WADe,gCAAgC,MAAM,EAAE,eAC7B,uBAAuB,YAAY,UAAU;CAC7E,IAAI,CAAC,YAAY,SAAS,YAAA,aACxB,OAAO;CAET,MAAM,aAAa,SAAS,YAAY;CACxC,IAAI,CAAC,MAAM,QAAQ,UAAU,KAAK,CAAC,WAAW,OAAO,MAAM,OAAO,MAAM,QAAQ,GAC9E,OAAO;CAET,OAAO;AACT;;;;;;;;;AAUA,SAAgB,kBACd,UACA,SACU;CACV,IAAI,YAAY,UAAU,OAAO,GAC/B,OAAO,EAAE,MAAM,YAAY;CAE7B,MAAM,cAAc,IAAI,IAAI,QAAQ;CACpC,MAAM,aAAa,IAAI,IAAI,OAAO;CAClC,MAAM,gBAAgB,QAAQ,QAAQ,UAAU,CAAC,YAAY,IAAI,KAAK,CAAC;CACvE,MAAM,gBAAgB,SAAS,QAAQ,UAAU,CAAC,WAAW,IAAI,KAAK,CAAC;CACvE,MAAM,gBACJ,cAAc,WAAW,KAAK,cAAc,WAAW,KAAK,CAAC,YAAY,UAAU,OAAO;CAC5F,IAAI,cAAc,SAAS,KAAK,eAC9B,OAAO;EAAE,MAAM;EAAW;CAAc;CAE1C,OAAO;EAAE,MAAM;EAAc,QAAQ;CAAc;AACrD;;;;;AAMA,SAAgB,qBAAqB,cAAmD;CACtF,OAAO,aAAa;AACtB"}
+{"version":3,"file":"enum-planning-BCyvlFHk.mjs","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"sourcesContent":["/**\n * Pure planning helpers for Postgres enum types: the diff/rebuild logic\n * that the verifier and planner use to walk `PostgresEnumType` instances\n * natively. Op builders live in `./operations/enums.ts`.\n */\n\nimport { arraysEqual } from '@prisma-next/family-sql/schema-verify';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { PG_ENUM_CODEC_ID } from '../codec-ids';\nimport type { PostgresEnumType } from '../postgres-enum-type';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Codec-typed enum entry shape stored under\n * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.\n */\ninterface PgStorageTypeEntry {\n  readonly codecId?: string;\n  readonly typeParams?: { readonly values?: unknown };\n}\n\n/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */\nexport interface PostgresSchemaIrAnnotations {\n  readonly schema?: string;\n  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;\n}\n\nfunction readOptionalString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nfunction readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const codecId = Reflect.get(value, 'codecId');\n  const typeParamsRaw = Reflect.get(value, 'typeParams');\n  const typeParams =\n    typeParamsRaw !== undefined &&\n    typeParamsRaw !== null &&\n    typeof typeParamsRaw === 'object' &&\n    !Array.isArray(typeParamsRaw)\n      ? { values: Reflect.get(typeParamsRaw, 'values') }\n      : undefined;\n  return {\n    ...(typeof codecId === 'string' ? { codecId } : {}),\n    ...(typeParams !== undefined ? { typeParams } : {}),\n  };\n}\n\nfunction readPgStorageTypesMap(\n  value: unknown,\n): Readonly<Record<string, PgStorageTypeEntry>> | undefined {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n  const entries: Record<string, PgStorageTypeEntry> = {};\n  for (const [key, entryValue] of Object.entries(value)) {\n    const entry = readPgStorageTypeEntry(entryValue);\n    if (entry !== undefined) {\n      entries[key] = entry;\n    }\n  }\n  return Object.keys(entries).length > 0 ? entries : undefined;\n}\n\n/**\n * Reads the Postgres annotation envelope (`schema.annotations.pg`) from\n * family Schema IR. `SqlAnnotations` is an open target-pack extensibility\n * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at\n * runtime so Postgres code can read introspection fields without casts.\n */\nexport function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {\n  const raw = schema.annotations?.['pg'];\n  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {\n    return {};\n  }\n  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));\n  const storageTypes = readPgStorageTypesMap(Reflect.get(raw, 'storageTypes'));\n  return {\n    ...(schemaField !== undefined ? { schema: schemaField } : {}),\n    ...(storageTypes !== undefined ? { storageTypes } : {}),\n  };\n}\n\n/**\n * Separator for `(schemaName, nativeType)` keys in introspected\n * `schema.annotations.pg.storageTypes`. NUL cannot appear in Postgres\n * identifiers, so the pair is unambiguous.\n */\nexport const ENUM_STORAGE_KEY_SEP = '\\u0000';\n\n/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */\nexport function enumStorageCompoundKey(schemaName: string, nativeType: string): string {\n  return `${schemaName}${ENUM_STORAGE_KEY_SEP}${nativeType}`;\n}\n\n/**\n * Resolves the live-schema name a namespace's enums are introspected under,\n * for keying `readExistingEnumValues` lookups. The unbound namespace's\n * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a\n * real schema, so for the unbound coordinate we read the *introspected* schema\n * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter\n * walked) — that is the schema the enum's `storageTypes` entry is keyed under.\n * Named namespaces resolve to their own DDL schema, which matches the\n * per-schema introspection key directly.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/** Contract-scoped bridge for the family verifier's enum value resolver. */\nexport function createResolveExistingEnumValues(\n  storage: SqlStorage,\n): (\n  schema: SqlSchemaIR,\n  enumType: PostgresEnumStorageEntry,\n  namespaceId: string,\n) => readonly string[] | null {\n  return (schema, enumType, namespaceId) =>\n    readExistingEnumValues(\n      schema,\n      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),\n      enumType.nativeType,\n    );\n}\n\n/**\n * Categorisation of how an existing enum type's values relate to the\n * desired set in the contract.\n */\nexport type EnumDiff =\n  | { readonly kind: 'unchanged' }\n  | { readonly kind: 'add_values'; readonly values: readonly string[] }\n  | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };\n\n/**\n * Reads existing enum values for `(schemaName, nativeType)` from the\n * Postgres-introspected `schema.annotations.pg.storageTypes` map.\n *\n * Schema IR's `storageTypes` slots are always codec-typed\n * (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector\n * writes that shape, and the Contract→Schema IR projector resolves\n * `PostgresEnumType` instances down to the same codec-typed triple before\n * they ever land in Schema IR. There is no second on-disk shape to\n * accept here.\n *\n * Returns `null` when no enum entry exists for the given native type.\n */\nexport function readExistingEnumValues(\n  schema: SqlSchemaIR,\n  schemaName: string,\n  nativeType: string,\n): readonly string[] | null {\n  const storageTypes = readPostgresSchemaIrAnnotations(schema).storageTypes;\n  const existing = storageTypes?.[enumStorageCompoundKey(schemaName, nativeType)];\n  if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {\n    return null;\n  }\n  const enumValues = existing.typeParams?.values;\n  if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {\n    return null;\n  }\n  return enumValues;\n}\n\n/**\n * Determines what changes are needed to transform existing enum values to\n * desired values.\n *\n * Postgres enums can only have values added (not removed or reordered)\n * without a full type rebuild involving temp type creation and column\n * migration; `'rebuild'` covers the value-removal and reorder cases.\n */\nexport function determineEnumDiff(\n  existing: readonly string[],\n  desired: readonly string[],\n): EnumDiff {\n  if (arraysEqual(existing, desired)) {\n    return { kind: 'unchanged' };\n  }\n  const existingSet = new Set(existing);\n  const desiredSet = new Set(desired);\n  const missingValues = desired.filter((value) => !existingSet.has(value));\n  const removedValues = existing.filter((value) => !desiredSet.has(value));\n  const orderMismatch =\n    missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);\n  if (removedValues.length > 0 || orderMismatch) {\n    return { kind: 'rebuild', removedValues };\n  }\n  return { kind: 'add_values', values: missingValues };\n}\n\n/**\n * Convenience accessor — returns the enum's desired values from a\n * `PostgresEnumType` IR instance.\n */\nexport function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[] {\n  return typeInstance.values;\n}\n"],"mappings":"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"}

package/dist/enum-planning.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-CNhPTDhy.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-BVn63a89.mjs";
 import { PostgresEnumStorageEntry, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 

package/dist/enum-planning.mjs

@@ -1,2 +1,2 @@
-import { a as readExistingEnumValues, i as getDesiredEnumValues, n as determineEnumDiff, o as readPostgresSchemaIrAnnotations, r as enumStorageCompoundKey, s as resolveDdlSchemaForNamespaceStorage, t as createResolveExistingEnumValues } from "./enum-planning-Dz0Ye3Lb.mjs";
+import { a as readExistingEnumValues, i as getDesiredEnumValues, n as determineEnumDiff, o as readPostgresSchemaIrAnnotations, r as enumStorageCompoundKey, s as resolveDdlSchemaForNamespaceStorage, t as createResolveExistingEnumValues } from "./enum-planning-BCyvlFHk.mjs";
 export { createResolveExistingEnumValues, determineEnumDiff, enumStorageCompoundKey, getDesiredEnumValues, readExistingEnumValues, readPostgresSchemaIrAnnotations, resolveDdlSchemaForNamespaceStorage };

package/dist/{errors--zafB5_n.mjs → errors-CUk87ByX.mjs}

@@ -30,4 +30,4 @@ function errorPostgresMigrationStackMissing() {
 //#endregion
 export { errorPostgresMigrationStackMissing as t };
 
-//# sourceMappingURL=errors--zafB5_n.mjs.map
+//# sourceMappingURL=errors-CUk87ByX.mjs.map

package/dist/{errors--zafB5_n.mjs.map → errors-CUk87ByX.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors--zafB5_n.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,CAAC;CACT,CACF;AACF"}
+{"version":3,"file":"errors-CUk87ByX.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,CAAC;CACT,CACF;AACF"}

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;AAAwE;;;;;;;;;;;;;iBAAxD,kCAAA,CAAA,GAAsC,kBAAkB"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;AAAwE;;;;;;;;;;;;;iBAAxD,kCAAA,IAAsC,kBAAkB"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors--zafB5_n.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
 export { errorPostgresMigrationStackMissing };

package/dist/{issue-planner-ByQhUzS4.mjs → issue-planner-Br0pt1Ea.mjs}

@@ -1,16 +1,19 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
-import { i as quoteIdentifier } from "./sql-utils-B_ruBD-M.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-Bm7vjlOv.mjs";
-import { a as readExistingEnumValues, n as determineEnumDiff, s as resolveDdlSchemaForNamespaceStorage } from "./enum-planning-Dz0Ye3Lb.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-D3H-xOO1.mjs";
-import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-B0WNg30h.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-BxRCSn_b.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-ojX-6cPV.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-BGyukuzG.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
+import { i as quoteIdentifier } from "./sql-utils-DcfMz4MQ.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-BuxCxbvB.mjs";
+import { a as readExistingEnumValues, n as determineEnumDiff, s as resolveDdlSchemaForNamespaceStorage } from "./enum-planning-BCyvlFHk.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-DAdhnI2c.mjs";
+import { C as RenameTypeCall, E as postgresDefaultToDdlColumnDefault, S as RawSqlCall, T as SetNotNullCall, _ as DropDefaultCall, a as AddPrimaryKeyCall, b as DropNotNullCall, c as CreateEnumTypeCall, d as CreateSchemaCall, f as CreateTableCall, g as DropConstraintCall, h as DropColumnCall, i as AddForeignKeyCall, m as DropCheckConstraintCall, n as AddColumnCall, o as AddUniqueCall, p as DataTransformCall, r as AddEnumValuesCall, s as AlterColumnTypeCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropEnumTypeCall, w as SetDefaultCall, x as DropTableCall, y as DropIndexCall } from "./op-factory-call-D2aAUhmS.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-Cw2n2llW.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-BIpa5p2I.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-CiVaAQP-.mjs";
+import { resolveValueSetValues } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
+import { StorageTable, isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
+import { blindCast } from "@prisma-next/utils/casts";
+import * as contractFree from "@prisma-next/sql-relational-core/contract-free";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/migrations/planner-target-details.ts
 function buildTargetDetails(objectType, name, schema, table) {
@@ -99,7 +102,7 @@ const REBUILD_SUFFIX = "__prisma_next_new";
 * contracts where two namespaces can carry the same table name).
 */
 function tableAt(storage, namespaceId, tableName) {
-	return storage.namespaces[namespaceId]?.tables[tableName];
+	return storage.namespaces[namespaceId]?.entries.table[tableName];
 }
 /**
 * Default namespace coordinate for an issue that does not carry one
@@ -134,8 +137,8 @@ function resolveDdlSchemaForNamespace(ctx, namespaceId) {
 const DEFAULT_ENUM_NAMESPACE_ID = "public";
 function namespaceHasEnum(storage, namespaceId, typeName) {
 	const ns = storage.namespaces[namespaceId];
-	if (!ns || !("enum" in ns) || ns.enum == null) return false;
-	return ns.enum[typeName] !== void 0;
+	if (!isPostgresSchema(ns)) return false;
+	return ns.entries.type[typeName] !== void 0;
 }
 /**
 * Resolves which namespace's enum a column's bare `typeRef` binds to.
@@ -158,14 +161,14 @@ function resolveColumnEnumNamespace(storage, columnNamespaceId, typeName) {
 }
 /**
 * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.
-* Postgres enums) live under `storage.namespaces[nsId].enum`. Returns the
+* Postgres enums) live under `storage.namespaces[nsId].entries.type`. Returns the
 * entry from the named namespace only — never scans other namespaces, so two
 * namespaces that hold an enum with the same name resolve independently.
 */
 function locateNamespaceType(storage, namespaceId, typeName) {
-	const ns = storage.namespaces[namespaceId];
-	if (!ns || !("enum" in ns) || ns.enum == null) return void 0;
-	return ns.enum[typeName];
+	const raw = storage.namespaces[namespaceId]?.entries["type"]?.[typeName];
+	if (raw === void 0) return void 0;
+	return blindCast(raw);
 }
 function buildColumnSpec(namespaceId, table, column, ctx, overrides) {
 	const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
@@ -176,6 +179,7 @@ function buildColumnSpec(namespaceId, table, column, ctx, overrides) {
 		name: column,
 		typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
 		defaultSql: buildColumnDefaultSql(col.default, col),
+		columnDefault: col.default,
 		nullable: overrides?.nullable ?? col.nullable
 	};
 }
@@ -282,7 +286,7 @@ function enumRebuildCallRecipe(namespaceId, typeName, ctx) {
 	const tempName = `${nativeType}${REBUILD_SUFFIX}`;
 	const ddlSchema = resolveDdlSchemaForNamespaceStorage(ctx.toContract.storage, namespaceId, ctx.schema);
 	const columnRefs = [];
-	for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const [tableName, tableNode] of Object.entries(ns.tables)) {
+	for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const [tableName, tableNode] of Object.entries(ns.entries.table)) {
 		const table = tableNode;
 		for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName && resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId) columnRefs.push({
 			namespaceId: nsId,
@@ -410,13 +414,89 @@ const nativeEnumPlanCallStrategy = (issues, ctx) => {
 function collectPostgresEnumTypes(storage) {
 	const result = /* @__PURE__ */ new Map();
 	for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-		if (!("enum" in ns) || ns.enum == null) continue;
-		const nsEnums = ns.enum;
-		for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(enumCompoundKey(nsId, name), instance);
+		if (!isPostgresSchema(ns)) continue;
+		for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(enumCompoundKey(nsId, name), instance);
 	}
 	return result;
 }
 /**
+* Collects every check constraint from a table in the contract storage.
+* Returns an empty array when the table has no checks or the table is absent.
+*/
+function collectContractChecks(storage, namespaceId, tableName) {
+	const tableRaw = storage.namespaces[namespaceId]?.entries.table[tableName];
+	if (!(tableRaw instanceof StorageTable)) return [];
+	const checks = tableRaw.checks;
+	if (!checks || checks.length === 0) return [];
+	return checks.map((c) => ({
+		name: c.name,
+		column: c.column,
+		permittedValues: resolveValueSetValues(c.valueSet, storage, `check "${c.name}" on "${tableName}"`)
+	}));
+}
+/**
+* Compares two value arrays as unordered sets.
+*/
+function checkValueSetsEqual(a, b) {
+	if (a.length !== b.length) return false;
+	const bSet = new Set(b);
+	return a.every((v) => bSet.has(v));
+}
+/**
+* Plans check-constraint migrations for `enumType`-authored columns.
+*
+* Walks every namespace's tables in the target contract. For each table that
+* carries `checks`, diffs the contract-expected checks against the live
+* schema's checks:
+*
+* - Check in contract, absent from live DB → `AddCheckConstraintCall`.
+* - Check in live DB, absent from contract → `DropCheckConstraintCall`.
+* - Check on both sides but value sets differ → `DropCheckConstraintCall`
+*   then `AddCheckConstraintCall` (drop + recreate; a check predicate cannot
+*   be altered in place).
+*
+* Consumes `check_missing`, `check_removed`, and `check_mismatch` issues.
+* Does not touch the native enum path (`nativeEnumPlanCallStrategy` is
+* unchanged).
+*/
+const checkConstraintPlanCallStrategy = (issues, ctx) => {
+	const calls = [];
+	const handledIssueKeys = /* @__PURE__ */ new Set();
+	for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const tableName of Object.keys(ns.entries.table)) {
+		const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
+		if (contractChecks.length === 0) continue;
+		const liveChecks = ctx.schema.tables[tableName]?.checks ?? [];
+		const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
+		for (const contractCheck of contractChecks) {
+			const liveCheck = liveChecks.find((c) => c.name === contractCheck.name);
+			const issueKey = `${tableName}${contractCheck.name}`;
+			if (!liveCheck) {
+				calls.push(new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
+				handledIssueKeys.add(issueKey);
+			} else if (!checkValueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {
+				calls.push(new DropCheckConstraintCall(ddlSchema, tableName, contractCheck.name), new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
+				handledIssueKeys.add(issueKey);
+			} else handledIssueKeys.add(issueKey);
+		}
+		for (const liveCheck of liveChecks) if (!contractChecks.some((c) => c.name === liveCheck.name)) {
+			const issueKey = `${tableName}${liveCheck.name}`;
+			calls.push(new DropCheckConstraintCall(ddlSchema, tableName, liveCheck.name));
+			handledIssueKeys.add(issueKey);
+		}
+	}
+	if (calls.length === 0 && handledIssueKeys.size === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((issue) => {
+			if (issue.kind !== "check_missing" && issue.kind !== "check_removed" && issue.kind !== "check_mismatch") return true;
+			if (!issue.table || !issue.indexOrConstraint) return true;
+			const key = `${issue.table}${issue.indexOrConstraint}`;
+			return !handledIssueKeys.has(key);
+		}),
+		calls
+	};
+};
+/**
 * Dispatches non-enum codec-typed storage types through their codec's
 * `planTypeOperations` hook (the authoritative source for codec-driven DDL
 * such as custom type creation). Enum dispatch lives in
@@ -608,6 +688,7 @@ const postgresPlannerStrategies = [
 	typeChangeCallStrategy,
 	nullableTighteningCallStrategy,
 	nativeEnumPlanCallStrategy,
+	checkConstraintPlanCallStrategy,
 	storageTypePlanCallStrategy,
 	notNullAddColumnCallStrategy
 ];
@@ -619,8 +700,7 @@ const postgresPlannerStrategies = [
 */
 function locateNamespaceTypeInStorage(storage, namespaceId, typeName) {
 	const ns = storage.namespaces[namespaceId];
-	if (!ns || !("enum" in ns) || ns.enum == null) return void 0;
-	return ns.enum[typeName];
+	return isPostgresSchema(ns) ? ns.entries.type[typeName] : void 0;
 }
 const ISSUE_KIND_ORDER = {
 	missing_schema: 1,
@@ -643,7 +723,10 @@ const ISSUE_KIND_ORDER = {
 	primary_key_mismatch: 50,
 	unique_constraint_mismatch: 51,
 	index_mismatch: 52,
-	foreign_key_mismatch: 60
+	foreign_key_mismatch: 60,
+	check_missing: 53,
+	check_mismatch: 54,
+	check_removed: 55
 };
 function issueOrder(issue) {
 	return ISSUE_KIND_ORDER[issue.kind] ?? 99;
@@ -668,6 +751,14 @@ function toColumnSpec(name, column, codecHooks, storageTypes) {
 		nullable: column.nullable
 	};
 }
+function toDdlColumn(name, column, codecHooks, storageTypes) {
+	const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
+	const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
+	return contractFree.col(name, typeSql, {
+		...!column.nullable ? { notNull: true } : {},
+		...ddlDefault ? { default: ddlDefault } : {}
+	});
+}
 function mapIssueToCall(issue, ctx) {
 	const { schemaName, codecHooks, storageTypes } = ctx;
 	const tableSchema = (issue) => {
@@ -687,9 +778,9 @@ function mapIssueToCall(issue, ctx) {
 			const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
 			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" in namespace "${namespaceId}" reported missing but not found in destination contract`));
 			const schemaForTable = tableSchema(issue);
-			const columns = Object.entries(contractTable.columns).map(([name, column]) => toColumnSpec(name, column, codecHooks, storageTypes));
-			const primaryKey = contractTable.primaryKey ? { columns: contractTable.primaryKey.columns } : void 0;
-			const calls = [new CreateTableCall(schemaForTable, issue.table, columns, primaryKey)];
+			const ddlColumns = Object.entries(contractTable.columns).map(([name, column]) => toDdlColumn(name, column, codecHooks, storageTypes));
+			const ddlConstraints = contractTable.primaryKey ? [contractFree.primaryKey(contractTable.primaryKey.columns, { ...contractTable.primaryKey.name ? { name: contractTable.primaryKey.name } : {} })] : void 0;
+			const calls = [new CreateTableCall(schemaForTable, issue.table, ddlColumns, ddlConstraints)];
 			for (const index of contractTable.indexes) {
 				const indexName = index.name ?? `${issue.table}_${index.columns.join("_")}_idx`;
 				const extras = {};
@@ -831,6 +922,15 @@ function mapIssueToCall(issue, ctx) {
 				return ok([new CreateIndexCall(tableSchema(issue), issue.table, indexName, columns, extras)]);
 			}
 			return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+		case "check_missing":
+			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check missing issue has no table/constraint name"));
+			return notOk(issueConflict("unsupportedOperation", `Check constraint "${issue.indexOrConstraint}" missing on "${issue.table}" — handled by checkConstraintPlanCallStrategy`));
+		case "check_mismatch":
+			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check mismatch issue has no table/constraint name"));
+			return notOk(issueConflict("unsupportedOperation", `Check constraint "${issue.indexOrConstraint}" values mismatch on "${issue.table}" — handled by checkConstraintPlanCallStrategy`));
+		case "check_removed":
+			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check removed issue has no table/constraint name"));
+			return ok([new DropCheckConstraintCall(tableSchema(issue), issue.table, issue.indexOrConstraint)]);
 		case "foreign_key_mismatch":
 			if (!issue.table) return notOk(issueConflict("foreignKeyConflict", "Foreign key issue has no table name"));
 			if (isMissing(issue) && issue.expected) {
@@ -888,8 +988,10 @@ function classifyCall(call) {
 		case "dropTable":
 		case "dropColumn":
 		case "dropConstraint":
+		case "dropCheckConstraint":
 		case "dropIndex":
 		case "dropDefault": return "drop";
+		case "addCheckConstraint": return "unique";
 		case "createTable": return "table";
 		case "addColumn": return "column";
 		case "alterColumnType":
@@ -1033,4 +1135,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-ByQhUzS4.mjs.map
+//# sourceMappingURL=issue-planner-Br0pt1Ea.mjs.map