@fougere/schema 0.6.0-alpha.0 → 0.7.0-alpha.0

package/src/entity/EntityAdapters.ts

@@ -1,100 +1,8 @@
-import type { FieldName, Fields } from '../schema/fields/Field.js';
-import { isObject } from '../utils.js';
+import type { FieldName, Fields } from '../field/Field.js';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-object-type
 export interface FougereEntityAdapters<K extends string> {}
 
-export type EntityAdapters<TFields extends Fields> = Readonly<Partial<FougereEntityAdapters<FieldName<TFields>>>>;
-
-/** What `cut` REQUIRES of an augmentation, and the open registry cannot state: addressed by field. */
-type FieldEntries = Record<FieldName<Fields>, unknown>;
-
-type AdapterEntries = Record<string, FieldEntries>;
-
-/**
- * What one schema states per adapter: an adapter name, a field name, then that adapter's own value.
- */
-export class EntityAdapterSet {
-  private constructor(private readonly byAdapter: AdapterEntries) {}
-
-  static of(declared: EntityAdapters<Fields> | undefined): EntityAdapterSet | undefined {
-    if (declared === undefined) return undefined;
-
-    if (!isObject(declared)) {
-      throw new Error(
-        `adapters: expected an object keyed by adapter name, got ${typeof declared}.`,
-      );
-    }
-
-    const byAdapter: AdapterEntries = {};
-
-    for (const [adapter, perField] of Object.entries(declared as AdapterEntries)) {
-      if (perField === undefined) continue;
-
-      if (!isObject(perField)) {
-        throw new Error(
-          `adapters.${adapter}: expected an object keyed by field name, got ${typeof perField}. ` +
-            `What an adapter is handed is addressed by the field it applies to.`,
-        );
-      }
-
-      if (Object.keys(perField).length) byAdapter[adapter] = perField;
-    }
-
-    return EntityAdapterSet.made(byAdapter);
-  }
-
-  /** Several schemas folded into one set; a later source wins, per adapter and per field. */
-  static merged(sources: readonly (EntityAdapters<Fields> | undefined)[]): EntityAdapterSet | undefined {
-    const out: AdapterEntries = {};
-
-    for (const source of sources) {
-      const set = EntityAdapterSet.of(source);
-      if (!set) continue;
-
-      for (const [adapter, perField] of Object.entries(set.byAdapter)) {
-        out[adapter] = { ...out[adapter], ...perField };
-      }
-    }
-
-    return EntityAdapterSet.made(out);
-  }
-
-  /** Every field name these entries address — what a caller checks against its own shape. */
-  get fieldNames(): string[] {
-    return [...new Set(Object.values(this.byAdapter).flatMap((perField) => Object.keys(perField)))];
-  }
-
-  /** The plain object, which is what a reader outside this package receives. */
-  get stated(): EntityAdapters<Fields> {
-    return this.byAdapter as EntityAdapters<Fields>;
-  }
-
-  /**
-   * The entries whose field survives a cut, re-addressed by that field's new name.
-   *
-   * The adapter name is not a field and does not move; only the level below it does. An
-   * entry left on the old name is not an error anywhere downstream — `adapter/sql` looks
-   * it up by the field it is iterating and simply finds nothing.
-   */
-  cut(survives: (key: string) => string | undefined): EntityAdapterSet | undefined {
-    const out: AdapterEntries = {};
-
-    for (const [adapter, perField] of Object.entries(this.byAdapter)) {
-      const mapped: FieldEntries = {};
-
-      for (const [key, entry] of Object.entries(perField)) {
-        const next = survives(key);
-        if (next !== undefined) mapped[next] = entry;
-      }
-
-      if (Object.keys(mapped).length) out[adapter] = mapped;
-    }
-
-    return EntityAdapterSet.made(out);
-  }
-
-  private static made(byAdapter: AdapterEntries): EntityAdapterSet | undefined {
-    return Object.keys(byAdapter).length ? new EntityAdapterSet(byAdapter) : undefined;
-  }
-}
+export type EntityAdapters<TFields extends Fields> = Readonly<
+  Partial<FougereEntityAdapters<FieldName<TFields>>>
+>;

