fix(mongo): suppress variants, fix validators, add Float

docs/architecture docs/subsystems/10. MongoDB Family.md

@@ -118,7 +118,7 @@ In the ORM, owned relations auto-project into the parent row — no separate que
 
 ### No schema enforcement
 
-SQL databases enforce types at the storage level: if a column is declared as `integer`, you can't store a string in it. MongoDB has no such enforcement by default. A field the contract says is a number might contain a string in the actual database. The contract describes intended structure, not database-enforced constraints.
+SQL databases enforce types at the storage level: if a column is declared as `integer`, you can't store a string in it. MongoDB has no such enforcement by default. A field the contract says is a number might contain a string in the actual database. The contract describes intended structure, not database-enforced constraints. However, the migration planner can generate `$jsonSchema` validators for collections, providing opt-in type enforcement at the database level — see [Schema validation](#schema-validation-jsonschema).
 
 `validateMongoContract()` validates the contract itself (not the data in the database) at load time. It performs three layers of validation:
 
@@ -164,7 +164,15 @@ The contract represents this with three concepts:
 - **Variants**: the specialized models with their type-specific fields
 - A **base** reference on each variant, pointing back to the base model
 
-Persistence strategy (whether variants share a collection or each have their own) is emergent from the storage mappings, not declared explicitly. Discriminator narrowing produces polymorphic return types — querying a base model returns a union of variant row types, and filtering by discriminator value narrows the type. See [ADR 173](../adrs/ADR%20173%20-%20Polymorphism%20via%20discriminator%20and%20variants.md).
+Persistence strategy (whether variants share a collection or each have their own) is emergent from the storage mappings, not declared explicitly. When variants share a base collection (single-collection polymorphism via `@@base`), the interpreter suppresses separate collection entries for variant models and merges any variant-specific indexes into the base collection. Discriminator narrowing produces polymorphic return types — querying a base model returns a union of variant row types, and filtering by discriminator value narrows the type. See [ADR 173](../adrs/ADR%20173%20-%20Polymorphism%20via%20discriminator%20and%20variants.md).
+
+### Schema validation ($jsonSchema)
+
+MongoDB collections can enforce document structure using `$jsonSchema` validators. The migration planner generates these validators from the contract so that documents inserted or updated in a collection must conform to the expected field types.
+
+BSON types in validators are derived from codec metadata, not hardcoded maps. When the interpreter generates a validator for a collection, it resolves each field's codec ID through the `CodecLookup` and reads the codec's `targetTypes[0]` to get the BSON type name (e.g., `mongo/double@1` → `double`, `mongo/string@1` → `string`). This means any codec registered by an adapter or extension automatically gets correct validator support without modifying the interpreter.
+
+For polymorphic collections (models with `@@discriminator` and `@@base`), the validator uses a `oneOf` pattern: base fields appear in the top-level `properties` and `required`, while variant-specific fields are grouped into `oneOf` branches, each constrained by the discriminator value. This ensures that a document in the collection must match exactly one variant shape.
 
 ### Aggregation pipelines
 
@@ -255,7 +263,7 @@ The Mongo-specific components are:
 - **`MongoRuntime.execute(plan)`** — single entry point `execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row>`. Both read and write operations flow through this path; the ORM’s `compileMongoQuery` returns a `MongoQueryPlan` (for reads, wrapping an `AggregateCommand`).
 - **`MongoDriver`** — wraps the `mongodb` Node.js driver, dispatches each wire command type to the correct driver method, and returns results as `AsyncIterable<Document>`.
 - **`MongoRuntime`** — validates the plan, calls the driver, and wraps results in `AsyncIterableResult<Row>` (the same streaming result type used by SQL).
-- **`MongoCodecRegistry`** — provides base codecs for BSON types (`objectId`, `string`, `int32`, `boolean`, `date`), following the same registry shape as SQL codecs.
+- **`MongoCodecRegistry`** — provides base codecs for BSON types (`objectId`, `string`, `int32`, `boolean`, `date`, `double`), following the same registry shape as SQL codecs. Each codec declares its `targetTypes` (e.g., `['double']` for the double codec), which are used to derive BSON type names for `$jsonSchema` validators via `codecLookup.get(codecId).targetTypes[0]`.
 
 ### Package layout
 

