@prisma-next/target-postgres 0.13.0 → 0.14.0

package/dist/data-transform-DGOqcLrf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-transform-DGOqcLrf.d.mts","names":[],"sources":["../src/core/migrations/operations/data-transform.ts"],"mappings":";;;;;;;;UAqEU,SAAA;EACR,KAAA,IAAS,YAAY,CAAC,CAAA;AAAA;AAiC8B;;;;AAAA,KA1B1C,oBAAA,SAA6B,YAAA,GAAe,SAAS;AAAA,UAEhD,oBAAA;;;;;;WAMN,WAAA;;;;;;;;WAQA,KAAA,GAAQ,oBAAA;;WAER,GAAA,EAAK,oBAAA,YAAgC,oBAAA;AAAA;AAAA,iBAGhC,aAAA,mBAAgC,QAAA,CAAS,UAAA,GACvD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,EAAS,iBAAA,eACR,yBAAA,CAA0B,yBAAA"}

package/dist/ddl-77SyXgFt.mjs

@@ -1,30 +0,0 @@
-import { n as PostgresCreateTable, t as PostgresCreateSchema } from "./nodes-DZk2JZG3.mjs";
-//#region src/contract-free/ddl.ts
-/**
-* Build a Postgres `CREATE TABLE` query node.
-*
-* Pass `constraints` for table-level composite primary keys, foreign keys, and
-* unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},
-* and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.
-*
-* Precondition: identifiers (`table`, `schema`, column names/types) are
-* emitted to SQL verbatim — they are not quoted or escaped, so callers must
-* pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
-* default values, by contrast, are single-quote-escaped (embedded `'` doubled)
-* by the renderer. Identifier quoting for untrusted identifiers is added when
-* the migration planner adopts this lowering path.
-*/
-function createTable(options) {
-	return new PostgresCreateTable(options);
-}
-/**
-* Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the
-* pre-trusted-identifier precondition.
-*/
-function createSchema(options) {
-	return new PostgresCreateSchema(options);
-}
-//#endregion
-export { createTable as n, createSchema as t };
-
-//# sourceMappingURL=ddl-77SyXgFt.mjs.map

