@fougere/schema 0.5.0-alpha.1 → 0.7.0-alpha.0

package/src/projection/Visibility.ts

@@ -1,7 +1,7 @@
 import { Boundary } from '../axis/boundary/Boundary.js';
 import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
 import { Role } from '../axis/role/Role.js';
-import type { Fields } from '../fields/Field.js';
+import type { Fields } from '../field/Field.js';
 
 export class Visibility {
   private constructor(private readonly fields: Fields) {}
@@ -10,6 +10,7 @@ export class Visibility {
     return new Visibility(fields);
   }
 
+  /** A write-only secret is absent from the type, not just from the value. */
   get input(): Fields {
     const result: Fields = {};
     for (const [name, field] of Object.entries(this.fields)) {
@@ -37,7 +38,10 @@ export class Visibility {
     for (const [key, field] of Object.entries(this.fields)) {
       if (!(key in record)) continue;
       const boundary = Boundary.of(field);
-      if (boundary.writeOnly) { delete out[key]; continue; }
+      if (boundary.writeOnly) {
+        delete out[key];
+        continue;
+      }
       const value = record[key];
       if (value === null || value === undefined) continue;
       out[key] = boundary.encode(value);

package/src/{card → projection/card}/Bundle.ts

@@ -1,7 +1,7 @@
-import type { Resolver } from '../axis/Axis.js';
-import type { EntityConstructor } from '../axis/role/Relation.js';
-import { lowerFirst } from '../utils.js';
-import type { SchemaView } from '../schema/SchemaView.js';
+import type { Resolver } from '../../axis/Axis.js';
+import type { EntityConstructor } from '../../axis/role/Relation.js';
+import { lowerFirst } from '../../lib/utils.js';
+import type { SchemaView } from '../../SchemaView.js';
 import { Card } from './Card.js';
 import type { SchemaBundle, SchemaDescriptor } from './Descriptor.js';
 import type { Diff, SetDiff, SetDiffOptions } from './diff.js';
@@ -47,12 +47,12 @@ export class Bundle {
   }
 
   toSchemas(): Record<string, SchemaView> {
-    const map: Record<string, EntityConstructor> = {};
-    const resolve: Resolver = (name) => map[name.toLowerCase()];
+    const byName: Record<string, EntityConstructor> = {};
+    const resolve: Resolver = (name) => byName[name.toLowerCase()];
     const schemas: Record<string, SchemaView> = {};
     for (const [name, descriptor] of Object.entries(this.descriptor.$defs)) {
       const schema = Card.fromDescriptor(descriptor).toSchema(resolve, name);
-      map[name.toLowerCase()] = schema as unknown as EntityConstructor;
+      byName[name.toLowerCase()] = schema as unknown as EntityConstructor;
       schemas[name] = schema;
     }
     return schemas;
@@ -65,11 +65,11 @@ export class Bundle {
     for (const [name, descriptor] of Object.entries(before)) {
       const target = after[name];
       if (target === undefined) continue;
-      const answer = Card.fromDescriptor(descriptor).diff(
+      const diff = Card.fromDescriptor(descriptor).diff(
         Card.fromDescriptor(target),
         { renamed: options.renamed?.[name] ?? {} },
       );
-      if (answer.changes.length > 0 || answer.ambiguous.length > 0) entities[name] = answer;
+      if (diff.changes.length > 0 || diff.ambiguous.length > 0) entities[name] = diff;
     }
     return {
       entitiesAdded: Object.keys(after).filter((name) => !(name in before)),

package/src/projection/card/Card.ts

@@ -0,0 +1,342 @@
+import { EXTENSION_AXES, EXTENSION_SLOTS, type Resolver } from '../../axis/Axis.js';
+import { dequal } from 'dequal';
+import { clean, isObject } from '../../lib/utils.js';
+import { Field, type Fields } from '../../field/Field.js';
+import { deduplicated } from '../../field/FieldSet.js';
+import { InputValidator } from '../../validator/InputValidator.js';
+import { Schema, type SchemaConstructor } from '../../Schema.js';
+import type { Values, SchemaView } from '../../SchemaView.js';
+import { refuse } from './admission.js';
+import type {
+  DerivedFrom,
+  FieldDescriptor,
+  FieldExtension,
+  SchemaDescriptor,
+} from './Descriptor.js';
+import type { Change, Diff, DiffOptions, RenameCandidate, TypeSet } from './diff.js';
+
+type FieldsOf<T> = { [K in keyof T]-?: Field<T[K]> };
+
+/** One portable schema description and every decision made about that description. */
+export class Card<T = Values<Fields>> {
+  private constructor(readonly descriptor: SchemaDescriptor) {}
+
+  static fromSchema<TFields extends Fields>(
+    schema: SchemaView<TFields>,
+    name?: string,
+  ): Card<Values<TFields>> {
+    const fields = schema.getFields();
+    const validator = InputValidator.of(fields);
+    const properties: Record<string, FieldDescriptor> = {};
+    const required: string[] = [];
+    for (const [key, field] of Object.entries(fields)) {
+      properties[key] = describeField(field, key);
+      if (validator.onAbsent(field) === null) required.push(key);
+    }
+    for (const group of schema.getUnique() ?? [])
+      for (const member of group) carryGroup(properties[member], group);
+
+    const descriptor: SchemaDescriptor = {
+      type: 'object',
+      properties,
+      'x-fougere-version': 1,
+      'x-fougere-vendor': 'fougere',
+    };
+    const title = name ?? schema.derivation?.sourceName ?? schema.name;
+    if (title) descriptor.title = title;
+    if (required.length) descriptor.required = required;
+
+    const origin = originOf(schema);
+    if (origin) descriptor['x-fougere-derived'] = origin;
+    return new Card<Values<TFields>>(descriptor);
+  }
+
+  static fromDescriptor<T = Values<Fields>>(descriptor: SchemaDescriptor): Card<T> {
+    return new Card<T>(descriptor);
+  }
+
+  get origin(): DerivedFrom | undefined {
+    return this.descriptor['x-fougere-derived'];
+  }
+
+  toSchema(resolve?: Resolver, name?: string): SchemaConstructor<FieldsOf<T>> {
+    const descriptor = this.descriptor;
+    const subject = name ? `schema '${name}'` : 'this schema';
+    if (!isObject(descriptor))
+      refuse(`${subject} is not an object`, 'A card carries one JSON Schema per door.');
+    const version = descriptor['x-fougere-version'];
+    if (version !== 1) {
+      refuse(
+        `${subject} states \`x-fougere-version: ${JSON.stringify(version)}\` and this reader speaks 1`,
+        'A producer and its readers move together: re-sync the consumer, or serve the version it speaks.',
+      );
+    }
+    if (!isObject(descriptor.properties)) {
+      refuse(
+        `${subject} carries no \`properties\` object`,
+        'A schema is its fields; there is nothing to rebuild.',
+      );
+    }
+
+    const fields: Fields = {};
+    const groups: string[][] = [];
+    for (const [key, property] of Object.entries(descriptor.properties)) {
+      fields[key] = reconstructField(property, key, resolve);
+      for (const group of property['x-fougere']?.role?.unique ?? [])
+        if (group.length > 1) groups.push([...group]);
+    }
+    const schema = Schema.of({ fields, constraints: { unique: deduplicated(groups) } });
+    const title = name ?? descriptor.title;
+    if (title)
+      Object.defineProperty(schema, 'name', { value: title, configurable: true });
+    return schema as unknown as SchemaConstructor<FieldsOf<T>>;
+  }
+
+  diff(other: Card, options: DiffOptions = {}): Diff {
+    const changes: Change[] = [];
+    const renamed = options.renamed ?? {};
+    const before = this.descriptor.properties ?? {};
+    const after = other.descriptor.properties ?? {};
+    const requiredBefore = new Set(this.descriptor.required ?? []);
+    const requiredAfter = new Set(other.descriptor.required ?? []);
+
+    // Apply a declared rename first so subsequent differences use the new field name.
+    const nameAfter = (field: string): string => renamed[field] ?? field;
+    const removed: string[] = [];
+    for (const [field, descriptor] of Object.entries(before)) {
+      const now = nameAfter(field);
+      const target = after[now];
+      if (target === undefined) {
+        removed.push(field);
+        continue;
+      }
+
+      if (now !== field)
+        changes.push({ kind: 'renamed', from: field, to: now, field: target });
+
+      const wasType = typesOf(descriptor);
+      const isType = typesOf(target);
+      if (!dequal(wasType, isType))
+        changes.push({ kind: 'retyped', field: now, from: wasType, to: isType });
+      else if (!dequal(boundsOf(descriptor), boundsOf(target))) {
+        changes.push({ kind: 'reshaped', field: now, from: descriptor, to: target });
+      }
+
+      const wasRequired = requiredBefore.has(field);
+      const isRequired = requiredAfter.has(now);
+      if (wasRequired !== isRequired) {
+        changes.push({ kind: 'required', field: now, from: wasRequired, to: isRequired });
+      }
+      changes.push(...restated(now, descriptor['x-fougere'], target['x-fougere']));
+    }
+
+    const claimed = new Set(Object.values(renamed));
+    const added = Object.keys(after).filter(
+      (field) => !(field in before) && !claimed.has(field),
+    );
+    for (const field of removed) {
+      changes.push({
+        kind: 'removed',
+        field,
+        from: before[field],
+        required: requiredBefore.has(field),
+      });
+    }
+    for (const field of added) {
+      changes.push({
+        kind: 'added',
+        field,
+        to: after[field],
+        required: requiredAfter.has(field),
+      });
+    }
+
+    return { changes, ambiguous: candidates(removed, added, before, after) };
+  }
+}
+
+/**
+ * So the three axes write themselves under `x-fougere`, each by its own hand.
+ * FR : pour que les trois axes s'écrivent sous `x-fougere`, chacun de sa main.
+ * `ref(User)` → `{ role: { relation: { to: 'user', kind: 'one' } } }`
+ */
+function describeExtension(field: Field, key: string): FieldExtension | undefined {
+  const extension: Record<string, unknown> = {};
+  for (const axis of EXTENSION_AXES) {
+    const declared = (field as unknown as Record<string, unknown>)[axis.slot];
+    if (declared === undefined) continue;
+    const wire = axis.describe(declared, key);
+    if (wire !== undefined) extension[axis.slot] = wire;
+  }
+  clean(extension);
+  return Object.keys(extension).length ? (extension as FieldExtension) : undefined;
+}
+
+/**
+ * So the shape stays plain JSON Schema, and what is ours sits under one key.
+ * FR : pour que la forme reste du JSON Schema, ce qui est à nous tenant sous une clé.
+ * `text({ max: 200 })` → `{ type: 'string', maxLength: 200 }`
+ */
+function describeField(field: Field, key: string): FieldDescriptor {
+  // The shape IS JSON Schema, so it lands whole rather than key by key — which is what let
+  // it be copied under a computed key into a type that names its own.
+  const descriptor: FieldDescriptor = clean({ ...field.shape }) as FieldDescriptor;
+  if (field.meta?.description) descriptor.description = field.meta.description;
+  const extension = describeExtension(field, key);
+  if (extension) descriptor['x-fougere'] = extension;
+  return descriptor;
+}
+
+/**
+ * So a derived card names its root and what became of each field.
+ * FR : pour qu'une carte dérivée nomme sa racine et le sort de chaque champ.
+ * `Post.pick('title')` → `{ from: 'Post', nameOf: { title: 'title' } }`
+ */
+function originOf(schema: SchemaView): DerivedFrom | undefined {
+  const { derivation } = schema;
+  if (!derivation) return undefined;
+  const nameOf = Object.fromEntries(
+    Object.entries(derivation.nameOf).map(([key, value]) => [key, value ?? null]),
+  );
+  return { from: derivation.sourceName, nameOf };
+}
+
+/**
+ * So a shape read back is the shape that was written, and an unknown type is refused.
+ * FR : pour qu'une forme relue soit celle qui a été écrite, un type inconnu étant refusé.
+ * `{ type: 'string', maxLength: 200 }` → the same shape a `text({ max: 200 })` states
+ */
+function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined {
+  const types = Array.isArray(property.type) ? property.type : property.type ? [property.type] : [];
+  if (!types.some((type) => type !== 'null')) return undefined;
+
+  // `describeField` writes the shape whole, so it is read whole: a list of keywords here
+  // would be a second inventory, and the one that forgets a keyword loses it in silence.
+  const { 'x-fougere': _extension, description: _description, ...shape } = property;
+  if (shape.items) shape.items = reconstructShape(shape.items) as FieldDescriptor;
+
+  return clean(shape) as Field['shape'];
+}
+
+/**
+ * So a field read back carries its axes, rebuilt by the axes themselves.
+ * FR : pour qu'un champ relu porte ses axes, reconstruits par les axes eux-mêmes.
+ * `{ 'x-fougere': { lifecycle: { create: 'now' } } }` → a field stamped at create
+ */
+function reconstructField(
+  property: FieldDescriptor,
+  key: string,
+  resolve?: Resolver,
+): Field {
+  const shape = reconstructShape(property);
+  if (!shape) {
+    throw new Error(
+      `Field '${key}': the card carries no \`type\` for it, so there is no shape to rebuild. ` +
+        'A field always states one.',
+    );
+  }
+  const extension = property['x-fougere'];
+  const axes: Record<string, unknown> = {};
+  for (const axis of EXTENSION_AXES) {
+    const wire = (extension as Record<string, unknown> | undefined)?.[axis.slot];
+    if (wire !== undefined) axes[axis.slot] = axis.reconstruct(wire, resolve);
+  }
+  return new Field({
+    shape,
+    ...axes,
+    meta:
+      property.description !== undefined
+        ? { description: property.description }
+        : undefined,
+  } as never);
+}
+
+/**
+ * So an axis that changed is one named difference, not a whole field marked dirty.
+ * FR : pour qu'un axe modifié soit une différence nommée, pas un champ entier marqué.
+ * `{ kind: 'restated', field: 'body', axis: 'boundary', … }`
+ */
+function restated(
+  field: string,
+  before: FieldExtension | undefined,
+  after: FieldExtension | undefined,
+): Change[] {
+  return EXTENSION_SLOTS.filter((axis) => !dequal(before?.[axis], after?.[axis])).map(
+    (axis) =>
+      ({
+        kind: 'restated',
+        field,
+        axis,
+        from: before?.[axis],
+        to: after?.[axis],
+      }) as Change,
+  );
+}
+
+/**
+ * So two shapes are compared without what is not shape getting in the way.
+ * FR : pour que deux formes se comparent sans que le reste s'en mêle.
+ * `{ type: 'string', description: 'x' }` → `{ type: 'string' }`
+ */
+function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
+  const { 'x-fougere': _extension, description: _description, ...shape } = descriptor;
+  return shape as Record<string, unknown>;
+}
+
+/**
+ * So `['string','null']` and `['null','string']` are the same type, not a change.
+ * FR : pour que `['string','null']` et `['null','string']` soient un même type.
+ * `typesOf({ type: ['null', 'string'] })` → `['null', 'string']`
+ */
+function typesOf(descriptor: FieldDescriptor): TypeSet {
+  const type = descriptor.type;
+  if (type === undefined) return [];
+  return (Array.isArray(type) ? [...type] : [type]).sort();
+}
+
+/**
+ * So a bound that moved is a `reshaped`, told apart from a type that changed.
+ * FR : pour qu'une borne déplacée soit un `reshaped`, distinct d'un type changé.
+ * `maxLength: 200` → `maxLength: 100` → one `reshaped`, never a `retyped`
+ */
+function boundsOf(descriptor: FieldDescriptor): Record<string, unknown> {
+  const { type: _type, ...rest } = shapeOf(descriptor);
+  return rest;
+}
+
+/**
+ * So a removal plus an addition of the same shape is a question, never a guess.
+ * FR : pour qu'une suppression plus un ajout de même forme soit une question, pas un pari.
+ * `body` gone, `content` appeared → `ambiguous: [{ removed: 'body', added: 'content' }]`
+ */
+function candidates(
+  removed: string[],
+  added: string[],
+  before: Record<string, FieldDescriptor>,
+  after: Record<string, FieldDescriptor>,
+): RenameCandidate[] {
+  const found: RenameCandidate[] = [];
+  for (const gone of removed) {
+    for (const appeared of added) {
+      if (dequal(shapeOf(before[gone]), shapeOf(after[appeared])))
+        found.push({ removed: gone, added: appeared });
+    }
+  }
+  const was = Object.keys(before);
+  const now = Object.keys(after);
+  const apart = ({ removed: gone, added: appeared }: RenameCandidate): number =>
+    Math.abs(now.indexOf(appeared) - was.indexOf(gone));
+  return found.sort((a, b) => apart(a) - apart(b));
+}
+
+/**
+ * So a group spanning several fields reaches a reader that only ever sees one field.
+ * FR : pour qu'un groupe couvrant plusieurs champs atteigne un lecteur qui n'en voit qu'un.
+ * `carryGroup(properties.listId, ['listId', 'docId'])` → the pair lands under its `role`
+ */
+function carryGroup(property: FieldDescriptor | undefined, group: readonly string[]): void {
+  if (!property) return;
+  const extension = (property['x-fougere'] ??= {}) as { role?: { unique?: string[][] } };
+  const role = (extension.role ??= {});
+  (role.unique ??= []).push([...group]);
+}

package/src/{card → projection/card}/Descriptor.ts

@@ -1,8 +1,8 @@
-import type { BoundaryRef } from '../axis/boundary/Boundary.js';
-import type { LifecycleRules } from '../axis/lifecycle/Lifecycle.js';
-import type { Relation } from '../axis/role/Relation.js';
-import type { RoleRules } from '../axis/role/Role.js';
-import type { Shape } from '../axis/shape/Shape.js';
+import type { BoundaryRef } from '../../axis/boundary/Boundary.js';
+import type { LifecycleRules } from '../../axis/lifecycle/Lifecycle.js';
+import type { Relation } from '../../axis/role/Relation.js';
+import type { RoleRules } from '../../axis/role/Role.js';
+import type { Shape } from '../../axis/shape/Shape.js';
 
 type JsonSchemaType =
   | 'string'
@@ -40,7 +40,7 @@ export type RoleDescriptor = Pick<RoleRules, 'primary' | 'index'> & {
 export type RelationDescriptor = Pick<Relation, 'kind' | 'onDelete'> & { to: string };
 
 /**
- * What a derivation was cut from, and what the cut left — `survived` keyed by the
+ * What a derivation was cut from, and what the cut left — `nameOf` keyed by the
  * ORIGIN's field names. Absent on a declaration that derives from nothing.
  *
  * A dropped field is `null` and never `undefined`: JSON.stringify erases the second,
@@ -48,7 +48,7 @@ export type RelationDescriptor = Pick<Relation, 'kind' | 'onDelete'> & { to: str
  */
 export interface DerivedFrom {
   from: string;
-  survived: Record<string, string | null>;
+  nameOf: Record<string, string | null>;
 }
 
 export interface SchemaDescriptor {

package/src/projection/card/admission.ts

@@ -0,0 +1,40 @@
+import type { ValidationError } from '../../validation.js';
+
+/**
+ * So a card that cannot be read says what is wrong and what to write instead.
+ * FR : pour qu'une carte illisible dise ce qui cloche et quoi écrire.
+ * `refuse('role.relation.kind is "maybe"', 'Expected one of one, many.')`
+ */
+export function refuse(what: string, fix: string): never {
+  throw new Error(`This card cannot be read: ${what}.\n  ${fix}`);
+}
+
+/**
+ * So a card's axis passes the same validator as a hand-written one, and no second validator exists.
+ * FR : pour qu'un axe d'une carte passe le juge des autres, sans second juge.
+ * `{ update: 'maybe' }` on a card → `lifecycle is malformed — lifecycle.update: Expected 'now' or 'forbidden'`
+ */
+export function admitWire(
+  validator: (value: unknown, errors: ValidationError[]) => void,
+  value: unknown,
+  slot: string,
+): void {
+  const errors: ValidationError[] = [];
+  validator(value, errors);
+  if (errors.length) {
+    refuse(
+      `${slot} is malformed — ${errors.map((e) => `${e.path}: ${e.message}`).join('; ')}`,
+      'A card states an axis the way a declaration does.',
+    );
+  }
+}
+
+/**
+ * So a closed set is checked against the list that declares it, never against a copy.
+ * FR : pour qu'un ensemble fermé soit vérifié contre la liste qui le déclare.
+ * `oneOfTokens('many', RELATION_KINDS)` → `true`
+ */
+export const oneOfTokens = <T extends readonly string[]>(
+  value: unknown,
+  tokens: T,
+): value is T[number] => typeof value === 'string' && (tokens as readonly string[]).includes(value);

package/src/{card → projection/card}/diff.ts

@@ -1,5 +1,5 @@
-import type { BoundaryRef } from '../axis/boundary/Boundary.js';
-import type { LifecycleRules } from '../axis/lifecycle/Lifecycle.js';
+import type { BoundaryRef } from '../../axis/boundary/Boundary.js';
+import type { LifecycleRules } from '../../axis/lifecycle/Lifecycle.js';
 import type { FieldDescriptor, RoleDescriptor } from './Descriptor.js';
 
 /** One named difference, at one place. Each kind exists because a reader asks for it. */
@@ -8,7 +8,7 @@ export type Change =
   | { kind: 'added'; field: string; to: FieldDescriptor; required: boolean }
   /** DDL: drop the column. Codec: the old caller still sends it, and it goes nowhere. */
   | { kind: 'removed'; field: string; from: FieldDescriptor; required: boolean }
-  /** DDL: rename the column. Codec and ORM: one more entry in the field-to-column map. */
+  /** DDL: rename the column. Codec and storage: one more entry in the field-to-column map. */
   | { kind: 'renamed'; from: string; to: string; field: FieldDescriptor }
   /** DDL: alter the type. Codec: convert the value, when it can. */
   | { kind: 'retyped'; field: string; from: TypeSet; to: TypeSet }

package/src/validator/AdapterFieldValidator.ts

@@ -0,0 +1,40 @@
+import { Validator } from '@cfworker/json-schema';
+import type { Shape } from '../axis/shape/Shape.js';
+import { isObject } from '../lib/utils.js';
+
+/**
+ * The format is DATA, not a TypeScript interface: an interface is erased before a JS
+ * caller, a config or a card from another language could be measured against it.
+ */
+export class AdapterFieldValidator {
+  private constructor(private readonly validator: Validator) {}
+
+  /** Compiled once, at the adapter's own module load. */
+  static of(format: Shape): AdapterFieldValidator {
+    return new AdapterFieldValidator(new Validator(format as object, '2020-12', true));
+  }
+
+  /** `Post.adapters.sql.body.columnType: Property "postgre" does not match …` */
+  assert(entries: unknown, path: string): void {
+    if (entries === undefined) return;
+
+    if (!isObject(entries)) {
+      throw new Error(
+        `${path}: expected an object keyed by field name, got ${typeof entries}.`,
+      );
+    }
+
+    for (const [field, entry] of Object.entries(entries)) {
+      const verdict = this.validator.validate(entry);
+      if (verdict.valid) continue;
+
+      // The engine reports outermost first and ends on `False boolean schema`, which names
+      // nothing. The last unit above that one is the one carrying the offending key.
+      const units = verdict.errors.filter((unit) => unit.keyword !== 'false');
+      const failure = units[units.length - 1] ?? verdict.errors[0];
+      const nested = (failure?.instanceLocation ?? '#').slice(1).replaceAll('/', '.');
+
+      throw new Error(`${path}.${field}${nested}: ${failure?.error ?? 'does not match the format'}`);
+    }
+  }
+}

package/src/{judge/FieldJudge.ts → validator/FieldDeclarationValidator.ts}

@@ -1,14 +1,14 @@
-import { EXTENSION_AXES } from "../axis/Axis.js";
-import { Anatomy } from "../axis/shape/Shape.js";
-import type { Field } from "../fields/Field.js";
-import { isObject } from "./ValueForm.js";
-import type { ValidationError, ValidationResult } from "./result.js";
+import { EXTENSION_AXES } from '../axis/Axis.js';
+import { Shapes } from '../axis/shape/Shape.js';
+import type { Field } from '../field/Field.js';
+import { isObject } from '../lib/utils.js';
+import type { ValidationError, ValidationResult } from '../validation.js';
 
-export class FieldJudge {
+export class FieldDeclarationValidator {
   private constructor(private readonly declaration: unknown) {}
 
-  static of(declaration: unknown): FieldJudge {
-    return new FieldJudge(declaration);
+  static of(declaration: unknown): FieldDeclarationValidator {
+    return new FieldDeclarationValidator(declaration);
   }
 
   get verdict(): ValidationResult<Field> {
@@ -19,7 +19,7 @@ export class FieldJudge {
         success: false,
         errors: [
           {
-            path: ".",
+            path: '.',
             message: `Expected an object — got ${JSON.stringify(declaration)}`,
           },
         ],
@@ -28,29 +28,29 @@ export class FieldJudge {
 
     const errors: ValidationError[] = [];
 
-    if (!Anatomy.is(declaration.shape)) {
+    if (!Shapes.is(declaration.shape)) {
       errors.push({
-        path: "shape",
+        path: 'shape',
         message: `Every field states a shape — got ${JSON.stringify(declaration.shape)}`,
       });
     }
 
     for (const axis of EXTENSION_AXES) {
       const declared = declaration[axis.slot];
-      if (declared !== undefined) axis.judge(declared, errors);
+      if (declared !== undefined) axis.validator(declared, errors);
     }
 
     if (declaration.meta !== undefined) {
       if (!isObject(declaration.meta)) {
         errors.push({
-          path: "meta",
+          path: 'meta',
           message: `Expected an object — got ${JSON.stringify(declaration.meta)}`,
         });
       } else if (
         declaration.meta.description !== undefined &&
-        typeof declaration.meta.description !== "string"
+        typeof declaration.meta.description !== 'string'
       ) {
-        errors.push({ path: "meta.description", message: "Expected a string" });
+        errors.push({ path: 'meta.description', message: 'Expected a string' });
       }
     }