@prisma-next/framework-components 0.11.0-dev.5 → 0.11.0-dev.51

package/dist/codec-BFOsuHKK.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codec-BFOsuHKK.d.mts","names":[],"sources":["../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/codec.ts"],"mappings":";;;;KAIY,UAAA;AAAZ;;;;;AAWA;;;;AAXA,UAWiB,QAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA,GAAa,SAAA;AAAA;;AAcxB;;;;;AAYA;;;;;UAZiB,gBAAA;EAAA,SACN,MAAA,GAAS,WAAA;AAAA;;;;;;;;;UAWH,WAAA;EACf,GAAA,CAAI,EAAA,WAAa,KAAA;EACjB,cAAA,CAAe,EAAA;EACf,OAAA,CAAQ,EAAA,WAAa,SAAA;EACrB,mBAAA,CAAoB,EAAA,UAAY,MAAA,EAAQ,MAAA;AAAA;AAAA,cAG7B,gBAAA,EAAkB,WAAA;;;;;AAc/B;;;UAAiB,oBAAA;EAAA,SACN,IAAA;AAAA;;;;UAMM,SAAA;EAAA,SACN,EAAA,GAAK,MAAA;AAAA;;;;cAMH,gBAAA,EAAkB,gBAAA;;;;;;;;;AA/C/B;;;;;UCDiB,eAAA;EDaW;EAAA,SCXjB,OAAA;EDYQ;EAAA,SCVR,MAAA,WAAiB,UAAA;EDac;EAAA,SCX/B,WAAA;EDWqC;EAAA,SCTrC,IAAA,GAAO,SAAA;EDMZ;EAAA,SCJK,YAAA,EAAc,gBAAA,CAAiB,CAAA;EDKxC;EAAA,SCHS,eAAA;EDIT;EAAA,SCFS,gBAAA,IAAoB,MAAA,EAAQ,CAAA;EDEhB;EAAA,SCAZ,OAAA,GAAU,MAAA,EAAQ,CAAA,MAAO,GAAA,EAAK,oBAAA,KAAyB,KAAA;AAAA;;;;;ADIlE;KCKY,kBAAA,GAAqB,eAAA;;;;ADSjC;;;;uBCAsB,mBAAA,4BAA+C,eAAA,CAAgB,OAAA;EAAA,kBACjE,OAAA;EAAA,kBACA,MAAA,WAAiB,UAAA;EAAA,kBACjB,WAAA;EAAA,SACT,IAAA,GAAO,SAAA;EAAA,kBAEE,YAAA,EAAc,gBAAA,CAAiB,OAAA;EDQtC;EAAA,ICLP,eAAA,CAAA;;EAKJ,gBAAA,CAAA,CAAkB,MAAA,EAAQ,OAAA;EDAmB;;;EAAA,SCKpC,OAAA,CACP,MAAA,EAAQ,OAAA,IACN,GAAA,EAAK,oBAAA,KAAyB,KAAA,kBAAuB,UAAA;AAAA;;;;;;;;;ADtD3D;;;;;AAYA;;;;;;;;UEViB,KAAA,sDAEU,UAAA,cAAwB,UAAA;EFS7C;EAAA,SEJK,EAAA,EAAI,EAAA;EFKb;EAAA,SEHS,aAAA,GAAgB,OAAA;EFIzB;EEFA,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EFEjC;EEArB,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EFChC;EECpB,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EFDK;EEGhC,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA;AFA/B;;;;;AAAA,uBEQsB,SAAA,sDAEK,UAAA,cAAwB,UAAA,kDAGtC,KAAA,CAAM,EAAA,EAAI,OAAA,EAAS,KAAA,EAAO,MAAA;EAAA,SAMT,UAAA,EAAY,eAAA;;;;cAAZ,UAAA,EAAY,eAAA;EAAA,IAEpC,EAAA,CAAA,GAAM,EAAA;EAAA,SAID,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EAAA,SACtD,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EAAA,SACpD,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EAAA,SAC3B,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA"}
+{"version":3,"file":"codec-BFOsuHKK.d.mts","names":[],"sources":["../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/codec.ts"],"mappings":";;;;KAIY,UAAA;AAAZ;;;;AAAsB;AAWtB;;;;AAXA,UAWiB,QAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA,GAAa,SAAS;AAAA;AAAA;AAcjC;;;;AAC+B;AAW/B;;;;;AA1BiC,UAchB,gBAAA;EAAA,SACN,MAAA,GAAS,WAAW;AAAA;;;;;;;;;UAWd,WAAA;EACf,GAAA,CAAI,EAAA,WAAa,KAAA;EACjB,cAAA,CAAe,EAAA;EACf,OAAA,CAAQ,EAAA,WAAa,SAAA;EACrB,mBAAA,CAAoB,EAAA,UAAY,MAAA,EAAQ,MAAA;AAAA;AAAA,cAG7B,gBAAA,EAAkB,WAK9B;;;;AAAA;AASD;;;UAAiB,oBAAA;EAAA,SACN,IAAI;AAAA;;;;UAME,SAAA;EAAA,SACN,EAAA,GAAK,MAAM;AAAA;;;AAMyB;cAAlC,gBAAA,EAAkB,gBAAgB;;;;;;;;AA7Dd;AAcjC;;;;AAC+B;UCFd,eAAA;EDaW;EAAA,SCXjB,OAAA;EDYQ;EAAA,SCVR,MAAA,WAAiB,UAAA;EDac;EAAA,SCX/B,WAAA;EDWqC;EAAA,SCTrC,IAAA,GAAO,SAAA;EDMZ;EAAA,SCJK,YAAA,EAAc,gBAAA,CAAiB,CAAA;EDKxC;EAAA,SCHS,eAAA;EDIT;EAAA,SCFS,gBAAA,IAAoB,MAAA,EAAQ,CAAA;EDEhB;EAAA,SCAZ,OAAA,GAAU,MAAA,EAAQ,CAAA,MAAO,GAAA,EAAK,oBAAA,KAAyB,KAAA;AAAA;;;;ADCD;AAGjE;KCKY,kBAAA,GAAqB,eAAe;;;ADA/C;AASD;;;;uBCAsB,mBAAA,4BAA+C,eAAA,CAAgB,OAAA;EAAA,kBACjE,OAAA;EAAA,kBACA,MAAA,WAAiB,UAAA;EAAA,kBACjB,WAAA;EAAA,SACT,IAAA,GAAO,SAAA;EAAA,kBAEE,YAAA,EAAc,gBAAA,CAAiB,OAAA;EDQtC;EAAA,ICLP,eAAA,CAAA;;EAKJ,gBAAA,CAAA,CAAkB,MAAA,EAAQ,OAAA;EDAmB;;;EAAA,SCKpC,OAAA,CACP,MAAA,EAAQ,OAAA,IACN,GAAA,EAAK,oBAAA,KAAyB,KAAA,kBAAuB,UAAA;AAAA;;;;;;;;ADpE1B;AAcjC;;;;AAC+B;AAW/B;;;;;;;;UEViB,KAAA,sDAEU,UAAA,cAAwB,UAAA;EFS7C;EAAA,SEJK,EAAA,EAAI,EAAA;EFKb;EAAA,SEHS,aAAA,GAAgB,OAAA;EFIzB;EEFA,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EFEjC;EEArB,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EFChC;EECpB,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EFDK;EEGhC,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA;AFA/B;;;;AAKC;AALD,uBEQsB,SAAA,sDAEK,UAAA,cAAwB,UAAA,kDAGtC,KAAA,CAAM,EAAA,EAAI,OAAA,EAAS,KAAA,EAAO,MAAA;EAAA,SAMT,UAAA,EAAY,eAAA;;;AFJ3B;cEIe,UAAA,EAAY,eAAA;EAAA,IAEpC,EAAA,CAAA,GAAM,EAAA;EAAA,SAID,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EAAA,SACtD,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EAAA,SACpD,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EAAA,SAC3B,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA"}

package/dist/codec.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codec.d.mts","names":[],"sources":["../src/shared/column-spec.ts"],"mappings":";;;;;;;;;;KAkBY,oBAAA;EAAA,SACD,OAAA,EAAS,QAAA;EAAA,SACT,UAAA;EAAA,SACA,UAAA,GAAa,MAAA;EAAA,SACb,OAAA;AAAA;;;;;;UAQM,UAAA,cAAwB,MAAA,uCAC/B,oBAAA;EAAA,SACC,YAAA,GAAe,GAAA,EAAK,oBAAA,KAAyB,CAAA;EAAA,SAC7C,UAAA,EAAY,CAAA;AAAA;;;;;;iBAQP,MAAA,cAAoB,MAAA,8BAAA,CAClC,YAAA,GAAe,GAAA,EAAK,oBAAA,KAAyB,CAAA,EAC7C,OAAA,UACA,UAAA,EAAY,CAAA,EACZ,UAAA,WACC,UAAA,CAAW,CAAA,EAAG,CAAA;;AALjB;;;;KAoBY,eAAA,WAA0B,eAAA,aAEjC,IAAA,YACA,UAAA,UAAoB,kBAAA,CAAmB,CAAA;;;;KAMhC,qBAAA,WAAgC,eAAA,aAEvC,IAAA,YACA,UAAA,CAAW,UAAA,CAAW,UAAA,CAAW,CAAA,eAAgB,kBAAA,CAAmB,CAAA;;;;KAMpE,kBAAA,WAA6B,eAAA,SAChC,UAAA,CAAW,CAAA,wBAAyB,MAAA,oBAChC,UAAA,CAAW,CAAA"}
+{"version":3,"file":"codec.d.mts","names":[],"sources":["../src/shared/column-spec.ts"],"mappings":";;;;;;;;;AAsBkB;KAJN,oBAAA;EAAA,SACD,OAAA,EAAS,QAAA;EAAA,SACT,UAAA;EAAA,SACA,UAAA,GAAa,MAAM;EAAA,SACnB,OAAA;AAAA;;;;;;UAQM,UAAA,cAAwB,MAAA,uCAC/B,oBAAA;EAAA,SACC,YAAA,GAAe,GAAA,EAAK,oBAAA,KAAyB,CAAA;EAAA,SAC7C,UAAA,EAAY,CAAA;AAAA;;;;;;iBAQP,MAAA,cAAoB,MAAA,8BAAA,CAClC,YAAA,GAAe,GAAA,EAAK,oBAAA,KAAyB,CAAA,EAC7C,OAAA,UACA,UAAA,EAAY,CAAA,EACZ,UAAA,WACC,UAAA,CAAW,CAAA,EAAG,CAAA;AAbO;AAQxB;;;;AARwB,KA4BZ,eAAA,WAA0B,eAAA,aAEjC,IAAA,YACA,UAAA,UAAoB,kBAAA,CAAmB,CAAA;;;;KAMhC,qBAAA,WAAgC,eAAA,aAEvC,IAAA,YACA,UAAA,CAAW,UAAA,CAAW,UAAA,CAAW,CAAA,eAAgB,kBAAA,CAAmB,CAAA;;;;KAMpE,kBAAA,WAA6B,eAAA,SAChC,UAAA,CAAW,CAAA,wBAAyB,MAAA,oBAChC,UAAA,CAAW,CAAA"}