examples/prisma-next-demo/prisma-next.config.ts

@@ -3,45 +3,20 @@ import postgresAdapter from '@prisma-next/adapter-postgres/control';
 import { defineConfig } from '@prisma-next/cli/config-types';
 import postgresDriver from '@prisma-next/driver-postgres/control';
 import pgvector from '@prisma-next/extension-pgvector/control';
-import sql, {
-  assembleAuthoringContributions,
-  assemblePslInterpretationContributions,
-} from '@prisma-next/family-sql/control';
+import sql from '@prisma-next/family-sql/control';
 import { prismaContract } from '@prisma-next/sql-contract-psl/provider';
 import postgres from '@prisma-next/target-postgres/control';
 
-const extensionPacks = [pgvector];
-const authoringContributions = assembleAuthoringContributions([
-  postgres,
-  postgresAdapter,
-  ...extensionPacks,
-]);
-const pslContributions = assemblePslInterpretationContributions([
-  postgres,
-  postgresAdapter,
-  ...extensionPacks,
-]);
-
 export default defineConfig({
   family: sql,
   target: postgres,
   driver: postgresDriver,
   adapter: postgresAdapter,
-  extensionPacks,
+  extensionPacks: [pgvector],
   contract: prismaContract('./prisma/schema.prisma', {
     output: 'src/prisma/contract.json',
     target: postgres,
-    authoringContributions,
-    scalarTypeDescriptors: pslContributions.scalarTypeDescriptors,
-    controlMutationDefaults: {
-      defaultFunctionRegistry: pslContributions.defaultFunctionRegistry,
-      generatorDescriptors: pslContributions.generatorDescriptors,
-    },
-    composedExtensionPacks: extensionPacks.map((pack) => pack.id),
   }),
-  // migrations: {
-  //   dir: 'migration-fixtures/long-spine',
-  // },
   db: {
     // biome-ignore lint/style/noNonNullAssertion: loaded from .env
     connection: process.env['DATABASE_URL']!,

examples/retail-store/prisma-next.config.ts

@@ -2,22 +2,15 @@ import mongoAdapter from '@prisma-next/adapter-mongo/control';
 import { defineConfig } from '@prisma-next/cli/config-types';
 import mongoDriver from '@prisma-next/driver-mongo/control';
 import { mongoFamilyDescriptor, mongoTargetDescriptor } from '@prisma-next/family-mongo/control';
-import { createMongoScalarTypeDescriptors } from '@prisma-next/mongo-contract-psl';
 import { mongoContract } from '@prisma-next/mongo-contract-psl/provider';
 
-const scalarTypeDescriptors = new Map([
-  ...createMongoScalarTypeDescriptors(),
-  ['Float', 'mongo/double@1'],
-]);
-
 export default defineConfig({
   family: mongoFamilyDescriptor,
   target: mongoTargetDescriptor,
   adapter: mongoAdapter,
   driver: mongoDriver,
   contract: mongoContract('./prisma/contract.prisma', {
     output: 'src/contract.json',
-    scalarTypeDescriptors,
   }),
   db: {
     connection: process.env['DB_URL'] ?? 'mongodb://localhost:27017/retail-store',

packages/1-framework/1-core/config/src/contract-source-types.ts

@@ -1,4 +1,9 @@
 import type { Contract } from '@prisma-next/contract/types';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type {
+  AssembledAuthoringContributions,
+  ControlMutationDefaults,
+} from '@prisma-next/framework-components/control';
 import type { Result } from '@prisma-next/utils/result';
 
 export interface ContractSourceDiagnosticPosition {
@@ -33,6 +38,10 @@ export interface ContractSourceDiagnostics {
 
 export interface ContractSourceContext {
   readonly composedExtensionPacks: readonly string[];
+  readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
+  readonly authoringContributions: AssembledAuthoringContributions;
+  readonly codecLookup: CodecLookup;
+  readonly controlMutationDefaults: ControlMutationDefaults;
 }
 
 export type ContractSourceProvider = (

packages/1-framework/1-core/framework-components/src/control-stack.ts

@@ -14,6 +14,11 @@ import type {
   AuthoringTypeNamespace,
 } from './framework-authoring';
 import type { ComponentMetadata } from './framework-components';
+import type {
+  ControlMutationDefaultEntry,
+  ControlMutationDefaults,
+  MutationDefaultGeneratorDescriptor,
+} from './mutation-default-types';
 import type { TypesImportSpec } from './types-import-spec';
 
 export interface AssembledAuthoringContributions {
@@ -37,6 +42,8 @@ export interface ControlStack<
   readonly extensionIds: ReadonlyArray<string>;
   readonly codecLookup: CodecLookup;
   readonly authoringContributions: AssembledAuthoringContributions;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
+  readonly controlMutationDefaults: ControlMutationDefaults;
 }
 
 export interface CreateControlStackInput<
@@ -244,6 +251,80 @@ export function assembleAuthoringContributions(
   };
 }
 
+export function assembleScalarTypeDescriptors(
+  descriptors: ReadonlyArray<
+    Pick<ComponentMetadata, 'scalarTypeDescriptors'> & { readonly id?: string }
+  >,
+): ReadonlyMap<string, string> {
+  const result = new Map<string, string>();
+  const owners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    const descriptorMap = descriptor.scalarTypeDescriptors;
+    if (!descriptorMap) continue;
+    const descriptorId = descriptor.id ?? '<unknown>';
+    for (const [typeName, codecId] of descriptorMap) {
+      const existingOwner = owners.get(typeName);
+      if (existingOwner !== undefined) {
+        throw new Error(
+          `Duplicate scalar type descriptor "${typeName}". ` +
+            `Descriptor "${descriptorId}" conflicts with "${existingOwner}".`,
+        );
+      }
+      result.set(typeName, codecId);
+      owners.set(typeName, descriptorId);
+    }
+  }
+
+  return result;
+}
+
+export function assembleControlMutationDefaults(
+  descriptors: ReadonlyArray<
+    Pick<ComponentMetadata, 'controlMutationDefaults'> & { readonly id?: string }
+  >,
+): ControlMutationDefaults {
+  const defaultFunctionRegistry = new Map<string, ControlMutationDefaultEntry>();
+  const functionOwners = new Map<string, string>();
+  const generatorMap = new Map<string, MutationDefaultGeneratorDescriptor>();
+  const generatorOwners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    const contributions = descriptor.controlMutationDefaults;
+    if (!contributions) continue;
+    const descriptorId = descriptor.id ?? '<unknown>';
+
+    for (const generatorDescriptor of contributions.generatorDescriptors) {
+      const existingOwner = generatorOwners.get(generatorDescriptor.id);
+      if (existingOwner !== undefined) {
+        throw new Error(
+          `Duplicate mutation default generator id "${generatorDescriptor.id}". ` +
+            `Descriptor "${descriptorId}" conflicts with "${existingOwner}".`,
+        );
+      }
+      generatorMap.set(generatorDescriptor.id, generatorDescriptor);
+      generatorOwners.set(generatorDescriptor.id, descriptorId);
+    }
+
+    for (const [functionName, handler] of contributions.defaultFunctionRegistry) {
+      const existingOwner = functionOwners.get(functionName);
+      if (existingOwner !== undefined) {
+        throw new Error(
+          `Duplicate mutation default function "${functionName}". ` +
+            `Descriptor "${descriptorId}" conflicts with "${existingOwner}".`,
+        );
+      }
+      defaultFunctionRegistry.set(functionName, handler);
+      functionOwners.set(functionName, descriptorId);
+    }
+  }
+
+  return {
+    defaultFunctionRegistry,
+    generatorDescriptors: Array.from(generatorMap.values()),
+  };
+}
+
 export function extractCodecLookup(
   descriptors: ReadonlyArray<Pick<ComponentMetadata & { id?: string }, 'types' | 'id'>>,
 ): CodecLookup {
@@ -268,13 +349,31 @@ export function extractCodecLookup(
   return { get: (id) => byId.get(id) };
 }
 
+export function validateScalarTypeCodecIds(
+  scalarTypeDescriptors: ReadonlyMap<string, string>,
+  codecLookup: CodecLookup,
+): string[] {
+  const errors: string[] = [];
+  for (const [typeName, codecId] of scalarTypeDescriptors) {
+    if (!codecLookup.get(codecId)) {
+      errors.push(
+        `Scalar type "${typeName}" references codec "${codecId}" which is not registered by any component.`,
+      );
+    }
+  }
+  return errors;
+}
+
 export function createControlStack<TFamilyId extends string, TTargetId extends string>(
   input: CreateControlStackInput<TFamilyId, TTargetId>,
 ): ControlStack<TFamilyId, TTargetId> {
   const { family, target, adapter, driver, extensionPacks = [] } = input;
 
   const allDescriptors = [family, target, ...(adapter ? [adapter] : []), ...extensionPacks];
 
+  const codecLookup = extractCodecLookup(allDescriptors);
+  const scalarTypeDescriptors = assembleScalarTypeDescriptors(allDescriptors);
+
   return {
     family,
     target,
@@ -286,7 +385,9 @@ export function createControlStack<TFamilyId extends string, TTargetId extends s
     operationTypeImports: extractOperationTypeImports(allDescriptors),
     queryOperationTypeImports: extractQueryOperationTypeImports(allDescriptors),
     extensionIds: extractComponentIds(family, target, adapter, extensionPacks),
-    codecLookup: extractCodecLookup(allDescriptors),
+    codecLookup,
     authoringContributions: assembleAuthoringContributions(allDescriptors),
+    scalarTypeDescriptors,
+    controlMutationDefaults: assembleControlMutationDefaults(allDescriptors),
   };
 }

packages/1-framework/1-core/framework-components/src/exports/control.ts

@@ -66,6 +66,8 @@ export type {
 } from '../control-stack';
 export {
   assembleAuthoringContributions,
+  assembleControlMutationDefaults,
+  assembleScalarTypeDescriptors,
   assertUniqueCodecOwner,
   createControlStack,
   extractCodecLookup,
@@ -74,3 +76,18 @@ export {
   extractOperationTypeImports,
   extractQueryOperationTypeImports,
 } from '../control-stack';
+export type {
+  ControlMutationDefaultEntry,
+  ControlMutationDefaultRegistry,
+  ControlMutationDefaults,
+  DefaultFunctionLoweringContext,
+  DefaultFunctionLoweringHandler,
+  DefaultFunctionRegistry,
+  DefaultFunctionRegistryEntry,
+  LoweredDefaultResult,
+  LoweredDefaultValue,
+  MutationDefaultGeneratorDescriptor,
+  ParsedDefaultFunctionCall,
+  SourceDiagnostic,
+  SourceSpan,
+} from '../mutation-default-types';

packages/1-framework/1-core/framework-components/src/framework-components.ts

@@ -1,5 +1,6 @@
 import type { Codec } from './codec-types';
 import type { AuthoringContributions } from './framework-authoring';
+import type { ControlMutationDefaults } from './mutation-default-types';
 import type { TypesImportSpec } from './types-import-spec';
 
 /**
@@ -65,6 +66,18 @@ export interface ComponentMetadata {
    * 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.
+   */
+  readonly scalarTypeDescriptors?: ReadonlyMap<string, string>;
+
+  /**
+   * Mutation default function handlers and generator descriptors contributed
+   * by this component. Assembled by `createControlStack` with duplicate detection.
+   */
+  readonly controlMutationDefaults?: ControlMutationDefaults;
 }
 
 /**