package/dist/ddl-77SyXgFt.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-77SyXgFt.mjs","names":[],"sources":["../src/contract-free/ddl.ts"],"sourcesContent":["import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';\n\n/**\n * Build a Postgres `CREATE TABLE` query node.\n *\n * Pass `constraints` for table-level composite primary keys, foreign keys, and\n * unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},\n * and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.\n *\n * Precondition: identifiers (`table`, `schema`, column names/types) are\n * emitted to SQL verbatim — they are not quoted or escaped, so callers must\n * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal\n * default values, by contrast, are single-quote-escaped (embedded `'` doubled)\n * by the renderer. Identifier quoting for untrusted identifiers is added when\n * the migration planner adopts this lowering path.\n */\nexport function createTable(options: {\n  readonly table: string;\n  readonly schema?: string;\n  readonly ifNotExists?: boolean;\n  readonly columns: readonly DdlColumn[];\n  readonly constraints?: readonly DdlTableConstraint[];\n}): PostgresCreateTable {\n  return new PostgresCreateTable(options);\n}\n\n/**\n * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the\n * pre-trusted-identifier precondition.\n */\nexport function createSchema(options: {\n  readonly schema: string;\n  readonly ifNotExists?: boolean;\n}): PostgresCreateSchema {\n  return new PostgresCreateSchema(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAY,SAMJ;CACtB,OAAO,IAAI,oBAAoB,OAAO;AACxC;;;;;AAMA,SAAgB,aAAa,SAGJ;CACvB,OAAO,IAAI,qBAAqB,OAAO;AACzC"}

package/dist/descriptor-meta-DKmj-IMN.mjs

@@ -1,14 +0,0 @@
-import { i as postgresAuthoringTypes, n as postgresAuthoringEntityTypes, r as postgresAuthoringFieldPresets, t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-My8_s4cs.mjs";
-const postgresTargetDescriptorMeta = {
-	...postgresTargetDescriptorMetaRuntime,
-	defaultNamespaceId: "public",
-	authoring: {
-		type: postgresAuthoringTypes,
-		field: postgresAuthoringFieldPresets,
-		entityTypes: postgresAuthoringEntityTypes
-	}
-};
-//#endregion
-export { postgresTargetDescriptorMeta as t };
-
-//# sourceMappingURL=descriptor-meta-DKmj-IMN.mjs.map

package/dist/descriptor-meta-DKmj-IMN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-DKmj-IMN.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  defaultNamespaceId: 'public',\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";AAkBA,MAAa,+BAET;CAXF,GAAG;CACH,oBAAoB;CACpB,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;CACf;AAKE"}

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

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

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

@@ -1 +0,0 @@
-{"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-BCyvlFHk.mjs.map

@@ -1 +0,0 @@
-{"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,86 +0,0 @@
-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";
-
-//#region src/core/migrations/enum-planning.d.ts
-/**
- * Codec-typed enum entry shape stored under
- * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.
- */
-interface PgStorageTypeEntry {
-  readonly codecId?: string;
-  readonly typeParams?: {
-    readonly values?: unknown;
-  };
-}
-/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */
-interface PostgresSchemaIrAnnotations {
-  readonly schema?: string;
-  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;
-}
-/**
- * Reads the Postgres annotation envelope (`schema.annotations.pg`) from
- * family Schema IR. `SqlAnnotations` is an open target-pack extensibility
- * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at
- * runtime so Postgres code can read introspection fields without casts.
- */
-declare function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations;
-/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */
-declare function enumStorageCompoundKey(schemaName: string, nativeType: string): string;
-/**
- * Resolves the live-schema name a namespace's enums are introspected under,
- * for keying `readExistingEnumValues` lookups. The unbound namespace's
- * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a
- * real schema, so for the unbound coordinate we read the *introspected* schema
- * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter
- * walked) — that is the schema the enum's `storageTypes` entry is keyed under.
- * Named namespaces resolve to their own DDL schema, which matches the
- * per-schema introspection key directly.
- */
-declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string, schemaIr?: SqlSchemaIR): string;
-/** Contract-scoped bridge for the family verifier's enum value resolver. */
-declare function createResolveExistingEnumValues(storage: SqlStorage): (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
-/**
- * Categorisation of how an existing enum type's values relate to the
- * desired set in the contract.
- */
-type EnumDiff = {
-  readonly kind: 'unchanged';
-} | {
-  readonly kind: 'add_values';
-  readonly values: readonly string[];
-} | {
-  readonly kind: 'rebuild';
-  readonly removedValues: readonly string[];
-};
-/**
- * Reads existing enum values for `(schemaName, nativeType)` from the
- * Postgres-introspected `schema.annotations.pg.storageTypes` map.
- *
- * Schema IR's `storageTypes` slots are always codec-typed
- * (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector
- * writes that shape, and the Contract→Schema IR projector resolves
- * `PostgresEnumType` instances down to the same codec-typed triple before
- * they ever land in Schema IR. There is no second on-disk shape to
- * accept here.
- *
- * Returns `null` when no enum entry exists for the given native type.
- */
-declare function readExistingEnumValues(schema: SqlSchemaIR, schemaName: string, nativeType: string): readonly string[] | null;
-/**
- * Determines what changes are needed to transform existing enum values to
- * desired values.
- *
- * Postgres enums can only have values added (not removed or reordered)
- * without a full type rebuild involving temp type creation and column
- * migration; `'rebuild'` covers the value-removal and reorder cases.
- */
-declare function determineEnumDiff(existing: readonly string[], desired: readonly string[]): EnumDiff;
-/**
- * Convenience accessor — returns the enum's desired values from a
- * `PostgresEnumType` IR instance.
- */
-declare function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[];
-//#endregion
-export { type EnumDiff, type PostgresSchemaIrAnnotations, createResolveExistingEnumValues, determineEnumDiff, enumStorageCompoundKey, getDesiredEnumValues, readExistingEnumValues, readPostgresSchemaIrAnnotations, resolveDdlSchemaForNamespaceStorage };
-//# sourceMappingURL=enum-planning.d.mts.map

package/dist/enum-planning.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum-planning.d.mts","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"mappings":";;;;;;;;;UAkBU,kBAAA;EAAA,SACC,OAAA;EAAA,SACA,UAAA;IAAA,SAAwB,MAAA;EAAA;AAAA;;UAIlB,2BAAA;EAAA,SACN,MAAA;EAAA,SACA,YAAA,GAAe,QAAA,CAAS,MAAA,SAAe,kBAAA;AAAA;;;;;;AAAkB;iBAgDpD,+BAAA,CAAgC,MAAA,EAAQ,WAAA,GAAc,2BAA2B;;iBAqBjF,sBAAA,CAAuB,UAAA,UAAoB,UAAkB;AAA7E;;;;AAA6E;AAc7E;;;;;AAdA,iBAcgB,mCAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,QAAA,GAAW,WAAW;;iBAaR,+BAAA,CACd,OAAA,EAAS,UAAA,IAET,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;;;AAlBsB;AAaxB;KAmBY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA6B,MAAA;AAAA;EAAA,SAC7B,IAAA;EAAA,SAA0B,aAAA;AAAA;;;;;;;AAjBpB;AAcrB;;;;;;iBAkBgB,sBAAA,CACd,MAAA,EAAQ,WAAW,EACnB,UAAA,UACA,UAAA;;;;AAlBoD;AAetD;;;;iBAyBgB,iBAAA,CACd,QAAA,qBACA,OAAA,sBACC,QAAQ;;;;;iBAoBK,oBAAA,CAAqB,YAA8B,EAAhB,gBAAgB"}

package/dist/enum-planning.mjs

@@ -1,2 +0,0 @@
-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/issue-planner-Br0pt1Ea.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"issue-planner-Br0pt1Ea.mjs","names":[],"sources":["../src/core/migrations/planner-target-details.ts","../src/core/migrations/planner-recipes.ts","../src/core/migrations/planner-strategies.ts","../src/core/migrations/issue-planner.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\n\nexport type OperationClass =\n  | 'dependency'\n  | 'type'\n  | 'table'\n  | 'column'\n  | 'primaryKey'\n  | 'unique'\n  | 'index'\n  | 'foreignKey'\n  | 'checkConstraint';\n\nexport interface PostgresPlanTargetDetails {\n  readonly schema: string;\n  readonly objectType: OperationClass;\n  readonly name: string;\n  readonly table?: string;\n}\n\nexport function buildTargetDetails(\n  objectType: OperationClass,\n  name: string,\n  schema: string,\n  table?: string,\n): PostgresPlanTargetDetails {\n  return {\n    schema,\n    objectType,\n    name,\n    ...ifDefined('table', table),\n  };\n}\n","import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type {\n  PostgresEnumStorageEntry,\n  StorageColumn,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { quoteIdentifier } from '../sql-utils';\nimport { buildAddColumnSql } from './planner-ddl-builders';\nimport {\n  columnExistsCheck,\n  columnHasNoDefaultCheck,\n  columnNullabilityCheck,\n  qualifyTableName,\n} from './planner-sql-checks';\nimport { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';\n\nexport function buildAddColumnOperationIdentity(\n  schema: string,\n  tableName: string,\n  columnName: string,\n): Pick<\n  SqlMigrationPlanOperation<PostgresPlanTargetDetails>,\n  'id' | 'label' | 'summary' | 'target'\n> {\n  return {\n    id: `column.${tableName}.${columnName}`,\n    label: `Add column ${columnName} to ${tableName}`,\n    summary: `Adds column ${columnName} to table ${tableName}`,\n    target: {\n      id: 'postgres',\n      details: buildTargetDetails('table', tableName, schema),\n    },\n  };\n}\n\nexport function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {\n  readonly schema: string;\n  readonly tableName: string;\n  readonly columnName: string;\n  readonly column: StorageColumn;\n  readonly codecHooks: Map<string, CodecControlHooks>;\n  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;\n  readonly temporaryDefault: string;\n}): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n  const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } =\n    options;\n  const qualified = qualifyTableName(schema, tableName);\n\n  return {\n    ...buildAddColumnOperationIdentity(schema, tableName, columnName),\n    operationClass: 'additive',\n    precheck: [\n      {\n        description: `ensure column \"${columnName}\" is missing`,\n        sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),\n      },\n    ],\n    execute: [\n      {\n        description: `add column \"${columnName}\"`,\n        sql: buildAddColumnSql(\n          qualified,\n          columnName,\n          column,\n          codecHooks,\n          temporaryDefault,\n          storageTypes,\n        ),\n      },\n      {\n        description: `drop temporary default from column \"${columnName}\"`,\n        sql: `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`,\n      },\n    ],\n    postcheck: [\n      {\n        description: `verify column \"${columnName}\" exists`,\n        sql: columnExistsCheck({ schema, table: tableName, column: columnName }),\n      },\n      {\n        description: `verify column \"${columnName}\" is NOT NULL`,\n        sql: columnNullabilityCheck({\n          schema,\n          table: tableName,\n          column: columnName,\n          nullable: false,\n        }),\n      },\n      {\n        description: `verify column \"${columnName}\" has no default after temporary default removal`,\n        sql: columnHasNoDefaultCheck({ schema, table: tableName, column: columnName }),\n      },\n    ],\n  };\n}\n","/**\n * Migration strategies.\n *\n * Each strategy examines the issue list, consumes issues it handles, and\n * returns the `PostgresOpFactoryCall[]` to address them. The issue planner\n * runs each strategy in order and routes whatever's left through\n * `mapIssueToCall`.\n *\n * The full ordered list is exported as `postgresPlannerStrategies` and is\n * used unchanged by both `migration plan` and `db update` / `db init`. The\n * two journeys differ only in `policy.allowedOperationClasses`:\n *\n * - When `'data'` is in the policy, data-safe strategies (NOT NULL backfill,\n *   nullability tightening, unsafe type changes, enum shrink/rebuild) emit\n *   `DataTransformCall` placeholders that the user fills in.\n * - When `'data'` is excluded, those strategies short-circuit so the\n *   downstream walk-schema strategies (codec-hook type ops and temp-default\n *   backfill) and `mapIssueToCall` defaults emit direct DDL instead.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  MigrationOperationPolicy,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport { resolveValueSetValues } from '@prisma-next/family-sql/control';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  isPostgresEnumStorageEntry,\n  type PostgresEnumStorageEntry,\n  type SqlStorage,\n  StorageTable,\n  type StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresEnumType } from '../postgres-enum-type';\nimport { isPostgresSchema } from '../postgres-schema';\nimport {\n  determineEnumDiff,\n  readExistingEnumValues,\n  resolveDdlSchemaForNamespaceStorage,\n} from './enum-planning';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddEnumValuesCall,\n  AlterColumnTypeCall,\n  CreateEnumTypeCall,\n  DataTransformCall,\n  DropCheckConstraintCall,\n  DropEnumTypeCall,\n  type PostgresOpFactoryCall,\n  RawSqlCall,\n  RenameTypeCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport {\n  buildAddColumnSql,\n  buildColumnDefaultSql,\n  buildColumnTypeSql,\n} from './planner-ddl-builders';\nimport { resolveIdentityValue } from './planner-identity-values';\nimport {\n  buildAddColumnOperationIdentity,\n  buildAddNotNullColumnWithTemporaryDefaultOperation,\n} from './planner-recipes';\nimport { buildSchemaLookupMap, hasForeignKey, hasUniqueConstraint } from './planner-schema-lookup';\nimport {\n  buildExpectedFormatType,\n  columnExistsCheck,\n  columnNullabilityCheck,\n  qualifyTableName,\n  tableIsEmptyCheck,\n} from './planner-sql-checks';\nimport { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';\n\nconst REBUILD_SUFFIX = '__prisma_next_new';\n\n/**\n * Look up a storage table by its explicit namespace coordinate. Returns\n * `undefined` when the namespace has no table by that name (or no such\n * namespace exists). Callers that get `undefined` MUST treat it as an\n * explicit conflict — never silently fall back to a global default\n * schema or a name-only walk, because that footgun would resolve a\n * stale or duplicate table name to whichever namespace the iteration\n * order surfaced first (a real data-loss hazard in multi-namespace\n * contracts where two namespaces can carry the same table name).\n */\nexport function tableAt(\n  storage: SqlStorage,\n  namespaceId: string,\n  tableName: string,\n): StorageTable | undefined {\n  // Namespace.tables is typed as Record<string, IRNode> at the interface level;\n  // SQL family namespaces always hold StorageTable instances.\n  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;\n}\n\n/**\n * Default namespace coordinate for an issue that does not carry one\n * explicitly. Hand-crafted unit-test issues and `extra_table` issues\n * fall back to `__unbound__`, the only namespace any single-namespace\n * contract carries — verifier-emitted issues for legacy\n * single-namespace contracts already stamp this id explicitly. Typed\n * structurally so issue variants without a `namespaceId` slot\n * (e.g. `EnumValuesChangedIssue`) flow through to the same fallback.\n */\nexport function resolveNamespaceIdForIssue(issue: { readonly namespaceId?: string }): string {\n  return issue.namespaceId ?? UNBOUND_NAMESPACE_ID;\n}\n\n/**\n * Resolve the DDL schema name for a namespace coordinate. Postgres-aware\n * namespaces dispatch to their polymorphic `ddlSchemaName` override —\n * named schemas return their own id; the unbound singleton returns\n * `UNBOUND_NAMESPACE_ID`. Legacy single-namespace contracts whose\n * `__unbound__` slot is the framework-default `SqlUnboundNamespace`\n * (rather than the Postgres-aware `PostgresUnboundSchema`) flow the\n * coordinate through unchanged so downstream `qualifyTableName`\n * resolves polymorphically.\n */\nexport function resolveDdlSchemaForNamespace(ctx: StrategyContext, namespaceId: string): string {\n  const namespace = ctx.toContract.storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(ctx.toContract.storage);\n  }\n  return namespaceId;\n}\n\n/** Default Postgres enum landing namespace — where contract-level (`types:`)\n * enums are placed by the authoring builder when no explicit namespace is\n * given. Mirrors `POSTGRES_ENUM_NAMESPACE_ID` in the contract-ts builder. */\nconst DEFAULT_ENUM_NAMESPACE_ID = 'public';\n\nfunction namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {\n  const ns = storage.namespaces[namespaceId];\n  if (!isPostgresSchema(ns)) return false;\n  return ns.entries.type[typeName] !== undefined;\n}\n\n/**\n * Resolves which namespace's enum a column's bare `typeRef` binds to.\n *\n * Columns carry a bare (non-namespace-qualified) `typeRef`; the enum it names\n * may live in a different namespace than the column's own (the authoring\n * builder places contract-level `types:` enums in the default `public`\n * namespace while a model's table may sit in the unbound namespace). The\n * binding rule: an enum declared in the column's *own* namespace shadows\n * everything; otherwise the column references the ambient enum — the sole\n * namespace that defines `typeName`, preferring the default `public`\n * namespace when several do. Returns `undefined` when no namespace defines it.\n */\nfunction resolveColumnEnumNamespace(\n  storage: SqlStorage,\n  columnNamespaceId: string,\n  typeName: string,\n): string | undefined {\n  if (namespaceHasEnum(storage, columnNamespaceId, typeName)) return columnNamespaceId;\n  const owners = Object.keys(storage.namespaces).filter((nsId) =>\n    namespaceHasEnum(storage, nsId, typeName),\n  );\n  if (owners.length === 1) return owners[0];\n  if (owners.includes(DEFAULT_ENUM_NAMESPACE_ID)) return DEFAULT_ENUM_NAMESPACE_ID;\n  return owners[0];\n}\n\n/**\n * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.\n * Postgres enums) live under `storage.namespaces[nsId].entries.type`. Returns the\n * entry from the named namespace only — never scans other namespaces, so two\n * namespaces that hold an enum with the same name resolve independently.\n */\nfunction locateNamespaceType(\n  storage: SqlStorage,\n  namespaceId: string,\n  typeName: string,\n): PostgresEnumStorageEntry | undefined {\n  const ns = storage.namespaces[namespaceId];\n  const raw = ns?.entries['type']?.[typeName];\n  if (raw === undefined) return undefined;\n  return blindCast<\n    PostgresEnumStorageEntry,\n    'postgres type slot carries PostgresEnumStorageEntry at the postgres target layer'\n  >(raw);\n}\n\n// ============================================================================\n// Strategy types\n// ============================================================================\n\n/**\n * Context passed to each migration strategy.\n *\n * Strategies read the source (`fromContract`), target (`toContract`), current\n * database state (`schema`), operation policy (`policy`), and component list\n * (`frameworkComponents`) to make planning decisions. `fromContract` is null\n * when no prior contract is available (e.g. `db update`, where the current\n * DB state is approximated via `schema`).\n */\nexport interface StrategyContext {\n  readonly toContract: Contract<SqlStorage>;\n  readonly fromContract: Contract<SqlStorage> | null;\n  readonly schemaName: string;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n  readonly storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;\n  readonly schema: SqlSchemaIR;\n  readonly policy: MigrationOperationPolicy;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}\n\n// ============================================================================\n// Call strategies (for issue planner)\n// ============================================================================\n\nexport type CallMigrationStrategy = (\n  issues: readonly SchemaIssue[],\n  context: StrategyContext,\n) =>\n  | {\n      kind: 'match';\n      issues: readonly SchemaIssue[];\n      calls: readonly PostgresOpFactoryCall[];\n      /**\n       * `true` for strategies that emit cohesive sequential recipes whose\n       * calls must stay contiguous and in the returned order — e.g.\n       * `nativeEnumPlanCallStrategy` (createEnumType → alterColumnType →\n       * dropEnumType → renameType, optionally prefixed by a\n       * `DataTransformCall` placeholder), `notNullBackfillCallStrategy`\n       * (addColumn → dataTransform → setNotNull). Defaults to `false`,\n       * which lets `planIssues` hoist individual calls into their DDL\n       * sequencing bucket.\n       */\n      recipe?: boolean;\n    }\n  | { kind: 'no_match' };\n\nfunction buildColumnSpec(\n  namespaceId: string,\n  table: string,\n  column: string,\n  ctx: StrategyContext,\n  overrides?: { nullable?: boolean },\n) {\n  const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];\n  if (!col) throw new Error(`Column \"${table}\".\"${column}\" not found in destination contract`);\n  const mutableHooks = ctx.codecHooks as Map<string, CodecControlHooks>;\n  const mutableTypes = ctx.storageTypes as Record<\n    string,\n    StorageTypeInstance | PostgresEnumStorageEntry\n  >;\n  return {\n    name: column,\n    typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),\n    defaultSql: buildColumnDefaultSql(col.default, col),\n    columnDefault: col.default,\n    nullable: overrides?.nullable ?? col.nullable,\n  };\n}\n\nfunction buildAlterTypeOptions(\n  namespaceId: string,\n  table: string,\n  column: string,\n  ctx: StrategyContext,\n  using?: string,\n) {\n  const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];\n  if (!col) throw new Error(`Column \"${table}\".\"${column}\" not found in destination contract`);\n  const mutableHooks = ctx.codecHooks as Map<string, CodecControlHooks>;\n  const mutableTypes = ctx.storageTypes as Record<\n    string,\n    StorageTypeInstance | PostgresEnumStorageEntry\n  >;\n  const qualifiedTargetType = buildColumnTypeSql(col, mutableHooks, mutableTypes, false);\n  const formatTypeExpected = buildExpectedFormatType(col, mutableHooks, mutableTypes);\n  return {\n    qualifiedTargetType,\n    formatTypeExpected,\n    rawTargetTypeForLabel: qualifiedTargetType,\n    ...(using !== undefined ? { using } : {}),\n  };\n}\n\nexport const notNullBackfillCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  // `DataTransformCall` is operation class `'data'`. When the policy excludes\n  // it (`db update` / `db init`), skip so `notNullAddColumnCallStrategy`\n  // (temp-default backfill) or `mapIssueToCall` can take the issue.\n  if (!ctx.policy.allowedOperationClasses.includes('data')) return { kind: 'no_match' };\n\n  const matched: SchemaIssue[] = [];\n  const calls: PostgresOpFactoryCall[] = [];\n\n  for (const issue of issues) {\n    if (issue.kind !== 'missing_column' || !issue.table || !issue.column) continue;\n\n    const namespaceId = resolveNamespaceIdForIssue(issue);\n    const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];\n    if (!column) continue;\n    if (column.nullable === true || column.default !== undefined) continue;\n\n    matched.push(issue);\n    const spec = buildColumnSpec(namespaceId, issue.table, issue.column, ctx, { nullable: true });\n    const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);\n    calls.push(\n      new AddColumnCall(schemaForTable, issue.table, spec),\n      new DataTransformCall(\n        `backfill-${issue.table}-${issue.column}`,\n        `backfill-${issue.table}-${issue.column}:check`,\n        `backfill-${issue.table}-${issue.column}:run`,\n      ),\n      new SetNotNullCall(schemaForTable, issue.table, issue.column),\n    );\n  }\n\n  if (matched.length === 0) return { kind: 'no_match' };\n  return {\n    kind: 'match',\n    issues: issues.filter((i) => !matched.includes(i)),\n    calls,\n    recipe: true,\n  };\n};\n\nconst SAFE_WIDENINGS = new Set(['int2→int4', 'int2→int8', 'int4→int8', 'float4→float8']);\n\nexport const typeChangeCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  // For unsafe widenings this strategy emits a `DataTransformCall` placeholder\n  // (operation class `'data'`); when the policy excludes `'data'`\n  // (`db update` / `db init`), skip those issues so `mapIssueToCall` can\n  // emit a direct `ALTER COLUMN TYPE`. Safe widenings still flow through\n  // here because the resulting `AlterColumnTypeCall` is `widening`-class.\n  const dataAllowed = ctx.policy.allowedOperationClasses.includes('data');\n\n  const matched: SchemaIssue[] = [];\n  const calls: PostgresOpFactoryCall[] = [];\n\n  for (const issue of issues) {\n    if (issue.kind !== 'type_mismatch') continue;\n    if (!issue.table || !issue.column) continue;\n    const namespaceId = resolveNamespaceIdForIssue(issue);\n    const fromColumn = ctx.fromContract\n      ? tableAt(ctx.fromContract.storage, namespaceId, issue.table)?.columns[issue.column]\n      : undefined;\n    const toColumn = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n      issue.column\n    ];\n    if (!fromColumn || !toColumn) continue;\n    const fromType = fromColumn.nativeType;\n    const toType = toColumn.nativeType;\n    if (fromType === toType) continue;\n    const isSafeWidening = SAFE_WIDENINGS.has(`${fromType}→${toType}`);\n    if (!isSafeWidening && !dataAllowed) continue;\n    matched.push(issue);\n    const alterOpts = buildAlterTypeOptions(namespaceId, issue.table, issue.column, ctx);\n    const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);\n    if (isSafeWidening) {\n      calls.push(new AlterColumnTypeCall(schemaForTable, issue.table, issue.column, alterOpts));\n    } else {\n      calls.push(\n        new DataTransformCall(\n          `typechange-${issue.table}-${issue.column}`,\n          `typechange-${issue.table}-${issue.column}:check`,\n          `typechange-${issue.table}-${issue.column}:run`,\n        ),\n        new AlterColumnTypeCall(schemaForTable, issue.table, issue.column, alterOpts),\n      );\n    }\n  }\n  if (matched.length === 0) return { kind: 'no_match' };\n  return {\n    kind: 'match',\n    issues: issues.filter((i) => !matched.includes(i)),\n    calls,\n    recipe: true,\n  };\n};\n\nexport const nullableTighteningCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  // `DataTransformCall` is operation class `'data'`. When the policy excludes\n  // it (`db update` / `db init`), skip so `mapIssueToCall` emits a direct\n  // `SET NOT NULL` instead.\n  if (!ctx.policy.allowedOperationClasses.includes('data')) return { kind: 'no_match' };\n\n  const matched: SchemaIssue[] = [];\n  const calls: PostgresOpFactoryCall[] = [];\n\n  for (const issue of issues) {\n    if (issue.kind !== 'nullability_mismatch' || !issue.table || !issue.column) continue;\n\n    const namespaceId = resolveNamespaceIdForIssue(issue);\n    const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];\n    if (!column) continue;\n    if (column.nullable === true) continue;\n\n    matched.push(issue);\n    const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);\n    calls.push(\n      new DataTransformCall(\n        `handle-nulls-${issue.table}-${issue.column}`,\n        `handle-nulls-${issue.table}-${issue.column}:check`,\n        `handle-nulls-${issue.table}-${issue.column}:run`,\n      ),\n      new SetNotNullCall(schemaForTable, issue.table, issue.column),\n    );\n  }\n\n  if (matched.length === 0) return { kind: 'no_match' };\n  return {\n    kind: 'match',\n    issues: issues.filter((i) => !matched.includes(i)),\n    calls,\n    recipe: true,\n  };\n};\n\nfunction enumRebuildCallRecipe(\n  namespaceId: string,\n  typeName: string,\n  ctx: StrategyContext,\n): readonly PostgresOpFactoryCall[] {\n  const toType = locateNamespaceType(ctx.toContract.storage, namespaceId, typeName);\n  if (!toType) return [];\n  const isEnum = isPostgresEnumStorageEntry(toType);\n  const nativeType = toType.nativeType;\n  const desiredValues: readonly string[] = isEnum\n    ? toType.values\n    : (((toType as StorageTypeInstance).typeParams['values'] ?? []) as readonly string[]);\n  const tempName = `${nativeType}${REBUILD_SUFFIX}`;\n  // Type DDL targets the enum's real schema — the unbound coordinate resolves\n  // to the introspected `current_schema()`, never the `__unbound__` sentinel.\n  const ddlSchema = resolveDdlSchemaForNamespaceStorage(\n    ctx.toContract.storage,\n    namespaceId,\n    ctx.schema,\n  );\n\n  // Migrate every column whose `typeRef` binds to *this* enum. The column's\n  // bare `typeRef` resolves to an enum namespace (own-namespace shadows;\n  // otherwise the ambient/default `public` enum), so a column in the unbound\n  // namespace correctly binds to a `public`-namespace enum, while two\n  // same-named enums in distinct namespaces keep their columns disjoint.\n  const columnRefs: { namespaceId: string; table: string; column: string }[] = [];\n  for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {\n    for (const [tableName, tableNode] of Object.entries(ns.entries.table)) {\n      const table = tableNode as StorageTable;\n      for (const [columnName, column] of Object.entries(table.columns)) {\n        if (\n          column.typeRef === typeName &&\n          resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId\n        ) {\n          columnRefs.push({ namespaceId: nsId, table: tableName, column: columnName });\n        }\n      }\n    }\n  }\n\n  return [\n    new CreateEnumTypeCall(ddlSchema, tempName, desiredValues),\n    ...columnRefs.map((ref) => {\n      const using = `${ref.column}::text::${tempName}`;\n      return new AlterColumnTypeCall(\n        resolveDdlSchemaForNamespace(ctx, ref.namespaceId),\n        ref.table,\n        ref.column,\n        {\n          qualifiedTargetType: tempName,\n          formatTypeExpected: tempName,\n          rawTargetTypeForLabel: tempName,\n          using,\n        },\n      );\n    }),\n    new DropEnumTypeCall(ddlSchema, nativeType),\n    new RenameTypeCall(ddlSchema, tempName, nativeType),\n  ];\n}\n\n// ============================================================================\n// Native enum planner strategy\n// ============================================================================\n\n/**\n * Single planner strategy for `PostgresEnumType` instances. Walks\n * `toContract.storage.types` directly (no codec-hook dispatch) and\n * resolves existing values via `readExistingEnumValues`, the same\n * Postgres bridging adapter the verifier uses.\n *\n * Per-enum dispatch:\n *\n * - No existing type → `CreateEnumTypeCall` with the contract's desired\n *   values.\n * - Diff is `unchanged` → no calls emitted (consumes the matching\n *   `enum_values_changed` issue if present).\n * - Diff is `add_values` → `AddEnumValuesCall` with the new labels.\n * - Diff is `rebuild` → the create-temp / migrate-columns /\n *   drop-original / rename rebuild recipe. When\n *   `policy.allowedOperationClasses` includes `'data'` and the rebuild\n *   removes labels (`removedValues.length > 0`), prepend a\n *   `DataTransformCall` placeholder so the user can author the value\n *   remap before the destructive recipe runs. Without `'data'` in the\n *   policy (`db update` / `db init`), the rebuild's PG `USING ::text`\n *   cast surfaces any value-removal data loss as a runtime error rather\n *   than silent loss.\n *\n * Returns `recipe: true` only when a rebuild recipe was emitted (its\n * `createEnumType(temp) → alterColumnType → dropEnumType(orig) →\n * renameType` sequence mixes `dep`-class and `alter`-class calls that\n * would mis-order if the planner hoisted them into its DDL sequencing\n * buckets). For the create-only and add-values paths the strategy\n * returns `recipe: false` so the planner hoists `CreateEnumTypeCall`\n * into the `dep` bucket — i.e. `CREATE TYPE` runs before any\n * `CreateTableCall` that references the new enum.\n */\n/**\n * Separator character for compound enum map keys (`namespaceId\\u0000typeName`).\n * NUL (`\\u0000`) is invalid in both Postgres identifiers and TypeScript symbol\n * names so it cannot appear in either component — unambiguous separator.\n */\nconst COMPOUND_KEY_SEP = '\\u0000';\n\n/** Builds the compound map key for a namespace-qualified enum entry. */\nfunction enumCompoundKey(namespaceId: string, typeName: string): string {\n  return `${namespaceId}${COMPOUND_KEY_SEP}${typeName}`;\n}\n\nexport const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage);\n  if (enumTypes.size === 0) return { kind: 'no_match' };\n\n  const dataAllowed = ctx.policy.allowedOperationClasses.includes('data');\n\n  const calls: PostgresOpFactoryCall[] = [];\n  const handledKeys = new Set<string>();\n  const introducedKeys = new Set<string>();\n  const rebuiltKeys = new Set<string>();\n  let emittedRebuildRecipe = false;\n\n  for (const [key, enumType] of enumTypes) {\n    const sepIdx = key.indexOf(COMPOUND_KEY_SEP);\n    const enumNamespaceId = key.slice(0, sepIdx);\n    const typeName = key.slice(sepIdx + 1);\n\n    const desired = enumType.values;\n    // The enum's live schema: for the unbound coordinate this resolves to the\n    // introspected `current_schema()` (e.g. `public`), never the `__unbound__`\n    // DDL-emit sentinel — so both the existing-values lookup key and the\n    // emitted `CREATE TYPE` / `ALTER TYPE` target the real schema the type\n    // lives in. Named namespaces resolve to their own DDL schema.\n    const ddlSchema = resolveDdlSchemaForNamespaceStorage(\n      ctx.toContract.storage,\n      enumNamespaceId,\n      ctx.schema,\n    );\n    const existing = readExistingEnumValues(ctx.schema, ddlSchema, enumType.nativeType);\n    if (!existing) {\n      calls.push(new CreateEnumTypeCall(ddlSchema, typeName, desired, enumType.nativeType));\n      handledKeys.add(key);\n      introducedKeys.add(key);\n      continue;\n    }\n    const diff = determineEnumDiff(existing, desired);\n    if (diff.kind === 'unchanged') {\n      handledKeys.add(key);\n      continue;\n    }\n    if (diff.kind === 'add_values') {\n      calls.push(new AddEnumValuesCall(ddlSchema, typeName, enumType.nativeType, diff.values));\n      handledKeys.add(key);\n      continue;\n    }\n    if (dataAllowed && diff.removedValues.length > 0) {\n      calls.push(\n        new DataTransformCall(\n          `migrate-${typeName}-values`,\n          `migrate-${typeName}-values:check`,\n          `migrate-${typeName}-values:run`,\n        ),\n      );\n    }\n    calls.push(...enumRebuildCallRecipe(enumNamespaceId, typeName, ctx));\n    emittedRebuildRecipe = true;\n    handledKeys.add(key);\n    rebuiltKeys.add(key);\n  }\n\n  // The strategy emits a single `recipe` flag for the entire pass,\n  // which routes every emitted call to either the contiguous recipe\n  // slot (rebuild path) or the `dep` bucket (introduce / add-values\n  // path). A plan that needs both shapes simultaneously cannot be\n  // expressed today — the introduced `CreateEnumTypeCall` would land\n  // in the recipe slot and any `CreateTableCall` referencing the new\n  // enum would fail at runtime with a confusing `type \"X\" does not\n  // exist` error. Surface the unrepresentable case here as a\n  // planner-time error so the failure mode is loud, not silent.\n  if (introducedKeys.size > 0 && rebuiltKeys.size > 0) {\n    const introducedDisplay = [...introducedKeys]\n      .sort()\n      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))\n      .join(', ');\n    const rebuiltDisplay = [...rebuiltKeys]\n      .sort()\n      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))\n      .join(', ');\n    throw new Error(\n      `nativeEnumPlanCallStrategy: cannot emit both a brand-new enum and a rebuild on a different enum in the same plan; the single recipe flag cannot route them to different buckets. Introduced: [${introducedDisplay}]; rebuilt: [${rebuiltDisplay}]. Split the strategy or grow the \\`match\\` return type before this case lands.`,\n    );\n  }\n\n  const remaining = issues.filter(\n    (issue) =>\n      !(\n        (issue.kind === 'type_missing' || issue.kind === 'enum_values_changed') &&\n        issue.typeName &&\n        handledKeys.has(enumCompoundKey(resolveNamespaceIdForIssue(issue), issue.typeName))\n      ),\n  );\n\n  if (calls.length === 0 && remaining.length === issues.length) {\n    return { kind: 'no_match' };\n  }\n  // `recipe: true` is required for the rebuild path — its\n  // `createEnumType(temp) → alterColumnType → dropEnumType(orig) →\n  // renameType` mixes `dep`-class and `alter`-class calls that would\n  // mis-order if the planner hoisted them into its DDL sequencing\n  // buckets. For the type_missing / add_values paths we want the\n  // opposite: hoisted into the `dep` bucket so a brand-new\n  // `CreateEnumTypeCall` runs *before* the `CreateTableCall` that\n  // references it. The two cases never co-occur in the same plan\n  // (introducing a new enum type and rebuilding an existing one in\n  // one shot would require both buckets — a shape today's interface\n  // does not surface; if that combination ever needs to land we'd\n  // split this strategy or grow the `match` return type).\n  return { kind: 'match', issues: remaining, calls, recipe: emittedRebuildRecipe };\n};\n\n/**\n * Collects every `PostgresEnumType` instance across all declared namespaces,\n * returning a compound-keyed map (`${namespaceId}\\u0000${typeName}`). Two\n * namespaces that declare an enum with the same name produce two distinct\n * entries — no name collision, no last-write-wins.\n *\n * Entries within each namespace are sorted by name for deterministic ordering.\n */\nfunction collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, PostgresEnumType> {\n  const result = new Map<string, PostgresEnumType>();\n  for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n    if (!isPostgresSchema(ns)) continue;\n    for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) =>\n      a.localeCompare(b),\n    )) {\n      if (instance instanceof PostgresEnumType) {\n        result.set(enumCompoundKey(nsId, name), instance);\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Collects every check constraint from a table in the contract storage.\n * Returns an empty array when the table has no checks or the table is absent.\n */\nfunction collectContractChecks(\n  storage: SqlStorage,\n  namespaceId: string,\n  tableName: string,\n): ReadonlyArray<{ name: string; column: string; permittedValues: readonly string[] }> {\n  const ns = storage.namespaces[namespaceId];\n  const tableRaw = ns?.entries.table[tableName];\n  if (!(tableRaw instanceof StorageTable)) return [];\n  const checks = tableRaw.checks;\n  if (!checks || checks.length === 0) return [];\n  return checks.map((c) => ({\n    name: c.name,\n    column: c.column,\n    permittedValues: resolveValueSetValues(\n      c.valueSet,\n      storage,\n      `check \"${c.name}\" on \"${tableName}\"`,\n    ),\n  }));\n}\n\n/**\n * Compares two value arrays as unordered sets.\n */\nfunction checkValueSetsEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  const bSet = new Set(b);\n  return a.every((v) => bSet.has(v));\n}\n\n/**\n * Plans check-constraint migrations for `enumType`-authored columns.\n *\n * Walks every namespace's tables in the target contract. For each table that\n * carries `checks`, diffs the contract-expected checks against the live\n * schema's checks:\n *\n * - Check in contract, absent from live DB → `AddCheckConstraintCall`.\n * - Check in live DB, absent from contract → `DropCheckConstraintCall`.\n * - Check on both sides but value sets differ → `DropCheckConstraintCall`\n *   then `AddCheckConstraintCall` (drop + recreate; a check predicate cannot\n *   be altered in place).\n *\n * Consumes `check_missing`, `check_removed`, and `check_mismatch` issues.\n * Does not touch the native enum path (`nativeEnumPlanCallStrategy` is\n * unchanged).\n */\nexport const checkConstraintPlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  const calls: PostgresOpFactoryCall[] = [];\n  const handledIssueKeys = new Set<string>();\n\n  for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {\n    for (const tableName of Object.keys(ns.entries.table)) {\n      const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);\n      if (contractChecks.length === 0) continue;\n\n      const schemaTable = ctx.schema.tables[tableName];\n      const liveChecks = schemaTable?.checks ?? [];\n      const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);\n\n      for (const contractCheck of contractChecks) {\n        const liveCheck = liveChecks.find((c) => c.name === contractCheck.name);\n        const issueKey = `${tableName}\u0000${contractCheck.name}`;\n        if (!liveCheck) {\n          calls.push(\n            new AddCheckConstraintCall(\n              ddlSchema,\n              tableName,\n              contractCheck.name,\n              contractCheck.column,\n              contractCheck.permittedValues,\n            ),\n          );\n          handledIssueKeys.add(issueKey);\n        } else if (!checkValueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {\n          calls.push(\n            new DropCheckConstraintCall(ddlSchema, tableName, contractCheck.name),\n            new AddCheckConstraintCall(\n              ddlSchema,\n              tableName,\n              contractCheck.name,\n              contractCheck.column,\n              contractCheck.permittedValues,\n            ),\n          );\n          handledIssueKeys.add(issueKey);\n        }\n        // else: values match — no op needed, still consume the issue\n        else {\n          handledIssueKeys.add(issueKey);\n        }\n      }\n\n      // Emit drops for checks that are live but not in the contract.\n      for (const liveCheck of liveChecks) {\n        const inContract = contractChecks.some((c) => c.name === liveCheck.name);\n        if (!inContract) {\n          const issueKey = `${tableName}\u0000${liveCheck.name}`;\n          calls.push(new DropCheckConstraintCall(ddlSchema, tableName, liveCheck.name));\n          handledIssueKeys.add(issueKey);\n        }\n      }\n    }\n  }\n\n  if (calls.length === 0 && handledIssueKeys.size === 0) return { kind: 'no_match' };\n\n  const remaining = issues.filter((issue) => {\n    if (\n      issue.kind !== 'check_missing' &&\n      issue.kind !== 'check_removed' &&\n      issue.kind !== 'check_mismatch'\n    ) {\n      return true;\n    }\n    if (!issue.table || !issue.indexOrConstraint) return true;\n    const key = `${issue.table}\u0000${issue.indexOrConstraint}`;\n    return !handledIssueKeys.has(key);\n  });\n\n  return { kind: 'match', issues: remaining, calls };\n};\n\n/**\n * Dispatches non-enum codec-typed storage types through their codec's\n * `planTypeOperations` hook (the authoritative source for codec-driven DDL\n * such as custom type creation). Enum dispatch lives in\n * `nativeEnumPlanCallStrategy` and no longer relies on codec hooks.\n */\nexport const storageTypePlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  const storageTypes = ctx.toContract.storage.types ?? {};\n  if (Object.keys(storageTypes).length === 0) return { kind: 'no_match' };\n\n  const calls: PostgresOpFactoryCall[] = [];\n  const handledTypeNames = new Set<string>();\n\n  for (const [typeName, typeInstance] of Object.entries(storageTypes).sort(([a], [b]) =>\n    a.localeCompare(b),\n  )) {\n    // Enums walk natively in `nativeEnumPlanCallStrategy`; codec-hook\n    // dispatch here is reserved for genuinely codec-typed entries\n    // (decimal, varchar, pgvector, …).\n    if (isPostgresEnumStorageEntry(typeInstance)) continue;\n    const codecInstance = typeInstance as StorageTypeInstance;\n    const hook = ctx.codecHooks.get(codecInstance.codecId);\n    if (!hook?.planTypeOperations) continue;\n    const planResult = hook.planTypeOperations({\n      typeName,\n      typeInstance: codecInstance,\n      contract: ctx.toContract,\n      schema: ctx.schema,\n      schemaName: ctx.schemaName,\n      policy: ctx.policy,\n    });\n    if (!planResult) continue;\n    if (planResult.operations.length === 0) {\n      handledTypeNames.add(typeName);\n      continue;\n    }\n    handledTypeNames.add(typeName);\n    for (const op of planResult.operations) {\n      calls.push(\n        new RawSqlCall({\n          ...op,\n          target: {\n            id: op.target.id,\n            details: buildTargetDetails('type', typeName, ctx.schemaName),\n          },\n        } as SqlMigrationPlanOperation<PostgresPlanTargetDetails>),\n      );\n    }\n  }\n\n  const remaining = issues.filter(\n    (issue) =>\n      !(\n        (issue.kind === 'type_missing' || issue.kind === 'enum_values_changed') &&\n        issue.typeName &&\n        handledTypeNames.has(issue.typeName)\n      ),\n  );\n\n  if (calls.length === 0 && remaining.length === issues.length) {\n    return { kind: 'no_match' };\n  }\n\n  return { kind: 'match', issues: remaining, calls };\n};\n\n/**\n * Handles `missing_column` issues for NOT NULL columns without a contract\n * default. Replaces the walk-schema `buildAddColumnItem` non-default branches.\n *\n * Two shapes:\n *  - Shared-temp-default safe: emit a single atomic composite op (add\n *    nullable → backfill identity value → `SET NOT NULL` → `DROP DEFAULT`).\n *  - Empty-table guarded: emit a hand-built op with a `tableIsEmptyCheck`\n *    precheck so the failure message is \"table is not empty\" rather than the\n *    raw PG NOT NULL violation.\n *\n * \"Normal\" missing_column cases (nullable or has a contract default) are left\n * for `mapIssueToCall`'s default `AddColumnCall` emission.\n */\nexport const notNullAddColumnCallStrategy: CallMigrationStrategy = (issues, ctx) => {\n  const matched: SchemaIssue[] = [];\n  const calls: PostgresOpFactoryCall[] = [];\n\n  const schemaLookups = buildSchemaLookupMap(ctx.schema);\n\n  const mutableCodecHooks = ctx.codecHooks as Map<string, CodecControlHooks>;\n  const mutableStorageTypes = ctx.storageTypes as Record<\n    string,\n    StorageTypeInstance | PostgresEnumType\n  >;\n\n  for (const issue of issues) {\n    if (issue.kind !== 'missing_column' || !issue.table || !issue.column) continue;\n    const namespaceId = resolveNamespaceIdForIssue(issue);\n    const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);\n    const column = contractTable?.columns[issue.column];\n    if (!column) continue;\n\n    const notNull = column.nullable !== true;\n    const hasDefault = column.default !== undefined;\n    if (!notNull || hasDefault) continue;\n\n    const schemaTable = ctx.schema.tables[issue.table];\n    if (!schemaTable) continue;\n\n    const temporaryDefault = resolveIdentityValue(column, mutableCodecHooks, mutableStorageTypes);\n    const schemaLookup = schemaLookups.get(issue.table);\n    const canUseSharedTempDefault =\n      temporaryDefault !== null &&\n      canUseSharedTemporaryDefaultStrategy({\n        table: contractTable,\n        schemaTable,\n        schemaLookup,\n        columnName: issue.column,\n      });\n\n    matched.push(issue);\n\n    const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);\n\n    if (canUseSharedTempDefault && temporaryDefault !== null) {\n      calls.push(\n        new RawSqlCall(\n          buildAddNotNullColumnWithTemporaryDefaultOperation({\n            schema: schemaForTable,\n            tableName: issue.table,\n            columnName: issue.column,\n            column,\n            codecHooks: mutableCodecHooks,\n            storageTypes: mutableStorageTypes,\n            temporaryDefault,\n          }),\n        ),\n      );\n      continue;\n    }\n\n    const qualified = qualifyTableName(schemaForTable, issue.table);\n    calls.push(\n      new RawSqlCall({\n        ...buildAddColumnOperationIdentity(schemaForTable, issue.table, issue.column),\n        operationClass: 'additive',\n        precheck: [\n          {\n            description: `ensure column \"${issue.column}\" is missing`,\n            sql: columnExistsCheck({\n              schema: schemaForTable,\n              table: issue.table,\n              column: issue.column,\n              exists: false,\n            }),\n          },\n          {\n            description: `ensure table \"${issue.table}\" is empty before adding NOT NULL column without default`,\n            sql: tableIsEmptyCheck(qualified),\n          },\n        ],\n        execute: [\n          {\n            description: `add column \"${issue.column}\"`,\n            sql: buildAddColumnSql(\n              qualified,\n              issue.column,\n              column,\n              mutableCodecHooks,\n              undefined,\n              mutableStorageTypes,\n            ),\n          },\n        ],\n        postcheck: [\n          {\n            description: `verify column \"${issue.column}\" exists`,\n            sql: columnExistsCheck({\n              schema: schemaForTable,\n              table: issue.table,\n              column: issue.column,\n            }),\n          },\n          {\n            description: `verify column \"${issue.column}\" is NOT NULL`,\n            sql: columnNullabilityCheck({\n              schema: schemaForTable,\n              table: issue.table,\n              column: issue.column,\n              nullable: false,\n            }),\n          },\n        ],\n      }),\n    );\n  }\n\n  if (matched.length === 0) return { kind: 'no_match' };\n  return {\n    kind: 'match',\n    issues: issues.filter((i) => !matched.includes(i)),\n    calls,\n  };\n};\n\n// ============================================================================\n// Strategy helpers\n// ============================================================================\n\nfunction canUseSharedTemporaryDefaultStrategy(options: {\n  readonly table: StorageTable;\n  readonly schemaTable: SqlSchemaIR['tables'][string];\n  readonly schemaLookup: ReturnType<typeof buildSchemaLookupMap> extends ReadonlyMap<\n    string,\n    infer V\n  >\n    ? V | undefined\n    : never;\n  readonly columnName: string;\n}): boolean {\n  const { table, schemaTable, schemaLookup, columnName } = options;\n\n  if (table.primaryKey?.columns.includes(columnName) && !schemaTable.primaryKey) {\n    return false;\n  }\n\n  for (const unique of table.uniques) {\n    if (!unique.columns.includes(columnName)) continue;\n    if (!schemaLookup || !hasUniqueConstraint(schemaLookup, unique.columns)) return false;\n  }\n\n  for (const foreignKey of table.foreignKeys) {\n    if (foreignKey.constraint === false || !foreignKey.source.columns.includes(columnName))\n      continue;\n    if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;\n  }\n\n  return true;\n}\n\n/**\n * Ordered list of Postgres planner strategies, shared by `migration plan`\n * and `db update` / `db init`. The issue planner runs each strategy in\n * order, letting it consume any issues it handles, and routes whatever's\n * left through `mapIssueToCall`. Behavior diverges purely on\n * `policy.allowedOperationClasses`:\n *\n * - When `'data'` is allowed (`migration plan`), the data-safe strategies\n *   (`notNullBackfillCallStrategy`, `typeChangeCallStrategy`,\n *   `nullableTighteningCallStrategy`) and the enum walk\n *   (`nativeEnumPlanCallStrategy`) consume their matching issues and emit\n *   `DataTransformCall` placeholders or recipe ops.\n *\n * - When `'data'` is not allowed (`db update` / `db init`), the\n *   placeholder-emitting strategies short-circuit to `no_match`, leaving\n *   the issue for the downstream walk-schema strategies\n *   (`storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) or the\n *   `mapIssueToCall` default to handle with direct DDL.\n *   `nativeEnumPlanCallStrategy` runs in both modes; under `db update` /\n *   `db init` it emits the rebuild recipe without the data-transform\n *   placeholder so value-removal data loss surfaces as a runtime cast\n *   error rather than silent loss.\n *\n * Enum dispatch is unified into a single strategy: the\n * `nativeEnumPlanCallStrategy` decides per-emission whether to emit a\n * rebuild recipe (`recipe: true`, contiguous slot) or hoist the call\n * into the `dep` bucket (`recipe: false`, so a brand-new\n * `CreateEnumTypeCall` runs before any `CreateTableCall` referencing\n * it). Codec-typed entries continue through `storageTypePlanCallStrategy`.\n */\nexport const postgresPlannerStrategies: readonly CallMigrationStrategy[] = [\n  notNullBackfillCallStrategy,\n  typeChangeCallStrategy,\n  nullableTighteningCallStrategy,\n  nativeEnumPlanCallStrategy,\n  checkConstraintPlanCallStrategy,\n  storageTypePlanCallStrategy,\n  notNullAddColumnCallStrategy,\n];\n","/**\n * Postgres migration planner.\n *\n * Takes schema issues (from verifySqlSchema) and emits migration IR\n * (`PostgresOpFactoryCall[]`). Strategies consume issues they recognize and\n * produce specialized call sequences (e.g. NOT NULL backfill →\n * addColumn(nullable) + dataTransform + setNotNull); remaining issues flow\n * through `mapIssueToCall` for the default case.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  MigrationOperationPolicy,\n  SqlPlannerConflict,\n  SqlPlannerConflictLocation,\n} from '@prisma-next/family-sql/control';\nimport { arraysEqual } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport type {\n  PostgresEnumStorageEntry,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport * as contractFree from '@prisma-next/sql-relational-core/contract-free';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { PostgresEnumType } from '../postgres-enum-type';\nimport { isPostgresSchema } from '../postgres-schema';\nimport {\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  CreateEnumTypeCall,\n  CreateIndexCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNotNullCall,\n  DropTableCall,\n  type PostgresOpFactoryCall,\n  postgresDefaultToDdlColumnDefault,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport type { ColumnSpec, ForeignKeySpec } from './operations/shared';\nimport { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';\nimport { buildExpectedFormatType } from './planner-sql-checks';\nimport {\n  type CallMigrationStrategy,\n  postgresPlannerStrategies,\n  resolveDdlSchemaForNamespace,\n  resolveNamespaceIdForIssue,\n  type StrategyContext,\n  tableAt,\n} from './planner-strategies';\n\nexport type { CallMigrationStrategy, StrategyContext };\n\n/**\n * Finds a type entry by explicit namespace coordinate. Reads the named\n * namespace's `enum` slot directly — never scans other namespaces.\n */\nfunction locateNamespaceTypeInStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  typeName: string,\n): unknown {\n  const ns = storage.namespaces[namespaceId];\n  return isPostgresSchema(ns) ? ns.entries.type[typeName] : undefined;\n}\n\n// ============================================================================\n// Issue kind ordering (dependency order)\n// ============================================================================\n\nconst ISSUE_KIND_ORDER: Record<string, number> = {\n  // Schemas first — the database container must exist before any DDL\n  // that targets it can run.\n  missing_schema: 1,\n\n  // Types next\n  type_missing: 2,\n  type_values_mismatch: 3,\n  enum_values_changed: 3,\n\n  // Drops (reconciliation — clear the way for creates)\n  // FKs dropped first (they depend on other constraints)\n  extra_foreign_key: 10,\n  extra_unique_constraint: 11,\n  extra_primary_key: 12,\n  extra_index: 13,\n  extra_default: 14,\n  extra_column: 15,\n  extra_table: 16,\n\n  // Tables before columns\n  missing_table: 20,\n\n  // Columns before constraints\n  missing_column: 30,\n\n  // Reconciliation alters (on existing objects)\n  type_mismatch: 40,\n  nullability_mismatch: 41,\n  default_missing: 42,\n  default_mismatch: 43,\n\n  // Constraints after columns exist\n  primary_key_mismatch: 50,\n  unique_constraint_mismatch: 51,\n  index_mismatch: 52,\n  foreign_key_mismatch: 60,\n\n  // Check constraints\n  check_missing: 53,\n  check_mismatch: 54,\n  check_removed: 55,\n};\n\nfunction issueOrder(issue: SchemaIssue): number {\n  return ISSUE_KIND_ORDER[issue.kind] ?? 99;\n}\n\n// ============================================================================\n// Conflict helpers\n// ============================================================================\n\nfunction issueConflict(\n  kind: SqlPlannerConflict['kind'],\n  summary: string,\n  location?: SqlPlannerConflict['location'],\n): SqlPlannerConflict {\n  return {\n    kind,\n    summary,\n    why: 'Use `migration new` to author a custom migration for this change.',\n    ...(location ? { location } : {}),\n  };\n}\n\nfunction isMissing(issue: SchemaIssue): boolean {\n  if (issue.kind === 'enum_values_changed') return false;\n  return issue.actual === undefined;\n}\n\n// ============================================================================\n// Issue planner\n// ============================================================================\n\nexport interface IssuePlannerOptions {\n  readonly issues: readonly SchemaIssue[];\n  readonly toContract: Contract<SqlStorage>;\n  readonly fromContract: Contract<SqlStorage> | null;\n  readonly schemaName: string;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n  readonly storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;\n  /**\n   * Current database schema IR. Strategies read this to detect whether a\n   * structure already exists (e.g. `buildSchemaLookupMap` for shared-temp-\n   * default safety, extension dependency checks). Defaults to an empty schema\n   * when omitted so the planner can still run over \"fresh DB\" contract\n   * snapshots.\n   */\n  readonly schema?: SqlSchemaIR;\n  /**\n   * Operation-class policy. `planIssues` filters calls whose `operationClass`\n   * is not in `policy.allowedOperationClasses` and surfaces them as conflicts\n   * instead of emitting disallowed DDL. Defaults to additive-only.\n   */\n  readonly policy?: MigrationOperationPolicy;\n  /**\n   * Framework components participating in this composition. Available to\n   * future strategies that may consult component metadata at plan time.\n   */\n  readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  readonly strategies?: readonly CallMigrationStrategy[];\n}\n\nexport interface IssuePlannerValue {\n  readonly calls: readonly PostgresOpFactoryCall[];\n}\n\nfunction toColumnSpec(\n  name: string,\n  column: StorageColumn,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,\n): ColumnSpec {\n  return {\n    name,\n    typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),\n    defaultSql: buildColumnDefaultSql(column.default, column),\n    nullable: column.nullable,\n  };\n}\n\nfunction toDdlColumn(\n  name: string,\n  column: StorageColumn,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,\n): DdlColumn {\n  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);\n  const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);\n  return contractFree.col(name, typeSql, {\n    ...(!column.nullable ? { notNull: true } : {}),\n    ...(ddlDefault ? { default: ddlDefault } : {}),\n  });\n}\n\nfunction mapIssueToCall(\n  issue: SchemaIssue,\n  ctx: StrategyContext,\n): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {\n  const { schemaName, codecHooks, storageTypes } = ctx;\n  // Per-table effective schema. `extra_table` issues intentionally\n  // omit `namespaceId` — the live DB carries a table that\n  // is not claimed by any contract namespace, so there is no contract\n  // coordinate to project from. Those issues fall back to the planner's\n  // global `ctx.schemaName`; every other issue dispatches through the\n  // resolved namespace's polymorphic `ddlSchemaName`.\n  const tableSchema = (issue: SchemaIssue): string => {\n    if (issue.kind === 'extra_table') return schemaName;\n    if (!('table' in issue) || !issue.table) return schemaName;\n    return resolveDdlSchemaForNamespace(ctx, resolveNamespaceIdForIssue(issue));\n  };\n\n  switch (issue.kind) {\n    case 'missing_schema': {\n      const namespaceId = issue.namespaceId;\n      if (!namespaceId)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Missing schema issue has no namespaceId'),\n        );\n      const ddlSchemaName = resolveDdlSchemaForNamespace(ctx, namespaceId);\n      return ok([new CreateSchemaCall(ddlSchemaName)]);\n    }\n\n    case 'missing_table': {\n      if (!issue.table)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Missing table issue has no table name'),\n        );\n      const namespaceId = resolveNamespaceIdForIssue(issue);\n      const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);\n      if (!contractTable) {\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            `Table \"${issue.table}\" in namespace \"${namespaceId}\" reported missing but not found in destination contract`,\n          ),\n        );\n      }\n      const schemaForTable = tableSchema(issue);\n      const ddlColumns: DdlColumn[] = Object.entries(contractTable.columns).map(([name, column]) =>\n        toDdlColumn(name, column, codecHooks, storageTypes),\n      );\n      const ddlConstraints: DdlTableConstraint[] | undefined = contractTable.primaryKey\n        ? [\n            contractFree.primaryKey(contractTable.primaryKey.columns, {\n              ...(contractTable.primaryKey.name ? { name: contractTable.primaryKey.name } : {}),\n            }),\n          ]\n        : undefined;\n      const calls: PostgresOpFactoryCall[] = [\n        new CreateTableCall(schemaForTable, issue.table, ddlColumns, ddlConstraints),\n      ];\n      for (const index of contractTable.indexes) {\n        const indexName = index.name ?? `${issue.table}_${index.columns.join('_')}_idx`;\n        const extras: { type?: string; options?: Record<string, unknown> } = {};\n        if (index.type !== undefined) extras.type = index.type;\n        if (index.options !== undefined) extras.options = index.options;\n        calls.push(\n          new CreateIndexCall(schemaForTable, issue.table, indexName, [...index.columns], extras),\n        );\n      }\n      const explicitIndexColumnSets = new Set(\n        contractTable.indexes.map((idx) => idx.columns.join(',')),\n      );\n      for (const fk of contractTable.foreignKeys) {\n        if (fk.constraint) {\n          const fkName = fk.name ?? `${issue.table}_${fk.source.columns.join('_')}_fkey`;\n          const fkSpec: ForeignKeySpec = {\n            name: fkName,\n            columns: fk.source.columns,\n            references: {\n              schema: fk.target.namespaceId,\n              table: fk.target.tableName,\n              columns: fk.target.columns,\n            },\n            ...(fk.onDelete !== undefined && { onDelete: fk.onDelete }),\n            ...(fk.onUpdate !== undefined && { onUpdate: fk.onUpdate }),\n          };\n          calls.push(new AddForeignKeyCall(schemaForTable, issue.table, fkSpec));\n        }\n        if (fk.index && !explicitIndexColumnSets.has(fk.source.columns.join(','))) {\n          const indexName = `${issue.table}_${fk.source.columns.join('_')}_idx`;\n          calls.push(\n            new CreateIndexCall(schemaForTable, issue.table, indexName, [...fk.source.columns]),\n          );\n        }\n      }\n      for (const unique of contractTable.uniques) {\n        const constraintName = unique.name ?? `${issue.table}_${unique.columns.join('_')}_key`;\n        calls.push(\n          new AddUniqueCall(schemaForTable, issue.table, constraintName, [...unique.columns]),\n        );\n      }\n      return ok(calls);\n    }\n\n    case 'missing_column':\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Missing column issue has no table/column name'),\n        );\n      {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n          issue.column\n        ];\n        if (!column)\n          return notOk(\n            issueConflict(\n              'unsupportedOperation',\n              `Column \"${issue.table}\".\"${issue.column}\" not in destination contract`,\n            ),\n          );\n        return ok([\n          new AddColumnCall(\n            tableSchema(issue),\n            issue.table,\n            toColumnSpec(issue.column, column, codecHooks, storageTypes),\n          ),\n        ]);\n      }\n\n    case 'default_missing':\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Default missing issue has no table/column name'),\n        );\n      {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n          issue.column\n        ];\n        if (!column?.default) {\n          return notOk(\n            issueConflict(\n              'unsupportedOperation',\n              `Column \"${issue.table}\".\"${issue.column}\" has no default in contract`,\n            ),\n          );\n        }\n        const defaultSql = buildColumnDefaultSql(column.default, column);\n        if (!defaultSql) return ok([]);\n        return ok([new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql)]);\n      }\n\n    case 'extra_table':\n      if (!issue.table)\n        return notOk(issueConflict('unsupportedOperation', 'Extra table issue has no table name'));\n      return ok([new DropTableCall(tableSchema(issue), issue.table)]);\n\n    case 'extra_column':\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Extra column issue has no table/column name'),\n        );\n      return ok([new DropColumnCall(tableSchema(issue), issue.table, issue.column)]);\n\n    case 'extra_index':\n      if (!issue.table || !issue.indexOrConstraint)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Extra index issue has no table/index name'),\n        );\n      return ok([new DropIndexCall(tableSchema(issue), issue.table, issue.indexOrConstraint)]);\n\n    case 'extra_unique_constraint':\n    case 'extra_foreign_key':\n    case 'extra_primary_key': {\n      if (!issue.table)\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            'Extra constraint issue has no table/constraint name',\n          ),\n        );\n      // `extra_primary_key` issues don't carry a constraint name — the\n      // verifier only has the table. Fall back to `<table>_pkey`, matching\n      // Postgres' default PK constraint naming and the old reconciliation\n      // planner's behavior.\n      const constraintName =\n        issue.indexOrConstraint ??\n        (issue.kind === 'extra_primary_key' ? `${issue.table}_pkey` : undefined);\n      if (!constraintName)\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            'Extra constraint issue has no table/constraint name',\n          ),\n        );\n      const kindMap = {\n        extra_unique_constraint: 'unique' as const,\n        extra_foreign_key: 'foreignKey' as const,\n        extra_primary_key: 'primaryKey' as const,\n      };\n      return ok([\n        new DropConstraintCall(\n          tableSchema(issue),\n          issue.table,\n          constraintName,\n          kindMap[issue.kind],\n        ),\n      ]);\n    }\n\n    case 'extra_default':\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Extra default issue has no table/column name'),\n        );\n      return ok([new DropDefaultCall(tableSchema(issue), issue.table, issue.column)]);\n\n    case 'nullability_mismatch': {\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('nullabilityConflict', 'Nullability mismatch has no table/column name'),\n        );\n      const namespaceId = resolveNamespaceIdForIssue(issue);\n      const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n        issue.column\n      ];\n      if (!column)\n        return notOk(\n          issueConflict(\n            'nullabilityConflict',\n            `Column \"${issue.table}\".\"${issue.column}\" not found in destination contract`,\n          ),\n        );\n      const schemaForTable = tableSchema(issue);\n      return ok(\n        column.nullable\n          ? [new DropNotNullCall(schemaForTable, issue.table, issue.column)]\n          : [new SetNotNullCall(schemaForTable, issue.table, issue.column)],\n      );\n    }\n\n    case 'type_mismatch':\n      if (!issue.table || !issue.column)\n        return notOk(issueConflict('typeMismatch', 'Type mismatch has no table/column name'));\n      {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n          issue.column\n        ];\n        if (!column)\n          return notOk(\n            issueConflict(\n              'typeMismatch',\n              `Column \"${issue.table}\".\"${issue.column}\" not in destination contract`,\n            ),\n          );\n        const hooksMap = codecHooks as Map<string, CodecControlHooks>;\n        const typesMap = storageTypes as Record<\n          string,\n          StorageTypeInstance | PostgresEnumStorageEntry\n        >;\n        const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);\n        const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);\n        return ok([\n          new AlterColumnTypeCall(tableSchema(issue), issue.table, issue.column, {\n            qualifiedTargetType,\n            formatTypeExpected,\n            rawTargetTypeForLabel: qualifiedTargetType,\n          }),\n        ]);\n      }\n\n    case 'default_mismatch':\n      if (!issue.table || !issue.column)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Default mismatch has no table/column name'),\n        );\n      {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[\n          issue.column\n        ];\n        if (!column?.default) return ok([]);\n        const defaultSql = buildColumnDefaultSql(column.default, column);\n        if (!defaultSql) return ok([]);\n        return ok([\n          new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql, 'widening'),\n        ]);\n      }\n\n    case 'primary_key_mismatch':\n      if (!issue.table)\n        return notOk(issueConflict('indexIncompatible', 'Primary key issue has no table name'));\n      if (isMissing(issue)) {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const pk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.primaryKey;\n        if (!pk)\n          return notOk(\n            issueConflict('indexIncompatible', `No primary key in contract for \"${issue.table}\"`),\n          );\n        const constraintName = pk.name ?? `${issue.table}_pkey`;\n        return ok([\n          new AddPrimaryKeyCall(tableSchema(issue), issue.table, constraintName, pk.columns),\n        ]);\n      }\n      return notOk(\n        issueConflict(\n          'indexIncompatible',\n          `Primary key on \"${issue.table}\" has different columns (expected: ${issue.expected}, actual: ${issue.actual})`,\n          { table: issue.table },\n        ),\n      );\n\n    case 'unique_constraint_mismatch':\n      if (!issue.table)\n        return notOk(\n          issueConflict('indexIncompatible', 'Unique constraint issue has no table name'),\n        );\n      if (isMissing(issue) && issue.expected) {\n        const columns = issue.expected.split(', ');\n        const constraintName = `${issue.table}_${columns.join('_')}_key`;\n        return ok([new AddUniqueCall(tableSchema(issue), issue.table, constraintName, columns)]);\n      }\n      return notOk(\n        issueConflict(\n          'indexIncompatible',\n          `Unique constraint on \"${issue.table}\" differs (expected: ${issue.expected}, actual: ${issue.actual})`,\n          { table: issue.table },\n        ),\n      );\n\n    case 'index_mismatch':\n      if (!issue.table)\n        return notOk(issueConflict('indexIncompatible', 'Index issue has no table name'));\n      if (isMissing(issue) && issue.expected) {\n        const namespaceId = resolveNamespaceIdForIssue(issue);\n        const columns = issue.expected.split(', ');\n        const contractIndex = tableAt(\n          ctx.toContract.storage,\n          namespaceId,\n          issue.table,\n        )?.indexes.find((idx: StorageTable['indexes'][number]) =>\n          arraysEqual(idx.columns, columns),\n        );\n        const indexName = contractIndex?.name ?? `${issue.table}_${columns.join('_')}_idx`;\n        const extras: { type?: string; options?: Record<string, unknown> } = {};\n        if (contractIndex?.type !== undefined) extras.type = contractIndex.type;\n        if (contractIndex?.options !== undefined) extras.options = contractIndex.options;\n        return ok([\n          new CreateIndexCall(tableSchema(issue), issue.table, indexName, columns, extras),\n        ]);\n      }\n      return notOk(\n        issueConflict(\n          'indexIncompatible',\n          `Index on \"${issue.table}\" differs (expected: ${issue.expected}, actual: ${issue.actual})`,\n          { table: issue.table },\n        ),\n      );\n\n    case 'check_missing': {\n      if (!issue.table || !issue.indexOrConstraint)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Check missing issue has no table/constraint name'),\n        );\n      // check_missing is normally consumed by checkConstraintPlanCallStrategy.\n      // This case handles any that arrive here (e.g. in tests that invoke\n      // mapIssueToCall directly or skip the strategy).\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Check constraint \"${issue.indexOrConstraint}\" missing on \"${issue.table}\" — handled by checkConstraintPlanCallStrategy`,\n        ),\n      );\n    }\n\n    case 'check_mismatch': {\n      if (!issue.table || !issue.indexOrConstraint)\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            'Check mismatch issue has no table/constraint name',\n          ),\n        );\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Check constraint \"${issue.indexOrConstraint}\" values mismatch on \"${issue.table}\" — handled by checkConstraintPlanCallStrategy`,\n        ),\n      );\n    }\n\n    case 'check_removed': {\n      if (!issue.table || !issue.indexOrConstraint)\n        return notOk(\n          issueConflict('unsupportedOperation', 'Check removed issue has no table/constraint name'),\n        );\n      return ok([\n        new DropCheckConstraintCall(tableSchema(issue), issue.table, issue.indexOrConstraint),\n      ]);\n    }\n\n    case 'foreign_key_mismatch':\n      if (!issue.table)\n        return notOk(issueConflict('foreignKeyConflict', 'Foreign key issue has no table name'));\n      if (isMissing(issue) && issue.expected) {\n        const arrowIdx = issue.expected.indexOf(' -> ');\n        if (arrowIdx >= 0) {\n          const namespaceId = resolveNamespaceIdForIssue(issue);\n          const columns = issue.expected.slice(0, arrowIdx).split(', ');\n          const fkName = `${issue.table}_${columns.join('_')}_fkey`;\n          const fk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.foreignKeys.find(\n            (k) => k.source.columns.join(', ') === columns.join(', '),\n          );\n          if (fk) {\n            const fkSpec: ForeignKeySpec = {\n              name: fkName,\n              columns: fk.source.columns,\n              references: {\n                schema: fk.target.namespaceId,\n                table: fk.target.tableName,\n                columns: fk.target.columns,\n              },\n              ...(fk.onDelete !== undefined && { onDelete: fk.onDelete }),\n              ...(fk.onUpdate !== undefined && { onUpdate: fk.onUpdate }),\n            };\n            return ok([new AddForeignKeyCall(tableSchema(issue), issue.table, fkSpec)]);\n          }\n          return notOk(\n            issueConflict(\n              'foreignKeyConflict',\n              `Foreign key on \"${issue.table}\" (${columns.join(', ')}) not found in destination contract`,\n              { table: issue.table },\n            ),\n          );\n        }\n      }\n      return notOk(\n        issueConflict(\n          'foreignKeyConflict',\n          `Foreign key on \"${issue.table}\" differs (expected: ${issue.expected}, actual: ${issue.actual})`,\n          { table: issue.table },\n        ),\n      );\n\n    case 'type_missing': {\n      if (!issue.typeName)\n        return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));\n      // Codec aliases live in storage.types; enum types live in namespace.entries.type.\n      // Check types first; fall back to the namespace-keyed enum slot using the\n      // issue's namespace coordinate (populated by the verifier for enum-related\n      // issues per the BaseSchemaIssue.namespaceId contract).\n      const namespaceId = resolveNamespaceIdForIssue(issue);\n      const typeInstance: unknown =\n        ctx.toContract.storage.types?.[issue.typeName] ??\n        locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);\n      if (!typeInstance) {\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            `Type \"${issue.typeName}\" reported missing but not found in destination contract`,\n          ),\n        );\n      }\n      if (typeInstance instanceof PostgresEnumType) {\n        const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);\n        return ok([\n          new CreateEnumTypeCall(\n            ddlSchema,\n            issue.typeName,\n            typeInstance.values,\n            typeInstance.nativeType,\n          ),\n        ]);\n      }\n      const codecInstance = typeInstance as StorageTypeInstance;\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Type \"${issue.typeName}\" uses codec \"${codecInstance.codecId}\" — only enum types are supported`,\n        ),\n      );\n    }\n\n    case 'type_values_mismatch':\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Type \"${issue.typeName ?? 'unknown'}\" values differ — type alteration not yet supported`,\n        ),\n      );\n\n    default:\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Unhandled issue kind: ${(issue as SchemaIssue).kind}`,\n        ),\n      );\n  }\n}\n\n/**\n * Classifies calls into dependency order categories for correct DDL sequencing.\n */\ntype CallCategory =\n  | 'dep'\n  | 'drop'\n  | 'table'\n  | 'column'\n  | 'alter'\n  | 'primaryKey'\n  | 'unique'\n  | 'index'\n  | 'foreignKey';\n\n/**\n * Classifies calls into DDL sequencing buckets. The order matches the\n * legacy walk-schema planner's emission order so `db init` and `db update`\n * produce byte-identical plans for the shared shape (deps → drops → tables\n * → columns → alters → PKs → uniques → indexes → FKs).\n */\nfunction classifyCall(call: PostgresOpFactoryCall): CallCategory {\n  switch (call.factoryName) {\n    case 'createExtension':\n    case 'createSchema':\n    case 'createEnumType':\n    case 'addEnumValues':\n    case 'dropEnumType':\n    case 'renameType':\n      return 'dep';\n    case 'dropTable':\n    case 'dropColumn':\n    case 'dropConstraint':\n    case 'dropCheckConstraint':\n    case 'dropIndex':\n    case 'dropDefault':\n      return 'drop';\n    case 'addCheckConstraint':\n      return 'unique'; // after uniques, before indexes\n    case 'createTable':\n      return 'table';\n    case 'addColumn':\n      return 'column';\n    case 'alterColumnType':\n    case 'setNotNull':\n    case 'dropNotNull':\n    case 'setDefault':\n      return 'alter';\n    case 'addPrimaryKey':\n      return 'primaryKey';\n    case 'addUnique':\n      return 'unique';\n    case 'createIndex':\n      return 'index';\n    case 'addForeignKey':\n      return 'foreignKey';\n    case 'rawSql': {\n      // Type ops lifted through `RawSqlCall` by `storageTypePlanCallStrategy`\n      // to preserve the codec-emitted label and precheck/postcheck.\n      // Classification falls back to inspecting the underlying op's target\n      // details (`objectType: 'type'`).\n      const op = (\n        call as {\n          op?: {\n            target?: { details?: { objectType?: string } };\n          };\n        }\n      ).op;\n      const objectType = op?.target?.details?.objectType;\n      if (objectType === 'type') return 'dep';\n      return 'alter';\n    }\n    default:\n      return 'alter';\n  }\n}\n\n/** Stable lexical key used to order issues within the same kind bucket. */\nfunction issueKey(issue: SchemaIssue): string {\n  const table = 'table' in issue && typeof issue.table === 'string' ? issue.table : '';\n  const column = 'column' in issue && typeof issue.column === 'string' ? issue.column : '';\n  const name =\n    'indexOrConstraint' in issue && typeof issue.indexOrConstraint === 'string'\n      ? issue.indexOrConstraint\n      : '';\n  return `${table}\\u0000${column}\\u0000${name}`;\n}\n\n// When no policy is explicitly supplied (test-only path; production callers\n// always pass one), allow every class so strategies that gate on\n// `'data'` (data-safe placeholders) still fire — the test is treated as\n// trusted. Filtering of actual emitted calls only runs when a policy was\n// explicitly provided (see `policyProvided` below).\nconst DEFAULT_POLICY: MigrationOperationPolicy = {\n  allowedOperationClasses: ['additive', 'widening', 'destructive', 'data'],\n};\n\nfunction emptySchemaIR(): SqlSchemaIR {\n  return { tables: {} };\n}\n\nfunction conflictKindForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['kind'] {\n  switch (call.factoryName) {\n    case 'alterColumnType':\n      return 'typeMismatch';\n    case 'setNotNull':\n    case 'dropNotNull':\n      return 'nullabilityConflict';\n    case 'addForeignKey':\n    case 'dropConstraint':\n      return 'foreignKeyConflict';\n    case 'createIndex':\n    case 'dropIndex':\n      return 'indexIncompatible';\n    default:\n      return 'missingButNonAdditive';\n  }\n}\n\nfunction locationForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['location'] | undefined {\n  // Most Postgres call classes expose `tableName`/`columnName`/`indexName`/\n  // `constraintName` as readonly fields. We avoid `toOp()` here because a\n  // `DataTransformCall` intentionally throws from `toOp`.\n  const anyCall = call as unknown as {\n    tableName?: string;\n    columnName?: string;\n    indexName?: string;\n    constraintName?: string;\n    typeName?: string;\n  };\n  const location: {\n    table?: string;\n    column?: string;\n    index?: string;\n    constraint?: string;\n    type?: string;\n  } = {};\n  if (anyCall.tableName) location.table = anyCall.tableName;\n  if (anyCall.columnName) location.column = anyCall.columnName;\n  if (anyCall.indexName) location.index = anyCall.indexName;\n  if (anyCall.constraintName) location.constraint = anyCall.constraintName;\n  if (anyCall.typeName) location.type = anyCall.typeName;\n  return Object.keys(location).length > 0 ? (location as SqlPlannerConflictLocation) : undefined;\n}\n\nfunction conflictForDisallowedCall(\n  call: PostgresOpFactoryCall,\n  allowed: readonly string[],\n): SqlPlannerConflict {\n  const summary = `Operation \"${call.label}\" requires class \"${call.operationClass}\", but policy allows only: ${allowed.join(', ')}`;\n  const location = locationForCall(call);\n  return {\n    kind: conflictKindForCall(call),\n    summary,\n    why: 'Use `migration new` to author a custom migration for this change.',\n    ...(location ? { location } : {}),\n  };\n}\n\nexport function planIssues(\n  options: IssuePlannerOptions,\n): Result<IssuePlannerValue, readonly SqlPlannerConflict[]> {\n  // When no policy is supplied, `planIssues` treats the call as trusted (the\n  // caller — typically a test — has already vetted the issues). Only explicit\n  // policies gate operation classes into conflicts.\n  // `PostgresMigrationPlanner` always passes an explicit policy.\n  const policyProvided = options.policy !== undefined;\n  const policy = options.policy ?? DEFAULT_POLICY;\n  const schema = options.schema ?? emptySchemaIR();\n  const frameworkComponents = options.frameworkComponents ?? [];\n\n  const context: StrategyContext = {\n    toContract: options.toContract,\n    fromContract: options.fromContract,\n    schemaName: options.schemaName,\n    codecHooks: options.codecHooks,\n    storageTypes: options.storageTypes,\n    schema,\n    policy,\n    frameworkComponents,\n  };\n\n  const strategies = options.strategies ?? postgresPlannerStrategies;\n\n  let remaining = options.issues;\n  const recipeCalls: PostgresOpFactoryCall[] = [];\n  const bucketablePatternCalls: PostgresOpFactoryCall[] = [];\n\n  for (const strategy of strategies) {\n    const result = strategy(remaining, context);\n    if (result.kind === 'match') {\n      remaining = result.issues;\n      if (result.recipe) {\n        recipeCalls.push(...result.calls);\n      } else {\n        bucketablePatternCalls.push(...result.calls);\n      }\n    }\n  }\n\n  const sorted = [...remaining].sort((a, b) => {\n    const kindDelta = issueOrder(a) - issueOrder(b);\n    if (kindDelta !== 0) return kindDelta;\n    const keyA = issueKey(a);\n    const keyB = issueKey(b);\n    return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;\n  });\n\n  const defaultCalls: PostgresOpFactoryCall[] = [];\n  const conflicts: SqlPlannerConflict[] = [];\n\n  for (const issue of sorted) {\n    const result = mapIssueToCall(issue, context);\n    if (result.ok) {\n      defaultCalls.push(...result.value);\n    } else {\n      conflicts.push(result.failure);\n    }\n  }\n\n  // Policy gating: drop calls whose operation class is not allowed and\n  // surface a conflict describing the disallowed op. Applies to both strategy\n  // output and default-mapped output. Only active when the caller explicitly\n  // supplied a policy — direct unit-test invocations (which pass no policy)\n  // stay as pass-through and keep destructive recipe steps intact.\n  const allowed = policy.allowedOperationClasses;\n  let gatedDefault = defaultCalls;\n  let gatedRecipe = recipeCalls;\n  let gatedBucketable = bucketablePatternCalls;\n  if (policyProvided) {\n    const keepIfAllowed = (bucket: PostgresOpFactoryCall[]) => (call: PostgresOpFactoryCall) => {\n      if (allowed.includes(call.operationClass)) {\n        bucket.push(call);\n        return;\n      }\n      conflicts.push(conflictForDisallowedCall(call, allowed));\n    };\n    const gatedDefaultBucket: PostgresOpFactoryCall[] = [];\n    const gatedRecipeBucket: PostgresOpFactoryCall[] = [];\n    const gatedBucketableBucket: PostgresOpFactoryCall[] = [];\n    defaultCalls.forEach(keepIfAllowed(gatedDefaultBucket));\n    recipeCalls.forEach(keepIfAllowed(gatedRecipeBucket));\n    bucketablePatternCalls.forEach(keepIfAllowed(gatedBucketableBucket));\n    gatedDefault = gatedDefaultBucket;\n    gatedRecipe = gatedRecipeBucket;\n    gatedBucketable = gatedBucketableBucket;\n  }\n\n  if (conflicts.length > 0) {\n    return notOk(conflicts);\n  }\n\n  // Recipe strategies (`nativeEnumPlanCallStrategy`,\n  // `notNullBackfillCallStrategy`, etc.) emit a cohesive sequence that must\n  // stay contiguous. They are inserted at a single pattern slot. Non-recipe\n  // pattern strategies (`dependencyInstallCallStrategy`,\n  // `storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) produce\n  // individually classifiable calls that slot into DDL buckets alongside\n  // default-mapped calls.\n  const combinedBucketable = [...gatedDefault, ...gatedBucketable];\n  const byCategory = (cat: CallCategory) =>\n    combinedBucketable.filter((c) => classifyCall(c) === cat);\n\n  const calls: PostgresOpFactoryCall[] = [\n    ...byCategory('dep'),\n    ...byCategory('drop'),\n    ...byCategory('table'),\n    ...byCategory('column'),\n    ...gatedRecipe,\n    ...byCategory('alter'),\n    ...byCategory('primaryKey'),\n    ...byCategory('unique'),\n    ...byCategory('index'),\n    ...byCategory('foreignKey'),\n  ];\n\n  return ok({ calls });\n}\n"],"mappings":"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"}

package/dist/nodes-779hmCfL.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodes-779hmCfL.d.mts","names":[],"sources":["../src/core/ddl/nodes.ts"],"mappings":";;;UAMiB,kBAAA;EACf,WAAA,CAAY,IAAA,EAAM,mBAAA,GAAsB,CAAA;EACxC,YAAA,CAAa,IAAA,EAAM,oBAAA,GAAuB,CAAA;AAAA;AAAA,uBAGtB,eAAA,SAAwB,OAAA;EAAA,SACnC,MAAA,IAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,cAazC,mBAAA,SAA4B,eAAA;EAAA,SAC9B,IAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA,EAAS,aAAA,CAAc,SAAA;EAAA,SACvB,WAAA,EAAa,aAAA,CAAc,kBAAA;cAExB,OAAA;IAAA,SACD,KAAA;IAAA,SACA,MAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA;EAWzB,MAAA,IAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,cAKzC,oBAAA,SAA6B,eAAA;EAAA,SAC/B,IAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;cAEG,OAAA;IAAA,SAAoB,MAAA;IAAA,SAAyB,WAAA;EAAA;EAOhD,MAAA,IAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,KAK1C,kBAAA,GAAqB,mBAAA,GAAsB,oBAAoB"}