@prisma-next/framework-components 0.5.0-dev.60 → 0.5.0-dev.61

package/src/shared/column-spec.ts

@@ -0,0 +1,83 @@
+/**
+ * `column()` packager + `ColumnSpec<R, P>` shape + `ColumnHelperFor<D>` variants for tying per-codec column helpers to their descriptor.
+ *
+ * `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).
+ *
+ * `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>`.
+ */
+
+import type { CodecDescriptor } from './codec-descriptor';
+import type { CodecInstanceContext } from './codec-types';
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * @template TCodecId Narrowed codec id literal for sites that thread a specific codec id through the type system.
+ */
+export type ColumnTypeDescriptor<TCodecId extends string = string> = {
+  readonly codecId: TCodecId;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown> | undefined;
+  readonly typeRef?: string;
+};
+
+/**
+ * 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`.
+ *
+ * Extends {@link ColumnTypeDescriptor} so `ColumnSpec` instances flow directly into contract-authoring sites that consume the descriptor shape — no structural mirroring required.
+ */
+export interface ColumnSpec<R, P extends Record<string, unknown> | undefined>
+  extends ColumnTypeDescriptor {
+  readonly codecFactory: (ctx: CodecInstanceContext) => R;
+  readonly typeParams: P;
+}
+
+/**
+ * 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`.
+ *
+ * `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.
+ */
+export function column<R, P extends Record<string, unknown> | undefined>(
+  codecFactory: (ctx: CodecInstanceContext) => R,
+  codecId: string,
+  typeParams: P,
+  nativeType: string,
+): ColumnSpec<R, P> {
+  return {
+    codecFactory,
+    codecId,
+    typeParams,
+    nativeType,
+  };
+}
+
+/**
+ * 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`).
+ *
+ * Use when the codec's `ReturnType<factory>` is unstable (e.g. heavily overloaded factories where extraction widens too much).
+ */
+// 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
+export type ColumnHelperFor<D extends CodecDescriptor<any>> = (
+  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference
+  ...args: any[]
+) => ColumnSpec<unknown, ColumnHelperParams<D>>;
+
+/**
+ * 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`.
+ */
+// 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
+export type ColumnHelperForStrict<D extends CodecDescriptor<any>> = (
+  // biome-ignore lint/suspicious/noExplicitAny: helper signature is the verification subject; satisfies clauses can't narrow this without circular inference
+  ...args: any[]
+) => ColumnSpec<ReturnType<ReturnType<D['factory']>>, ColumnHelperParams<D>>;
+
+/**
+ * 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.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: variance erasure — see above
+type ColumnHelperParams<D extends CodecDescriptor<any>> =
+  Parameters<D['factory']>[0] extends Record<string, unknown>
+    ? Parameters<D['factory']>[0]
+    : undefined;

package/src/shared/framework-components.ts

@@ -1,4 +1,4 @@
-import type { Codec } from './codec-types';
+import type { AnyCodecDescriptor } from './codec-descriptor';
 import type { AuthoringContributions } from './framework-authoring';
 import type { ControlMutationDefaults } from './mutation-default-types';
 import type { TypesImportSpec } from './types-import-spec';
@@ -13,10 +13,7 @@ export interface ComponentMetadata {
   /**
    * Capabilities this component provides.
    *
-   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into
-   * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);
-   * keep these declarations in sync. Targets are identifiers/descriptors and typically do not
-   * declare capabilities.
+   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`); keep these declarations in sync. Targets are identifiers/descriptors and typically do not declare capabilities.
    */
   readonly capabilities?: Record<string, unknown>;
 