package/dist/codec.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"codec.mjs","names":[],"sources":["../src/shared/codec.ts","../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/column-spec.ts"],"sourcesContent":["/**\n * Codec interface (consumer surface) and abstract `CodecImpl` base (codec-author surface).\n *\n * Consumers depend on the {@link Codec} interface — it describes the runtime instance returned by a descriptor's curried factory and is what the framework threads through emit, validate, and execute paths.\n *\n * Codec authors `extend` the {@link CodecImpl} abstract class to declare a typed runtime codec instance. The class carries a variance-erased descriptor reference (`CodecDescriptor<any>`); `id` proxies through the descriptor so one source of truth governs both metadata reads and aliasing semantics (alias subclasses inherit the descriptor's id automatically).\n *\n * Class generic shape: `Id`, `TTraits`, `TWire`, `TInput`. Method generics on the codec subclass's own surface (e.g. arktype-json's schema generic, pgvector's dimension generic) flow through the subclass's constructor and propagate via the descriptor's typed `factory(params)` return at *direct* call sites.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecDescriptor } from './codec-descriptor';\nimport type { CodecCallContext, CodecTrait } from './codec-types';\n\n/**\n * A codec is the contract between an application value and its on-wire and on-contract-disk representations.\n *\n * The author's mental model is two JS-side types — `TInput` (the application JS type) and `TWire` (the database driver wire format) — plus `JsonValue` for build-time contract artifacts. The codec translates `TInput` to `TWire` on writes and back on reads, and to/from `JsonValue` during contract emission and loading.\n *\n * Three representations participate:\n * - **Input** (`TInput`): the JS type at the application boundary.\n * - **Wire** (`TWire`): the format exchanged with the database driver.\n * - **JSON** (`JsonValue`): a JSON-safe form used in contract artifacts.\n *\n * The runtime instance carries only its `id` (the descriptor's `codecId`, set by the factory) and the four conversion methods. Static metadata (`traits`, `targetTypes`, `meta`) and the build-time `renderOutputType` renderer live on the {@link CodecDescriptor} keyed by `codecId` — the read-surface single source of truth. Consumers that need them resolve through `descriptorFor(codecId)`.\n *\n * Codec methods split into two groups:\n *\n * - **Query-time** methods (`encode`, `decode`) run per row/parameter at the IO boundary; they are required and Promise-returning. The per-family codec factory accepts sync or async author functions and lifts sync ones to Promise-shaped methods automatically.\n * - **Build-time** methods (`encodeJson`, `decodeJson`) run when the contract is serialized or loaded. They stay synchronous so contract validation and client construction are synchronous.\n *\n * Target-family codec interfaces extend this base; family-specific concerns (e.g. the SQL `column?` per-call context) layer on through the `CodecCallContext` extension pattern.\n */\nexport interface Codec<\n  Id extends string = string,\n  TTraits extends readonly CodecTrait[] = readonly CodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> {\n  /** Unique codec identifier in `namespace/name@version` format (e.g. `pg/timestamptz@1`). The factory sets this to the descriptor's `codecId`; consumers use it as a back-reference for descriptor lookups and for decode-error diagnostics. */\n  readonly id: Id;\n  /** Phantom carrier for the `TTraits` generic; type-only, undefined at runtime. Runtime traits live on {@link CodecDescriptor.traits}. Implemented as a string-key phantom (`__codecTraits`) rather than `unique symbol` so bundlers that split `.d.ts` chunks do not strand symbol identity on chunk-private paths (the same `TS2742` family that the public re-export of `CodecTypes` works around). */\n  readonly __codecTraits?: TTraits;\n  /** Converts a JS value to the wire format expected by the database driver. Always Promise-returning at the boundary. The {@link CodecCallContext} is supplied by the runtime on every call (allocated once per `runtime.execute()`); family layers may narrow the ctx to extend it (e.g. SQL adds `column`). Author-side single-arg `(value) => …` functions remain legal via TypeScript's bivariance for trailing parameters. */\n  encode(value: TInput, ctx: CodecCallContext): Promise<TWire>;\n  /** Converts a wire value from the database driver into the JS application type. Always Promise-returning at the boundary. The {@link CodecCallContext} is supplied by the runtime on every call (allocated once per `runtime.execute()`); family layers may narrow the ctx to extend it (e.g. SQL adds `column`). Author-side single-arg `(wire) => …` functions remain legal via TypeScript's bivariance for trailing parameters. */\n  decode(wire: TWire, ctx: CodecCallContext): Promise<TInput>;\n  /** Converts a JS value to a JSON-safe representation for contract serialization. Synchronous; called during contract emission. */\n  encodeJson(value: TInput): JsonValue;\n  /** Converts a JSON representation back to the JS input type. Synchronous; called during contract loading via `family.deserializeContract`. */\n  decodeJson(json: JsonValue): TInput;\n}\n\n/**\n * Abstract base class for concrete codec implementations.\n *\n * Codec authors extend this class with their typed `Id`, `TTraits`, `TWire`, `TInput` and override `encode`/`decode` (and optionally `encodeJson`/`decodeJson`). The runtime instance carries only its `id` (proxied through the descriptor so alias subclasses inherit the descriptor's id automatically) and the conversion methods — static metadata lives on the {@link CodecDescriptor}.\n */\nexport abstract class CodecImpl<\n  Id extends string = string,\n  TTraits extends readonly CodecTrait[] = readonly CodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> implements Codec<Id, TTraits, TWire, TInput>\n{\n  /**\n   * Variance-erased descriptor reference. Concrete codec subclasses receive the typed descriptor in their own constructors and forward it via `super(descriptor)`; the variance erasure lives at this base because the abstract surface can't carry the concrete `TParams`.\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: variance-erased descriptor reference; subclasses retain typed access via their own state\n  constructor(public readonly descriptor: CodecDescriptor<any>) {}\n\n  get id(): Id {\n    return this.descriptor.codecId as Id;\n  }\n\n  abstract encode(value: TInput, ctx: CodecCallContext): Promise<TWire>;\n  abstract decode(wire: TWire, ctx: CodecCallContext): Promise<TInput>;\n  abstract encodeJson(value: TInput): JsonValue;\n  abstract decodeJson(json: JsonValue): TInput;\n}\n","import type { JsonValue } from '@prisma-next/contract/types';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Codec } from './codec';\n\nexport type CodecTrait = 'equality' | 'order' | 'boolean' | 'numeric' | 'textual';\n\n/**\n * Serializable codec identity carried by every codec-bearing AST node.\n *\n * `(codecId, typeParams?)` is the single fact the runtime needs to materialize a codec via `descriptorFor(codecId).factory(typeParams)(ctx)`. The pair is content-keyed: two refs with the same `codecId` and structurally equal `typeParams` (regardless of object key ordering) resolve to the same memoized {@link Codec} instance.\n *\n * `typeParams` is `JsonValue`-constrained so the ref survives JSON serialization (relevant for AST-embedded migration ops). Non-parameterized codecs leave `typeParams` undefined; the descriptor's `paramsSchema` validates the value at the JSON boundary.\n *\n * Family-agnostic by design — both SQL and Mongo AST nodes carry `codec: CodecRef | undefined`, and the resolver is the only dispatch path that survives serialization.\n */\nexport interface CodecRef {\n  readonly codecId: string;\n  readonly typeParams?: JsonValue;\n}\n\n/**\n * Per-call context the runtime threads to every `codec.encode` / `codec.decode` invocation for a single `runtime.execute()` call.\n *\n * The framework-level shape is family-agnostic and carries one field:\n *\n * - `signal?: AbortSignal` — per-query cancellation. The runtime returns a `RUNTIME.ABORTED` envelope when the signal aborts; codec authors who forward `signal` to their underlying SDK get true cancellation of in-flight network calls.\n *\n * Family layers extend this base with their own shape-of-call metadata: the SQL family adds `column?: SqlColumnRef` via `SqlCodecCallContext` (see `@prisma-next/sql-relational-core`). Mongo currently uses this framework type unchanged. Column metadata is intentionally **not** on the framework type — it is a SQL-family concept rooted in SQL's `(table, column)` addressing model and would not generalise to other families.\n *\n * The interface is named explicitly (not inlined) so future framework fields and family extensions can land additively without breaking codec author signatures.\n */\nexport interface CodecCallContext {\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Codec-id-keyed read surface threaded into emit and authoring paths.\n *\n * - `get(id)` returns the runtime {@link Codec} instance for the codec id (used by `family.deserializeContract` for `decodeJson` of literal column defaults).\n * - `targetTypesFor(id)` exposes the codec-id-keyed `targetTypes` metadata the runtime instance no longer carries (TML-2357). Returns the same array `CodecDescriptor.targetTypes` would; for Mongo (whose registration doesn't yet resolve through the unified descriptor map — TML-2324) the family-side assembly populates this directly from the contributor's codec metadata.\n * - `metaFor(id)` exposes the codec-id-keyed `meta` (e.g. SQL-side `db.sql.postgres.nativeType`) the runtime instance no longer carries.\n * - `renderOutputTypeFor(id, params)` exposes the codec-id-keyed `renderOutputType` renderer the runtime instance no longer carries. Returns `undefined` when the codec doesn't render a custom type or when the codec id is unknown.\n */\nexport interface CodecLookup {\n  get(id: string): Codec | undefined;\n  targetTypesFor(id: string): readonly string[] | undefined;\n  metaFor(id: string): CodecMeta | undefined;\n  renderOutputTypeFor(id: string, params: Record<string, unknown>): string | undefined;\n}\n\nexport const emptyCodecLookup: CodecLookup = {\n  get: () => undefined,\n  targetTypesFor: () => undefined,\n  metaFor: () => undefined,\n  renderOutputTypeFor: () => undefined,\n};\n\n/**\n * Family-agnostic per-instance context supplied by the framework when applying a higher-order codec factory. Allows stateful codecs (e.g. column-scoped encryption) to derive per-instance state from the materialization site.\n *\n * - `name` — the family-agnostic instance identity. For SQL, the runtime populates this as the `storage.types` instance name (e.g. `Embedding1536`) for typeRef-shaped columns, an inline-column sentinel (`<col:Document.embedding>`) for inline-`typeParams` columns, a shared codec-id sentinel (`<codec:pg/text@1>`) for non-parameterized codec ids, or the canonical cache key (`<codecId>:<canonicalizeJson(typeParams)>`) for ad-hoc refs the contract walk did not pre-populate. Other families pick the analogous identity for their materialization sites.\n *\n * Family-specific extensions (e.g. {@link import('@prisma-next/sql-relational-core/ast').SqlCodecInstanceContext} in the SQL layer) augment this base with domain-shaped column-set metadata. Codec authors target the base when they don't read family-specific metadata; they target the family extension when they do.\n */\nexport interface CodecInstanceContext {\n  readonly name: string;\n}\n\n/**\n * Family-agnostic codec metadata. Family-specific extensions augment the base `db.<family>.<target>` block with native-type information; the base shape is an empty object so non-relational codecs can carry no metadata.\n */\nexport interface CodecMeta {\n  readonly db?: Record<string, unknown>;\n}\n\n/**\n * Standard Schema validator for `void` params. Accepts only `undefined` (or absent input); rejects any other value so a contract that tries to thread `typeParams` through a non-parameterized codec id fails fast at the JSON boundary instead of silently coercing the value away. Used by the framework-supplied non-parameterized descriptor synthesizer.\n */\nexport const voidParamsSchema: StandardSchemaV1<void> = {\n  '~standard': {\n    version: 1,\n    vendor: 'prisma-next',\n    validate: (input) =>\n      input === undefined\n        ? { value: undefined }\n        : {\n            issues: [\n              {\n                message: 'unexpected typeParams for non-parameterized codec (void params expected)',\n              },\n            ],\n          },\n  },\n};\n","/**\n * Codec descriptor interface (consumer surface) and abstract `CodecDescriptorImpl` base (codec-author surface).\n *\n * Consumers depend on the {@link CodecDescriptor} interface — it is the codec-id-keyed source of truth for static metadata (`traits`, `targetTypes`, `meta`) and registration concerns (`paramsSchema`; optional `renderOutputType`). The runtime `Codec` instance returned by `factory(params)(ctx)` carries only the conversion behavior.\n *\n * Codec authors `extend` the {@link CodecDescriptorImpl} abstract class to declare their codec id, traits, target types, params schema, the `factory(params)` that materializes a typed `Codec<...>`, and (optionally) a `renderOutputType(params)` for the emit path.\n *\n * The factory's method-level generic is the load-bearing piece for literal preservation: per-codec column helpers invoke `descriptor.factory(...)` *directly*, and the direct call binds the generic at its call site. Type extraction (`ReturnType<D['factory']>`, structural matching) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Codec } from './codec';\nimport {\n  type CodecInstanceContext,\n  type CodecMeta,\n  type CodecTrait,\n  voidParamsSchema,\n} from './codec-types';\n\n/**\n * Unified codec descriptor. Every codec in the framework registers through this shape — non-parameterized codecs use `P = void` and a constant factory that returns the same shared codec instance for every column; parameterized codecs use a non-empty `P` and a curried higher-order factory that returns a per-instance codec.\n *\n * The descriptor is the codec-id-keyed source of truth for static metadata (`traits`, `targetTypes`, `meta`) and registration concerns (`paramsSchema` for JSON-boundary validation; optional `renderOutputType` for the `contract.d.ts` emit path). The runtime `Codec` instance returned by `factory(params)(ctx)` carries only the conversion behavior.\n *\n * Whether a codec id \"is parameterized\" stops being a registration-time distinction — it's a property of `P` on the descriptor. The descriptor map indexes every descriptor by `codecId`; both `descriptorFor(codecId)` and `forColumn(table, column)` resolve through the same map without branching on parameterization.\n *\n * @template P - The shape of the params accepted by the factory (`void` for non-parameterized codecs; a record like `{ length: number }` for parameterized codecs).\n *\n * Codec-registry-unification project § Decision.\n */\nexport interface CodecDescriptor<P = void> {\n  /** The codec ID this descriptor applies to (e.g. `pg/vector@1`, `pg/text@1`). */\n  readonly codecId: string;\n  /** Semantic traits for operator gating (e.g. equality, order, numeric). */\n  readonly traits: readonly CodecTrait[];\n  /** Database-native type names this codec handles (e.g. `['timestamptz']`). */\n  readonly targetTypes: readonly string[];\n  /** Optional family-specific metadata (e.g. SQL-side `db.sql.postgres.nativeType`). */\n  readonly meta?: CodecMeta;\n  /** Standard Schema validator for the factory's params. Validates JSON-sourced params at the contract boundary (PSL → IR; `contract.json` → runtime). For non-parameterized codecs (`P = void`), the schema validates `void`/`undefined` — the framework supplies no params at the call boundary. */\n  readonly paramsSchema: StandardSchemaV1<P>;\n  /** Whether this descriptor is parameterized — i.e. its `paramsSchema` is something other than the singleton `voidParamsSchema`. Consumers that need to gate column-aware dispatch read this directly rather than threading a free-floating `(codecId) => boolean` callback. */\n  readonly isParameterized: boolean;\n  /** Emit-path string renderer for `contract.d.ts`. Returns the TypeScript output type expression for given params (e.g. `Vector<1536>`). Optional; absent renderers cause the emitter to fall back to the codec's base output type. Non-parameterized codecs typically omit it. */\n  readonly renderOutputType?: (params: P) => string | undefined;\n  /** The curried higher-order codec. For non-parameterized codecs, the factory is constant — every call returns the same shared codec instance. For parameterized codecs, the factory is called once per `storage.types` instance (or once per inline-`typeParams` column), with `ctx` carrying the column set the resulting codec serves. */\n  readonly factory: (params: P) => (ctx: CodecInstanceContext) => Codec;\n}\n\n/**\n * Variance-erased {@link CodecDescriptor} alias. `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly), so `CodecDescriptor<P>` does not extend `CodecDescriptor<unknown>` for specific `P`. Heterogeneous descriptor collections — e.g. `SqlStaticContributions.codecs:` returning a list that mixes parameterized and non-parameterized descriptors — type against this alias and narrow per codec id at the consumer.\n *\n * Codec-registry-unification spec § Decision: every codec resolves through one descriptor map; reads are non-branching.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure for heterogeneous descriptor collections\nexport type AnyCodecDescriptor = CodecDescriptor<any>;\n\n/**\n * Abstract base class for concrete codec descriptors.\n *\n * Codec authors extend this class with their typed `TParams` and declare `codecId`, `traits`, `targetTypes`, `paramsSchema`, the curried `factory(params)`, and (optionally) `renderOutputType`.\n *\n * Implements the {@link CodecDescriptor} interface so a concrete subclass instance is directly usable wherever the framework expects a `CodecDescriptor<P>`.\n */\nexport abstract class CodecDescriptorImpl<TParams = void> implements CodecDescriptor<TParams> {\n  abstract readonly codecId: string;\n  abstract readonly traits: readonly CodecTrait[];\n  abstract readonly targetTypes: readonly string[];\n  readonly meta?: CodecMeta;\n\n  abstract readonly paramsSchema: StandardSchemaV1<TParams>;\n\n  /** Boolean derived from `paramsSchema`: `true` whenever the schema is not the singleton `voidParamsSchema`. */\n  get isParameterized(): boolean {\n    return this.paramsSchema !== voidParamsSchema;\n  }\n\n  /** Optional emit-path string renderer for `contract.d.ts`. Returns the TypeScript output type expression for the given params (e.g. `Vector<1536>`). Non-parameterized codecs typically omit it. */\n  renderOutputType?(params: TParams): string | undefined;\n\n  /**\n   * Materialize a curried codec factory for the given params. Concrete subclasses override with a typed return type (e.g. `factory<N>(params: { length: N }): (ctx) => VectorCodec<N>`); per-codec helpers read the typed return at the *direct* call site, which is what preserves method-level generics. Type extraction (e.g. `ReturnType<D['factory']>`) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.\n   */\n  abstract factory(\n    params: TParams,\n  ): (ctx: CodecInstanceContext) => Codec<string, readonly CodecTrait[], unknown, unknown>;\n}\n","/**\n * `column()` packager + `ColumnSpec<R, P>` shape + `ColumnHelperFor<D>` variants for tying per-codec column helpers to their descriptor.\n *\n * `ColumnSpec<R, P>` extends {@link ColumnTypeDescriptor} so it remains a drop-in for contract authoring sites that consume `ColumnTypeDescriptor` shapes — both types live at the framework-components layer so the `extends` clause is real (no structural mirror).\n *\n * `column()` is a trivial, non-polymorphic packager. Generic over `R` (the codec instance type returned by the descriptor's curried factory) and `P` (the typeParams record). The framework does NOT try to infer `R` and `P` from a descriptor — that path is the variance trap. Per-codec helpers absorb the descriptor relationship instead and tie themselves to their descriptor via `satisfies ColumnHelperFor<D>` or `satisfies ColumnHelperForStrict<D>`.\n */\n\nimport type { CodecDescriptor } from './codec-descriptor';\nimport type { CodecInstanceContext } from './codec-types';\n\n/**\n * Authored column-type descriptor — the data shape an authoring site (PSL or TypeScript builders) attaches to a column to identify its codec and its native database type.\n *\n * Lives at the framework-components layer alongside the codec types so codec-author packages (e.g. column-spec / `column()` packagers) can extend it directly without crossing layer boundaries.\n *\n * @template TCodecId Narrowed codec id literal for sites that thread a specific codec id through the type system.\n */\nexport type ColumnTypeDescriptor<TCodecId extends string = string> = {\n  readonly codecId: TCodecId;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown> | undefined;\n  readonly typeRef?: string;\n};\n\n/**\n * Column spec carrying the codec factory closure alongside the {@link ColumnTypeDescriptor} fields. Codec authors return a `ColumnSpec` from per-codec column helpers; the runtime materializes the codec instance by calling `codecFactory(ctx)` once it knows the column's `CodecInstanceContext`.\n *\n * Extends {@link ColumnTypeDescriptor} so `ColumnSpec` instances flow directly into contract-authoring sites that consume the descriptor shape — no structural mirroring required.\n */\nexport interface ColumnSpec<R, P extends Record<string, unknown> | undefined>\n  extends ColumnTypeDescriptor {\n  readonly codecFactory: (ctx: CodecInstanceContext) => R;\n  readonly typeParams: P;\n}\n\n/**\n * Trivial column packager. Per-codec helpers call this directly with the result of `descriptor.factory(params)` — direct method invocation binds the descriptor's method-level generic at the call site and the literal flows through `R`.\n *\n * `nativeType` is the column's database-native type spelling — the value the postgres adapter's migration planner, the SQL renderer's cast policy, and the contract's `meta.db.<family>.<target>.nativeType` slot read. Per-codec helpers pass the literal native-type string for their codec (e.g. `'text'`, `'int4'`, `'character varying'`); for codecs whose native-type spelling depends on parameters (none today; reserved for future shapes), the helper computes the rendered string before calling `column`. The framework does not derive the value from `codecId` — that mapping is target-specific and lives at the helper.\n */\nexport function column<R, P extends Record<string, unknown> | undefined>(\n  codecFactory: (ctx: CodecInstanceContext) => R,\n  codecId: string,\n  typeParams: P,\n  nativeType: string,\n): ColumnSpec<R, P> {\n  return {\n    codecFactory,\n    codecId,\n    typeParams,\n    nativeType,\n  };\n}\n\n/**\n * Coarse `satisfies` shape — checks the helper's typeParams record matches the descriptor's factory params. Catches \"wrong typeParams shape\" wiring mistakes; does NOT catch \"wrong descriptor's factory\" mistakes (the codec slot is left as `unknown`).\n *\n * Use when the codec's `ReturnType<factory>` is unstable (e.g. heavily overloaded factories where extraction widens too much).\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — `CodecDescriptor<P>` is invariant in P, so concrete subclasses do not extend `CodecDescriptor<unknown>`; matches the existing `AnyCodecDescriptor` pattern\nexport type ColumnHelperFor<D extends CodecDescriptor<any>> = (\n  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference\n  ...args: any[]\n) => ColumnSpec<unknown, ColumnHelperParams<D>>;\n\n/**\n * Strict `satisfies` shape — also checks the helper's codec is at least the *base* codec instance type the descriptor's factory returns. `ReturnType<ReturnType<D['factory']>>` widens method generics to their constraint, so this only sanity-checks the wiring at the base type level. Literal preservation comes from the direct `descriptor.factory(...)` call inside the helper, not from `satisfies`.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — `CodecDescriptor<P>` is invariant in P, so concrete subclasses do not extend `CodecDescriptor<unknown>`; matches the existing `AnyCodecDescriptor` pattern\nexport type ColumnHelperForStrict<D extends CodecDescriptor<any>> = (\n  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference\n  ...args: any[]\n) => ColumnSpec<ReturnType<ReturnType<D['factory']>>, ColumnHelperParams<D>>;\n\n/**\n * Coerce a descriptor's `factory` first parameter into the typeParams shape `ColumnSpec` accepts. Non-parameterized descriptors (factory with no params, or `params: void`) collapse to `undefined`; parameterized descriptors keep the params record shape.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — see above\ntype ColumnHelperParams<D extends CodecDescriptor<any>> =\n  Parameters<D['factory']>[0] extends Record<string, unknown>\n    ? Parameters<D['factory']>[0]\n    : undefined;\n"],"mappings":";;;;;;AA0DA,IAAsB,YAAtB,MAMA;CAK8B;;;;CAA5B,YAAY,YAAkD;EAAlC,KAAA,aAAA;;CAE5B,IAAI,KAAS;EACX,OAAO,KAAK,WAAW;;;;;ACtB3B,MAAa,mBAAgC;CAC3C,WAAW,KAAA;CACX,sBAAsB,KAAA;CACtB,eAAe,KAAA;CACf,2BAA2B,KAAA;CAC5B;;;;AAuBD,MAAa,mBAA2C,EACtD,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,UACT,UAAU,KAAA,IACN,EAAE,OAAO,KAAA,GAAW,GACpB,EACE,QAAQ,CACN,EACE,SAAS,4EACV,CACF,EACF;CACR,EACF;;;;;;;;;;AC7BD,IAAsB,sBAAtB,MAA8F;CAI5F;;CAKA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,iBAAiB;;;;;;;;;;ACjCjC,SAAgB,OACd,cACA,SACA,YACA,YACkB;CAClB,OAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"codec.mjs","names":[],"sources":["../src/shared/codec.ts","../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/column-spec.ts"],"sourcesContent":["/**\n * Codec interface (consumer surface) and abstract `CodecImpl` base (codec-author surface).\n *\n * Consumers depend on the {@link Codec} interface — it describes the runtime instance returned by a descriptor's curried factory and is what the framework threads through emit, validate, and execute paths.\n *\n * Codec authors `extend` the {@link CodecImpl} abstract class to declare a typed runtime codec instance. The class carries a variance-erased descriptor reference (`CodecDescriptor<any>`); `id` proxies through the descriptor so one source of truth governs both metadata reads and aliasing semantics (alias subclasses inherit the descriptor's id automatically).\n *\n * Class generic shape: `Id`, `TTraits`, `TWire`, `TInput`. Method generics on the codec subclass's own surface (e.g. arktype-json's schema generic, pgvector's dimension generic) flow through the subclass's constructor and propagate via the descriptor's typed `factory(params)` return at *direct* call sites.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecDescriptor } from './codec-descriptor';\nimport type { CodecCallContext, CodecTrait } from './codec-types';\n\n/**\n * A codec is the contract between an application value and its on-wire and on-contract-disk representations.\n *\n * The author's mental model is two JS-side types — `TInput` (the application JS type) and `TWire` (the database driver wire format) — plus `JsonValue` for build-time contract artifacts. The codec translates `TInput` to `TWire` on writes and back on reads, and to/from `JsonValue` during contract emission and loading.\n *\n * Three representations participate:\n * - **Input** (`TInput`): the JS type at the application boundary.\n * - **Wire** (`TWire`): the format exchanged with the database driver.\n * - **JSON** (`JsonValue`): a JSON-safe form used in contract artifacts.\n *\n * The runtime instance carries only its `id` (the descriptor's `codecId`, set by the factory) and the four conversion methods. Static metadata (`traits`, `targetTypes`, `meta`) and the build-time `renderOutputType` renderer live on the {@link CodecDescriptor} keyed by `codecId` — the read-surface single source of truth. Consumers that need them resolve through `descriptorFor(codecId)`.\n *\n * Codec methods split into two groups:\n *\n * - **Query-time** methods (`encode`, `decode`) run per row/parameter at the IO boundary; they are required and Promise-returning. The per-family codec factory accepts sync or async author functions and lifts sync ones to Promise-shaped methods automatically.\n * - **Build-time** methods (`encodeJson`, `decodeJson`) run when the contract is serialized or loaded. They stay synchronous so contract validation and client construction are synchronous.\n *\n * Target-family codec interfaces extend this base; family-specific concerns (e.g. the SQL `column?` per-call context) layer on through the `CodecCallContext` extension pattern.\n */\nexport interface Codec<\n  Id extends string = string,\n  TTraits extends readonly CodecTrait[] = readonly CodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> {\n  /** Unique codec identifier in `namespace/name@version` format (e.g. `pg/timestamptz@1`). The factory sets this to the descriptor's `codecId`; consumers use it as a back-reference for descriptor lookups and for decode-error diagnostics. */\n  readonly id: Id;\n  /** Phantom carrier for the `TTraits` generic; type-only, undefined at runtime. Runtime traits live on {@link CodecDescriptor.traits}. Implemented as a string-key phantom (`__codecTraits`) rather than `unique symbol` so bundlers that split `.d.ts` chunks do not strand symbol identity on chunk-private paths (the same `TS2742` family that the public re-export of `CodecTypes` works around). */\n  readonly __codecTraits?: TTraits;\n  /** Converts a JS value to the wire format expected by the database driver. Always Promise-returning at the boundary. The {@link CodecCallContext} is supplied by the runtime on every call (allocated once per `runtime.execute()`); family layers may narrow the ctx to extend it (e.g. SQL adds `column`). Author-side single-arg `(value) => …` functions remain legal via TypeScript's bivariance for trailing parameters. */\n  encode(value: TInput, ctx: CodecCallContext): Promise<TWire>;\n  /** Converts a wire value from the database driver into the JS application type. Always Promise-returning at the boundary. The {@link CodecCallContext} is supplied by the runtime on every call (allocated once per `runtime.execute()`); family layers may narrow the ctx to extend it (e.g. SQL adds `column`). Author-side single-arg `(wire) => …` functions remain legal via TypeScript's bivariance for trailing parameters. */\n  decode(wire: TWire, ctx: CodecCallContext): Promise<TInput>;\n  /** Converts a JS value to a JSON-safe representation for contract serialization. Synchronous; called during contract emission. */\n  encodeJson(value: TInput): JsonValue;\n  /** Converts a JSON representation back to the JS input type. Synchronous; called during contract loading via `family.deserializeContract`. */\n  decodeJson(json: JsonValue): TInput;\n}\n\n/**\n * Abstract base class for concrete codec implementations.\n *\n * Codec authors extend this class with their typed `Id`, `TTraits`, `TWire`, `TInput` and override `encode`/`decode` (and optionally `encodeJson`/`decodeJson`). The runtime instance carries only its `id` (proxied through the descriptor so alias subclasses inherit the descriptor's id automatically) and the conversion methods — static metadata lives on the {@link CodecDescriptor}.\n */\nexport abstract class CodecImpl<\n  Id extends string = string,\n  TTraits extends readonly CodecTrait[] = readonly CodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> implements Codec<Id, TTraits, TWire, TInput>\n{\n  /**\n   * Variance-erased descriptor reference. Concrete codec subclasses receive the typed descriptor in their own constructors and forward it via `super(descriptor)`; the variance erasure lives at this base because the abstract surface can't carry the concrete `TParams`.\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: variance-erased descriptor reference; subclasses retain typed access via their own state\n  constructor(public readonly descriptor: CodecDescriptor<any>) {}\n\n  get id(): Id {\n    return this.descriptor.codecId as Id;\n  }\n\n  abstract encode(value: TInput, ctx: CodecCallContext): Promise<TWire>;\n  abstract decode(wire: TWire, ctx: CodecCallContext): Promise<TInput>;\n  abstract encodeJson(value: TInput): JsonValue;\n  abstract decodeJson(json: JsonValue): TInput;\n}\n","import type { JsonValue } from '@prisma-next/contract/types';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Codec } from './codec';\n\nexport type CodecTrait = 'equality' | 'order' | 'boolean' | 'numeric' | 'textual';\n\n/**\n * Serializable codec identity carried by every codec-bearing AST node.\n *\n * `(codecId, typeParams?)` is the single fact the runtime needs to materialize a codec via `descriptorFor(codecId).factory(typeParams)(ctx)`. The pair is content-keyed: two refs with the same `codecId` and structurally equal `typeParams` (regardless of object key ordering) resolve to the same memoized {@link Codec} instance.\n *\n * `typeParams` is `JsonValue`-constrained so the ref survives JSON serialization (relevant for AST-embedded migration ops). Non-parameterized codecs leave `typeParams` undefined; the descriptor's `paramsSchema` validates the value at the JSON boundary.\n *\n * Family-agnostic by design — both SQL and Mongo AST nodes carry `codec: CodecRef | undefined`, and the resolver is the only dispatch path that survives serialization.\n */\nexport interface CodecRef {\n  readonly codecId: string;\n  readonly typeParams?: JsonValue;\n}\n\n/**\n * Per-call context the runtime threads to every `codec.encode` / `codec.decode` invocation for a single `runtime.execute()` call.\n *\n * The framework-level shape is family-agnostic and carries one field:\n *\n * - `signal?: AbortSignal` — per-query cancellation. The runtime returns a `RUNTIME.ABORTED` envelope when the signal aborts; codec authors who forward `signal` to their underlying SDK get true cancellation of in-flight network calls.\n *\n * Family layers extend this base with their own shape-of-call metadata: the SQL family adds `column?: SqlColumnRef` via `SqlCodecCallContext` (see `@prisma-next/sql-relational-core`). Mongo currently uses this framework type unchanged. Column metadata is intentionally **not** on the framework type — it is a SQL-family concept rooted in SQL's `(table, column)` addressing model and would not generalise to other families.\n *\n * The interface is named explicitly (not inlined) so future framework fields and family extensions can land additively without breaking codec author signatures.\n */\nexport interface CodecCallContext {\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Codec-id-keyed read surface threaded into emit and authoring paths.\n *\n * - `get(id)` returns the runtime {@link Codec} instance for the codec id (used by `family.deserializeContract` for `decodeJson` of literal column defaults).\n * - `targetTypesFor(id)` exposes the codec-id-keyed `targetTypes` metadata the runtime instance no longer carries (TML-2357). Returns the same array `CodecDescriptor.targetTypes` would; for Mongo (whose registration doesn't yet resolve through the unified descriptor map — TML-2324) the family-side assembly populates this directly from the contributor's codec metadata.\n * - `metaFor(id)` exposes the codec-id-keyed `meta` (e.g. SQL-side `db.sql.postgres.nativeType`) the runtime instance no longer carries.\n * - `renderOutputTypeFor(id, params)` exposes the codec-id-keyed `renderOutputType` renderer the runtime instance no longer carries. Returns `undefined` when the codec doesn't render a custom type or when the codec id is unknown.\n */\nexport interface CodecLookup {\n  get(id: string): Codec | undefined;\n  targetTypesFor(id: string): readonly string[] | undefined;\n  metaFor(id: string): CodecMeta | undefined;\n  renderOutputTypeFor(id: string, params: Record<string, unknown>): string | undefined;\n}\n\nexport const emptyCodecLookup: CodecLookup = {\n  get: () => undefined,\n  targetTypesFor: () => undefined,\n  metaFor: () => undefined,\n  renderOutputTypeFor: () => undefined,\n};\n\n/**\n * Family-agnostic per-instance context supplied by the framework when applying a higher-order codec factory. Allows stateful codecs (e.g. column-scoped encryption) to derive per-instance state from the materialization site.\n *\n * - `name` — the family-agnostic instance identity. For SQL, the runtime populates this as the `storage.types` instance name (e.g. `Embedding1536`) for typeRef-shaped columns, an inline-column sentinel (`<col:Document.embedding>`) for inline-`typeParams` columns, a shared codec-id sentinel (`<codec:pg/text@1>`) for non-parameterized codec ids, or the canonical cache key (`<codecId>:<canonicalizeJson(typeParams)>`) for ad-hoc refs the contract walk did not pre-populate. Other families pick the analogous identity for their materialization sites.\n *\n * Family-specific extensions (e.g. {@link import('@prisma-next/sql-relational-core/ast').SqlCodecInstanceContext} in the SQL layer) augment this base with domain-shaped column-set metadata. Codec authors target the base when they don't read family-specific metadata; they target the family extension when they do.\n */\nexport interface CodecInstanceContext {\n  readonly name: string;\n}\n\n/**\n * Family-agnostic codec metadata. Family-specific extensions augment the base `db.<family>.<target>` block with native-type information; the base shape is an empty object so non-relational codecs can carry no metadata.\n */\nexport interface CodecMeta {\n  readonly db?: Record<string, unknown>;\n}\n\n/**\n * Standard Schema validator for `void` params. Accepts only `undefined` (or absent input); rejects any other value so a contract that tries to thread `typeParams` through a non-parameterized codec id fails fast at the JSON boundary instead of silently coercing the value away. Used by the framework-supplied non-parameterized descriptor synthesizer.\n */\nexport const voidParamsSchema: StandardSchemaV1<void> = {\n  '~standard': {\n    version: 1,\n    vendor: 'prisma-next',\n    validate: (input) =>\n      input === undefined\n        ? { value: undefined }\n        : {\n            issues: [\n              {\n                message: 'unexpected typeParams for non-parameterized codec (void params expected)',\n              },\n            ],\n          },\n  },\n};\n","/**\n * Codec descriptor interface (consumer surface) and abstract `CodecDescriptorImpl` base (codec-author surface).\n *\n * Consumers depend on the {@link CodecDescriptor} interface — it is the codec-id-keyed source of truth for static metadata (`traits`, `targetTypes`, `meta`) and registration concerns (`paramsSchema`; optional `renderOutputType`). The runtime `Codec` instance returned by `factory(params)(ctx)` carries only the conversion behavior.\n *\n * Codec authors `extend` the {@link CodecDescriptorImpl} abstract class to declare their codec id, traits, target types, params schema, the `factory(params)` that materializes a typed `Codec<...>`, and (optionally) a `renderOutputType(params)` for the emit path.\n *\n * The factory's method-level generic is the load-bearing piece for literal preservation: per-codec column helpers invoke `descriptor.factory(...)` *directly*, and the direct call binds the generic at its call site. Type extraction (`ReturnType<D['factory']>`, structural matching) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Codec } from './codec';\nimport {\n  type CodecInstanceContext,\n  type CodecMeta,\n  type CodecTrait,\n  voidParamsSchema,\n} from './codec-types';\n\n/**\n * Unified codec descriptor. Every codec in the framework registers through this shape — non-parameterized codecs use `P = void` and a constant factory that returns the same shared codec instance for every column; parameterized codecs use a non-empty `P` and a curried higher-order factory that returns a per-instance codec.\n *\n * The descriptor is the codec-id-keyed source of truth for static metadata (`traits`, `targetTypes`, `meta`) and registration concerns (`paramsSchema` for JSON-boundary validation; optional `renderOutputType` for the `contract.d.ts` emit path). The runtime `Codec` instance returned by `factory(params)(ctx)` carries only the conversion behavior.\n *\n * Whether a codec id \"is parameterized\" stops being a registration-time distinction — it's a property of `P` on the descriptor. The descriptor map indexes every descriptor by `codecId`; both `descriptorFor(codecId)` and `forColumn(table, column)` resolve through the same map without branching on parameterization.\n *\n * @template P - The shape of the params accepted by the factory (`void` for non-parameterized codecs; a record like `{ length: number }` for parameterized codecs).\n *\n * Codec-registry-unification project § Decision.\n */\nexport interface CodecDescriptor<P = void> {\n  /** The codec ID this descriptor applies to (e.g. `pg/vector@1`, `pg/text@1`). */\n  readonly codecId: string;\n  /** Semantic traits for operator gating (e.g. equality, order, numeric). */\n  readonly traits: readonly CodecTrait[];\n  /** Database-native type names this codec handles (e.g. `['timestamptz']`). */\n  readonly targetTypes: readonly string[];\n  /** Optional family-specific metadata (e.g. SQL-side `db.sql.postgres.nativeType`). */\n  readonly meta?: CodecMeta;\n  /** Standard Schema validator for the factory's params. Validates JSON-sourced params at the contract boundary (PSL → IR; `contract.json` → runtime). For non-parameterized codecs (`P = void`), the schema validates `void`/`undefined` — the framework supplies no params at the call boundary. */\n  readonly paramsSchema: StandardSchemaV1<P>;\n  /** Whether this descriptor is parameterized — i.e. its `paramsSchema` is something other than the singleton `voidParamsSchema`. Consumers that need to gate column-aware dispatch read this directly rather than threading a free-floating `(codecId) => boolean` callback. */\n  readonly isParameterized: boolean;\n  /** Emit-path string renderer for `contract.d.ts`. Returns the TypeScript output type expression for given params (e.g. `Vector<1536>`). Optional; absent renderers cause the emitter to fall back to the codec's base output type. Non-parameterized codecs typically omit it. */\n  readonly renderOutputType?: (params: P) => string | undefined;\n  /** The curried higher-order codec. For non-parameterized codecs, the factory is constant — every call returns the same shared codec instance. For parameterized codecs, the factory is called once per `storage.types` instance (or once per inline-`typeParams` column), with `ctx` carrying the column set the resulting codec serves. */\n  readonly factory: (params: P) => (ctx: CodecInstanceContext) => Codec;\n}\n\n/**\n * Variance-erased {@link CodecDescriptor} alias. `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly), so `CodecDescriptor<P>` does not extend `CodecDescriptor<unknown>` for specific `P`. Heterogeneous descriptor collections — e.g. `SqlStaticContributions.codecs:` returning a list that mixes parameterized and non-parameterized descriptors — type against this alias and narrow per codec id at the consumer.\n *\n * Codec-registry-unification spec § Decision: every codec resolves through one descriptor map; reads are non-branching.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure for heterogeneous descriptor collections\nexport type AnyCodecDescriptor = CodecDescriptor<any>;\n\n/**\n * Abstract base class for concrete codec descriptors.\n *\n * Codec authors extend this class with their typed `TParams` and declare `codecId`, `traits`, `targetTypes`, `paramsSchema`, the curried `factory(params)`, and (optionally) `renderOutputType`.\n *\n * Implements the {@link CodecDescriptor} interface so a concrete subclass instance is directly usable wherever the framework expects a `CodecDescriptor<P>`.\n */\nexport abstract class CodecDescriptorImpl<TParams = void> implements CodecDescriptor<TParams> {\n  abstract readonly codecId: string;\n  abstract readonly traits: readonly CodecTrait[];\n  abstract readonly targetTypes: readonly string[];\n  readonly meta?: CodecMeta;\n\n  abstract readonly paramsSchema: StandardSchemaV1<TParams>;\n\n  /** Boolean derived from `paramsSchema`: `true` whenever the schema is not the singleton `voidParamsSchema`. */\n  get isParameterized(): boolean {\n    return this.paramsSchema !== voidParamsSchema;\n  }\n\n  /** Optional emit-path string renderer for `contract.d.ts`. Returns the TypeScript output type expression for the given params (e.g. `Vector<1536>`). Non-parameterized codecs typically omit it. */\n  renderOutputType?(params: TParams): string | undefined;\n\n  /**\n   * Materialize a curried codec factory for the given params. Concrete subclasses override with a typed return type (e.g. `factory<N>(params: { length: N }): (ctx) => VectorCodec<N>`); per-codec helpers read the typed return at the *direct* call site, which is what preserves method-level generics. Type extraction (e.g. `ReturnType<D['factory']>`) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.\n   */\n  abstract factory(\n    params: TParams,\n  ): (ctx: CodecInstanceContext) => Codec<string, readonly CodecTrait[], unknown, unknown>;\n}\n","/**\n * `column()` packager + `ColumnSpec<R, P>` shape + `ColumnHelperFor<D>` variants for tying per-codec column helpers to their descriptor.\n *\n * `ColumnSpec<R, P>` extends {@link ColumnTypeDescriptor} so it remains a drop-in for contract authoring sites that consume `ColumnTypeDescriptor` shapes — both types live at the framework-components layer so the `extends` clause is real (no structural mirror).\n *\n * `column()` is a trivial, non-polymorphic packager. Generic over `R` (the codec instance type returned by the descriptor's curried factory) and `P` (the typeParams record). The framework does NOT try to infer `R` and `P` from a descriptor — that path is the variance trap. Per-codec helpers absorb the descriptor relationship instead and tie themselves to their descriptor via `satisfies ColumnHelperFor<D>` or `satisfies ColumnHelperForStrict<D>`.\n */\n\nimport type { CodecDescriptor } from './codec-descriptor';\nimport type { CodecInstanceContext } from './codec-types';\n\n/**\n * Authored column-type descriptor — the data shape an authoring site (PSL or TypeScript builders) attaches to a column to identify its codec and its native database type.\n *\n * Lives at the framework-components layer alongside the codec types so codec-author packages (e.g. column-spec / `column()` packagers) can extend it directly without crossing layer boundaries.\n *\n * @template TCodecId Narrowed codec id literal for sites that thread a specific codec id through the type system.\n */\nexport type ColumnTypeDescriptor<TCodecId extends string = string> = {\n  readonly codecId: TCodecId;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown> | undefined;\n  readonly typeRef?: string;\n};\n\n/**\n * Column spec carrying the codec factory closure alongside the {@link ColumnTypeDescriptor} fields. Codec authors return a `ColumnSpec` from per-codec column helpers; the runtime materializes the codec instance by calling `codecFactory(ctx)` once it knows the column's `CodecInstanceContext`.\n *\n * Extends {@link ColumnTypeDescriptor} so `ColumnSpec` instances flow directly into contract-authoring sites that consume the descriptor shape — no structural mirroring required.\n */\nexport interface ColumnSpec<R, P extends Record<string, unknown> | undefined>\n  extends ColumnTypeDescriptor {\n  readonly codecFactory: (ctx: CodecInstanceContext) => R;\n  readonly typeParams: P;\n}\n\n/**\n * Trivial column packager. Per-codec helpers call this directly with the result of `descriptor.factory(params)` — direct method invocation binds the descriptor's method-level generic at the call site and the literal flows through `R`.\n *\n * `nativeType` is the column's database-native type spelling — the value the postgres adapter's migration planner, the SQL renderer's cast policy, and the contract's `meta.db.<family>.<target>.nativeType` slot read. Per-codec helpers pass the literal native-type string for their codec (e.g. `'text'`, `'int4'`, `'character varying'`); for codecs whose native-type spelling depends on parameters (none today; reserved for future shapes), the helper computes the rendered string before calling `column`. The framework does not derive the value from `codecId` — that mapping is target-specific and lives at the helper.\n */\nexport function column<R, P extends Record<string, unknown> | undefined>(\n  codecFactory: (ctx: CodecInstanceContext) => R,\n  codecId: string,\n  typeParams: P,\n  nativeType: string,\n): ColumnSpec<R, P> {\n  return {\n    codecFactory,\n    codecId,\n    typeParams,\n    nativeType,\n  };\n}\n\n/**\n * Coarse `satisfies` shape — checks the helper's typeParams record matches the descriptor's factory params. Catches \"wrong typeParams shape\" wiring mistakes; does NOT catch \"wrong descriptor's factory\" mistakes (the codec slot is left as `unknown`).\n *\n * Use when the codec's `ReturnType<factory>` is unstable (e.g. heavily overloaded factories where extraction widens too much).\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — `CodecDescriptor<P>` is invariant in P, so concrete subclasses do not extend `CodecDescriptor<unknown>`; matches the existing `AnyCodecDescriptor` pattern\nexport type ColumnHelperFor<D extends CodecDescriptor<any>> = (\n  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference\n  ...args: any[]\n) => ColumnSpec<unknown, ColumnHelperParams<D>>;\n\n/**\n * Strict `satisfies` shape — also checks the helper's codec is at least the *base* codec instance type the descriptor's factory returns. `ReturnType<ReturnType<D['factory']>>` widens method generics to their constraint, so this only sanity-checks the wiring at the base type level. Literal preservation comes from the direct `descriptor.factory(...)` call inside the helper, not from `satisfies`.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — `CodecDescriptor<P>` is invariant in P, so concrete subclasses do not extend `CodecDescriptor<unknown>`; matches the existing `AnyCodecDescriptor` pattern\nexport type ColumnHelperForStrict<D extends CodecDescriptor<any>> = (\n  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference\n  ...args: any[]\n) => ColumnSpec<ReturnType<ReturnType<D['factory']>>, ColumnHelperParams<D>>;\n\n/**\n * Coerce a descriptor's `factory` first parameter into the typeParams shape `ColumnSpec` accepts. Non-parameterized descriptors (factory with no params, or `params: void`) collapse to `undefined`; parameterized descriptors keep the params record shape.\n */\n// biome-ignore lint/suspicious/noExplicitAny: variance erasure — see above\ntype ColumnHelperParams<D extends CodecDescriptor<any>> =\n  Parameters<D['factory']>[0] extends Record<string, unknown>\n    ? Parameters<D['factory']>[0]\n    : undefined;\n"],"mappings":";;;;;;AA0DA,IAAsB,YAAtB,MAMA;CAK8B;;;;CAA5B,YAAY,YAAkD;EAAlC,KAAA,aAAA;CAAmC;CAE/D,IAAI,KAAS;EACX,OAAO,KAAK,WAAW;CACzB;AAMF;;;AC7BA,MAAa,mBAAgC;CAC3C,WAAW,KAAA;CACX,sBAAsB,KAAA;CACtB,eAAe,KAAA;CACf,2BAA2B,KAAA;AAC7B;;;;AAuBA,MAAa,mBAA2C,EACtD,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,UACT,UAAU,KAAA,IACN,EAAE,OAAO,KAAA,EAAU,IACnB,EACE,QAAQ,CACN,EACE,SAAS,2EACX,CACF,EACF;AACR,EACF;;;;;;;;;;AC7BA,IAAsB,sBAAtB,MAA8F;CAI5F;;CAKA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,iBAAiB;CAC/B;AAWF;;;;;;;;AC7CA,SAAgB,OACd,cACA,SACA,YACA,YACkB;CAClB,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}

package/dist/components.d.mts

@@ -1,2 +1,34 @@
 import { S as checkContractComponentRequirements, _ as PackRefBase, a as ComponentMetadata, b as TargetInstance, c as DriverDescriptor, d as ExtensionDescriptor, f as ExtensionInstance, g as FamilyPackRef, h as FamilyInstance, i as ComponentDescriptor, l as DriverInstance, m as FamilyDescriptor, n as AdapterInstance, o as ContractComponentRequirementsCheckInput, p as ExtensionPackRef, r as AdapterPackRef, s as ContractComponentRequirementsCheckResult, t as AdapterDescriptor, u as DriverPackRef, v as TargetBoundComponentDescriptor, x as TargetPackRef, y as TargetDescriptor } from "./framework-components-CuoUhyB5.mjs";
-export { type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type DriverDescriptor, type DriverInstance, type DriverPackRef, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type FamilyPackRef, type PackRefBase, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetPackRef, checkContractComponentRequirements };
+
+//#region src/shared/capabilities.d.ts
+/**
+ * Capability matrix merge primitive shared by emit-time and runtime stack composition.
+ *
+ * The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need
+ * to fold a stack of component descriptors' `capabilities` declarations into a single
+ * matrix keyed by namespace. Keeping the primitive here lets both call sites stay
+ * byte-for-byte consistent without one depending on the other.
+ */
+/**
+ * Merge an ordered list of contributor capability declarations into a base matrix.
+ *
+ * Behaviour:
+ * - `base` and each contributor's `capabilities` are filtered through the same
+ *   structural extraction: non-plain-object namespace blocks are dropped,
+ *   non-boolean leaves inside a namespace block are dropped, and a namespace
+ *   block that ends up with zero boolean leaves is omitted entirely (so a
+ *   later contributor with a malformed namespace cannot erase a namespace
+ *   already present in `base`).
+ * - Non-plain-object `capabilities` on a contributor (including `undefined`,
+ *   `null`, arrays, primitives) are skipped silently — the contributor
+ *   contributes nothing.
+ * - Later contributors win on `(namespace, key)` collisions.
+ * - The returned object is fresh — neither `base` nor any contributor is mutated.
+ * - Output keys are sorted lexicographically at every plain-object level.
+ */
+declare function mergeCapabilityMatrices(base: Record<string, Record<string, boolean>>, contributors: ReadonlyArray<{
+  readonly capabilities?: unknown;
+}>): Record<string, Record<string, boolean>>;
+//#endregion
+export { type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type DriverDescriptor, type DriverInstance, type DriverPackRef, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type FamilyPackRef, type PackRefBase, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetPackRef, checkContractComponentRequirements, mergeCapabilityMatrices };
+//# sourceMappingURL=components.d.mts.map

package/dist/components.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.mts","names":[],"sources":["../src/shared/capabilities.ts"],"mappings":";;;;;;AAqEA;;;;;;;;;;;;;;;;;;;AAGwB;;;iBAHR,uBAAA,CACd,IAAA,EAAM,MAAA,SAAe,MAAA,oBACrB,YAAA,EAAc,aAAA;EAAA,SAAyB,YAAA;AAAA,KACtC,MAAA,SAAe,MAAA"}

package/dist/components.mjs

@@ -1,2 +1,65 @@
 import { t as checkContractComponentRequirements } from "./framework-components-FdqmlGUj.mjs";
-export { checkContractComponentRequirements };
+import { blindCast } from "@prisma-next/utils/casts";
+//#region src/shared/capabilities.ts
+/**
+* Capability matrix merge primitive shared by emit-time and runtime stack composition.
+*
+* The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need
+* to fold a stack of component descriptors' `capabilities` declarations into a single
+* matrix keyed by namespace. Keeping the primitive here lets both call sites stay
+* byte-for-byte consistent without one depending on the other.
+*/
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortDeep(value) {
+	if (Array.isArray(value)) return value.map(sortDeep);
+	if (!isPlainObject(value)) return value;
+	const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+	const next = {};
+	for (const [key, child] of entries) next[key] = sortDeep(child);
+	return next;
+}
+function extractCapabilityMatrix(value) {
+	if (!isPlainObject(value)) return {};
+	const out = {};
+	for (const [namespace, maybeCaps] of Object.entries(value)) {
+		if (!isPlainObject(maybeCaps)) continue;
+		const caps = {};
+		for (const [key, flag] of Object.entries(maybeCaps)) if (typeof flag === "boolean") caps[key] = flag;
+		if (Object.keys(caps).length > 0) out[namespace] = caps;
+	}
+	return out;
+}
+/**
+* Merge an ordered list of contributor capability declarations into a base matrix.
+*
+* Behaviour:
+* - `base` and each contributor's `capabilities` are filtered through the same
+*   structural extraction: non-plain-object namespace blocks are dropped,
+*   non-boolean leaves inside a namespace block are dropped, and a namespace
+*   block that ends up with zero boolean leaves is omitted entirely (so a
+*   later contributor with a malformed namespace cannot erase a namespace
+*   already present in `base`).
+* - Non-plain-object `capabilities` on a contributor (including `undefined`,
+*   `null`, arrays, primitives) are skipped silently — the contributor
+*   contributes nothing.
+* - Later contributors win on `(namespace, key)` collisions.
+* - The returned object is fresh — neither `base` nor any contributor is mutated.
+* - Output keys are sorted lexicographically at every plain-object level.
+*/
+function mergeCapabilityMatrices(base, contributors) {
+	const merged = extractCapabilityMatrix(base);
+	for (const contributor of contributors) {
+		const extracted = extractCapabilityMatrix(contributor.capabilities);
+		for (const [namespace, capabilities] of Object.entries(extracted)) merged[namespace] = {
+			...merged[namespace] ?? {},
+			...capabilities
+		};
+	}
+	return blindCast(sortDeep(merged));
+}
+//#endregion
+export { checkContractComponentRequirements, mergeCapabilityMatrices };
+
+//# sourceMappingURL=components.mjs.map

package/dist/components.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.mjs","names":[],"sources":["../src/shared/capabilities.ts"],"sourcesContent":["/**\n * Capability matrix merge primitive shared by emit-time and runtime stack composition.\n *\n * The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need\n * to fold a stack of component descriptors' `capabilities` declarations into a single\n * matrix keyed by namespace. Keeping the primitive here lets both call sites stay\n * byte-for-byte consistent without one depending on the other.\n */\n\nimport { blindCast } from '@prisma-next/utils/casts';\n\ntype CapabilityMatrix = Record<string, Record<string, boolean>>;\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction sortDeep(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(sortDeep);\n  }\n  if (!isPlainObject(value)) {\n    return value;\n  }\n  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));\n  const next: Record<string, unknown> = {};\n  for (const [key, child] of entries) {\n    next[key] = sortDeep(child);\n  }\n  return next;\n}\n\nfunction extractCapabilityMatrix(value: unknown): CapabilityMatrix {\n  if (!isPlainObject(value)) return {};\n\n  const out: CapabilityMatrix = {};\n  for (const [namespace, maybeCaps] of Object.entries(value)) {\n    if (!isPlainObject(maybeCaps)) continue;\n    const caps: Record<string, boolean> = {};\n    for (const [key, flag] of Object.entries(maybeCaps)) {\n      if (typeof flag === 'boolean') {\n        caps[key] = flag;\n      }\n    }\n    if (Object.keys(caps).length > 0) {\n      out[namespace] = caps;\n    }\n  }\n\n  return out;\n}\n\n/**\n * Merge an ordered list of contributor capability declarations into a base matrix.\n *\n * Behaviour:\n * - `base` and each contributor's `capabilities` are filtered through the same\n *   structural extraction: non-plain-object namespace blocks are dropped,\n *   non-boolean leaves inside a namespace block are dropped, and a namespace\n *   block that ends up with zero boolean leaves is omitted entirely (so a\n *   later contributor with a malformed namespace cannot erase a namespace\n *   already present in `base`).\n * - Non-plain-object `capabilities` on a contributor (including `undefined`,\n *   `null`, arrays, primitives) are skipped silently — the contributor\n *   contributes nothing.\n * - Later contributors win on `(namespace, key)` collisions.\n * - The returned object is fresh — neither `base` nor any contributor is mutated.\n * - Output keys are sorted lexicographically at every plain-object level.\n */\nexport function mergeCapabilityMatrices(\n  base: Record<string, Record<string, boolean>>,\n  contributors: ReadonlyArray<{ readonly capabilities?: unknown }>,\n): Record<string, Record<string, boolean>> {\n  const merged: CapabilityMatrix = extractCapabilityMatrix(base);\n\n  for (const contributor of contributors) {\n    const extracted = extractCapabilityMatrix(contributor.capabilities);\n    for (const [namespace, capabilities] of Object.entries(extracted)) {\n      merged[namespace] = {\n        ...(merged[namespace] ?? {}),\n        ...capabilities,\n      };\n    }\n  }\n\n  return blindCast<\n    CapabilityMatrix,\n    \"sortDeep preserves the matrix shape but the recursive generic relationship can't be expressed to TS\"\n  >(sortDeep(merged));\n}\n"],"mappings":";;;;;;;;;;;AAaA,SAAS,cAAc,OAAkD;CACvE,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,SAAS,OAAyB;CACzC,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,IAAI,QAAQ;CAE3B,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;CAET,MAAM,UAAU,OAAO,QAAQ,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;CAC3E,MAAM,OAAgC,CAAC;CACvC,KAAK,MAAM,CAAC,KAAK,UAAU,SACzB,KAAK,OAAO,SAAS,KAAK;CAE5B,OAAO;AACT;AAEA,SAAS,wBAAwB,OAAkC;CACjE,IAAI,CAAC,cAAc,KAAK,GAAG,OAAO,CAAC;CAEnC,MAAM,MAAwB,CAAC;CAC/B,KAAK,MAAM,CAAC,WAAW,cAAc,OAAO,QAAQ,KAAK,GAAG;EAC1D,IAAI,CAAC,cAAc,SAAS,GAAG;EAC/B,MAAM,OAAgC,CAAC;EACvC,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,SAAS,GAChD,IAAI,OAAO,SAAS,WAClB,KAAK,OAAO;EAGhB,IAAI,OAAO,KAAK,IAAI,EAAE,SAAS,GAC7B,IAAI,aAAa;CAErB;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,wBACd,MACA,cACyC;CACzC,MAAM,SAA2B,wBAAwB,IAAI;CAE7D,KAAK,MAAM,eAAe,cAAc;EACtC,MAAM,YAAY,wBAAwB,YAAY,YAAY;EAClE,KAAK,MAAM,CAAC,WAAW,iBAAiB,OAAO,QAAQ,SAAS,GAC9D,OAAO,aAAa;GAClB,GAAI,OAAO,cAAc,CAAC;GAC1B,GAAG;EACL;CAEJ;CAEA,OAAO,UAGL,SAAS,MAAM,CAAC;AACpB"}