package/src/entity/EntityDeclarations.ts

@@ -1,4 +1,4 @@
-import type { FieldName, Fields } from '../schema/fields/Field.js';
+import type { FieldName, Fields } from '../field/Field.js';
 import type { EntityAdapters } from './EntityAdapters.js';
 
 // Ex: [['title', 'name'], ['id']]

package/src/entity.ts

@@ -1,7 +1,12 @@
-import { type Fields } from './schema/fields/Field.js';
+import { type Fields } from './field/Field.js';
 import { type EntityDeclarations } from './entity/EntityDeclarations.js';
-import { Schema, type SchemaConstructor } from './schema/Schema.js';
+import { Schema, type SchemaConstructor } from './Schema.js';
 
+/**
+ * So the whole framework starts from one call: fields, and what they say about themselves.
+ * FR : pour que tout parte d'un appel : les champs, et ce qu'ils disent d'eux-mêmes.
+ * `class Post extends entity({ id: primary(), title: text() }, { unique: [['title']] }) {}`
+ */
 export function entity<TFields extends Fields>(
   fields: TFields,
   declarations: EntityDeclarations<TFields> = {},

package/src/{schema/fields → field}/Field.ts

@@ -1,18 +1,18 @@
 import type { Shape } from '../axis/shape/Shape.js';
-import { Role, type RoleRules } from '../axis/role/Role.js';
+import type { RoleRules } from '../axis/role/Role.js';
 import type { LifecycleRules } from '../axis/lifecycle/Lifecycle.js';
 import type { BoundaryRef } from '../axis/boundary/Boundary.js';
 import type { Meta } from '../axis/Meta.js';
 import type { Axis } from '../axis/Axis.js';
-import { FieldJudge } from '../../judge/FieldJudge.js';
-import { ValueJudge } from '../../judge/ValueJudge.js';
+import { FieldDeclarationValidator } from '../validator/FieldDeclarationValidator.js';
+import { FieldValueValidator } from '../validator/FieldValueValidator.js';
 
 export type Fields = Record<string, Field>;
 
 /** A key of a field set — the name a declaration addresses a field by. */
 export type FieldName<TFields extends Fields> = Extract<keyof TFields, string>;
 
-/** The carrier, the three extension axes, the annotation — the five the judge reads. */
+/** The carrier, the three extension axes, the annotation — the five the validator reads. */
 export type FieldDeclaration = Pick<Field, 'shape' | Axis['slot'] | 'meta'>;
 
 export class Field<T = unknown> {
@@ -25,7 +25,7 @@ export class Field<T = unknown> {
   declare readonly _type?: T;
 
   constructor(init: FieldDeclaration, key?: string) {
-    const verdict = FieldJudge.of(init).verdict;
+    const verdict = FieldDeclarationValidator.of(init).verdict;
 
     if (!verdict.success) {
       throw new Error(
@@ -35,14 +35,14 @@ export class Field<T = unknown> {
     }
 
     this.shape = init.shape;
-    this.role = Role.resolvedOn(init.role, key);
+    this.role = init.role;
     this.lifecycle = init.lifecycle;
     this.boundary = init.boundary;
     this.meta = init.meta;
 
     const create = this.lifecycle?.create;
     if (typeof create === 'object' && create !== null && 'value' in create) {
-      const checked = ValueJudge.of(this).check(create.value);
+      const checked = FieldValueValidator.of(this).validate(create.value);
       if ('error' in checked)
         throw new Error(
           `${key ? `Field '${key}': ` : ''}the declared default ${JSON.stringify(create.value)} ` +
@@ -52,28 +52,10 @@ export class Field<T = unknown> {
   }
 
   static is(value: unknown): value is Field {
-    return FieldJudge.of(value).verdict.success;
+    return FieldDeclarationValidator.of(value).verdict.success;
   }
 
   with<U = T>(overrides: Partial<FieldDeclaration>): Field<U> {
     return new Field<U>({ ...this, ...overrides });
   }
-
-  rename(map: (key: string) => string | undefined): Field<T> {
-    const rules = this.role?.rules;
-    if (!rules?.length) return this;
-
-    const carried = rules
-      .map((group) => group.rename(map))
-      .filter((group) => group !== null);
-    const unchanged =
-      carried.length === rules.length &&
-      carried.every((group, i) => group.equals(rules[i]!));
-    if (unchanged) return this;
-
-    const { rules: _dropped, ...rest } = this.role!;
-    return this.with({
-      role: carried.length ? { ...rest, rules: carried } : rest,
-    });
-  }
 }

package/src/field/FieldSet.ts

@@ -0,0 +1,75 @@
+import { Role } from '../axis/role/Role.js';
+import type { CompositeUnique } from '../entity/EntityDeclarations.js';
+import { Field, type FieldName, type Fields } from './Field.js';
+
+export class FieldSet<TFields extends Fields = Fields> {
+  private constructor(private readonly fields: TFields) {}
+
+  static of<TFields extends Fields>(fields: TFields): FieldSet<TFields> {
+    return new FieldSet(fields);
+  }
+
+  /**
+   * So a declared unique lands where it belongs: on the field, or on the schema.
+   * FR : pour qu'une unicité déclarée atterrisse sur le champ ou sur le schéma.
+   * `declaring(fields, [['email'], ['listId', 'docId']])`
+   * → `email` carries `role.unique`, the pair becomes a schema constraint
+   */
+  static declaring<TFields extends Fields>(
+    declared: TFields,
+    unique?: CompositeUnique<TFields>,
+  ): { fields: TFields; unique: CompositeUnique<TFields> | undefined } {
+    const fields: Fields = {};
+    for (const [key, field] of Object.entries(declared))
+      fields[key] = new Field(field, key);
+
+    const composite: string[][] = [];
+    for (const group of unique ?? []) {
+      const missing = group.filter((key) => !(key in fields));
+      if (missing.length)
+        throw new Error(
+          `unique: [${group.join(', ')}] names ` +
+            `${missing.map((key) => `'${key}'`).join(', ')}, which the entity does not declare.`,
+        );
+
+      if (group.length === 1) {
+        const key = group[0]!;
+        fields[key] = fields[key]!.with({ role: { ...fields[key]!.role, unique: true } });
+        continue;
+      }
+      composite.push([...group]);
+    }
+
+    return {
+      fields: fields as TFields,
+      unique: deduplicated(composite) as CompositeUnique<TFields> | undefined,
+    };
+  }
+
+  /** A second `primary` is refused, naming both, rather than the first winning silently. */
+  get primary(): FieldName<TFields> | undefined {
+    const primaries = Object.entries(this.fields)
+      .filter(([, field]) => Role.of(field).isPrimary)
+      .map(([name]) => name);
+
+    if (primaries.length > 1) {
+      throw new Error(
+        `FieldSet.primary: ${primaries.map((name) => JSON.stringify(name)).join(', ')} all declare ` +
+          '`primary`; a field set can have only one primary field.',
+      );
+    }
+
+    return primaries[0] as FieldName<TFields> | undefined;
+  }
+
+}
+
+/** The order is part of a group: `['a','b']` and `['b','a']` are two constraints. */
+export function deduplicated(
+  groups: readonly (readonly string[])[],
+): readonly (readonly string[])[] | undefined {
+  const seen = new Map<string, readonly string[]>();
+  for (const group of groups) seen.set(JSON.stringify(group), group);
+
+  return seen.size ? [...seen.values()] : undefined;
+}

package/src/index.ts

@@ -1,42 +1,39 @@
-export { Field, type Fields } from './schema/fields/Field.js';
-export { FieldSet } from './schema/fields/FieldSet.js';
-export { type Shape, Anatomy } from './schema/axis/shape/Shape.js';
+export { Field, type Fields } from './field/Field.js';
+export { FieldSet } from './field/FieldSet.js';
+export { type Shape, Shapes } from './axis/shape/Shape.js';
 export {
   type StringFormat,
   type FormatPredicate,
   Formats,
-} from './schema/axis/shape/Formats.js';
-export { Role, type RoleRules } from './schema/axis/role/Role.js';
-export { type Relation, type EntityConstructor } from './schema/axis/role/Relation.js';
-export { Lifecycle, type LifecycleRules } from './schema/axis/lifecycle/Lifecycle.js';
-export { type GeneratorRef, Generators } from './schema/axis/lifecycle/Generators.js';
-export { Clock } from './schema/axis/lifecycle/Clock.js';
+} from './axis/shape/Formats.js';
+export { Role, type RoleRules } from './axis/role/Role.js';
+export { type Relation, type EntityConstructor } from './axis/role/Relation.js';
+export { Lifecycle, type LifecycleRules } from './axis/lifecycle/Lifecycle.js';
+export { type GeneratorRef, Generators } from './axis/lifecycle/Generators.js';
+export { Clock } from './axis/lifecycle/Clock.js';
 export {
   Boundary,
   type BoundaryRules,
   type BoundaryRef,
-} from './schema/axis/boundary/Boundary.js';
-export { type Decoder, type Encoder, Boundaries } from './schema/axis/boundary/Boundaries.js';
-export { type Meta } from './schema/axis/Meta.js';
-export { FieldGroup } from './schema/fields/constraint/FieldGroup.js';
-export { Unique } from './schema/fields/constraint/Unique.js';
+} from './axis/boundary/Boundary.js';
+export { type Decoder, type Encoder, Boundaries } from './axis/boundary/Boundaries.js';
+export { type Meta } from './axis/Meta.js';
 
+export { Schema, ANONYMOUS_SCHEMA_NAME, type SchemaConstructor } from './Schema.js';
+export { SchemaDerivation } from './SchemaDerivation.js';
+export { Cases, type ValidationCase } from './projection/Cases.js';
+export { InputRefusal } from './validator/InputRefusal.js';
+export { type SchemaView, type Values, type PartialValues } from './SchemaView.js';
 export {
-  Schema,
-  ANONYMOUS_SCHEMA_NAME,
-  type SchemaConstructor,
-} from './schema/Schema.js';
-export { SchemaDerivation } from './schema/SchemaDerivation.js';
-export { Cases, type Case } from './projection/Cases.js';
-export { RowRefusal } from './judge/RowRefusal.js';
-export { type SchemaView, type Row, type PartialRow } from './schema/SchemaView.js';
-export { type FougereEntityAdapters, type EntityAdapters } from './entity/EntityAdapters.js';
+  type FougereEntityAdapters,
+  type EntityAdapters,
+} from './entity/EntityAdapters.js';
 export {
   type EntityDeclarations,
   type CompositeUnique,
   type PreviousNames,
 } from './entity/EntityDeclarations.js';
-export { lowerFirst, upperFirst, isObject } from './utils.js';
+export { lowerFirst, upperFirst, isObject } from './lib/utils.js';
 
 export { primary } from './vocabulary/primary.js';
 export { text } from './vocabulary/text.js';
@@ -60,7 +57,7 @@ export { readOnly } from './vocabulary/readOnly.js';
 export { writeOnly } from './vocabulary/writeOnly.js';
 export { json } from './vocabulary/json.js';
 
-export { applyCreate, applyUpdate } from './schema/axis/lifecycle/apply.js';
+export { applyCreate, applyUpdate } from './axis/lifecycle/apply.js';
 export { Visibility } from './projection/Visibility.js';
 export { Card } from './projection/card/Card.js';
 export { Bundle } from './projection/card/Bundle.js';
@@ -73,15 +70,6 @@ export type {
   RenameCandidate,
   TypeSet,
 } from './projection/card/diff.js';
-export {
-  EntityTypeSource,
-  type EntityTypeSourceOptions,
-} from './projection/card/EntityTypeSource.js';
-export {
-  FacadeTypeSource,
-  type FacadeTypeSourceOptions,
-  type OpDescriptor,
-} from './projection/card/FacadeTypeSource.js';
 export {
   type SchemaBundle,
   type SchemaDescriptor,
@@ -90,17 +78,14 @@ export {
   type RoleDescriptor,
   type RelationDescriptor,
 } from './projection/card/Descriptor.js';
-export { type SchemaOrCard, schemaOf, fieldsOf } from './projection/SchemaOrCard.js';
 export type { StandardSchemaV1 } from './projection/standard.js';
 
 export { entity } from './entity.js';
 
-export { FieldJudge } from './judge/FieldJudge.js';
-export { ValueJudge } from './judge/ValueJudge.js';
-export { RowJudge } from './judge/RowJudge.js';
-export { type ValidateOptions } from './judge/options.js';
-export {
-  type ValidationError,
-  type ValidationResult,
-  type Checked,
-} from './judge/result.js';
+export { FieldDeclarationValidator } from './validator/FieldDeclarationValidator.js';
+export { FieldValueValidator } from './validator/FieldValueValidator.js';
+export { InputValidator } from './validator/InputValidator.js';
+export { AdapterFieldValidator } from './validator/AdapterFieldValidator.js';
+export { Registry } from './lib/Registry.js';
+export { type ValidateOptions } from './validator/InputValidator.js';
+export { type ValidationError, type ValidationResult, type Checked } from './validation.js';

package/src/lib/Registry.ts

@@ -0,0 +1,37 @@
+export class Registry<T> {
+  private readonly entries: Map<string, T>;
+
+  /** `Unknown boundary decoder 'celsius' — call Boundaries.decoders.register(name, fn).` */
+  constructor(
+    private readonly label: string,
+    private readonly hint?: string,
+    builtins?: Iterable<readonly [string, T]>,
+  ) {
+    this.entries = new Map(builtins);
+  }
+
+  register(name: string, value: T): T {
+    this.entries.set(name, value);
+
+    return value;
+  }
+
+  find(name: string): T | undefined {
+    return this.entries.get(name);
+  }
+
+  resolve(name: string, path?: string): T {
+    const found = this.find(name);
+
+    if (found !== undefined) return found;
+
+    throw new Error(
+      `${path ? `${path}: ` : ''}Unknown ${this.label} '${name}'${this.hint ? ` — ${this.hint}` : ''}. ` +
+        `This process answers ${this.names.join(', ') || 'nothing yet'}.`,
+    );
+  }
+
+  private get names(): string[] {
+    return [...this.entries.keys()];
+  }
+}

package/src/projection/Cases.ts

@@ -1,70 +1,74 @@
-import { Anatomy } from '../schema/axis/shape/Shape.js';
-import { Boundary } from '../schema/axis/boundary/Boundary.js';
-import { Lifecycle } from '../schema/axis/lifecycle/Lifecycle.js';
-import { Role } from '../schema/axis/role/Role.js';
-import type { Field } from '../schema/fields/Field.js';
-import type { SchemaView } from '../schema/SchemaView.js';
-import { RowJudge } from '../judge/RowJudge.js';
-import { RowRefusal } from '../judge/RowRefusal.js';
+import { Shapes } from '../axis/shape/Shape.js';
+import { Boundary } from '../axis/boundary/Boundary.js';
+import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
+import { Role } from '../axis/role/Role.js';
+import type { Field } from '../field/Field.js';
+import type { SchemaView } from '../SchemaView.js';
+import { InputValidator } from '../validator/InputValidator.js';
+import { InputRefusal } from '../validator/InputRefusal.js';
 
 /**
- * One input, and what the judge must answer.
+ * One input, and what the validator must answer.
  *
  * `expect` carries the PATH of the field at fault and never the message. We know which
  * field must be refused because we are the ones who broke it; naming the message would
- * make this list a second judge, and the two would then have to be kept in step by hand —
+ * make this list a second validator, and the two would then have to be kept in step by hand —
  * which is the duplication the whole thing exists to remove.
  */
-export interface Case {
+export interface ValidationCase {
   /** What this input does, in one clause — carried into the assertion so a failure reads. */
   why: string;
-  body: unknown;
-  /**
-   * Judged as an update rather than a creation. The two modes refuse different things:
-   * an absence is `Required` on create and legal on patch, an immutable field is legal
-   * on create and refused on patch.
-   */
+  input: unknown;
+  /** Judged as an update rather than a creation. */
   patch: boolean;
   expect: 'accept' | { reject: string };
 }
 
-/** A value of the wrong type for the declared shape — the one violation every field has. */
+/**
+ * So every field has at least one case, whatever else it declares.
+ * FR : pour que chaque champ ait un cas, quoi qu'il déclare par ailleurs.
+ * `text()` → `42`; `number()` → `'not-a-value-of-this-shape'`
+ */
 function wrongTypeFor(field: Field): unknown {
   const declared = (field.shape as { type?: string | readonly string[] }).type;
   const names = Array.isArray(declared) ? declared : [declared];
   return names.includes('string') ? 42 : 'not-a-value-of-this-shape';
 }
 
-/** Values that break a stated bound. Empty when the field states none. */
+/**
+ * So a bound stated in a shape produces the case that breaks it, and none is invented.
+ * FR : pour qu'une borne énoncée produise le cas qui la casse, et aucun autre.
+ * `text({ maxLength: 3 })` → one case with `'xxxx'`; `text()` → no case
+ */
 function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
-  // Through `Anatomy`, not a cast: the cast admitted any keyword, and it declared
+  // Through `Shapes`, not a cast: the cast admitted any keyword, and it declared
   // `maxItems` — which no branch below ever produced. In the one function whose job is
   // to be exhaustive, a bound the type does not carry is a case nobody notices missing.
-  const shape = Anatomy.of(field.shape).base;
-  const out: { why: string; value: unknown }[] = [];
+  const shape = Shapes.of(field.shape).base;
+  const cases: { why: string; value: unknown }[] = [];
   if (shape?.type === 'string') {
     if (typeof shape.minLength === 'number' && shape.minLength > 0)
-      out.push({ why: 'shorter than min', value: 'x'.repeat(shape.minLength - 1) });
+      cases.push({ why: 'shorter than min', value: 'x'.repeat(shape.minLength - 1) });
     if (typeof shape.maxLength === 'number')
-      out.push({ why: 'longer than max', value: 'x'.repeat(shape.maxLength + 1) });
-    if (shape.enum) out.push({ why: 'outside the stated set', value: '__not-in-enum__' });
+      cases.push({ why: 'longer than max', value: 'x'.repeat(shape.maxLength + 1) });
+    if (shape.enum) cases.push({ why: 'outside the stated set', value: '__not-in-enum__' });
   }
   if (shape?.type === 'number' || shape?.type === 'integer') {
     if (typeof shape.minimum === 'number')
-      out.push({ why: 'below minimum', value: shape.minimum - 1 });
+      cases.push({ why: 'below minimum', value: shape.minimum - 1 });
     if (typeof shape.maximum === 'number')
-      out.push({ why: 'above maximum', value: shape.maximum + 1 });
+      cases.push({ why: 'above maximum', value: shape.maximum + 1 });
   }
   if (shape?.type === 'array') {
     if (typeof shape.minItems === 'number' && shape.minItems > 0)
-      out.push({ why: 'fewer items than min', value: [] });
+      cases.push({ why: 'fewer items than min', value: [] });
     if (typeof shape.maxItems === 'number')
-      out.push({
+      cases.push({
         why: 'more items than max',
         value: Array.from({ length: shape.maxItems + 1 }, () => null),
       });
   }
-  return out;
+  return cases;
 }
 
 /**
@@ -74,20 +78,14 @@ function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
  * supplies a valid row; generating data belongs to the testing package.
  */
 export class Cases {
-  private constructor(readonly all: readonly Case[]) {}
+  private constructor(readonly all: readonly ValidationCase[]) {}
 
   static of(entity: SchemaView, valid: Record<string, unknown>): Cases {
     return new Cases(enumerate(entity, valid));
   }
 
-  /**
-   * Whether a verdict is the one a case expected.
-   *
-   * Takes the RESULT rather than the input so the same reader serves the local judge, the
-   * façade and a door — the three that have to agree.
-   */
   static holds(
-    expected: Case['expect'],
+    expected: ValidationCase['expect'],
     result: { success: boolean; errors?: { path: string }[] },
   ): boolean {
     if (expected === 'accept') return result.success;
@@ -95,32 +93,35 @@ export class Cases {
     return (result.errors ?? []).some((error) => error.path === expected.reject);
   }
 
-  /** Every way a row is refused for its structure — the closed set this table must cover. */
   static get refusals(): string[] {
-    return Object.values(RowRefusal);
+    return Object.values(InputRefusal);
   }
 
-  [Symbol.iterator](): Iterator<Case> {
+  [Symbol.iterator](): Iterator<ValidationCase> {
     return this.all[Symbol.iterator]();
   }
 }
 
-function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
+/**
+ * So the four axes decide which cases exist, and no list of them is maintained by hand.
+ * FR : pour que les axes décident des cas, sans liste tenue à la main.
+ */
+function enumerate(entity: SchemaView, valid: Record<string, unknown>): ValidationCase[] {
   const fields = entity.getFields();
-  const judge = RowJudge.of(fields);
-  const cases: Case[] = [];
+  const validator = InputValidator.of(fields);
+  const cases: ValidationCase[] = [];
   const withField = (name: string, value: unknown) => ({ ...valid, [name]: value });
 
-  cases.push({ why: 'a valid body', body: valid, patch: false, expect: 'accept' });
+  cases.push({ why: 'a valid input', input: valid, patch: false, expect: 'accept' });
   cases.push({
     why: 'a key outside the contract',
-    body: { ...valid, __unknown__: 'x' },
+    input: { ...valid, __unknown__: 'x' },
     patch: false,
     expect: { reject: '__unknown__' },
   });
   cases.push({
     why: 'not an object at all',
-    body: 'a string',
+    input: 'a string',
     patch: false,
     expect: { reject: '.' },
   });
@@ -130,16 +131,16 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
     // get to invent a second one, so the only case we can state about it is the bound one.
     const isRef = Role.of(field).isReference;
 
-    if (judge.onAbsent(field) === null && name in valid) {
-      const body = { ...valid };
-      delete body[name];
-      cases.push({ why: `${name} absent`, body, patch: false, expect: { reject: name } });
+    if (validator.onAbsent(field) === null && name in valid) {
+      const input = { ...valid };
+      delete input[name];
+      cases.push({ why: `${name} absent`, input, patch: false, expect: { reject: name } });
     }
 
     if (Boundary.of(field).readOnly) {
       cases.push({
         why: `${name} supplied although read-only`,
-        body: withField(name, wrongTypeFor(field)),
+        input: withField(name, wrongTypeFor(field)),
         patch: false,
         expect: { reject: name },
       });
@@ -148,7 +149,7 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
     if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
       cases.push({
         why: `${name} supplied on an update`,
-        body: { [name]: valid[name] ?? wrongTypeFor(field) },
+        input: { [name]: valid[name] ?? wrongTypeFor(field) },
         patch: true,
         expect: { reject: name },
       });
@@ -157,14 +158,14 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
     if (name in valid && !isRef) {
       cases.push({
         why: `${name} of the wrong type`,
-        body: withField(name, wrongTypeFor(field)),
+        input: withField(name, wrongTypeFor(field)),
         patch: false,
         expect: { reject: name },
       });
       for (const { why, value } of outOfBoundsFor(field))
         cases.push({
           why: `${name} ${why}`,
-          body: withField(name, value),
+          input: withField(name, value),
           patch: false,
           expect: { reject: name },
         });