@prisma-next/sql-runtime 0.5.0-dev.7 → 0.5.0-dev.71

package/src/sql-context.ts

@@ -1,4 +1,5 @@
 import type { Contract, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type { AnyCodecDescriptor, CodecDescriptor } from '@prisma-next/framework-components/codec';
 import type { ComponentDescriptor } from '@prisma-next/framework-components/components';
 import { checkContractComponentRequirements } from '@prisma-next/framework-components/components';
 import {
@@ -14,7 +15,7 @@ import {
   type RuntimeTargetInstance,
 } from '@prisma-next/framework-components/execution';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
-import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   createSqlOperationRegistry,
   type SqlOperationDescriptor,
@@ -22,46 +23,55 @@ import {
 import type {
   Adapter,
   AnyQueryAst,
-  CodecParamsDescriptor,
-  CodecRegistry,
+  Codec,
+  ContractCodecRegistry,
   LoweredStatement,
+  SqlCodecInstanceContext,
   SqlDriver,
 } from '@prisma-next/sql-relational-core/ast';
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type {
   AppliedMutationDefault,
+  CodecDescriptorRegistry,
   ExecutionContext,
-  JsonSchemaValidateFn,
-  JsonSchemaValidatorRegistry,
   MutationDefaultsOptions,
   TypeHelperRegistry,
 } from '@prisma-next/sql-relational-core/query-lane-context';
-import { type as arktype } from 'arktype';
 
 /**
  * Runtime parameterized codec descriptor.
- * Provides validation schema and optional init hook for codecs that support type parameters.
- * Used at runtime to validate typeParams and create type helpers.
  *
- * This is a type alias for `CodecParamsDescriptor` from the AST layer,
- * which is the shared definition used by both adapter and runtime.
+ * The unified `CodecDescriptor<P>` shape applied to parameterized codecs — `paramsSchema: StandardSchemaV1<P>` for JSON-boundary validation, `factory: (P) => (CodecInstanceContext) => Codec` for the curried higher-order codec. The factory is called once per `storage.types` instance (or once per inline-`typeParams` column); per-instance state lives in the closure.
+ *
+ * Codec-registry-unification spec § Decision.
  */
-export type RuntimeParameterizedCodecDescriptor<
-  TParams = Record<string, unknown>,
-  THelper = unknown,
-> = CodecParamsDescriptor<TParams, THelper>;
+export type RuntimeParameterizedCodecDescriptor<P = Record<string, unknown>> = CodecDescriptor<P>;
 
+/**
+ * Contributor protocol for SQL components (target, adapter, extension pack). The unified `codecs:` slot returns the full {@link CodecDescriptor} list — non-parameterized and parameterized descriptors live side-by-side in the same array. The framework dispatches every codec id through the unified descriptor map without branching on parameterization.
+ */
 export interface SqlStaticContributions {
-  readonly codecs: () => CodecRegistry;
-  // biome-ignore lint/suspicious/noExplicitAny: needed for covariance with concrete descriptor types
-  readonly parameterizedCodecs: () => ReadonlyArray<RuntimeParameterizedCodecDescriptor<any, any>>;
+  readonly codecs: () => ReadonlyArray<AnyCodecDescriptor>;
   readonly queryOperations?: () => ReadonlyArray<SqlOperationDescriptor>;
   readonly mutationDefaultGenerators?: () => ReadonlyArray<RuntimeMutationDefaultGenerator>;
 }
 
+/**
+ * Scope across which a generator's value is constant.
+ *
+ * - `'field'` — one value per defaulting site (one column, one row). Cache strategy: no cache; call per defaulting site. Right for per-row identifiers (UUIDs, CUIDs, ULIDs, nanoid, ksuid).
+ * - `'row'` — one value across all defaulting sites of one row of one operation. Cache strategy: per-call cache keyed by `generatorId`. Right for correlation ids stamped into multiple columns of one row.
+ * - `'query'` — one value across all rows and columns of one ORM operation. Cache strategy: caller-provided cache keyed by `generatorId`. Right for `timestampNow` (a single timestamp per bulk insert/update).
+ */
+export type GeneratorStability = 'field' | 'row' | 'query';
+
 export interface RuntimeMutationDefaultGenerator {
   readonly id: string;
   readonly generate: (params?: Record<string, unknown>) => unknown;
+  /**
+   * Scope across which the generator's value is constant. The framework derives the cache strategy from this declaration; generator authors never need to know about cache keys. See `GeneratorStability` for the per-value semantics.
+   */
+  readonly stability: GeneratorStability;
 }
 
 export interface SqlRuntimeTargetDescriptor<
@@ -122,10 +132,7 @@ export type SqlRuntimeAdapterInstance<TTargetId extends string = string> = Runti
   Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
 
 /**
- * NOTE: Binding type is intentionally erased to unknown at this shared runtime layer.
- * Target clients (for example `postgres()`) validate and construct the concrete binding
- * before calling `driver.connect(binding)`, which keeps runtime behavior safe today.
- * A future follow-up can preserve TBinding through stack/context generics end-to-end.
+ * NOTE: Binding type is intentionally erased to unknown at this shared runtime layer. Target clients (for example `postgres()`) validate and construct the concrete binding before calling `driver.connect(binding)`, which keeps runtime behavior safe today. A future follow-up can preserve TBinding through stack/context generics end-to-end.
  */
 export type SqlRuntimeDriverInstance<TTargetId extends string = string> = RuntimeDriverInstance<
   'sql',
@@ -149,7 +156,7 @@ export function createSqlExecutionStack<TTargetId extends string>(options: {
   });
 }
 
-export type { ExecutionContext, JsonSchemaValidatorRegistry, TypeHelperRegistry };
+export type { ExecutionContext, TypeHelperRegistry };
 
 export function assertExecutionStackContractRequirements(
   contract: Contract<SqlStorage>,
@@ -203,71 +210,117 @@ export function assertExecutionStackContractRequirements(
 
 function validateTypeParams(
   typeParams: Record<string, unknown>,
-  codecDescriptor: RuntimeParameterizedCodecDescriptor,
+  descriptor: RuntimeParameterizedCodecDescriptor,
   context: { typeName?: string; tableName?: string; columnName?: string },
 ): Record<string, unknown> {
-  const result = codecDescriptor.paramsSchema(typeParams);
-  if (result instanceof arktype.errors) {
-    const messages = result.map((p: { message: string }) => p.message).join('; ');
+  const result = descriptor.paramsSchema['~standard'].validate(typeParams);
+  if (result instanceof Promise) {
+    throw runtimeError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
+      `paramsSchema for codec '${descriptor.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`,
+      { ...context, codecId: descriptor.codecId, typeParams },
+    );
+  }
+  if (result.issues) {
+    const messages = result.issues.map((issue) => issue.message).join('; ');
     const locationInfo = context.typeName
       ? `type '${context.typeName}'`
       : `column '${context.tableName}.${context.columnName}'`;
     throw runtimeError(
       'RUNTIME.TYPE_PARAMS_INVALID',
-      `Invalid typeParams for ${locationInfo} (codecId: ${codecDescriptor.codecId}): ${messages}`,
-      { ...context, codecId: codecDescriptor.codecId, typeParams },
+      `Invalid typeParams for ${locationInfo} (codecId: ${descriptor.codecId}): ${messages}`,
+      { ...context, codecId: descriptor.codecId, typeParams },
     );
   }
-  return result as Record<string, unknown>;
+  return result.value as Record<string, unknown>;
 }
 
-function collectParameterizedCodecDescriptors(
-  contributors: ReadonlyArray<SqlStaticContributions>,
-): Map<string, RuntimeParameterizedCodecDescriptor> {
-  const descriptors = new Map<string, RuntimeParameterizedCodecDescriptor>();
+/**
+ * Collect every {@link CodecDescriptor} contributed by the SQL stack and partition into "parameterized" vs "non-parameterized" via the descriptor's own {@link CodecDescriptorImpl.isParameterized} getter. The getter is the canonical discriminator — a `paramsSchema` identity check would misroute any descriptor that doesn't reuse the exact `voidParamsSchema` singleton (e.g. a non-parameterized codec authoring its own no-op schema).
+ *
+ * The unified descriptor list collapses the legacy split (a separate slot used to register parameterized codecs) — every codec id resolves through the same map (codec-registry-unification spec § Decision).
+ */
+function collectCodecDescriptors(contributors: ReadonlyArray<SqlStaticContributions>): {
+  readonly all: ReadonlyArray<AnyCodecDescriptor>;
+  readonly parameterized: Map<string, RuntimeParameterizedCodecDescriptor>;
+} {
+  const all: AnyCodecDescriptor[] = [];
+  const parameterized = new Map<string, RuntimeParameterizedCodecDescriptor>();
+  const seen = new Set<string>();
 
   for (const contributor of contributors) {
-    for (const descriptor of contributor.parameterizedCodecs()) {
-      if (descriptors.has(descriptor.codecId)) {
+    for (const descriptor of contributor.codecs()) {
+      if (seen.has(descriptor.codecId)) {
         throw runtimeError(
-          'RUNTIME.DUPLICATE_PARAMETERIZED_CODEC',
-          `Duplicate parameterized codec descriptor for codecId '${descriptor.codecId}'.`,
+          'RUNTIME.DUPLICATE_CODEC',
+          `Duplicate codec descriptor for codecId '${descriptor.codecId}'.`,
           { codecId: descriptor.codecId },
         );
       }
-      descriptors.set(descriptor.codecId, descriptor);
+      seen.add(descriptor.codecId);
+      all.push(descriptor);
+
+      if (descriptor.isParameterized) {
+        // Cast widens the descriptor's heterogeneous `P` to the runtime alias surface; consumers narrow per codec id at the dispatch site, where the descriptor's own `paramsSchema` validates JSON-sourced params before the factory ever sees them.
+        parameterized.set(
+          descriptor.codecId,
+          descriptor as unknown as RuntimeParameterizedCodecDescriptor,
+        );
+      }
     }
   }
 
-  return descriptors;
+  return { all, parameterized };
+}
+
+function collectTypeRefSites(
+  storage: SqlStorage,
+): Map<string, Array<{ readonly table: string; readonly column: string }>> {
+  const sites = new Map<string, Array<{ readonly table: string; readonly column: string }>>();
+  for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const [columnName, column] of Object.entries(table.columns)) {
+      if (typeof column.typeRef !== 'string') continue;
+      const list = sites.get(column.typeRef);
+      const entry = { table: tableName, column: columnName };
+      if (list) {
+        list.push(entry);
+      } else {
+        sites.set(column.typeRef, [entry]);
+      }
+    }
+  }
+  return sites;
 }
 
 function initializeTypeHelpers(
-  storageTypes: Record<string, StorageTypeInstance> | undefined,
+  storage: SqlStorage,
   codecDescriptors: Map<string, RuntimeParameterizedCodecDescriptor>,
 ): TypeHelperRegistry {
   const helpers: TypeHelperRegistry = {};
+  const storageTypes = storage.types;
 
   if (!storageTypes) {
     return helpers;
   }
 
+  const typeRefSites = collectTypeRefSites(storage);
+
   for (const [typeName, typeInstance] of Object.entries(storageTypes)) {
     const descriptor = codecDescriptors.get(typeInstance.codecId);
 
-    if (descriptor) {
-      const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, {
-        typeName,
-      });
-
-      if (descriptor.init) {
-        helpers[typeName] = descriptor.init(validatedParams);
-      } else {
-        helpers[typeName] = typeInstance;
-      }
-    } else {
+    if (!descriptor) {
+      // No parameterized descriptor for this codec id — store the raw type instance for callers that need typeParams metadata.
       helpers[typeName] = typeInstance;
+      continue;
     }
+
+    const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, {
+      typeName,
+    });
+
+    const usedAt = typeRefSites.get(typeName) ?? [];
+    const ctx: SqlCodecInstanceContext = { name: typeName, usedAt };
+    helpers[typeName] = descriptor.factory(validatedParams)(ctx);
   }
 
   return helpers;
@@ -289,68 +342,177 @@ function validateColumnTypeParams(
   }
 }
 
+function isResolvedCodec(candidate: unknown): candidate is Codec {
+  return (
+    candidate !== null &&
+    typeof candidate === 'object' &&
+    'id' in candidate &&
+    'decode' in candidate
+  );
+}
+
 /**
- * Builds a registry of compiled JSON Schema validators by scanning the contract
- * for columns whose codec descriptor provides an `init` hook returning `{ validate }`.
+ * Walk the contract's `storage.tables[].columns[]` and resolve each column to a `Codec` through the unified descriptor map. Per-instance behavior:
+ *
+ * - **typeRef columns**: reuse the resolved codec materialized once by `initializeTypeHelpers` for the `storage.types` entry. Multiple columns sharing one typeRef share one codec instance.
+ * - **inline-typeParams columns**: call `descriptor.factory(typeParams) (ctx)` once per column (per-column anonymous instance).
+ * - **non-parameterized columns**: call `descriptor.factory()(ctx)` once. The synthesized descriptor's factory is constant — every call returns the same shared codec instance — so columns sharing a non-parameterized codec id share one resolved codec without explicit caching.
  *
- * Handles both:
- * - Inline `typeParams.schema` on columns
- * - `typeRef` → `storage.types[ref]` with init hook results already in `types` registry
+ * Codec-registry-unification spec § AC-4: every column resolves through one descriptor map without branching on parameterization. JSON-Schema validation, when required, lives inside the resolved codec's `decode` body (see `arktype-json`'s `ArktypeJsonCodecClass`); the framework no longer maintains a parallel validator registry.
  */
-function buildJsonSchemaValidatorRegistry(
+function buildContractCodecRegistry(
   contract: Contract<SqlStorage>,
+  codecDescriptors: CodecDescriptorRegistry,
   types: TypeHelperRegistry,
-  codecDescriptors: Map<string, RuntimeParameterizedCodecDescriptor>,
-): JsonSchemaValidatorRegistry | undefined {
-  const validators = new Map<string, JsonSchemaValidateFn>();
-
-  // Collect codec IDs that have init hooks (these produce { validate } helpers)
-  const codecIdsWithInit = new Set<string>();
-  for (const [codecId, descriptor] of codecDescriptors) {
-    if (descriptor.init) {
-      codecIdsWithInit.add(codecId);
-    }
+  parameterizedDescriptors: Map<string, RuntimeParameterizedCodecDescriptor>,
+): ContractCodecRegistry {
+  const byColumn = new Map<string, Codec>();
+  const byCodecId = new Map<string, Codec>();
+  // Codec ids whose `byCodecId` entry is ambiguous — multiple distinct resolved instances landed under the same parameterized codec id (e.g. `Vector<1024>` and `Vector<1536>` both registering under `pg/vector@1`). The refs-less `forCodecId` fallback rejects these ids so a DSL-param without a column ref cannot silently bind to the wrong instance. The validator pass enforces refs on every parameterized `ParamRef`, so this
+  // branch is reachable only as a defensive guard for non-parameterized columns whose `byCodecId` entry is unique by construction.
+  const ambiguousCodecIds = new Set<string>();
+
+  // Pre-populate `byCodecId` with non-parameterized descriptor instances. Refs-less encode/decode call sites (computed projections without a column ref, transient builder ParamRefs) resolve through `forCodecId(id)` and need a representative instance for codec ids that no contract column declares. Non-parameterized descriptors' factories are constant — every call yields the same shared codec — so a single materialization
+  // is correct.
+  for (const descriptor of codecDescriptors.values()) {
+    if (descriptor.isParameterized) continue;
+    const ctx: SqlCodecInstanceContext = {
+      name: `<shared:${descriptor.codecId}>`,
+      usedAt: [],
+    };
+    const voidFactory = descriptor.factory as unknown as (
+      params: undefined,
+    ) => (ctx: SqlCodecInstanceContext) => Codec;
+    byCodecId.set(descriptor.codecId, voidFactory(undefined)(ctx));
   }
 
-  if (codecIdsWithInit.size === 0) {
-    return undefined;
+  // Representative instances for parameterized descriptors whose factory tolerates `factory(undefined)` (e.g. pgvector — the factory ignores its params and returns the same shared codec). Used as the last-resort fallback in `forCodecId` for refs-less call sites whose codec id has no contract column the walk could resolve through (e.g. `cosineSimilarity(col, [literal])` builds an inline `ParamRef` without column refs).
+  // Stored separately so column-bound walk results don't trip the ambiguity check, and consulted only when `byCodecId` has no column-bound entry. Descriptors whose factory needs real params (arktype-json) raise and are skipped — the per-column dispatch path materializes those lazily when refs are populated.
+  const parameterizedRepresentatives = new Map<string, Codec>();
+  for (const descriptor of codecDescriptors.values()) {
+    if (!descriptor.isParameterized) continue;
+    const ctx: SqlCodecInstanceContext = {
+      name: `<shared:${descriptor.codecId}>`,
+      usedAt: [],
+    };
+    // Call `factory` *as a method on the descriptor* — `descriptor.factory(undefined)` — rather than detaching it into a local. Several descriptors implement `factory` as a class method whose body returns an arrow that captures `this` (`return () => new SomeCodec(this);`), and detaching loses that binding so the codec ends up with an `undefined` descriptor and `codec.id` throws.
+    const factory = descriptor.factory.bind(descriptor) as unknown as (
+      params: unknown,
+    ) => (ctx: SqlCodecInstanceContext) => Codec;
+    try {
+      parameterizedRepresentatives.set(descriptor.codecId, factory(undefined)(ctx));
+    } catch {
+      // Parameterized descriptor whose factory requires real params; refs-less fallback for this codec id is unavailable.
+    }
   }
 
   for (const [tableName, table] of Object.entries(contract.storage.tables)) {
     for (const [columnName, column] of Object.entries(table.columns)) {
-      if (!codecIdsWithInit.has(column.codecId)) continue;
+      const columnKey = `${tableName}.${columnName}`;
+      const descriptor = codecDescriptors.descriptorFor(column.codecId);
 
-      const key = `${tableName}.${columnName}`;
+      let resolvedCodec: Codec | undefined;
 
-      // Case 1: column references a named type → validator already compiled via init hook
-      if (column.typeRef) {
-        const helper = types[column.typeRef] as { validate?: JsonSchemaValidateFn } | undefined;
-        if (helper?.validate) {
-          validators.set(key, helper.validate);
+      if (descriptor) {
+        const isParameterized = parameterizedDescriptors.has(column.codecId);
+
+        if (column.typeRef) {
+          // The named instance was already materialized once by `initializeTypeHelpers`; reuse it so multiple columns sharing the same typeRef share one codec instance (and any per-instance helper state on it).
+          const helper = types[column.typeRef];
+          if (isResolvedCodec(helper)) {
+            resolvedCodec = helper;
+          }
+        } else if (column.typeParams && isParameterized) {
+          const parameterizedDescriptor = parameterizedDescriptors.get(column.codecId);
+          if (parameterizedDescriptor) {
+            const validatedParams = validateTypeParams(column.typeParams, parameterizedDescriptor, {
+              tableName,
+              columnName,
+            });
+            const ctx: SqlCodecInstanceContext = {
+              name: `<col:${tableName}.${columnName}>`,
+              usedAt: [{ table: tableName, column: columnName }],
+            };
+            resolvedCodec = parameterizedDescriptor.factory(validatedParams)(ctx);
+          }
+        } else if (!isParameterized) {
+          // Non-parameterized column: materialize a fresh codec instance per `forColumn(table, column)` entry with a column-specific `SqlCodecInstanceContext`. The pre-populated `byCodecId` representative (built with the synthetic `<shared:codecId>` context and empty `usedAt`) is reserved for `forCodecId()` refs-less fallbacks; reusing it for column-bound dispatch would erase per-column diagnostics for any descriptor whose factory reads `CodecInstanceContext`.
+          const ctx: SqlCodecInstanceContext = {
+            name: `<col:${tableName}.${columnName}>`,
+            usedAt: [{ table: tableName, column: columnName }],
+          };
+          // The descriptor's `P` is `void` for non-parameterized codecs; the runtime's `void` value is `undefined`. The cast narrows the descriptor's family-agnostic `CodecInstanceContext` slot to the SQL `SqlCodecInstanceContext` we pass at this call site — function-argument contravariance makes the narrow safe.
+          // `bind` preserves the `this`-on-descriptor invariant — several descriptors implement `factory` as a class method whose body returns an arrow that captures `this`; detaching loses the binding and produces a codec whose `descriptor` is `undefined`.
+          const voidFactory = descriptor.factory.bind(descriptor) as unknown as (
+            params: undefined,
+          ) => (ctx: SqlCodecInstanceContext) => Codec;
+          resolvedCodec = voidFactory(undefined)(ctx);
         }
-        continue;
+        // else: parameterized codec id with no typeRef and no typeParams — this is the legitimate "undimensioned" form for codecs that ship a no-params column variant alongside a parameterized one (e.g. pgvector's `vectorColumn` vs. `vector(N)`). Leave `resolvedCodec` undefined; encode/decode for this column flows through `forCodecId`. The fallback works for these cases because their wire format is params-independent (vector
+        // formats `[v1,v2,...]` regardless of declared length).
       }
 
-      // Case 2: inline typeParams with schema → compile via init hook
-      if (column.typeParams) {
-        const descriptor = codecDescriptors.get(column.codecId);
-        if (descriptor?.init) {
-          const helper = descriptor.init(column.typeParams) as
-            | { validate?: JsonSchemaValidateFn }
-            | undefined;
-          if (helper?.validate) {
-            validators.set(key, helper.validate);
-          }
+      if (resolvedCodec) {
+        byColumn.set(columnKey, resolvedCodec);
+        const existing = byCodecId.get(column.codecId);
+        if (existing === undefined) {
+          byCodecId.set(column.codecId, resolvedCodec);
+        } else if (existing !== resolvedCodec && parameterizedDescriptors.has(column.codecId)) {
+          ambiguousCodecIds.add(column.codecId);
         }
       }
     }
   }
 
-  if (validators.size === 0) return undefined;
-  return {
-    get: (key: string) => validators.get(key),
-    size: validators.size,
+  const registry: ContractCodecRegistry = {
+    forColumn(table, column) {
+      return byColumn.get(`${table}.${column}`);
+    },
+    forCodecId(codecId) {
+      // Codec-id-only fallback for refs-less sites. The validator pass (`validateParamRefRefs`) enforces refs on every parameterized `ParamRef` before encode, so this path is only legitimately reachable for non-parameterized codec ids. The map is pre-populated with every non-parameterized descriptor's canonical instance and overlaid with column-resolved instances from the contract walk; parameterized codec ids without a
+      // typeRef/typeParams-bound column never reach this map.
+      //
+      // Reject ambiguous parameterized fallbacks: if the contract walk resolved more than one distinct codec instance under this id (e.g. multiple vector dimensions, multiple arktype-json schemas), the codec-id-keyed lookup cannot honor the call site — fail fast rather than bind to whichever instance happened to land first.
+      if (ambiguousCodecIds.has(codecId)) {
+        throw runtimeError(
+          'RUNTIME.TYPE_PARAMS_INVALID',
+          `Codec '${codecId}' resolves to multiple parameterized instances; column-aware dispatch is required.`,
+          { codecId },
+        );
+      }
+      return byCodecId.get(codecId) ?? parameterizedRepresentatives.get(codecId);
+    },
   };
+
+  return registry;
+}
+
+function assertMutationDefaultGeneratorsAvailable(
+  contract: Contract<SqlStorage>,
+  generatorRegistry: ReadonlyMap<string, RuntimeMutationDefaultGenerator>,
+): void {
+  const defaults = contract.execution?.mutations.defaults ?? [];
+  if (defaults.length === 0) return;
+
+  const missing = new Set<string>();
+  for (const mutationDefault of defaults) {
+    for (const phase of [mutationDefault.onCreate, mutationDefault.onUpdate]) {
+      if (!phase) continue;
+      if (phase.kind === 'generator' && !generatorRegistry.has(phase.id)) {
+        missing.add(phase.id);
+      }
+    }
+  }
+
+  if (missing.size === 0) return;
+
+  const ids = Array.from(missing);
+  const idList = ids.map((id) => `'${id}'`).join(', ');
+  throw runtimeError(
+    'RUNTIME.MISSING_MUTATION_DEFAULT_GENERATOR',
+    `Contract requires mutation default generator(s) ${idList}, but no runtime component provides them.`,
+    { ids },
+  );
 }
 
 function collectMutationDefaultGenerators(
@@ -414,8 +576,12 @@ function applyMutationDefaults(
     return [];
   }
 
+  const isEmptyUpdate = options.op === 'update' && Object.keys(options.values).length === 0;
+
   const applied: AppliedMutationDefault[] = [];
   const appliedColumns = new Set<string>();
+  // Fresh per-call cache for `stability: 'row'` generators — they share across columns of a single row but regenerate on the next call.
+  const rowCache = new Map<string, unknown>();
 
   for (const mutationDefault of defaults) {
     if (mutationDefault.ref.table !== options.table) {
@@ -428,6 +594,11 @@ function applyMutationDefaults(
       continue;
     }
 
+    // RD2: empty update payloads skip onUpdate defaults — no write means no `@updatedAt` advance.
+    if (isEmptyUpdate) {
+      continue;
+    }
+
     const columnName = mutationDefault.ref.column;
     if (Object.hasOwn(options.values, columnName) || appliedColumns.has(columnName)) {
       continue;
@@ -435,7 +606,12 @@ function applyMutationDefaults(
 
     applied.push({
       column: columnName,
-      value: computeExecutionDefaultValue(defaultSpec, generatorRegistry),
+      value: resolveScopedValue(
+        defaultSpec,
+        generatorRegistry,
+        rowCache,
+        options.defaultValueCache,
+      ),
     });
     appliedColumns.add(columnName);
   }
@@ -443,6 +619,43 @@ function applyMutationDefaults(
   return applied;
 }
 
+function resolveScopedValue(
+  spec: ExecutionMutationDefaultValue,
+  generatorRegistry: ReadonlyMap<string, RuntimeMutationDefaultGenerator>,
+  rowCache: Map<string, unknown>,
+  queryCache: Map<string, unknown> | undefined,
+): unknown {
+  if (spec.kind !== 'generator') {
+    return computeExecutionDefaultValue(spec, generatorRegistry);
+  }
+  const generator = generatorRegistry.get(spec.id);
+  const cache = scopedCache(generator?.stability, rowCache, queryCache);
+  if (!cache) {
+    return computeExecutionDefaultValue(spec, generatorRegistry);
+  }
+  if (cache.has(spec.id)) {
+    return cache.get(spec.id);
+  }
+  const value = computeExecutionDefaultValue(spec, generatorRegistry);
+  cache.set(spec.id, value);
+  return value;
+}
+
+function scopedCache(
+  stability: GeneratorStability | undefined,
+  rowCache: Map<string, unknown>,
+  queryCache: Map<string, unknown> | undefined,
+): Map<string, unknown> | undefined {
+  switch (stability) {
+    case 'row':
+      return rowCache;
+    case 'query':
+      return queryCache;
+    default:
+      return undefined;
+  }
+}
+
 export function createExecutionContext<
   TContract extends Contract<SqlStorage> = Contract<SqlStorage>,
   TTargetId extends string = string,
@@ -454,19 +667,14 @@ export function createExecutionContext<
 
   assertExecutionStackContractRequirements(contract, stack);
 
-  const codecRegistry = createCodecRegistry();
-
   const contributors: Array<SqlStaticContributions & ComponentDescriptor<string>> = [
     stack.target,
     stack.adapter,
     ...stack.extensionPacks,
   ];
 
-  for (const contributor of contributors) {
-    for (const c of contributor.codecs().values()) {
-      codecRegistry.register(c);
-    }
-  }
+  const { all: allCodecDescriptors, parameterized: parameterizedCodecDescriptors } =
+    collectCodecDescriptors(contributors);
 
   const queryOperationRegistry = createSqlOperationRegistry();
   for (const contributor of contributors) {
@@ -475,27 +683,29 @@ export function createExecutionContext<
     }
   }
 
-  const parameterizedCodecDescriptors = collectParameterizedCodecDescriptors(contributors);
+  const codecDescriptors = buildCodecDescriptorRegistry(allCodecDescriptors);
   const mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
+  assertMutationDefaultGeneratorsAvailable(contract, mutationDefaultGeneratorRegistry);
 
   if (parameterizedCodecDescriptors.size > 0) {
     validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
   }
 
-  const types = initializeTypeHelpers(contract.storage.types, parameterizedCodecDescriptors);
+  const types = initializeTypeHelpers(contract.storage, parameterizedCodecDescriptors);
 
-  const jsonSchemaValidators = buildJsonSchemaValidatorRegistry(
+  const contractCodecs = buildContractCodecRegistry(
     contract,
+    codecDescriptors,
     types,
     parameterizedCodecDescriptors,
   );
 
   return {
     contract,
-    codecs: codecRegistry,
+    contractCodecs,
+    codecDescriptors,
     queryOperations: queryOperationRegistry,
     types,
-    ...(jsonSchemaValidators ? { jsonSchemaValidators } : {}),
     applyMutationDefaults: (options) =>
       applyMutationDefaults(contract, mutationDefaultGeneratorRegistry, options),
   };

package/src/sql-family-adapter.ts

@@ -1,8 +1,9 @@
-import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
+import type { Contract } from '@prisma-next/contract/types';
+import type { ExecutionPlan } from '@prisma-next/framework-components/runtime';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
-import type { MarkerReader, RuntimeFamilyAdapter } from '@prisma-next/runtime-executor';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { AdapterProfile } from '@prisma-next/sql-relational-core/ast';
+import type { MarkerReader, RuntimeFamilyAdapter } from './runtime-spi';
 
 export class SqlFamilyAdapter<TContract extends Contract<SqlStorage>>
   implements RuntimeFamilyAdapter<TContract>