@@ -24,29 +21,25 @@ export interface ComponentMetadata {
   readonly types?: {
     readonly codecTypes?: {
       /**
-       * Base codec types import spec.
-       * Optional: adapters typically provide this, extensions usually don't.
+       * Base codec types import spec. Optional: adapters typically provide this, extensions usually don't.
        */
       readonly import?: TypesImportSpec;
       /**
        * Additional type-only imports for parameterized codec branded types.
        *
-       * These imports are included in generated `contract.d.ts` but are NOT treated as
-       * codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).
+       * These imports are included in generated `contract.d.ts` but are NOT treated as codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).
        *
        * Example: `Vector<N>` for pgvector codecs that emit `Vector<1536>`
        */
       readonly typeImports?: ReadonlyArray<TypesImportSpec>;
       /**
-       * Optional control-plane hooks keyed by codecId.
-       * Used by family-specific planners/verifiers to handle storage types.
+       * Optional control-plane hooks keyed by codecId. Used by family-specific planners/verifiers to handle storage types.
        */
       readonly controlPlaneHooks?: Record<string, unknown>;
       /**
-       * Codec instances contributed by this component.
-       * Used to build a CodecLookup for codec-dispatched type rendering during emission.
+       * Codec descriptors contributed by this component. Source of truth for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`, `renderOutputType`) consumed by `extractCodecLookup`, and used to materialize representative `Codec` instances for codec-dispatched type rendering during emission.
        */
-      readonly codecInstances?: ReadonlyArray<Codec>;
+      readonly codecDescriptors?: ReadonlyArray<AnyCodecDescriptor>;
     };
     readonly operationTypes?: { readonly import: TypesImportSpec };
     readonly queryOperationTypes?: { readonly import: TypesImportSpec };
@@ -61,21 +54,17 @@ export interface ComponentMetadata {
   /**
    * Optional pure-data authoring contributions exposed by this component.
    *
-   * These contributions are safe to include on pack refs and descriptors because
-   * they contain only declarative metadata. Higher-level authoring packages may
-   * project them into concrete helper functions for TS-first workflows.
+   * These contributions are safe to include on pack refs and descriptors because they contain only declarative metadata. Higher-level authoring packages may project them into concrete helper functions for TS-first workflows.
    */
   readonly authoring?: AuthoringContributions;
 
   /**
-   * Scalar type name to codec ID mapping contributed by this component.
-   * Assembled by `createControlStack` with duplicate detection.
+   * Scalar type name to codec ID mapping contributed by this component. Assembled by `createControlStack` with duplicate detection.
    */
   readonly scalarTypeDescriptors?: ReadonlyMap<string, string>;
 
   /**
-   * Mutation default function handlers and generator descriptors contributed
-   * by this component. Assembled by `createControlStack` with duplicate detection.
+   * Mutation default function handlers and generator descriptors contributed by this component. Assembled by `createControlStack` with duplicate detection.
    */
   readonly controlMutationDefaults?: ControlMutationDefaults;
 }
@@ -83,13 +72,9 @@ export interface ComponentMetadata {
 /**
  * Base descriptor for any framework component.
  *
- * All component descriptors share these fundamental properties that identify
- * the component and provide its metadata. This interface is extended by
- * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).
+ * All component descriptors share these fundamental properties that identify the component and provide its metadata. This interface is extended by specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).
  *
- * @template Kind - Discriminator literal identifying the component type.
- *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',
- *   but the type accepts any string to allow ecosystem extensions.
+ * @template Kind - Discriminator literal identifying the component type. Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension', but the type accepts any string to allow ecosystem extensions.
  *
  * @example
  * ```ts
@@ -163,14 +148,12 @@ export function checkContractComponentRequirements(
 /**
  * Descriptor for a family component.
  *
- * A "family" represents a category of data sources with shared semantics
- * (e.g., SQL databases, document stores). Families define:
+ * A "family" represents a category of data sources with shared semantics (e.g., SQL databases, document stores). Families define:
  * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)
  * - Contract structure (tables vs collections, columns vs fields)
  * - Type system and codecs
  *
- * Families are the top-level grouping. Each family contains multiple targets
- * (e.g., SQL family contains Postgres, MySQL, SQLite targets).
+ * Families are the top-level grouping. Each family contains multiple targets (e.g., SQL family contains Postgres, MySQL, SQLite targets).
  *
  * Extended by plane-specific descriptors:
  * - `ControlFamilyDescriptor` - adds `emission` for CLI/tooling operations
@@ -195,13 +178,11 @@ export interface FamilyDescriptor<TFamilyId extends string> extends ComponentDes
 /**
  * Descriptor for a target component.
  *
- * A "target" represents a specific database or data store within a family
- * (e.g., Postgres, MySQL, MongoDB). Targets define:
+ * A "target" represents a specific database or data store within a family (e.g., Postgres, MySQL, MongoDB). Targets define:
  * - Native type mappings (e.g., Postgres int4 → TypeScript number)
  * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)
  *
- * Targets are bound to a family and provide the target-specific implementation
- * details that adapters and drivers use.
+ * Targets are bound to a family and provide the target-specific implementation details that adapters and drivers use.
  *
  * Extended by plane-specific descriptors:
  * - `ControlTargetDescriptor` - adds optional `migrations` capability
@@ -229,8 +210,7 @@ export interface TargetDescriptor<TFamilyId extends string, TTargetId extends st
 }
 
 /**
- * Base shape for any pack reference.
- * Pack refs are pure JSON-friendly objects safe to import in authoring flows.
+ * Base shape for any pack reference. Pack refs are pure JSON-friendly objects safe to import in authoring flows.
  */
 export interface PackRefBase<Kind extends string, TFamilyId extends string>
   extends ComponentMetadata {
@@ -274,14 +254,12 @@ export type DriverPackRef<
 /**
  * Descriptor for an adapter component.
  *
- * An "adapter" provides the protocol and dialect implementation for a target.
- * Adapters handle:
+ * An "adapter" provides the protocol and dialect implementation for a target. Adapters handle:
  * - SQL/query generation (lowering AST to target-specific syntax)
  * - Codec registration (encoding/decoding between JS and wire types)
  * - Type mappings and coercions
  *
- * Adapters are bound to a specific family+target combination and work with
- * any compatible driver for that target.
+ * Adapters are bound to a specific family+target combination and work with any compatible driver for that target.
  *
  * Extended by plane-specific descriptors:
  * - `ControlAdapterDescriptor` - control-plane factory
@@ -311,16 +289,13 @@ export interface AdapterDescriptor<TFamilyId extends string, TTargetId extends s
 /**
  * Descriptor for a driver component.
  *
- * A "driver" provides the connection and execution layer for a target.
- * Drivers handle:
+ * A "driver" provides the connection and execution layer for a target. Drivers handle:
  * - Connection management (pooling, timeouts, retries)
  * - Query execution (sending SQL/commands, receiving results)
  * - Transaction management
  * - Wire protocol communication
  *
- * Drivers are bound to a specific family+target and work with any compatible
- * adapter. Multiple drivers can exist for the same target (e.g., node-postgres
- * vs postgres.js for Postgres).
+ * Drivers are bound to a specific family+target and work with any compatible adapter. Multiple drivers can exist for the same target (e.g., node-postgres vs postgres.js for Postgres).
  *
  * Extended by plane-specific descriptors:
  * - `ControlDriverDescriptor` - creates driver from connection URL
@@ -355,8 +330,7 @@ export interface DriverDescriptor<TFamilyId extends string, TTargetId extends st
  * - Custom types and codecs (e.g., vector type)
  * - Extended query capabilities
  *
- * Extensions are bound to a specific family+target and are registered in the
- * config alongside the core components. Multiple extensions can be used together.
+ * Extensions are bound to a specific family+target and are registered in the config alongside the core components. Multiple extensions can be used together.
  *
  * Extended by plane-specific descriptors:
  * - `ControlExtensionDescriptor` - control-plane extension factory

package/dist/codec-types-MWvfFmu1.d.mts

@@ -1,207 +0,0 @@
-import { JsonValue } from "@prisma-next/contract/types";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/shared/codec-types.d.ts
-type CodecTrait = 'equality' | 'order' | 'boolean' | 'numeric' | 'textual'
-/**
- * The codec carries a per-instance `validate(value: unknown) =>
- * JsonSchemaValidationResult` function on the resolved codec object that
- * the framework's `JsonSchemaValidatorRegistry` consults at runtime. The
- * trait gates the `extractValidator` cast from structurally-typed
- * `unknown` to a typed validator view.
- *
- * Retirement target. The unified `CodecDescriptor` model moves
- * validation into the resolved codec's `decode` body; the parallel
- * `JsonSchemaValidatorRegistry` (and this trait alongside it) retires
- * under TML-2357 (T3.5.12). Per-library JSON extensions like
- * `@prisma-next/extension-arktype-json` already follow the new pattern.
- */ | 'json-validator';
-/**
- * Per-call context the runtime threads to every `codec.encode` /
- * `codec.decode` invocation for a single `runtime.execute()` call.
- *
- * The framework-level shape is family-agnostic and carries one field:
- *
- * - `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.
- *
- * 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.
- *
- * The interface is named explicitly (not inlined) so future framework
- * fields and family extensions can land additively without breaking
- * codec author signatures.
- */
-interface CodecCallContext {
-  readonly signal?: AbortSignal;
-}
-/**
- * A codec is the contract between an application value and its on-wire and
- * on-contract-disk representations.
- *
- * 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.
- *
- * Three representations participate:
- * - **Input** (`TInput`): the JS type at the application boundary.
- * - **Wire** (`TWire`): the format exchanged with the database driver.
- * - **JSON** (`JsonValue`): a JSON-safe form used in contract artifacts.
- *
- * Codec methods split into two groups:
- *
- * - **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.
- * - **Build-time** methods (`encodeJson`, `decodeJson`, `renderOutputType`)
- *   run when the contract is serialized, loaded, or when client types are
- *   emitted. They stay synchronous so contract validation and client
- *   construction are synchronous.
- *
- * Target-family codec interfaces extend this base with target-shaped
- * metadata.
- */
-interface Codec<Id extends string = string, TTraits extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TInput = unknown> {
-  /** Unique codec identifier in `namespace/name@version` format (e.g. `pg/timestamptz@1`). */
-  readonly id: Id;
-  /** Database-native type names this codec handles (e.g. `['timestamptz']`). */
-  readonly targetTypes: readonly string[];
-  /** Semantic traits for operator gating (e.g. equality, order, numeric). */
-  readonly traits?: TTraits;
-  /** 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. */
-  encode(value: TInput, ctx: CodecCallContext): Promise<TWire>;
-  /** 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. */
-  decode(wire: TWire, ctx: CodecCallContext): Promise<TInput>;
-  /** Converts a JS value to a JSON-safe representation for contract serialization. Synchronous; called during contract emission. */
-  encodeJson(value: TInput): JsonValue;
-  /** Converts a JSON representation back to the JS input type. Synchronous; called during contract loading via `validateContract`. */
-  decodeJson(json: JsonValue): TInput;
-  /** Produces the TypeScript output type expression for a field given its `typeParams`. Synchronous; used during contract.d.ts emission. */
-  renderOutputType?(typeParams: Record<string, unknown>): string | undefined;
-}
-interface CodecLookup {
-  get(id: string): Codec | undefined;
-}
-declare const emptyCodecLookup: CodecLookup;
-/**
- * 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.
- *
- * - `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, the synthesized
- *   anonymous instance name (`<anon:Document.embedding>`) for inline-
- *   `typeParams` columns, or a shared sentinel (`<shared:pg/text@1>`)
- *   for non-parameterized codec ids. Other families pick the analogous
- *   identity for their materialization sites.
- *
- * 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.
- */
-interface CodecInstanceContext {
-  readonly name: string;
-}
-/**
- * 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.
- */
-interface CodecMeta {
-  readonly db?: Record<string, unknown>;
-}
-/**
- * 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.
- *
- * 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.
- *
- * 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.
- *
- * @template P - The shape of the params accepted by the factory (`void` for
- *   non-parameterized codecs; a record like `{ length: number }` for
- *   parameterized codecs).
- *
- * Codec-registry-unification project § Decision.
- */
-interface CodecDescriptor<P = void> {
-  /** The codec ID this descriptor applies to (e.g. `pg/vector@1`, `pg/text@1`). */
-  readonly codecId: string;
-  /** Semantic traits for operator gating (e.g. equality, order, numeric). */
-  readonly traits: readonly CodecTrait[];
-  /** Database-native type names this codec handles (e.g. `['timestamptz']`). */
-  readonly targetTypes: readonly string[];
-  /** Optional family-specific metadata (e.g. SQL-side `db.sql.postgres.nativeType`). */
-  readonly meta?: CodecMeta;
-  /**
-   * 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.
-   */
-  readonly paramsSchema: StandardSchemaV1<P>;
-  /**
-   * 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.
-   */
-  readonly renderOutputType?: (params: P) => string | undefined;
-  /**
-   * 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.
-   */
-  readonly factory: (params: P) => (ctx: CodecInstanceContext) => Codec;
-}
-/**
- * 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.
- */
-declare const voidParamsSchema: StandardSchemaV1<void>;
-/**
- * Synthesize a `CodecDescriptor<void>` for a non-parameterized codec
- * runtime instance. The factory is constant — every call returns the same
- * shared codec instance — so columns sharing this codec id share one
- * resolved codec.
- *
- * Codec-registry-unification spec § Decision (Case T — non-parameterized
- * text codec). This is the bridge while non-parameterized codec
- * contributors still register through the legacy `codecs:` slot; once they
- * migrate to ship descriptors directly (TML-2357 T3.5.3), this synthesis
- * steps aside.
- */
-declare function synthesizeNonParameterizedDescriptor(codec: Codec): CodecDescriptor<void>;
-//#endregion
-export { CodecLookup as a, emptyCodecLookup as c, CodecInstanceContext as i, synthesizeNonParameterizedDescriptor as l, CodecCallContext as n, CodecMeta as o, CodecDescriptor as r, CodecTrait as s, Codec as t, voidParamsSchema as u };
-//# sourceMappingURL=codec-types-MWvfFmu1.d.mts.map

package/dist/codec-types-MWvfFmu1.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-MWvfFmu1.d.mts","names":[],"sources":["../src/shared/codec-types.ts"],"sourcesContent":[],"mappings":";;;;KAGY,UAAA;;AAAZ;AA4CA;AAiCA;;;;;;;;;MAe2B,gBAAA;;;;;;;;;AAS3B;AAIA;AAuBA;AASA;AA6BA;;;;;;;;;;AAyCA;AA6BgB,UAhMC,gBAAA,CAgMD;oBA/LI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCH,2DAEU,wBAAwB;;eAKpC;;;;oBAIK;;gBAEJ,aAAa,mBAAmB,QAAQ;;eAEzC,YAAY,mBAAmB,QAAQ;;oBAElC,SAAS;;mBAEV,YAAY;;gCAEC;;UAGf,WAAA;mBACE;;cAGN,kBAAkB;;;;;;;;;;;;;;;;;;;;UAuBd,oBAAA;;;;;;;;UASA,SAAA;gBACD;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BC;;;;4BAIW;;;;kBAIV;;;;;;;;yBAQO,iBAAiB;;;;;;;uCAOH;;;;;;;;6BAQV,YAAY,yBAAyB;;;;;;;;;cAUrD,kBAAkB;;;;;;;;;;;;;iBA6Bf,oCAAA,QAA4C,QAAQ"}

package/dist/framework-components-BvzjH6Pt.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-components-BvzjH6Pt.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"sourcesContent":[],"mappings":"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"}