package/dist/control.d.mts

@@ -6,6 +6,7 @@ import { t as EmissionSpi } from "./emission-types-CMv_053d.mjs";
 import { m as PslDocumentAst } from "./psl-ast-BDXL7iCg.mjs";
 import { Contract, ContractMarkerRecord } from "@prisma-next/contract/types";
 import { ImportRequirement, ImportRequirement as ImportRequirement$1 } from "@prisma-next/ts-render";
+import { PreserveEmptyPredicate, StorageSort } from "@prisma-next/contract/hashing";
 import { JsonObject } from "@prisma-next/utils/json";
 import { Result } from "@prisma-next/utils/result";
 
@@ -49,6 +50,22 @@ interface ContractSerializer<TContract> {
    * fields, normalizing numeric encodings) do that work here.
    */
   serializeContract(contract: TContract): JsonObject;
+  /**
+   * Optional family-contributed preserve-empty predicate for the
+   * framework canonicalizer. When present, the canonicalizer calls this
+   * inside its default-omission walk to let the family veto the stripping
+   * of empty objects/arrays/`false` values at family-specific storage paths.
+   * Families whose storage has no such special-case paths omit this hook.
+   */
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  /**
+   * Optional family-contributed storage sort hook for the framework
+   * canonicalizer. When present, the canonicalizer applies this to the
+   * serialized `storage` subtree after the omission walk and before the
+   * final key sort. Families that need deterministic ordering of storage
+   * arrays (e.g. SQL `indexes`/`uniques`) supply this hook.
+   */
+  readonly sortStorage?: StorageSort;
 }
 //#endregion
 //#region src/control/control-result-types.d.ts
@@ -114,6 +131,13 @@ interface BaseSchemaIssue {
 }
 interface EnumValuesChangedIssue {
   readonly kind: 'enum_values_changed';
+  /**
+   * Namespace coordinate of the enum type that changed values. Populated by
+   * family verifiers that have the coordinate in scope when constructing the
+   * issue. Downstream planners trust this field as the authoritative subject
+   * coordinate and do not re-derive it by name lookup.
+   */
+  readonly namespaceId: string;
   readonly typeName: string;
   readonly addedValues: readonly string[];
   readonly removedValues: readonly string[];
@@ -392,20 +416,6 @@ interface ControlExtensionDescriptor<TFamilyId extends string, TTargetId extends
 }
 //#endregion
 //#region src/control/control-migration-types.d.ts
-/**
- * Planner provenance recorded inside {@link MigrationMetadata}.
- *
- * `used` / `applied` track which migration hints the planner consulted
- * vs. which it actually applied during emission; `plannerVersion`
- * pins the planner build that produced the migration so future
- * verification passes can recognise plans authored against an older
- * planner.
- */
-interface MigrationHints {
-  readonly used: readonly string[];
-  readonly applied: readonly string[];
-  readonly plannerVersion: string;
-}
 /**
  * In-memory migration metadata envelope. Every migration is
  * content-addressed: the `migrationHash` is a hash over the metadata
@@ -435,8 +445,6 @@ interface MigrationMetadata {
   readonly migrationHash: string;
   readonly from: string | null;
   readonly to: string;
-  readonly hints: MigrationHints;
-  readonly labels: readonly string[];
   /**
    * Sorted, deduplicated list of `invariantId`s declared by the
    * migration's data-transform ops. Always present; an empty array
@@ -1118,5 +1126,5 @@ interface SchemaVerifyResult {
   readonly issues: readonly SchemaIssue[];
 }
 //#endregion
-export { APP_SPACE_ID, type AssembledAuthoringContributions, type BaseSchemaIssue, type ContractSerializer, type ContractSpace, type ContractSpaceHeadRef, type ControlAdapterDescriptor, type ControlAdapterInstance, type ControlDriverDescriptor, type ControlDriverInstance, type ControlExtensionDescriptor, type ControlExtensionInstance, type ControlFamilyDescriptor, type ControlFamilyInstance, type ControlMutationDefaultEntry, type ControlMutationDefaultRegistry, type ControlMutationDefaults, type ControlStack, type ControlTargetDescriptor, type ControlTargetInstance, type CoreSchemaView, type CreateControlStackInput, type DefaultFunctionLoweringContext, type DefaultFunctionLoweringHandler, type DefaultFunctionRegistry, type DefaultFunctionRegistryEntry, type EmitContractResult, type EnumValuesChangedIssue, type ImportRequirement, type IntrospectSchemaResult, type LoweredDefaultResult, type LoweredDefaultValue, type MigratableTargetDescriptor, type MigrationHints, type MigrationMetadata, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPackage, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanWithAuthoringSurface, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerFailureResult, type MigrationPlannerResult, type MigrationPlannerSuccessResult, type MigrationRunner, type MigrationRunnerExecutionChecks, type MigrationRunnerFailure, type MigrationRunnerResult, type MigrationRunnerSuccessValue, type MigrationScaffoldContext, type MultiSpaceCapableRunner, type MultiSpaceRunnerFailure, type MultiSpaceRunnerPerSpaceOptions, type MultiSpaceRunnerResult, type MultiSpaceRunnerSuccessValue, type MutationDefaultGeneratorDescriptor, type OpFactoryCall, type OperationContext, type OperationPreview, type OperationPreviewCapable, type OperationPreviewStatement, type ParsedDefaultFunctionCall, type PslContractInferCapable, type SchemaIssue, SchemaTreeNode, type SchemaTreeNodeOptions, type SchemaTreeVisitor, type SchemaVerificationNode, type SchemaVerifier, type SchemaVerifyOptions, type SchemaVerifyResult, type SchemaViewCapable, type SchemaViewNodeKind, type SerializedQueryPlan, type SignDatabaseResult, type SourceDiagnostic, type SourceSpan, type TargetMigrationsCapability, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, assembleAuthoringContributions, assembleControlMutationDefaults, assembleScalarTypeDescriptors, assertUniqueCodecOwner, createControlStack, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, hasMigrations, hasMultiSpaceRunner, hasOperationPreview, hasPslContractInfer, hasSchemaView };
+export { APP_SPACE_ID, type AssembledAuthoringContributions, type BaseSchemaIssue, type ContractSerializer, type ContractSpace, type ContractSpaceHeadRef, type ControlAdapterDescriptor, type ControlAdapterInstance, type ControlDriverDescriptor, type ControlDriverInstance, type ControlExtensionDescriptor, type ControlExtensionInstance, type ControlFamilyDescriptor, type ControlFamilyInstance, type ControlMutationDefaultEntry, type ControlMutationDefaultRegistry, type ControlMutationDefaults, type ControlStack, type ControlTargetDescriptor, type ControlTargetInstance, type CoreSchemaView, type CreateControlStackInput, type DefaultFunctionLoweringContext, type DefaultFunctionLoweringHandler, type DefaultFunctionRegistry, type DefaultFunctionRegistryEntry, type EmitContractResult, type EnumValuesChangedIssue, type ImportRequirement, type IntrospectSchemaResult, type LoweredDefaultResult, type LoweredDefaultValue, type MigratableTargetDescriptor, type MigrationMetadata, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPackage, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanWithAuthoringSurface, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerFailureResult, type MigrationPlannerResult, type MigrationPlannerSuccessResult, type MigrationRunner, type MigrationRunnerExecutionChecks, type MigrationRunnerFailure, type MigrationRunnerResult, type MigrationRunnerSuccessValue, type MigrationScaffoldContext, type MultiSpaceCapableRunner, type MultiSpaceRunnerFailure, type MultiSpaceRunnerPerSpaceOptions, type MultiSpaceRunnerResult, type MultiSpaceRunnerSuccessValue, type MutationDefaultGeneratorDescriptor, type OpFactoryCall, type OperationContext, type OperationPreview, type OperationPreviewCapable, type OperationPreviewStatement, type ParsedDefaultFunctionCall, type PslContractInferCapable, type SchemaIssue, SchemaTreeNode, type SchemaTreeNodeOptions, type SchemaTreeVisitor, type SchemaVerificationNode, type SchemaVerifier, type SchemaVerifyOptions, type SchemaVerifyResult, type SchemaViewCapable, type SchemaViewNodeKind, type SerializedQueryPlan, type SignDatabaseResult, type SourceDiagnostic, type SourceSpan, type TargetMigrationsCapability, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, assembleAuthoringContributions, assembleControlMutationDefaults, assembleScalarTypeDescriptors, assertUniqueCodecOwner, createControlStack, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, hasMigrations, hasMultiSpaceRunner, hasOperationPreview, hasPslContractInfer, hasSchemaView };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/control/contract-serializer.ts","../src/control/control-result-types.ts","../src/control/control-instances.ts","../src/control/control-stack.ts","../src/control/control-descriptors.ts","../src/control/control-migration-types.ts","../src/control/control-operation-preview.ts","../src/control/control-schema-view.ts","../src/control/control-capabilities.ts","../src/control/control-spaces.ts","../src/control/schema-verifier.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkBA;;;;;UAAiB,kBAAA;EAuBa;;;;;;;;;;;EAX5B,mBAAA,WAA8B,SAAA,GAAY,SAAA,EAAW,IAAA,YAAgB,CAAA;EAWzC;;;;;;;;ACzC9B;EDyCE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;AAAA;;;cCzC7B,0BAAA;AAAA,cACA,yBAAA;AAAA,cACA,2BAAA;AAAA,cACA,0BAAA;AAAA,UAEI,gBAAA;EAAA,SACN,YAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA,GAAO,QAAA,CAAS,MAAA;AAAA;AAAA,UAGV,oBAAA;EAAA,SACN,EAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,QAAA;IAAA,SACA,MAAA;EAAA;EAAA,SAEF,aAAA;EAAA,SACA,oBAAA;EAAA,SACA,IAAA;IAAA,SACE,UAAA;IAAA,SACA,YAAA;EAAA;EAAA,SAEF,OAAA;IAAA,SACE,KAAA;EAAA;AAAA;AAAA,UAII,eAAA;EAAA,SACN,IAAA;EAAA,SAsBA,KAAA;EA7DE;;;;;AACb;;;;;AACA;;;;EAFa,SA4EF,WAAA;EAAA,SACA,MAAA;EAAA,SACA,iBAAA;EAAA,SACA,QAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,WAAA;EAAA,SACA,aAAA;EAAA,SACA,OAAA;AAAA;AAAA,KAGC,WAAA,GAAc,eAAA,GAAkB,sBAAA;AAAA,UAE3B,sBAAA;EAAA,SACN,MAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,YAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,WAAmB,sBAAA;AAAA;AAAA,UAGb,0BAAA;EAAA,SACN,EAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,QAAA;IAAA,SACA,MAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,MAAA,WAAiB,WAAA;IAAA,SACjB,IAAA,EAAM,sBAAA;IAAA,SACN,MAAA;MAAA,SACE,IAAA;MAAA,SACA,IAAA;MAAA,SACA,IAAA;MAAA,SACA,UAAA;IAAA;EAAA;EAAA,SAGJ,IAAA;IAAA,SACE,UAAA;IAAA,SACA,YAAA;IAAA,SACA,MAAA;EAAA;EAAA,SAEF,OAAA;IAAA,SACE,KAAA;EAAA;AAAA;AAAA,UAII,kBAAA;EAAA,SACN,YAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;EAAA,SACA,MAAA;IAAA,SACE,QAAA;IAAA,SACA,EAAA;EAAA;EAAA,SAEF,MAAA,EAAQ,SAAA;EAAA,SACR,IAAA;IAAA,SACE,UAAA;IAAA,SACA,KAAA;EAAA;EAAA,SAEF,OAAA;IAAA,SACE,KAAA;EAAA;AAAA;AAAA,UAII,kBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,QAAA;IAAA,SACA,MAAA;EAAA;EAAA,SAEF,MAAA;IAAA,SACE,OAAA;IAAA,SACA,OAAA;IAAA,SACA,QAAA;MAAA,SACE,WAAA;MAAA,SACA,WAAA;IAAA;EAAA;EAAA,SAGJ,IAAA;IAAA,SACE,UAAA;IAAA,SACA,YAAA;EAAA;EAAA,SAEF,OAAA;IAAA,SACE,KAAA;EAAA;AAAA;;;UC7KI,qBAAA,8CACP,cAAA,CAAe,SAAA;;;;;;;;;EASvB,mBAAA,CAAoB,YAAA,YAAwB,QAAA;EAE5C,MAAA,CAAO,OAAA;IAAA,SACI,MAAA,EAAQ,qBAAA,CAAsB,SAAA;IAAA,SAC9B,QAAA;IAAA,SACA,gBAAA;IAAA,SACA,YAAA;IAAA,SACA,UAAA;EAAA,IACP,OAAA,CAAQ,oBAAA;EFQsC;;;;;;;;;;;;EEMlD,YAAA,CAAa,OAAA;IAAA,SACF,QAAA;IAAA,SACA,MAAA,EAAQ,SAAA;IAAA,SACR,MAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA,CAA+B,SAAA;EAAA,IACzE,0BAAA;EAEJ,IAAA,CAAK,OAAA;IAAA,SACM,MAAA,EAAQ,qBAAA,CAAsB,SAAA;IAAA,SAC9B,QAAA;IAAA,SACA,YAAA;IAAA,SACA,UAAA;EAAA,IACP,OAAA,CAAQ,kBAAA;ED1DwB;;;;AACtC;;;;;AACA;;;;;AAEA;;;;EC0EE,UAAA,CAAW,OAAA;IAAA,SACA,MAAA,EAAQ,qBAAA,CAAsB,SAAA;IAAA,SAC9B,KAAA;EAAA,IACP,OAAA,CAAQ,oBAAA;ED1Ea;;;AAG3B;;EC8EE,cAAA,CAAe,OAAA;IAAA,SACJ,MAAA,EAAQ,qBAAA,CAAsB,SAAA;EAAA,IACrC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EAEhC,UAAA,CAAW,OAAA;IAAA,SACA,MAAA,EAAQ,qBAAA,CAAsB,SAAA;IAAA,SAC9B,QAAA;EAAA,IACP,OAAA,CAAQ,SAAA;AAAA;AAAA,UAGG,qBAAA,6DACP,cAAA,CAAe,SAAA,EAAW,SAAA;AAAA,UAEnB,sBAAA,6DACP,eAAA,CAAgB,SAAA,EAAW,SAAA;AAAA,UAEpB,qBAAA,6DACP,cAAA,CAAe,SAAA,EAAW,SAAA;EAClC,KAAA,OAAY,MAAA,mBACV,GAAA,UACA,MAAA,wBACC,OAAA;IAAA,SAAmB,IAAA,EAAM,GAAA;EAAA;EAC5B,KAAA,IAAS,OAAA;AAAA;AAAA,UAGM,wBAAA,6DACP,iBAAA,CAAkB,SAAA,EAAW,SAAA;;;UCrFtB,+BAAA;EAAA,SACN,KAAA,EAAO,uBAAA;EAAA,SACP,IAAA,EAAM,sBAAA;EAAA,SACN,WAAA,EAAa,4BAAA;AAAA;AAAA,UAGP,YAAA;EAAA,SAIN,MAAA,EAAQ,uBAAA,CAAwB,SAAA;EAAA,SAChC,MAAA,EAAQ,uBAAA,CAAwB,SAAA,EAAW,SAAA;EAAA,SAC3C,OAAA,GAAU,wBAAA,CAAyB,SAAA,EAAW,SAAA;EAAA,SAC9C,MAAA,GAAS,uBAAA,CAAwB,SAAA,EAAW,SAAA;EAAA,SAC5C,cAAA,WAAyB,0BAAA,CAA2B,SAAA,EAAW,SAAA;EAAA,SAE/D,gBAAA,EAAkB,aAAA,CAAc,eAAA;EAAA,SAChC,yBAAA,EAA2B,aAAA,CAAc,eAAA;EAAA,SACzC,YAAA,EAAc,aAAA;EAAA,SACd,WAAA,EAAa,WAAA;EAAA,SACb,sBAAA,EAAwB,+BAAA;EAAA,SACxB,qBAAA,EAAuB,WAAA;EAAA,SACvB,uBAAA,EAAyB,uBAAA;AAAA;AAAA,UAGnB,uBAAA;EAAA,SAIN,MAAA,EAAQ,uBAAA,CAAwB,SAAA;EAAA,SAChC,MAAA,EAAQ,uBAAA,CAAwB,SAAA,EAAW,SAAA;EAAA,SAC3C,OAAA,GAAU,wBAAA,CAAyB,SAAA,EAAW,SAAA;EAAA,SAC9C,MAAA,GAAS,uBAAA,CAAwB,SAAA,EAAW,SAAA;EAAA,SAC5C,cAAA,GACL,aAAA,CAAc,0BAAA,CAA2B,SAAA,EAAW,SAAA;AAAA;AAAA,iBAW1C,sBAAA,CAAuB,OAAA;EAAA,SAC5B,OAAA;EAAA,SACA,MAAA,EAAQ,GAAA;EAAA,SACR,YAAA;EAAA,SACA,WAAA;EAAA,SACA,oBAAA;AAAA;AAAA,iBAYK,uBAAA,CACd,WAAA,EAAa,aAAA,CAAc,IAAA,CAAK,iBAAA,cAC/B,aAAA,CAAc,eAAA;AAAA,iBAgBD,gCAAA,CACd,WAAA,EAAa,aAAA,CAAc,IAAA,CAAK,iBAAA,cAC/B,aAAA,CAAc,eAAA;AAAA,iBAaD,mBAAA,CACd,MAAA;EAAA,SAAmB,EAAA;AAAA,GACnB,MAAA;EAAA,SAAmB,EAAA;AAAA,GACnB,OAAA;EAAA,SAAoB,EAAA;AAAA,eACpB,UAAA,EAAY,aAAA;EAAA,SAAyB,EAAA;AAAA,KACpC,aAAA;AAAA,iBAiBa,8BAAA,CACd,WAAA,EAAa,aAAA;EAAA,SAAyB,SAAA,GAAY,sBAAA;AAAA,KACjD,+BAAA;AAAA,iBA+Ca,6BAAA,CACd,WAAA,EAAa,aAAA,CACX,IAAA,CAAK,iBAAA;EAAA,SAAyD,EAAA;AAAA,KAE/D,WAAA;AAAA,iBAwBa,+BAAA,CACd,WAAA,EAAa,aAAA,CACX,IAAA,CAAK,iBAAA;EAAA,SAA2D,EAAA;AAAA,KAEjE,uBAAA;AAAA,iBA0Ca,kBAAA,CACd,WAAA,EAAa,aAAA,CAAc,IAAA,CAAK,iBAAA;EAAsB,EAAA;AAAA,sBACrD,WAAA;AAAA,iBA2Ea,kBAAA,oDAAA,CACd,KAAA,EAAO,uBAAA,CAAwB,SAAA,EAAW,SAAA,IACzC,YAAA,CAAa,SAAA,EAAW,SAAA;;;UC1UV,uBAAA,mDAES,qBAAA,CAAsB,SAAA,aAAsB,qBAAA,CAClE,SAAA,oBAGM,gBAAA,CAAiB,SAAA;EAAA,SAChB,QAAA,EAAU,WAAA;EACnB,MAAA,2BAAiC,KAAA,EAAO,YAAA,CAAa,SAAA,EAAW,SAAA,IAAa,eAAA;AAAA;AAAA,UAG9D,uBAAA,6EAGS,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAAa,qBAAA,CACpE,SAAA,EACA,SAAA,qBAEgB,QAAA,GAAW,QAAA,UACrB,gBAAA,CAAiB,SAAA,EAAW,SAAA;;AJpBtC;;;;;WI2BW,kBAAA,EAAoB,kBAAA,CAAmB,SAAA;EAChD,MAAA,IAAU,eAAA;AAAA;AAAA,UAGK,wBAAA,8EAGU,sBAAA,CAAuB,SAAA,EAAW,SAAA,IAAa,sBAAA,CACtE,SAAA,EACA,SAAA,WAEM,iBAAA,CAAkB,SAAA,EAAW,SAAA;EJfa;;;;;;;EIuBlD,MAAA,CAAO,KAAA,EAAO,YAAA,CAAa,SAAA,EAAW,SAAA,IAAa,gBAAA;AAAA;AAAA,UAGpC,uBAAA,6EAGS,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAAa,qBAAA,CACpE,SAAA,EACA,SAAA,iCAGM,gBAAA,CAAiB,SAAA,EAAW,SAAA;EACpC,MAAA,CAAO,UAAA,EAAY,WAAA,GAAc,OAAA,CAAQ,eAAA;AAAA;AAAA,UAG1B,0BAAA,gFAGY,wBAAA,CACzB,SAAA,EACA,SAAA,IACE,wBAAA,CAAyB,SAAA,EAAW,SAAA,WAChC,mBAAA,CAAoB,SAAA,EAAW,SAAA;EACvC,MAAA,IAAU,kBAAA;AAAA;;;;;;;;;;;;UCzDK,cAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,cAAA;AAAA;;;;;;;;;;AJjCX;;;;;AACA;;;;;AACA;;;;;AACA;UI0DiB,iBAAA;EAAA,SACN,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,KAAA,EAAO,cAAA;EAAA,SACP,MAAA;;;;;;WAMA,kBAAA;EAAA,SACA,SAAA;AAAA;;AJ9DX;;;;;;KI4EY,uBAAA;;;;;;;;;;UAeK,mBAAA;EAAA,SACN,GAAA;EAAA,SACA,MAAA;AAAA;;;;UAMM,wBAAA;EAAA,SACN,uBAAA,WAAkC,uBAAA;AAAA;;;;;UAW5B,sBAAA;EJ9CN;EAAA,SIgDA,EAAA;EJ9CA;EAAA,SIgDA,KAAA;EJ9CA;EAAA,SIgDA,cAAA,EAAgB,uBAAA;EJ9ChB;;;AAGX;;;;;;;EAHW,SIyDA,WAAA;AAAA;;;AJ9CX;;;;;AAEA;;;;;;;;;;;;;;;;AAYA;;;;;;UIoEiB,aAAA;EJhEN;EAAA,SIkEA,WAAA;EJhEE;EAAA,SIkEF,cAAA,EAAgB,uBAAA;EJ/Dd;EAAA,SIiEF,KAAA;EJ9DA;;;;;;EIqET,gBAAA;EJhEa;;;;;EIsEb,kBAAA,aAA+B,mBAAA;EJ9DpB;;;;;AAOb;EI8DE,IAAA,IAAQ,sBAAA;AAAA;;;;;UAWO,aAAA;EJpEN;EAAA,SIsEA,QAAA;EJtEW;AAGtB;;;;;;;;EAHsB,SIgFX,OAAA;EJxEE;;;;EAAA,SI6EF,MAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EJvEK;EAAA,SI0EP,WAAA;IAAA,SACE,WAAA;IAAA,SACA,WAAA;EAAA;EJxEsB;EAAA,SI2ExB,UAAA,WAAqB,sBAAA;EJzErB;;;;;;;;;;EAAA,SIoFA,kBAAA;AAAA;;;;;;;;;;;;UAcM,iCAAA,SAA0C,aAAA;EHzPrB;;;;;EG+PpC,gBAAA;AAAA;;;;UAUe,wBAAA;EHrOiB;EAAA,SGuOvB,IAAA;EHnOgC;EAAA,SGqOhC,OAAA;EHjOG;EAAA,SGmOH,GAAA;AAAA;;;;;;;UASM,6BAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA,EAAM,iCAAA;AAAA;;;;UAMA,6BAAA;EAAA,SACN,IAAA;EAAA,SACA,SAAA,WAAoB,wBAAA;AAAA;;;;KAMnB,sBAAA,GAAyB,6BAAA,GAAgC,6BAAA;;;;UASpD,2BAAA;EAAA,SACN,iBAAA;EAAA,SACA,kBAAA;AAAA;;;;UAMM,sBAAA;EHvSH;EAAA,SGySH,IAAA;EH1RE;EAAA,SG4RF,OAAA;EH3RU;EAAA,SG6RV,GAAA;EH3RE;EAAA,SG6RF,IAAA,GAAO,MAAA;AAAA;;;;KAMN,qBAAA,GAAwB,MAAA,CAAO,2BAAA,EAA6B,sBAAA;;;;;UAUvD,8BAAA;EHtSJ;;;;EAAA,SG2SF,SAAA;EHrRE;;;;EAAA,SG0RF,UAAA;EHxRL;;;;EAAA,SG6RK,iBAAA;AAAA;;;;;;;;UAcM,gBAAA;EAIf,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IHpSE;;AAGvB;;;;;;;;;;;;;;IAHuB,SGqTV,YAAA,EAAc,QAAA;IH/SV;;;;;IAAA,SGqTJ,mBAAA,EAAqB,aAAA,CAC5B,8BAAA,CAA+B,SAAA,EAAW,SAAA;IHrTvB;;;;;;IAAA,SG6TZ,OAAA;EAAA,IACP,sBAAA;EH9TwC;AAE9C;;;;;;;;;;EGyUE,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;AAAA;;;;;;;;UAUY,eAAA;EHnVb;;;;;;;;;AAMJ;EG2VE,OAAA,CAAQ,OAAA;IAAA,SACG,IAAA,EAAM,aAAA;IAAA,SACN,MAAA,EAAQ,qBAAA,CAAsB,SAAA,EAAW,SAAA;IAAA,SACzC,mBAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IAAA,SACR,SAAA;MACP,gBAAA,EAAkB,EAAA,EAAI,sBAAA;MACtB,mBAAA,EAAqB,EAAA,EAAI,sBAAA;IAAA;IHjWrB;;;;IAAA,SGuWG,eAAA,GAAkB,8BAAA;;;;AF5b/B;;aEkca,mBAAA,EAAqB,aAAA,CAC5B,8BAAA,CAA+B,SAAA,EAAW,SAAA;EAAA,IAE1C,OAAA,CAAQ,qBAAA;AAAA;;;;;;;;;;;;AF/bd;;;UEodiB,+BAAA;EAAA,SAIN,KAAA;EAAA,SACA,IAAA,EAAM,aAAA;EAAA,SACN,MAAA,EAAQ,qBAAA,CAAsB,SAAA,EAAW,SAAA;EAAA,SACzC,mBAAA;EAAA,SACA,MAAA,EAAQ,wBAAA;EAAA,SACR,eAAA,GAAkB,8BAAA;EAAA,SAClB,mBAAA,EAAqB,aAAA,CAAc,8BAAA,CAA+B,SAAA,EAAW,SAAA;AAAA;AAAA,UAGvE,4BAAA;EAAA,SACN,eAAA,EAAiB,aAAA;IAAA,SACf,KAAA;IAAA,SACA,KAAA,EAAO,2BAAA;EAAA;AAAA;AAAA,UAIH,uBAAA,SAAgC,sBAAA;EF7dG;EAAA,SE+dzC,YAAA;AAAA;AAAA,KAGC,sBAAA,GAAyB,MAAA,CAAO,4BAAA,EAA8B,uBAAA;;;;;;;;;;;;;;;;UAiBzD,uBAAA;EAIf,mBAAA,CAAoB,OAAA;IAAA,SACT,MAAA,EAAQ,qBAAA,CAAsB,SAAA,EAAW,SAAA;IAAA,SACzC,eAAA,EAAiB,aAAA,CAAc,+BAAA,CAAgC,SAAA,EAAW,SAAA;EAAA,IACjF,OAAA,CAAQ,sBAAA;AAAA;;;;;;;;;UAeG,0BAAA,+FAGS,qBAAA,CAAsB,SAAA,aAAsB,qBAAA,CAClE,SAAA;EAIF,aAAA,CAAc,MAAA,EAAQ,eAAA,GAAkB,gBAAA,CAAiB,SAAA,EAAW,SAAA;EACpE,YAAA,CAAa,MAAA,EAAQ,eAAA,GAAkB,eAAA,CAAgB,SAAA,EAAW,SAAA;EFjhBzD;;;;;;;;;EE2hBT,gBAAA,CACE,QAAA,EAAU,QAAA,SACV,mBAAA,GAAsB,aAAA,CAAc,8BAAA,CAA+B,SAAA,EAAW,SAAA;AAAA;;AFthBlF;;;;;;UEqiBiB,wBAAA;EFhiBE;EAAA,SEkiBR,UAAA;EFjiB8C;EAAA,SEmiB9C,gBAAA;EFliBiC;;;;;;EAAA,SEyiBjC,QAAA;EFviBQ;;;;;EAAA,SE6iBR,MAAA;AAAA;;;;;;;;;;;;;;;AL3lBX;UMJiB,yBAAA;EAAA,SACN,IAAA;ENeqB;EAAA,SMbrB,QAAA;AAAA;AAAA,UAGM,gBAAA;EAAA,SACN,UAAA,WAAqB,yBAAA;AAAA;;;;;;;;;;;;KCXpB,kBAAA;AAAA,UASK,iBAAA;EACf,KAAA,CAAM,IAAA,EAAM,cAAA,GAAiB,CAAA;AAAA;AAAA,UAGd,qBAAA;EAAA,SACN,IAAA,EAAM,kBAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA,GAAO,MAAA;EAAA,SACP,QAAA,YAAoB,cAAA;AAAA;AAAA,cAGlB,cAAA;EAAA,SACF,IAAA,EAAM,kBAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA,GAAO,MAAA;EAAA,SACP,QAAA,YAAoB,cAAA;cAEjB,OAAA,EAAS,qBAAA;EASrB,MAAA,GAAA,CAAU,OAAA,EAAS,iBAAA,CAAkB,CAAA,IAAK,CAAA;AAAA;;;;;UAS3B,cAAA;EAAA,SACN,IAAA,EAAM,cAAA;AAAA;;;UC7CA,0BAAA,6EAGS,qBAAA,CAAsB,SAAA,aAAsB,qBAAA,CAClE,SAAA,oBAGM,uBAAA,CAAwB,SAAA,EAAW,SAAA;EAAA,SAClC,UAAA,EAAY,0BAAA,CAA2B,SAAA,EAAW,SAAA,EAAW,eAAA;AAAA;AAAA,iBAGxD,aAAA,oDAAA,CACd,MAAA,EAAQ,uBAAA,CAAwB,SAAA,EAAW,SAAA,IAC1C,MAAA,IAAU,0BAAA,CAA2B,SAAA,EAAW,SAAA;AAAA,UAIlC,iBAAA;EACf,YAAA,CAAa,MAAA,EAAQ,SAAA,GAAY,cAAA;AAAA;AAAA,iBAGnB,aAAA,qCAAA,CACd,QAAA,EAAU,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAC1C,QAAA,IAAY,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAAa,iBAAA,CAAkB,SAAA;;;;;UAW9D,uBAAA;EACf,gBAAA,CAAiB,QAAA,EAAU,SAAA,GAAY,cAAA;AAAA;AAAA,iBAGzB,mBAAA,qCAAA,CACd,QAAA,EAAU,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAC1C,QAAA,IAAY,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAAa,uBAAA,CAAwB,SAAA;;;;;;UAYpE,uBAAA;EACf,kBAAA,CAAmB,UAAA,WAAqB,sBAAA,KAA2B,gBAAA;AAAA;AAAA,iBAGrD,mBAAA,qCAAA,CACd,QAAA,EAAU,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAC1C,QAAA,IAAY,qBAAA,CAAsB,SAAA,EAAW,SAAA,IAAa,uBAAA;;;;;;;;APtE7D;;;;iBOwFgB,mBAAA,oDAAA,CACd,MAAA,EAAQ,eAAA,CAAgB,SAAA,EAAW,SAAA,IAClC,MAAA,IAAU,eAAA,CAAgB,SAAA,EAAW,SAAA,IAAa,uBAAA,CAAwB,SAAA,EAAW,SAAA;;;;;;;;;;;;;ARxExF;;;;;;;;;cSIa,YAAA;;;;;;;;;;;UAYI,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;AAAA;;;ARpCX;;;;;AACA;;;;;AACA;;UQmDiB,gBAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA,EAAU,iBAAA;EAAA,SACV,GAAA,WAAc,sBAAA;AAAA;;;;ARnDzB;;;;;;;;;;;AAMA;;;UQiEiB,aAAA,mBAAgC,QAAA,GAAW,QAAA;EAAA,SACjD,YAAA,EAAc,SAAA;EAAA,SACd,UAAA,WAAqB,gBAAA;EAAA,SACrB,OAAA,EAAS,oBAAA;AAAA;;;;;;;;;;;;;;AT7DpB;;;;;;;;;;;;UUOiB,cAAA;EACf,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;AAAA;;;;;;;UASjD,mBAAA;EAAA,SACN,QAAA,EAAU,SAAA;EAAA,SACV,MAAA,EAAQ,OAAA;AAAA;;ATrCnB;;;;;AACA;US8CiB,kBAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA,WAAiB,WAAA;AAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/control/contract-serializer.ts","../src/control/control-result-types.ts","../src/control/control-instances.ts","../src/control/control-stack.ts","../src/control/control-descriptors.ts","../src/control/control-migration-types.ts","../src/control/control-operation-preview.ts","../src/control/control-schema-view.ts","../src/control/control-capabilities.ts","../src/control/control-spaces.ts","../src/control/schema-verifier.ts"],"mappings":"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"}

package/dist/control.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"control.mjs","names":[],"sources":["../src/control/control-capabilities.ts","../src/control/control-result-types.ts","../src/control/control-schema-view.ts","../src/control/control-spaces.ts","../src/control/control-stack.ts"],"sourcesContent":["import type { ControlTargetDescriptor } from './control-descriptors';\nimport type { ControlFamilyInstance } from './control-instances';\nimport type {\n  MigrationPlanOperation,\n  MigrationRunner,\n  MultiSpaceCapableRunner,\n  TargetMigrationsCapability,\n} from './control-migration-types';\nimport type { OperationPreview } from './control-operation-preview';\nimport type { CoreSchemaView } from './control-schema-view';\nimport type { PslDocumentAst } from './psl-ast';\n\nexport interface MigratableTargetDescriptor<\n  TFamilyId extends string,\n  TTargetId extends string,\n  TFamilyInstance extends ControlFamilyInstance<TFamilyId, unknown> = ControlFamilyInstance<\n    TFamilyId,\n    unknown\n  >,\n> extends ControlTargetDescriptor<TFamilyId, TTargetId> {\n  readonly migrations: TargetMigrationsCapability<TFamilyId, TTargetId, TFamilyInstance>;\n}\n\nexport function hasMigrations<TFamilyId extends string, TTargetId extends string>(\n  target: ControlTargetDescriptor<TFamilyId, TTargetId>,\n): target is MigratableTargetDescriptor<TFamilyId, TTargetId> {\n  return 'migrations' in target && !!(target as Record<string, unknown>)['migrations'];\n}\n\nexport interface SchemaViewCapable<TSchemaIR = unknown> {\n  toSchemaView(schema: TSchemaIR): CoreSchemaView;\n}\n\nexport function hasSchemaView<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & SchemaViewCapable<TSchemaIR> {\n  return (\n    'toSchemaView' in instance &&\n    typeof (instance as Record<string, unknown>)['toSchemaView'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a family can infer a PSL contract AST from its\n * opaque introspected schema IR. Consumed by `prisma-next contract infer`.\n */\nexport interface PslContractInferCapable<TSchemaIR = unknown> {\n  inferPslContract(schemaIR: TSchemaIR): PslDocumentAst;\n}\n\nexport function hasPslContractInfer<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & PslContractInferCapable<TSchemaIR> {\n  return (\n    'inferPslContract' in instance &&\n    typeof (instance as Record<string, unknown>)['inferPslContract'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a family can render a textual preview of migration\n * operations for the CLI's \"DDL preview\" output. SQL families emit\n * `language: 'sql'` statements; Mongo families emit `language: 'mongodb-shell'`.\n */\nexport interface OperationPreviewCapable {\n  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;\n}\n\nexport function hasOperationPreview<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & OperationPreviewCapable {\n  return (\n    'toOperationPreview' in instance &&\n    typeof (instance as Record<string, unknown>)['toOperationPreview'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a runner can apply per-space plans inside a\n * single outer transaction. The SQL family (`SqlMigrationRunner`) implements\n * this with a true outer transaction. The Mongo family implements a\n * degenerate single-space shim (Mongo per-space is a non-goal per the\n * extension-contract-spaces project spec — TML-2397).\n *\n * The CLI's shared `applyAggregate` primitive uses this guard so that\n * `db init` / `db update` / `migrate` route uniformly through one\n * dispatch path regardless of family.\n */\nexport function hasMultiSpaceRunner<TFamilyId extends string, TTargetId extends string>(\n  runner: MigrationRunner<TFamilyId, TTargetId>,\n): runner is MigrationRunner<TFamilyId, TTargetId> & MultiSpaceCapableRunner<TFamilyId, TTargetId> {\n  return (\n    'executeAcrossSpaces' in runner &&\n    typeof (runner as Record<string, unknown>)['executeAcrossSpaces'] === 'function'\n  );\n}\n","export const VERIFY_CODE_MARKER_MISSING = 'PN-RUN-3001';\nexport const VERIFY_CODE_HASH_MISMATCH = 'PN-RUN-3002';\nexport const VERIFY_CODE_TARGET_MISMATCH = 'PN-RUN-3003';\nexport const VERIFY_CODE_SCHEMA_FAILURE = 'PN-RUN-3010';\n\nexport interface OperationContext {\n  readonly contractPath?: string;\n  readonly configPath?: string;\n  readonly meta?: Readonly<Record<string, unknown>>;\n}\n\nexport interface VerifyDatabaseResult {\n  readonly ok: boolean;\n  readonly code?: string;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly marker?: {\n    readonly storageHash?: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly missingCodecs?: readonly string[];\n  readonly codecCoverageSkipped?: boolean;\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface BaseSchemaIssue {\n  readonly kind:\n    | 'missing_schema'\n    | 'missing_table'\n    | 'missing_column'\n    | 'extra_table'\n    | 'extra_column'\n    | 'extra_primary_key'\n    | 'extra_foreign_key'\n    | 'extra_unique_constraint'\n    | 'extra_index'\n    | 'extra_validator'\n    | 'type_mismatch'\n    | 'type_missing'\n    | 'type_values_mismatch'\n    | 'nullability_mismatch'\n    | 'primary_key_mismatch'\n    | 'foreign_key_mismatch'\n    | 'unique_constraint_mismatch'\n    | 'index_mismatch'\n    | 'default_missing'\n    | 'default_mismatch'\n    | 'extra_default';\n  readonly table?: string;\n  /**\n   * Namespace coordinate of the issue's subject (e.g. the schema a SQL\n   * table lives in). Populated by family verifiers that have the\n   * coordinate in scope when constructing the issue; absent for issues\n   * whose family has no namespace concept (e.g. Mongo collections) or\n   * whose subject isn't in any contract namespace (e.g. an extra-table\n   * issue raised for a table that exists in the live DB but not in the\n   * contract).\n   *\n   * Downstream planners trust this field as the authoritative subject\n   * coordinate and do not re-derive it by name lookup. A finer-grained\n   * structural split between framework-shared and family-specific issue\n   * fields is tracked under a follow-up ticket.\n   */\n  readonly namespaceId?: string;\n  readonly column?: string;\n  readonly indexOrConstraint?: string;\n  readonly typeName?: string;\n  readonly expected?: string;\n  readonly actual?: string;\n  readonly message: string;\n}\n\nexport interface EnumValuesChangedIssue {\n  readonly kind: 'enum_values_changed';\n  readonly typeName: string;\n  readonly addedValues: readonly string[];\n  readonly removedValues: readonly string[];\n  readonly message: string;\n}\n\nexport type SchemaIssue = BaseSchemaIssue | EnumValuesChangedIssue;\n\nexport interface SchemaVerificationNode {\n  readonly status: 'pass' | 'warn' | 'fail';\n  readonly kind: string;\n  readonly name: string;\n  readonly contractPath: string;\n  readonly code: string;\n  readonly message: string;\n  readonly expected: unknown;\n  readonly actual: unknown;\n  readonly children: readonly SchemaVerificationNode[];\n}\n\nexport interface VerifyDatabaseSchemaResult {\n  readonly ok: boolean;\n  readonly code?: string;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly schema: {\n    readonly issues: readonly SchemaIssue[];\n    readonly root: SchemaVerificationNode;\n    readonly counts: {\n      readonly pass: number;\n      readonly warn: number;\n      readonly fail: number;\n      readonly totalNodes: number;\n    };\n  };\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath?: string;\n    readonly strict: boolean;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface EmitContractResult {\n  readonly contractJson: string;\n  readonly contractDts: string;\n  readonly storageHash: string;\n  readonly executionHash?: string;\n  readonly profileHash: string;\n}\n\nexport interface IntrospectSchemaResult<TSchemaIR> {\n  readonly ok: true;\n  readonly summary: string;\n  readonly target: {\n    readonly familyId: string;\n    readonly id: string;\n  };\n  readonly schema: TSchemaIR;\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly dbUrl?: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface SignDatabaseResult {\n  readonly ok: boolean;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly marker: {\n    readonly created: boolean;\n    readonly updated: boolean;\n    readonly previous?: {\n      readonly storageHash?: string;\n      readonly profileHash?: string;\n    };\n  };\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n","/**\n * Core schema view types for family-agnostic schema visualization.\n *\n * These types provide a minimal, generic, tree-shaped representation of schemas\n * across families, designed for CLI visualization and lightweight tooling.\n *\n * Families can optionally project their family-specific Schema IR into this\n * core view via the `toSchemaView` method on `FamilyInstance`.\n */\n\nexport type SchemaViewNodeKind =\n  | 'root'\n  | 'namespace'\n  | 'collection'\n  | 'entity'\n  | 'field'\n  | 'index'\n  | 'dependency';\n\nexport interface SchemaTreeVisitor<R> {\n  visit(node: SchemaTreeNode): R;\n}\n\nexport interface SchemaTreeNodeOptions {\n  readonly kind: SchemaViewNodeKind;\n  readonly id: string;\n  readonly label: string;\n  readonly meta?: Record<string, unknown>;\n  readonly children?: readonly SchemaTreeNode[];\n}\n\nexport class SchemaTreeNode {\n  readonly kind: SchemaViewNodeKind;\n  readonly id: string;\n  readonly label: string;\n  readonly meta?: Record<string, unknown>;\n  readonly children?: readonly SchemaTreeNode[];\n\n  constructor(options: SchemaTreeNodeOptions) {\n    this.kind = options.kind;\n    this.id = options.id;\n    this.label = options.label;\n    if (options.meta !== undefined) this.meta = options.meta;\n    if (options.children !== undefined) this.children = options.children;\n    Object.freeze(this);\n  }\n\n  accept<R>(visitor: SchemaTreeVisitor<R>): R {\n    return visitor.visit(this);\n  }\n}\n\n/**\n * Core schema view providing a family-agnostic tree representation of a schema.\n * Used by CLI and cross-family tooling for visualization.\n */\nexport interface CoreSchemaView {\n  readonly root: SchemaTreeNode;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationMetadata, MigrationPlanOperation } from './control-migration-types';\n\n/**\n * Canonical control-plane identifiers for contract spaces.\n *\n * A contract space is the disjoint `(contract.json, migration-graph)` unit\n * the per-space planner / runner / verifier (project: extension contract\n * spaces, TML-2397) operates on. The application owns one well-known\n * space — the value below — and each loaded extension that contributes\n * schema owns a uniquely-named space.\n *\n * Lives in `framework-components/control` so every layer that has to\n * reason about space identity (the migration tooling, the SQL runtime's\n * marker reader, target-side statement builders, target-side adapters)\n * can import a single value rather than duplicating the literal. Raw\n * `'app'` string literals in framework / target / runtime / adapter\n * source code are forbidden and policed by\n * `scripts/lint-app-space-id.mjs` (wired into `pnpm lint:deps`).\n *\n * @see specs/framework-mechanism.spec.md § 3 — Layout convention (γ).\n */\nexport const APP_SPACE_ID = 'app' as const;\n\n/**\n * Head ref for a contract space — the `(hash, invariants)` tuple\n * a runner targets when applying that space's migration graph. Identical\n * in shape to the on-disk `migrations/<space-id>/refs/head.json` the\n * framework writes per loaded extension, and to the app-space\n * `<projectRoot>/refs/head.json`. Family-agnostic: SQL, Mongo, and any\n * future family share the same head-ref shape.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface ContractSpaceHeadRef {\n  readonly hash: string;\n  readonly invariants: readonly string[];\n}\n\n/**\n * Canonical structural shape of a migration package — the unit a planner\n * produces and a runner consumes: a directory name, the metadata\n * envelope, and the operation list.\n *\n * In-memory by default. Readers in `@prisma-next/migration-tools`\n * (`readMigrationPackage` / `readMigrationsDir`) return the augmented\n * {@link import('@prisma-next/migration-tools/package').OnDiskMigrationPackage}\n * variant which adds `dirPath`; everything else operates against the\n * canonical shape so the same value flows through pre-emission\n * authoring, on-disk loading, and runner execution without conversion.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface MigrationPackage {\n  readonly dirName: string;\n  readonly metadata: MigrationMetadata;\n  readonly ops: readonly MigrationPlanOperation[];\n}\n\n/**\n * Canonical structural shape of a contract space — one disjoint\n * `(contractJson, migration-graph)` unit the per-space planner / runner\n * / verifier operates on. The application owns one well-known space\n * ({@link APP_SPACE_ID}); each loaded extension that contributes schema\n * owns a uniquely-named space. Whether a value is the app's space or an\n * extension's space is a control-plane concern; the type carries no\n * such distinction.\n *\n * Generic over the contract so each family pins a typed contract value\n * at consumption time. The SQL family specialises to\n * `ContractSpace<Contract<SqlStorage>>` at the descriptor surface;\n * Mongo's symmetrical `ContractSpace<Contract<MongoStorage>>` will land\n * with that family.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface ContractSpace<TContract extends Contract = Contract> {\n  readonly contractJson: TContract;\n  readonly migrations: readonly MigrationPackage[];\n  readonly headRef: ContractSpaceHeadRef;\n}\n","import type { Codec } from '../shared/codec';\nimport type { CodecLookup, CodecMeta } from '../shared/codec-types';\nimport type {\n  AuthoringContributions,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '../shared/framework-authoring';\nimport {\n  assertNoCrossRegistryCollisions,\n  isAuthoringEntityTypeDescriptor,\n  isAuthoringFieldPresetDescriptor,\n  isAuthoringTypeConstructorDescriptor,\n  mergeAuthoringNamespaces,\n} from '../shared/framework-authoring';\nimport type { ComponentMetadata } from '../shared/framework-components';\nimport type {\n  ControlMutationDefaultEntry,\n  ControlMutationDefaults,\n  MutationDefaultGeneratorDescriptor,\n} from '../shared/mutation-default-types';\nimport type { TypesImportSpec } from '../shared/types-import-spec';\nimport type {\n  ControlAdapterDescriptor,\n  ControlDriverDescriptor,\n  ControlExtensionDescriptor,\n  ControlFamilyDescriptor,\n  ControlTargetDescriptor,\n} from './control-descriptors';\n\nexport interface AssembledAuthoringContributions {\n  readonly field: AuthoringFieldNamespace;\n  readonly type: AuthoringTypeNamespace;\n  readonly entityTypes: AuthoringEntityTypeNamespace;\n}\n\nexport interface ControlStack<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> {\n  readonly family: ControlFamilyDescriptor<TFamilyId>;\n  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;\n  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly extensionPacks: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[];\n\n  readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;\n  readonly queryOperationTypeImports: ReadonlyArray<TypesImportSpec>;\n  readonly extensionIds: ReadonlyArray<string>;\n  readonly codecLookup: CodecLookup;\n  readonly authoringContributions: AssembledAuthoringContributions;\n  readonly scalarTypeDescriptors: ReadonlyMap<string, string>;\n  readonly controlMutationDefaults: ControlMutationDefaults;\n}\n\nexport interface CreateControlStackInput<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> {\n  readonly family: ControlFamilyDescriptor<TFamilyId>;\n  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;\n  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly extensionPacks?:\n    | ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>\n    | undefined;\n}\n\nfunction addUniqueId(ids: string[], seen: Set<string>, id: string): void {\n  if (!seen.has(id)) {\n    ids.push(id);\n    seen.add(id);\n  }\n}\n\nexport function assertUniqueCodecOwner(options: {\n  readonly codecId: string;\n  readonly owners: Map<string, string>;\n  readonly descriptorId: string;\n  readonly entityLabel: string;\n  readonly entityOwnershipLabel: string;\n}): void {\n  const existingOwner = options.owners.get(options.codecId);\n  if (existingOwner !== undefined) {\n    throw new Error(\n      `Duplicate ${options.entityLabel} for codecId \"${options.codecId}\". ` +\n        `Descriptor \"${options.descriptorId}\" conflicts with \"${existingOwner}\". ` +\n        `Each codecId can only have one ${options.entityOwnershipLabel}.`,\n    );\n  }\n}\n\nexport function extractCodecTypeImports(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const codecTypes = descriptor.types?.codecTypes;\n    if (codecTypes?.import) {\n      imports.push(codecTypes.import);\n    }\n    if (codecTypes?.typeImports) {\n      imports.push(...codecTypes.typeImports);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractQueryOperationTypeImports(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const queryOperationTypes = descriptor.types?.queryOperationTypes;\n    if (queryOperationTypes?.import) {\n      imports.push(queryOperationTypes.import);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractComponentIds(\n  family: { readonly id: string },\n  target: { readonly id: string },\n  adapter: { readonly id: string } | undefined,\n  extensions: ReadonlyArray<{ readonly id: string }>,\n): ReadonlyArray<string> {\n  const ids: string[] = [];\n  const seen = new Set<string>();\n\n  addUniqueId(ids, seen, family.id);\n  addUniqueId(ids, seen, target.id);\n  if (adapter) {\n    addUniqueId(ids, seen, adapter.id);\n  }\n\n  for (const ext of extensions) {\n    addUniqueId(ids, seen, ext.id);\n  }\n\n  return ids;\n}\n\nexport function assembleAuthoringContributions(\n  descriptors: ReadonlyArray<{ readonly authoring?: AuthoringContributions }>,\n): AssembledAuthoringContributions {\n  const field = {} as Record<string, unknown>;\n  const type = {} as Record<string, unknown>;\n  const entityTypes = {} as Record<string, unknown>;\n\n  for (const descriptor of descriptors) {\n    if (descriptor.authoring?.field) {\n      mergeAuthoringNamespaces(\n        field,\n        descriptor.authoring.field,\n        [],\n        isAuthoringFieldPresetDescriptor,\n        'field',\n      );\n    }\n    if (descriptor.authoring?.type) {\n      mergeAuthoringNamespaces(\n        type,\n        descriptor.authoring.type,\n        [],\n        isAuthoringTypeConstructorDescriptor,\n        'type',\n      );\n    }\n    if (descriptor.authoring?.entityTypes) {\n      mergeAuthoringNamespaces(\n        entityTypes,\n        descriptor.authoring.entityTypes,\n        [],\n        isAuthoringEntityTypeDescriptor,\n        'entity',\n      );\n    }\n  }\n\n  const fieldNamespace = field as AuthoringFieldNamespace;\n  const typeNamespace = type as AuthoringTypeNamespace;\n  const entityTypeNamespace = entityTypes as AuthoringEntityTypeNamespace;\n  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace);\n\n  return {\n    field: fieldNamespace,\n    type: typeNamespace,\n    entityTypes: entityTypeNamespace,\n  };\n}\n\nexport function assembleScalarTypeDescriptors(\n  descriptors: ReadonlyArray<\n    Pick<ComponentMetadata, 'scalarTypeDescriptors'> & { readonly id?: string }\n  >,\n): ReadonlyMap<string, string> {\n  const result = new Map<string, string>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    const descriptorMap = descriptor.scalarTypeDescriptors;\n    if (!descriptorMap) continue;\n    const descriptorId = descriptor.id ?? '<unknown>';\n    for (const [typeName, codecId] of descriptorMap) {\n      const existingOwner = owners.get(typeName);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate scalar type descriptor \"${typeName}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      result.set(typeName, codecId);\n      owners.set(typeName, descriptorId);\n    }\n  }\n\n  return result;\n}\n\nexport function assembleControlMutationDefaults(\n  descriptors: ReadonlyArray<\n    Pick<ComponentMetadata, 'controlMutationDefaults'> & { readonly id?: string }\n  >,\n): ControlMutationDefaults {\n  const defaultFunctionRegistry = new Map<string, ControlMutationDefaultEntry>();\n  const functionOwners = new Map<string, string>();\n  const generatorMap = new Map<string, MutationDefaultGeneratorDescriptor>();\n  const generatorOwners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    const contributions = descriptor.controlMutationDefaults;\n    if (!contributions) continue;\n    const descriptorId = descriptor.id ?? '<unknown>';\n\n    for (const generatorDescriptor of contributions.generatorDescriptors) {\n      const existingOwner = generatorOwners.get(generatorDescriptor.id);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate mutation default generator id \"${generatorDescriptor.id}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      generatorMap.set(generatorDescriptor.id, generatorDescriptor);\n      generatorOwners.set(generatorDescriptor.id, descriptorId);\n    }\n\n    for (const [functionName, handler] of contributions.defaultFunctionRegistry) {\n      const existingOwner = functionOwners.get(functionName);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate mutation default function \"${functionName}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      defaultFunctionRegistry.set(functionName, handler);\n      functionOwners.set(functionName, descriptorId);\n    }\n  }\n\n  return {\n    defaultFunctionRegistry,\n    generatorDescriptors: Array.from(generatorMap.values()),\n  };\n}\n\nexport function extractCodecLookup(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata & { id: string }, 'types' | 'id'>>,\n): CodecLookup {\n  const byId = new Map<string, Codec>();\n  const targetTypesById = new Map<string, readonly string[]>();\n  const metaById = new Map<string, CodecMeta>();\n  const renderersById = new Map<string, (params: Record<string, unknown>) => string | undefined>();\n  const owners = new Map<string, string>();\n  for (const descriptor of descriptors) {\n    const codecTypes = descriptor.types?.codecTypes;\n    const descriptorId = descriptor.id;\n    // Descriptor-side metadata is the single source of truth for `targetTypes` / `meta` / `renderOutputType`. Every contributor ships a `codecDescriptors` list on `types.codecTypes`.\n    for (const codecDescriptor of codecTypes?.codecDescriptors ?? []) {\n      assertUniqueCodecOwner({\n        codecId: codecDescriptor.codecId,\n        owners,\n        descriptorId,\n        entityLabel: 'codec descriptor',\n        entityOwnershipLabel: 'codec descriptor provider',\n      });\n      owners.set(codecDescriptor.codecId, descriptorId);\n      if (Array.isArray(codecDescriptor.targetTypes)) {\n        targetTypesById.set(codecDescriptor.codecId, codecDescriptor.targetTypes);\n      }\n      if (codecDescriptor.meta !== undefined) {\n        metaById.set(codecDescriptor.codecId, codecDescriptor.meta);\n      }\n      if (typeof codecDescriptor.renderOutputType === 'function') {\n        renderersById.set(codecDescriptor.codecId, codecDescriptor.renderOutputType);\n      }\n      // Materialize a representative `Codec` instance for `byId.get()` so consumers reading the lookup's instance side (e.g. SQL renderer's cast-policy lookup, or the contract emitter's literal-default `encodeJson` resolver) keep finding the codec.\n      //\n      // Two cohorts:\n      // - Non-parameterized descriptors: factory must succeed; any throw is a real bug and we let it propagate (no silent try/catch).\n      // - Parameterized descriptors: try with empty params. Many parameterized codecs treat params as advisory (e.g. `pg/timestamptz@1` whose precision is rendered into the `nativeType` only and never read by the runtime codec), so an empty-params construction yields a usable representative for id-keyed lookups (e.g. emit-time literal-default encoding). Codecs whose factory genuinely requires params (e.g. `pg/vector@1` threading `length` into the runtime codec) will throw; for those, per-column instances are materialized at runtime by `buildContractCodecRegistry` and the id-keyed lookup miss is correct (the column-aware path resolves them).\n      if (!byId.has(codecDescriptor.codecId)) {\n        if (codecDescriptor.isParameterized) {\n          try {\n            const representative = codecDescriptor.factory({} as never)({\n              name: `<lookup:${codecDescriptor.codecId}>`,\n            } as Parameters<ReturnType<typeof codecDescriptor.factory>>[0]);\n            byId.set(codecDescriptor.codecId, representative);\n          } catch {\n            // Factory requires concrete params; skip representative materialization. Per-column instances are built at runtime; id-keyed lookup miss is the correct outcome here.\n          }\n        } else {\n          const representative = codecDescriptor.factory(undefined as never)({\n            name: `<lookup:${codecDescriptor.codecId}>`,\n          } as Parameters<ReturnType<typeof codecDescriptor.factory>>[0]);\n          byId.set(codecDescriptor.codecId, representative);\n        }\n      }\n    }\n  }\n  return {\n    get: (id) => byId.get(id),\n    targetTypesFor: (id) => targetTypesById.get(id),\n    metaFor: (id) => metaById.get(id),\n    renderOutputTypeFor: (id, params) => renderersById.get(id)?.(params),\n  };\n}\n\nexport function validateScalarTypeCodecIds(\n  scalarTypeDescriptors: ReadonlyMap<string, string>,\n  codecLookup: CodecLookup,\n): string[] {\n  const errors: string[] = [];\n  for (const [typeName, codecId] of scalarTypeDescriptors) {\n    if (!codecLookup.get(codecId)) {\n      errors.push(\n        `Scalar type \"${typeName}\" references codec \"${codecId}\" which is not registered by any component.`,\n      );\n    }\n  }\n  return errors;\n}\n\nexport function createControlStack<TFamilyId extends string, TTargetId extends string>(\n  input: CreateControlStackInput<TFamilyId, TTargetId>,\n): ControlStack<TFamilyId, TTargetId> {\n  const { family, target, adapter, driver, extensionPacks = [] } = input;\n\n  const allDescriptors = [family, target, ...(adapter ? [adapter] : []), ...extensionPacks];\n\n  const codecLookup = extractCodecLookup(allDescriptors);\n  const scalarTypeDescriptors = assembleScalarTypeDescriptors(allDescriptors);\n\n  return {\n    family,\n    target,\n    adapter,\n    driver,\n    extensionPacks: extensionPacks as readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[],\n\n    codecTypeImports: extractCodecTypeImports(allDescriptors),\n    queryOperationTypeImports: extractQueryOperationTypeImports(allDescriptors),\n    extensionIds: extractComponentIds(family, target, adapter, extensionPacks),\n    codecLookup,\n    authoringContributions: assembleAuthoringContributions(allDescriptors),\n    scalarTypeDescriptors,\n    controlMutationDefaults: assembleControlMutationDefaults(allDescriptors),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/control/control-capabilities.ts","../src/control/control-result-types.ts","../src/control/control-schema-view.ts","../src/control/control-spaces.ts","../src/control/control-stack.ts"],"sourcesContent":["import type { ControlTargetDescriptor } from './control-descriptors';\nimport type { ControlFamilyInstance } from './control-instances';\nimport type {\n  MigrationPlanOperation,\n  MigrationRunner,\n  MultiSpaceCapableRunner,\n  TargetMigrationsCapability,\n} from './control-migration-types';\nimport type { OperationPreview } from './control-operation-preview';\nimport type { CoreSchemaView } from './control-schema-view';\nimport type { PslDocumentAst } from './psl-ast';\n\nexport interface MigratableTargetDescriptor<\n  TFamilyId extends string,\n  TTargetId extends string,\n  TFamilyInstance extends ControlFamilyInstance<TFamilyId, unknown> = ControlFamilyInstance<\n    TFamilyId,\n    unknown\n  >,\n> extends ControlTargetDescriptor<TFamilyId, TTargetId> {\n  readonly migrations: TargetMigrationsCapability<TFamilyId, TTargetId, TFamilyInstance>;\n}\n\nexport function hasMigrations<TFamilyId extends string, TTargetId extends string>(\n  target: ControlTargetDescriptor<TFamilyId, TTargetId>,\n): target is MigratableTargetDescriptor<TFamilyId, TTargetId> {\n  return 'migrations' in target && !!(target as Record<string, unknown>)['migrations'];\n}\n\nexport interface SchemaViewCapable<TSchemaIR = unknown> {\n  toSchemaView(schema: TSchemaIR): CoreSchemaView;\n}\n\nexport function hasSchemaView<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & SchemaViewCapable<TSchemaIR> {\n  return (\n    'toSchemaView' in instance &&\n    typeof (instance as Record<string, unknown>)['toSchemaView'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a family can infer a PSL contract AST from its\n * opaque introspected schema IR. Consumed by `prisma-next contract infer`.\n */\nexport interface PslContractInferCapable<TSchemaIR = unknown> {\n  inferPslContract(schemaIR: TSchemaIR): PslDocumentAst;\n}\n\nexport function hasPslContractInfer<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & PslContractInferCapable<TSchemaIR> {\n  return (\n    'inferPslContract' in instance &&\n    typeof (instance as Record<string, unknown>)['inferPslContract'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a family can render a textual preview of migration\n * operations for the CLI's \"DDL preview\" output. SQL families emit\n * `language: 'sql'` statements; Mongo families emit `language: 'mongodb-shell'`.\n */\nexport interface OperationPreviewCapable {\n  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;\n}\n\nexport function hasOperationPreview<TFamilyId extends string, TSchemaIR>(\n  instance: ControlFamilyInstance<TFamilyId, TSchemaIR>,\n): instance is ControlFamilyInstance<TFamilyId, TSchemaIR> & OperationPreviewCapable {\n  return (\n    'toOperationPreview' in instance &&\n    typeof (instance as Record<string, unknown>)['toOperationPreview'] === 'function'\n  );\n}\n\n/**\n * Capability declaring that a runner can apply per-space plans inside a\n * single outer transaction. The SQL family (`SqlMigrationRunner`) implements\n * this with a true outer transaction. The Mongo family implements a\n * degenerate single-space shim (Mongo per-space is a non-goal per the\n * extension-contract-spaces project spec — TML-2397).\n *\n * The CLI's shared `applyAggregate` primitive uses this guard so that\n * `db init` / `db update` / `migrate` route uniformly through one\n * dispatch path regardless of family.\n */\nexport function hasMultiSpaceRunner<TFamilyId extends string, TTargetId extends string>(\n  runner: MigrationRunner<TFamilyId, TTargetId>,\n): runner is MigrationRunner<TFamilyId, TTargetId> & MultiSpaceCapableRunner<TFamilyId, TTargetId> {\n  return (\n    'executeAcrossSpaces' in runner &&\n    typeof (runner as Record<string, unknown>)['executeAcrossSpaces'] === 'function'\n  );\n}\n","export const VERIFY_CODE_MARKER_MISSING = 'PN-RUN-3001';\nexport const VERIFY_CODE_HASH_MISMATCH = 'PN-RUN-3002';\nexport const VERIFY_CODE_TARGET_MISMATCH = 'PN-RUN-3003';\nexport const VERIFY_CODE_SCHEMA_FAILURE = 'PN-RUN-3010';\n\nexport interface OperationContext {\n  readonly contractPath?: string;\n  readonly configPath?: string;\n  readonly meta?: Readonly<Record<string, unknown>>;\n}\n\nexport interface VerifyDatabaseResult {\n  readonly ok: boolean;\n  readonly code?: string;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly marker?: {\n    readonly storageHash?: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly missingCodecs?: readonly string[];\n  readonly codecCoverageSkipped?: boolean;\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface BaseSchemaIssue {\n  readonly kind:\n    | 'missing_schema'\n    | 'missing_table'\n    | 'missing_column'\n    | 'extra_table'\n    | 'extra_column'\n    | 'extra_primary_key'\n    | 'extra_foreign_key'\n    | 'extra_unique_constraint'\n    | 'extra_index'\n    | 'extra_validator'\n    | 'type_mismatch'\n    | 'type_missing'\n    | 'type_values_mismatch'\n    | 'nullability_mismatch'\n    | 'primary_key_mismatch'\n    | 'foreign_key_mismatch'\n    | 'unique_constraint_mismatch'\n    | 'index_mismatch'\n    | 'default_missing'\n    | 'default_mismatch'\n    | 'extra_default';\n  readonly table?: string;\n  /**\n   * Namespace coordinate of the issue's subject (e.g. the schema a SQL\n   * table lives in). Populated by family verifiers that have the\n   * coordinate in scope when constructing the issue; absent for issues\n   * whose family has no namespace concept (e.g. Mongo collections) or\n   * whose subject isn't in any contract namespace (e.g. an extra-table\n   * issue raised for a table that exists in the live DB but not in the\n   * contract).\n   *\n   * Downstream planners trust this field as the authoritative subject\n   * coordinate and do not re-derive it by name lookup. A finer-grained\n   * structural split between framework-shared and family-specific issue\n   * fields is tracked under a follow-up ticket.\n   */\n  readonly namespaceId?: string;\n  readonly column?: string;\n  readonly indexOrConstraint?: string;\n  readonly typeName?: string;\n  readonly expected?: string;\n  readonly actual?: string;\n  readonly message: string;\n}\n\nexport interface EnumValuesChangedIssue {\n  readonly kind: 'enum_values_changed';\n  /**\n   * Namespace coordinate of the enum type that changed values. Populated by\n   * family verifiers that have the coordinate in scope when constructing the\n   * issue. Downstream planners trust this field as the authoritative subject\n   * coordinate and do not re-derive it by name lookup.\n   */\n  readonly namespaceId: string;\n  readonly typeName: string;\n  readonly addedValues: readonly string[];\n  readonly removedValues: readonly string[];\n  readonly message: string;\n}\n\nexport type SchemaIssue = BaseSchemaIssue | EnumValuesChangedIssue;\n\nexport interface SchemaVerificationNode {\n  readonly status: 'pass' | 'warn' | 'fail';\n  readonly kind: string;\n  readonly name: string;\n  readonly contractPath: string;\n  readonly code: string;\n  readonly message: string;\n  readonly expected: unknown;\n  readonly actual: unknown;\n  readonly children: readonly SchemaVerificationNode[];\n}\n\nexport interface VerifyDatabaseSchemaResult {\n  readonly ok: boolean;\n  readonly code?: string;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly schema: {\n    readonly issues: readonly SchemaIssue[];\n    readonly root: SchemaVerificationNode;\n    readonly counts: {\n      readonly pass: number;\n      readonly warn: number;\n      readonly fail: number;\n      readonly totalNodes: number;\n    };\n  };\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath?: string;\n    readonly strict: boolean;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface EmitContractResult {\n  readonly contractJson: string;\n  readonly contractDts: string;\n  readonly storageHash: string;\n  readonly executionHash?: string;\n  readonly profileHash: string;\n}\n\nexport interface IntrospectSchemaResult<TSchemaIR> {\n  readonly ok: true;\n  readonly summary: string;\n  readonly target: {\n    readonly familyId: string;\n    readonly id: string;\n  };\n  readonly schema: TSchemaIR;\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly dbUrl?: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nexport interface SignDatabaseResult {\n  readonly ok: boolean;\n  readonly summary: string;\n  readonly contract: {\n    readonly storageHash: string;\n    readonly profileHash?: string;\n  };\n  readonly target: {\n    readonly expected: string;\n    readonly actual?: string;\n  };\n  readonly marker: {\n    readonly created: boolean;\n    readonly updated: boolean;\n    readonly previous?: {\n      readonly storageHash?: string;\n      readonly profileHash?: string;\n    };\n  };\n  readonly meta?: {\n    readonly configPath?: string;\n    readonly contractPath: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n","/**\n * Core schema view types for family-agnostic schema visualization.\n *\n * These types provide a minimal, generic, tree-shaped representation of schemas\n * across families, designed for CLI visualization and lightweight tooling.\n *\n * Families can optionally project their family-specific Schema IR into this\n * core view via the `toSchemaView` method on `FamilyInstance`.\n */\n\nexport type SchemaViewNodeKind =\n  | 'root'\n  | 'namespace'\n  | 'collection'\n  | 'entity'\n  | 'field'\n  | 'index'\n  | 'dependency';\n\nexport interface SchemaTreeVisitor<R> {\n  visit(node: SchemaTreeNode): R;\n}\n\nexport interface SchemaTreeNodeOptions {\n  readonly kind: SchemaViewNodeKind;\n  readonly id: string;\n  readonly label: string;\n  readonly meta?: Record<string, unknown>;\n  readonly children?: readonly SchemaTreeNode[];\n}\n\nexport class SchemaTreeNode {\n  readonly kind: SchemaViewNodeKind;\n  readonly id: string;\n  readonly label: string;\n  readonly meta?: Record<string, unknown>;\n  readonly children?: readonly SchemaTreeNode[];\n\n  constructor(options: SchemaTreeNodeOptions) {\n    this.kind = options.kind;\n    this.id = options.id;\n    this.label = options.label;\n    if (options.meta !== undefined) this.meta = options.meta;\n    if (options.children !== undefined) this.children = options.children;\n    Object.freeze(this);\n  }\n\n  accept<R>(visitor: SchemaTreeVisitor<R>): R {\n    return visitor.visit(this);\n  }\n}\n\n/**\n * Core schema view providing a family-agnostic tree representation of a schema.\n * Used by CLI and cross-family tooling for visualization.\n */\nexport interface CoreSchemaView {\n  readonly root: SchemaTreeNode;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationMetadata, MigrationPlanOperation } from './control-migration-types';\n\n/**\n * Canonical control-plane identifiers for contract spaces.\n *\n * A contract space is the disjoint `(contract.json, migration-graph)` unit\n * the per-space planner / runner / verifier (project: extension contract\n * spaces, TML-2397) operates on. The application owns one well-known\n * space — the value below — and each loaded extension that contributes\n * schema owns a uniquely-named space.\n *\n * Lives in `framework-components/control` so every layer that has to\n * reason about space identity (the migration tooling, the SQL runtime's\n * marker reader, target-side statement builders, target-side adapters)\n * can import a single value rather than duplicating the literal. Raw\n * `'app'` string literals in framework / target / runtime / adapter\n * source code are forbidden and policed by\n * `scripts/lint-app-space-id.mjs` (wired into `pnpm lint:deps`).\n *\n * @see specs/framework-mechanism.spec.md § 3 — Layout convention (γ).\n */\nexport const APP_SPACE_ID = 'app' as const;\n\n/**\n * Head ref for a contract space — the `(hash, invariants)` tuple\n * a runner targets when applying that space's migration graph. Identical\n * in shape to the on-disk `migrations/<space-id>/refs/head.json` the\n * framework writes per loaded extension, and to the app-space\n * `<projectRoot>/refs/head.json`. Family-agnostic: SQL, Mongo, and any\n * future family share the same head-ref shape.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface ContractSpaceHeadRef {\n  readonly hash: string;\n  readonly invariants: readonly string[];\n}\n\n/**\n * Canonical structural shape of a migration package — the unit a planner\n * produces and a runner consumes: a directory name, the metadata\n * envelope, and the operation list.\n *\n * In-memory by default. Readers in `@prisma-next/migration-tools`\n * (`readMigrationPackage` / `readMigrationsDir`) return the augmented\n * {@link import('@prisma-next/migration-tools/package').OnDiskMigrationPackage}\n * variant which adds `dirPath`; everything else operates against the\n * canonical shape so the same value flows through pre-emission\n * authoring, on-disk loading, and runner execution without conversion.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface MigrationPackage {\n  readonly dirName: string;\n  readonly metadata: MigrationMetadata;\n  readonly ops: readonly MigrationPlanOperation[];\n}\n\n/**\n * Canonical structural shape of a contract space — one disjoint\n * `(contractJson, migration-graph)` unit the per-space planner / runner\n * / verifier operates on. The application owns one well-known space\n * ({@link APP_SPACE_ID}); each loaded extension that contributes schema\n * owns a uniquely-named space. Whether a value is the app's space or an\n * extension's space is a control-plane concern; the type carries no\n * such distinction.\n *\n * Generic over the contract so each family pins a typed contract value\n * at consumption time. The SQL family specialises to\n * `ContractSpace<Contract<SqlStorage>>` at the descriptor surface;\n * Mongo's symmetrical `ContractSpace<Contract<MongoStorage>>` will land\n * with that family.\n *\n * @see specs/framework-mechanism.spec.md § 1.\n */\nexport interface ContractSpace<TContract extends Contract = Contract> {\n  readonly contractJson: TContract;\n  readonly migrations: readonly MigrationPackage[];\n  readonly headRef: ContractSpaceHeadRef;\n}\n","import type { Codec } from '../shared/codec';\nimport type { CodecLookup, CodecMeta } from '../shared/codec-types';\nimport type {\n  AuthoringContributions,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '../shared/framework-authoring';\nimport {\n  assertNoCrossRegistryCollisions,\n  isAuthoringEntityTypeDescriptor,\n  isAuthoringFieldPresetDescriptor,\n  isAuthoringTypeConstructorDescriptor,\n  mergeAuthoringNamespaces,\n} from '../shared/framework-authoring';\nimport type { ComponentMetadata } from '../shared/framework-components';\nimport type {\n  ControlMutationDefaultEntry,\n  ControlMutationDefaults,\n  MutationDefaultGeneratorDescriptor,\n} from '../shared/mutation-default-types';\nimport type { TypesImportSpec } from '../shared/types-import-spec';\nimport type {\n  ControlAdapterDescriptor,\n  ControlDriverDescriptor,\n  ControlExtensionDescriptor,\n  ControlFamilyDescriptor,\n  ControlTargetDescriptor,\n} from './control-descriptors';\n\nexport interface AssembledAuthoringContributions {\n  readonly field: AuthoringFieldNamespace;\n  readonly type: AuthoringTypeNamespace;\n  readonly entityTypes: AuthoringEntityTypeNamespace;\n}\n\nexport interface ControlStack<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> {\n  readonly family: ControlFamilyDescriptor<TFamilyId>;\n  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;\n  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly extensionPacks: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[];\n\n  readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;\n  readonly queryOperationTypeImports: ReadonlyArray<TypesImportSpec>;\n  readonly extensionIds: ReadonlyArray<string>;\n  readonly codecLookup: CodecLookup;\n  readonly authoringContributions: AssembledAuthoringContributions;\n  readonly scalarTypeDescriptors: ReadonlyMap<string, string>;\n  readonly controlMutationDefaults: ControlMutationDefaults;\n}\n\nexport interface CreateControlStackInput<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> {\n  readonly family: ControlFamilyDescriptor<TFamilyId>;\n  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;\n  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;\n  readonly extensionPacks?:\n    | ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>\n    | undefined;\n}\n\nfunction addUniqueId(ids: string[], seen: Set<string>, id: string): void {\n  if (!seen.has(id)) {\n    ids.push(id);\n    seen.add(id);\n  }\n}\n\nexport function assertUniqueCodecOwner(options: {\n  readonly codecId: string;\n  readonly owners: Map<string, string>;\n  readonly descriptorId: string;\n  readonly entityLabel: string;\n  readonly entityOwnershipLabel: string;\n}): void {\n  const existingOwner = options.owners.get(options.codecId);\n  if (existingOwner !== undefined) {\n    throw new Error(\n      `Duplicate ${options.entityLabel} for codecId \"${options.codecId}\". ` +\n        `Descriptor \"${options.descriptorId}\" conflicts with \"${existingOwner}\". ` +\n        `Each codecId can only have one ${options.entityOwnershipLabel}.`,\n    );\n  }\n}\n\nexport function extractCodecTypeImports(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const codecTypes = descriptor.types?.codecTypes;\n    if (codecTypes?.import) {\n      imports.push(codecTypes.import);\n    }\n    if (codecTypes?.typeImports) {\n      imports.push(...codecTypes.typeImports);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractQueryOperationTypeImports(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const queryOperationTypes = descriptor.types?.queryOperationTypes;\n    if (queryOperationTypes?.import) {\n      imports.push(queryOperationTypes.import);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractComponentIds(\n  family: { readonly id: string },\n  target: { readonly id: string },\n  adapter: { readonly id: string } | undefined,\n  extensions: ReadonlyArray<{ readonly id: string }>,\n): ReadonlyArray<string> {\n  const ids: string[] = [];\n  const seen = new Set<string>();\n\n  addUniqueId(ids, seen, family.id);\n  addUniqueId(ids, seen, target.id);\n  if (adapter) {\n    addUniqueId(ids, seen, adapter.id);\n  }\n\n  for (const ext of extensions) {\n    addUniqueId(ids, seen, ext.id);\n  }\n\n  return ids;\n}\n\nexport function assembleAuthoringContributions(\n  descriptors: ReadonlyArray<{ readonly authoring?: AuthoringContributions }>,\n): AssembledAuthoringContributions {\n  const field = {} as Record<string, unknown>;\n  const type = {} as Record<string, unknown>;\n  const entityTypes = {} as Record<string, unknown>;\n\n  for (const descriptor of descriptors) {\n    if (descriptor.authoring?.field) {\n      mergeAuthoringNamespaces(\n        field,\n        descriptor.authoring.field,\n        [],\n        isAuthoringFieldPresetDescriptor,\n        'field',\n      );\n    }\n    if (descriptor.authoring?.type) {\n      mergeAuthoringNamespaces(\n        type,\n        descriptor.authoring.type,\n        [],\n        isAuthoringTypeConstructorDescriptor,\n        'type',\n      );\n    }\n    if (descriptor.authoring?.entityTypes) {\n      mergeAuthoringNamespaces(\n        entityTypes,\n        descriptor.authoring.entityTypes,\n        [],\n        isAuthoringEntityTypeDescriptor,\n        'entity',\n      );\n    }\n  }\n\n  const fieldNamespace = field as AuthoringFieldNamespace;\n  const typeNamespace = type as AuthoringTypeNamespace;\n  const entityTypeNamespace = entityTypes as AuthoringEntityTypeNamespace;\n  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace);\n\n  return {\n    field: fieldNamespace,\n    type: typeNamespace,\n    entityTypes: entityTypeNamespace,\n  };\n}\n\nexport function assembleScalarTypeDescriptors(\n  descriptors: ReadonlyArray<\n    Pick<ComponentMetadata, 'scalarTypeDescriptors'> & { readonly id?: string }\n  >,\n): ReadonlyMap<string, string> {\n  const result = new Map<string, string>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    const descriptorMap = descriptor.scalarTypeDescriptors;\n    if (!descriptorMap) continue;\n    const descriptorId = descriptor.id ?? '<unknown>';\n    for (const [typeName, codecId] of descriptorMap) {\n      const existingOwner = owners.get(typeName);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate scalar type descriptor \"${typeName}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      result.set(typeName, codecId);\n      owners.set(typeName, descriptorId);\n    }\n  }\n\n  return result;\n}\n\nexport function assembleControlMutationDefaults(\n  descriptors: ReadonlyArray<\n    Pick<ComponentMetadata, 'controlMutationDefaults'> & { readonly id?: string }\n  >,\n): ControlMutationDefaults {\n  const defaultFunctionRegistry = new Map<string, ControlMutationDefaultEntry>();\n  const functionOwners = new Map<string, string>();\n  const generatorMap = new Map<string, MutationDefaultGeneratorDescriptor>();\n  const generatorOwners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    const contributions = descriptor.controlMutationDefaults;\n    if (!contributions) continue;\n    const descriptorId = descriptor.id ?? '<unknown>';\n\n    for (const generatorDescriptor of contributions.generatorDescriptors) {\n      const existingOwner = generatorOwners.get(generatorDescriptor.id);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate mutation default generator id \"${generatorDescriptor.id}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      generatorMap.set(generatorDescriptor.id, generatorDescriptor);\n      generatorOwners.set(generatorDescriptor.id, descriptorId);\n    }\n\n    for (const [functionName, handler] of contributions.defaultFunctionRegistry) {\n      const existingOwner = functionOwners.get(functionName);\n      if (existingOwner !== undefined) {\n        throw new Error(\n          `Duplicate mutation default function \"${functionName}\". ` +\n            `Descriptor \"${descriptorId}\" conflicts with \"${existingOwner}\".`,\n        );\n      }\n      defaultFunctionRegistry.set(functionName, handler);\n      functionOwners.set(functionName, descriptorId);\n    }\n  }\n\n  return {\n    defaultFunctionRegistry,\n    generatorDescriptors: Array.from(generatorMap.values()),\n  };\n}\n\nexport function extractCodecLookup(\n  descriptors: ReadonlyArray<Pick<ComponentMetadata & { id: string }, 'types' | 'id'>>,\n): CodecLookup {\n  const byId = new Map<string, Codec>();\n  const targetTypesById = new Map<string, readonly string[]>();\n  const metaById = new Map<string, CodecMeta>();\n  const renderersById = new Map<string, (params: Record<string, unknown>) => string | undefined>();\n  const owners = new Map<string, string>();\n  for (const descriptor of descriptors) {\n    const codecTypes = descriptor.types?.codecTypes;\n    const descriptorId = descriptor.id;\n    // Descriptor-side metadata is the single source of truth for `targetTypes` / `meta` / `renderOutputType`. Every contributor ships a `codecDescriptors` list on `types.codecTypes`.\n    for (const codecDescriptor of codecTypes?.codecDescriptors ?? []) {\n      assertUniqueCodecOwner({\n        codecId: codecDescriptor.codecId,\n        owners,\n        descriptorId,\n        entityLabel: 'codec descriptor',\n        entityOwnershipLabel: 'codec descriptor provider',\n      });\n      owners.set(codecDescriptor.codecId, descriptorId);\n      if (Array.isArray(codecDescriptor.targetTypes)) {\n        targetTypesById.set(codecDescriptor.codecId, codecDescriptor.targetTypes);\n      }\n      if (codecDescriptor.meta !== undefined) {\n        metaById.set(codecDescriptor.codecId, codecDescriptor.meta);\n      }\n      if (typeof codecDescriptor.renderOutputType === 'function') {\n        renderersById.set(codecDescriptor.codecId, codecDescriptor.renderOutputType);\n      }\n      // Materialize a representative `Codec` instance for `byId.get()` so consumers reading the lookup's instance side (e.g. SQL renderer's cast-policy lookup, or the contract emitter's literal-default `encodeJson` resolver) keep finding the codec.\n      //\n      // Two cohorts:\n      // - Non-parameterized descriptors: factory must succeed; any throw is a real bug and we let it propagate (no silent try/catch).\n      // - Parameterized descriptors: try with empty params. Many parameterized codecs treat params as advisory (e.g. `pg/timestamptz@1` whose precision is rendered into the `nativeType` only and never read by the runtime codec), so an empty-params construction yields a usable representative for id-keyed lookups (e.g. emit-time literal-default encoding). Codecs whose factory genuinely requires params (e.g. `pg/vector@1` threading `length` into the runtime codec) will throw; for those, per-column instances are materialized at runtime by `buildContractCodecRegistry` and the id-keyed lookup miss is correct (the column-aware path resolves them).\n      if (!byId.has(codecDescriptor.codecId)) {\n        if (codecDescriptor.isParameterized) {\n          try {\n            const representative = codecDescriptor.factory({} as never)({\n              name: `<lookup:${codecDescriptor.codecId}>`,\n            } as Parameters<ReturnType<typeof codecDescriptor.factory>>[0]);\n            byId.set(codecDescriptor.codecId, representative);\n          } catch {\n            // Factory requires concrete params; skip representative materialization. Per-column instances are built at runtime; id-keyed lookup miss is the correct outcome here.\n          }\n        } else {\n          const representative = codecDescriptor.factory(undefined as never)({\n            name: `<lookup:${codecDescriptor.codecId}>`,\n          } as Parameters<ReturnType<typeof codecDescriptor.factory>>[0]);\n          byId.set(codecDescriptor.codecId, representative);\n        }\n      }\n    }\n  }\n  return {\n    get: (id) => byId.get(id),\n    targetTypesFor: (id) => targetTypesById.get(id),\n    metaFor: (id) => metaById.get(id),\n    renderOutputTypeFor: (id, params) => renderersById.get(id)?.(params),\n  };\n}\n\nexport function validateScalarTypeCodecIds(\n  scalarTypeDescriptors: ReadonlyMap<string, string>,\n  codecLookup: CodecLookup,\n): string[] {\n  const errors: string[] = [];\n  for (const [typeName, codecId] of scalarTypeDescriptors) {\n    if (!codecLookup.get(codecId)) {\n      errors.push(\n        `Scalar type \"${typeName}\" references codec \"${codecId}\" which is not registered by any component.`,\n      );\n    }\n  }\n  return errors;\n}\n\nexport function createControlStack<TFamilyId extends string, TTargetId extends string>(\n  input: CreateControlStackInput<TFamilyId, TTargetId>,\n): ControlStack<TFamilyId, TTargetId> {\n  const { family, target, adapter, driver, extensionPacks = [] } = input;\n\n  const allDescriptors = [family, target, ...(adapter ? [adapter] : []), ...extensionPacks];\n\n  const codecLookup = extractCodecLookup(allDescriptors);\n  const scalarTypeDescriptors = assembleScalarTypeDescriptors(allDescriptors);\n\n  return {\n    family,\n    target,\n    adapter,\n    driver,\n    extensionPacks: extensionPacks as readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[],\n\n    codecTypeImports: extractCodecTypeImports(allDescriptors),\n    queryOperationTypeImports: extractQueryOperationTypeImports(allDescriptors),\n    extensionIds: extractComponentIds(family, target, adapter, extensionPacks),\n    codecLookup,\n    authoringContributions: assembleAuthoringContributions(allDescriptors),\n    scalarTypeDescriptors,\n    controlMutationDefaults: assembleControlMutationDefaults(allDescriptors),\n  };\n}\n"],"mappings":";;AAuBA,SAAgB,cACd,QAC4D;CAC5D,OAAO,gBAAgB,UAAU,CAAC,CAAE,OAAmC;AACzE;AAMA,SAAgB,cACd,UACwF;CACxF,OACE,kBAAkB,YAClB,OAAQ,SAAqC,oBAAoB;AAErE;AAUA,SAAgB,oBACd,UAC8F;CAC9F,OACE,sBAAsB,YACtB,OAAQ,SAAqC,wBAAwB;AAEzE;AAWA,SAAgB,oBACd,UACmF;CACnF,OACE,wBAAwB,YACxB,OAAQ,SAAqC,0BAA0B;AAE3E;;;;;;;;;;;;AAaA,SAAgB,oBACd,QACiG;CACjG,OACE,yBAAyB,UACzB,OAAQ,OAAmC,2BAA2B;AAE1E;;;AC/FA,MAAa,6BAA6B;AAC1C,MAAa,4BAA4B;AACzC,MAAa,8BAA8B;AAC3C,MAAa,6BAA6B;;;AC4B1C,IAAa,iBAAb,MAA4B;CAC1B;CACA;CACA;CACA;CACA;CAEA,YAAY,SAAgC;EAC1C,KAAK,OAAO,QAAQ;EACpB,KAAK,KAAK,QAAQ;EAClB,KAAK,QAAQ,QAAQ;EACrB,IAAI,QAAQ,SAAS,KAAA,GAAW,KAAK,OAAO,QAAQ;EACpD,IAAI,QAAQ,aAAa,KAAA,GAAW,KAAK,WAAW,QAAQ;EAC5D,OAAO,OAAO,IAAI;CACpB;CAEA,OAAU,SAAkC;EAC1C,OAAO,QAAQ,MAAM,IAAI;CAC3B;AACF;;;;;;;;;;;;;;;;;;;;;;AC5BA,MAAa,eAAe;;;AC8C5B,SAAS,YAAY,KAAe,MAAmB,IAAkB;CACvE,IAAI,CAAC,KAAK,IAAI,EAAE,GAAG;EACjB,IAAI,KAAK,EAAE;EACX,KAAK,IAAI,EAAE;CACb;AACF;AAEA,SAAgB,uBAAuB,SAM9B;CACP,MAAM,gBAAgB,QAAQ,OAAO,IAAI,QAAQ,OAAO;CACxD,IAAI,kBAAkB,KAAA,GACpB,MAAM,IAAI,MACR,aAAa,QAAQ,YAAY,gBAAgB,QAAQ,QAAQ,iBAChD,QAAQ,aAAa,oBAAoB,cAAc,oCACpC,QAAQ,qBAAqB,EACnE;AAEJ;AAEA,SAAgB,wBACd,aACgC;CAChC,MAAM,UAA6B,CAAC;CAEpC,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,aAAa,WAAW,OAAO;EACrC,IAAI,YAAY,QACd,QAAQ,KAAK,WAAW,MAAM;EAEhC,IAAI,YAAY,aACd,QAAQ,KAAK,GAAG,WAAW,WAAW;CAE1C;CAEA,OAAO;AACT;AAEA,SAAgB,iCACd,aACgC;CAChC,MAAM,UAA6B,CAAC;CAEpC,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,sBAAsB,WAAW,OAAO;EAC9C,IAAI,qBAAqB,QACvB,QAAQ,KAAK,oBAAoB,MAAM;CAE3C;CAEA,OAAO;AACT;AAEA,SAAgB,oBACd,QACA,QACA,SACA,YACuB;CACvB,MAAM,MAAgB,CAAC;CACvB,MAAM,uBAAO,IAAI,IAAY;CAE7B,YAAY,KAAK,MAAM,OAAO,EAAE;CAChC,YAAY,KAAK,MAAM,OAAO,EAAE;CAChC,IAAI,SACF,YAAY,KAAK,MAAM,QAAQ,EAAE;CAGnC,KAAK,MAAM,OAAO,YAChB,YAAY,KAAK,MAAM,IAAI,EAAE;CAG/B,OAAO;AACT;AAEA,SAAgB,+BACd,aACiC;CACjC,MAAM,QAAQ,CAAC;CACf,MAAM,OAAO,CAAC;CACd,MAAM,cAAc,CAAC;CAErB,KAAK,MAAM,cAAc,aAAa;EACpC,IAAI,WAAW,WAAW,OACxB,yBACE,OACA,WAAW,UAAU,OACrB,CAAC,GACD,kCACA,OACF;EAEF,IAAI,WAAW,WAAW,MACxB,yBACE,MACA,WAAW,UAAU,MACrB,CAAC,GACD,sCACA,MACF;EAEF,IAAI,WAAW,WAAW,aACxB,yBACE,aACA,WAAW,UAAU,aACrB,CAAC,GACD,iCACA,QACF;CAEJ;CAEA,MAAM,iBAAiB;CACvB,MAAM,gBAAgB;CACtB,MAAM,sBAAsB;CAC5B,gCAAgC,eAAe,gBAAgB,mBAAmB;CAElF,OAAO;EACL,OAAO;EACP,MAAM;EACN,aAAa;CACf;AACF;AAEA,SAAgB,8BACd,aAG6B;CAC7B,MAAM,yBAAS,IAAI,IAAoB;CACvC,MAAM,yBAAS,IAAI,IAAoB;CAEvC,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,gBAAgB,WAAW;EACjC,IAAI,CAAC,eAAe;EACpB,MAAM,eAAe,WAAW,MAAM;EACtC,KAAK,MAAM,CAAC,UAAU,YAAY,eAAe;GAC/C,MAAM,gBAAgB,OAAO,IAAI,QAAQ;GACzC,IAAI,kBAAkB,KAAA,GACpB,MAAM,IAAI,MACR,qCAAqC,SAAS,iBAC7B,aAAa,oBAAoB,cAAc,GAClE;GAEF,OAAO,IAAI,UAAU,OAAO;GAC5B,OAAO,IAAI,UAAU,YAAY;EACnC;CACF;CAEA,OAAO;AACT;AAEA,SAAgB,gCACd,aAGyB;CACzB,MAAM,0CAA0B,IAAI,IAAyC;CAC7E,MAAM,iCAAiB,IAAI,IAAoB;CAC/C,MAAM,+BAAe,IAAI,IAAgD;CACzE,MAAM,kCAAkB,IAAI,IAAoB;CAEhD,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,gBAAgB,WAAW;EACjC,IAAI,CAAC,eAAe;EACpB,MAAM,eAAe,WAAW,MAAM;EAEtC,KAAK,MAAM,uBAAuB,cAAc,sBAAsB;GACpE,MAAM,gBAAgB,gBAAgB,IAAI,oBAAoB,EAAE;GAChE,IAAI,kBAAkB,KAAA,GACpB,MAAM,IAAI,MACR,4CAA4C,oBAAoB,GAAG,iBAClD,aAAa,oBAAoB,cAAc,GAClE;GAEF,aAAa,IAAI,oBAAoB,IAAI,mBAAmB;GAC5D,gBAAgB,IAAI,oBAAoB,IAAI,YAAY;EAC1D;EAEA,KAAK,MAAM,CAAC,cAAc,YAAY,cAAc,yBAAyB;GAC3E,MAAM,gBAAgB,eAAe,IAAI,YAAY;GACrD,IAAI,kBAAkB,KAAA,GACpB,MAAM,IAAI,MACR,wCAAwC,aAAa,iBACpC,aAAa,oBAAoB,cAAc,GAClE;GAEF,wBAAwB,IAAI,cAAc,OAAO;GACjD,eAAe,IAAI,cAAc,YAAY;EAC/C;CACF;CAEA,OAAO;EACL;EACA,sBAAsB,MAAM,KAAK,aAAa,OAAO,CAAC;CACxD;AACF;AAEA,SAAgB,mBACd,aACa;CACb,MAAM,uBAAO,IAAI,IAAmB;CACpC,MAAM,kCAAkB,IAAI,IAA+B;CAC3D,MAAM,2BAAW,IAAI,IAAuB;CAC5C,MAAM,gCAAgB,IAAI,IAAqE;CAC/F,MAAM,yBAAS,IAAI,IAAoB;CACvC,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,aAAa,WAAW,OAAO;EACrC,MAAM,eAAe,WAAW;EAEhC,KAAK,MAAM,mBAAmB,YAAY,oBAAoB,CAAC,GAAG;GAChE,uBAAuB;IACrB,SAAS,gBAAgB;IACzB;IACA;IACA,aAAa;IACb,sBAAsB;GACxB,CAAC;GACD,OAAO,IAAI,gBAAgB,SAAS,YAAY;GAChD,IAAI,MAAM,QAAQ,gBAAgB,WAAW,GAC3C,gBAAgB,IAAI,gBAAgB,SAAS,gBAAgB,WAAW;GAE1E,IAAI,gBAAgB,SAAS,KAAA,GAC3B,SAAS,IAAI,gBAAgB,SAAS,gBAAgB,IAAI;GAE5D,IAAI,OAAO,gBAAgB,qBAAqB,YAC9C,cAAc,IAAI,gBAAgB,SAAS,gBAAgB,gBAAgB;GAO7E,IAAI,CAAC,KAAK,IAAI,gBAAgB,OAAO,GACnC,IAAI,gBAAgB,iBAClB,IAAI;IACF,MAAM,iBAAiB,gBAAgB,QAAQ,CAAC,CAAU,EAAE,EAC1D,MAAM,WAAW,gBAAgB,QAAQ,GAC3C,CAA8D;IAC9D,KAAK,IAAI,gBAAgB,SAAS,cAAc;GAClD,QAAQ,CAER;QACK;IACL,MAAM,iBAAiB,gBAAgB,QAAQ,KAAA,CAAkB,EAAE,EACjE,MAAM,WAAW,gBAAgB,QAAQ,GAC3C,CAA8D;IAC9D,KAAK,IAAI,gBAAgB,SAAS,cAAc;GAClD;EAEJ;CACF;CACA,OAAO;EACL,MAAM,OAAO,KAAK,IAAI,EAAE;EACxB,iBAAiB,OAAO,gBAAgB,IAAI,EAAE;EAC9C,UAAU,OAAO,SAAS,IAAI,EAAE;EAChC,sBAAsB,IAAI,WAAW,cAAc,IAAI,EAAE,IAAI,MAAM;CACrE;AACF;AAiBA,SAAgB,mBACd,OACoC;CACpC,MAAM,EAAE,QAAQ,QAAQ,SAAS,QAAQ,iBAAiB,CAAC,MAAM;CAEjE,MAAM,iBAAiB;EAAC;EAAQ;EAAQ,GAAI,UAAU,CAAC,OAAO,IAAI,CAAC;EAAI,GAAG;CAAc;CAExF,MAAM,cAAc,mBAAmB,cAAc;CACrD,MAAM,wBAAwB,8BAA8B,cAAc;CAE1E,OAAO;EACL;EACA;EACA;EACA;EACgB;EAEhB,kBAAkB,wBAAwB,cAAc;EACxD,2BAA2B,iCAAiC,cAAc;EAC1E,cAAc,oBAAoB,QAAQ,QAAQ,SAAS,cAAc;EACzE;EACA,wBAAwB,+BAA+B,cAAc;EACrE;EACA,yBAAyB,gCAAgC,cAAc;CACzE;AACF"}