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

package/src/axis/boundary/Boundaries.ts

@@ -1,44 +1,37 @@
 import type { BoundaryRules } from './Boundary.js';
+import { Registry } from '../../lib/Registry.js';
 
 export type Decoder = (value: unknown) => { value: unknown } | { error: string };
 export type Encoder = (value: unknown) => unknown;
 
-export class Boundaries {
-  private static readonly decoders = new Map<string, Decoder>();
-  private static readonly encoders = new Map<string, Encoder>();
-  private static readonly aliases = new Map<string, BoundaryRules>();
-
-  static registerDecoder(name: string, fn: Decoder): void { this.decoders.set(name, fn); }
-  static registerEncoder(name: string, fn: Encoder): void { this.encoders.set(name, fn); }
-
-  static registerAlias(name: string, boundary: BoundaryRules): void { this.aliases.set(name, boundary); }
-
-  static alias(name: string): BoundaryRules | undefined { return this.aliases.get(name); }
-
-  static decoder(name: string): Decoder { return this.named(this.decoders, name, 'decoder'); }
-  static encoder(name: string): Encoder { return this.named(this.encoders, name, 'encoder'); }
-
-  private static named<T>(registry: Map<string, T>, name: string, kind: string): T {
-    const fn = registry.get(name);
-    if (!fn) {
-      throw new Error(
-        `Unknown boundary ${kind}: '${name}'. Register it with ` +
-          `Boundaries.register${kind[0].toUpperCase()}${kind.slice(1)}('${name}', …).`,
-      );
-    }
-    return fn;
-  }
-}
-
-Boundaries.registerDecoder('isoDate', (value) => {
+/**
+ * `decoders` for a value coming in, `encoders` for one going out, `aliases` for the word
+ * that names a pair. Three registries, so a codec is never half declared.
+ * FR : `decoders` à l'entrée, `encoders` à la sortie, `aliases` pour le mot qui nomme la paire.
+ * `Boundaries.aliases.register('isoDate', { in: { decode: 'isoDate' }, out: { encode: 'isoDate' } })`
+ * → a field saying `boundary: 'isoDate'` decodes to a `Date` and leaves as a string
+ */
+export const Boundaries = {
+  decoders: new Registry<Decoder>(
+    'boundary decoder',
+    'call Boundaries.decoders.register(name, fn)',
+  ),
+  encoders: new Registry<Encoder>(
+    'boundary encoder',
+    'call Boundaries.encoders.register(name, fn)',
+  ),
+  aliases: new Registry<BoundaryRules>('boundary alias'),
+};
+
+Boundaries.decoders.register('isoDate', (value) => {
   if (value instanceof Date) return { value };
   if (typeof value === 'string') {
-    const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? { error: 'Invalid date' } : { value: d };
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? { error: 'Invalid date' } : { value: date };
   }
   return { error: 'Expected a date' };
 });
-Boundaries.registerEncoder('isoDate', (value) =>
+Boundaries.encoders.register('isoDate', (value) =>
   value instanceof Date ? value.toISOString() : value,
 );
-Boundaries.registerAlias('isoDate', { in: { decode: 'isoDate' }, out: { encode: 'isoDate' } });
+Boundaries.aliases.register('isoDate', { in: { decode: 'isoDate' }, out: { encode: 'isoDate' } });

package/src/axis/boundary/Boundary.ts

@@ -1,7 +1,7 @@
 import type { Decoder, Encoder } from './Boundaries.js';
 import { Boundaries } from './Boundaries.js';
-import type { Field } from '../../fields/Field.js';
-import { Anatomy, type Shape } from '../shape/Shape.js';
+import type { Field } from '../../field/Field.js';
+import { Shapes, type Shape } from '../shape/Shape.js';
 
 export interface BoundaryRules {
   in?: 'closed' | { decode: string };
@@ -19,19 +19,23 @@ export class Boundary implements BoundaryRules {
   readonly decode: Decoder;
   readonly encode: Encoder;
 
-  private constructor(rules: BoundaryRules = {}, codecs?: { decode: Decoder; encode: Encoder }) {
+  private constructor(
+    rules: BoundaryRules = {},
+    codecs?: { decode: Decoder; encode: Encoder },
+  ) {
     this.in = rules.in;
     this.out = rules.out;
     this.decode = codecs?.decode ?? identityDecoder;
     this.encode = codecs?.encode ?? identityEncoder;
   }
 
+  /** An unknown alias stops here. */
   static declared(field: Field): Boundary {
     const ref = field.boundary;
     if (ref === undefined) return new Boundary();
     if (typeof ref !== 'string') return new Boundary(ref);
 
-    const alias = Boundaries.alias(ref);
+    const alias = Boundaries.aliases.find(ref);
     if (!alias) throw new Error(`Unknown boundary alias: '${ref}'`);
     return new Boundary(alias);
   }
@@ -39,17 +43,27 @@ export class Boundary implements BoundaryRules {
   static of(field: Field): Boundary {
     const declared = Boundary.declared(field);
     const derived = Boundary.forShape(field.shape);
-    const rules: BoundaryRules = { in: declared.in ?? derived.in, out: declared.out ?? derived.out };
+    const rules: BoundaryRules = {
+      in: declared.in ?? derived.in,
+      out: declared.out ?? derived.out,
+    };
     return new Boundary(rules, {
-      decode: typeof rules.in === 'object' ? Boundaries.decoder(rules.in.decode) : identityDecoder,
-      encode: typeof rules.out === 'object' ? Boundaries.encoder(rules.out.encode) : identityEncoder,
+      decode:
+        typeof rules.in === 'object'
+          ? Boundaries.decoders.resolve(rules.in.decode)
+          : identityDecoder,
+      encode:
+        typeof rules.out === 'object'
+          ? Boundaries.encoders.resolve(rules.out.encode)
+          : identityEncoder,
     });
   }
 
+  /** `date-time` means a `Date` on both sides, without a word in the entity. */
   static forShape(shape: Shape | undefined): Boundary {
-    const base = Anatomy.of(shape).base;
+    const base = Shapes.of(shape).base;
     if (base?.type === 'string' && base.format === 'date-time') {
-      return new Boundary(Boundaries.alias('isoDate')!);
+      return new Boundary(Boundaries.aliases.find('isoDate')!);
     }
     return new Boundary();
   }
@@ -65,5 +79,4 @@ export class Boundary implements BoundaryRules {
   get writeOnly(): boolean {
     return this.out === 'closed';
   }
-
 }

package/src/axis/boundary/BoundaryAxis.ts

@@ -1,12 +1,12 @@
 import type { Axis } from '../Axis.js';
-import { admitWire } from '../../card/admission.js';
-import { isObject } from '../../judge/ValueForm.js';
+import { admitWire } from '../../projection/card/admission.js';
+import { isObject } from '../../lib/utils.js';
 import type { BoundaryRef } from './Boundary.js';
 
 export const boundaryAxis: Axis<BoundaryRef, BoundaryRef> = {
   slot: 'boundary',
 
-  judge(value, errors) {
+  validator(value, errors) {
     if (typeof value === 'string') return; 
     if (!isObject(value)) {
       errors.push({
@@ -26,7 +26,7 @@ export const boundaryAxis: Axis<BoundaryRef, BoundaryRef> = {
 
   describe: (value) => value,
   reconstruct: (wire) => {
-    admitWire(boundaryAxis.judge, wire, 'boundary');
+    admitWire(boundaryAxis.validator, wire, 'boundary');
     return wire;
   },
 };

package/src/axis/lifecycle/Clock.ts

@@ -16,7 +16,7 @@ export class Clock {
     return this.reading();
   }
 
-  /** Freeze the instant this clock reads. Returns the gesture that restores it. */
+  /** One substitution moves time for every stamp in the process at once. */
   static freeze(at: number | Date): () => void {
     const previous = this.reading;
     const instant = at instanceof Date ? at.getTime() : at;

package/src/axis/lifecycle/Generators.ts

@@ -1,5 +1,7 @@
 import { createId } from '@paralleldrive/cuid2';
 
+import { Registry } from '../../lib/Registry.js';
+
 export type GeneratorRef = 'cuid2' | 'uuid' | 'nanoid' | (string & {});
 
 const NANOID_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
@@ -11,36 +13,17 @@ function nanoid(): string {
 }
 
 /**
- * Who answers a `generate` by name — one registry per process, like `Formats` and
- * `Boundaries`.
- *
- * The three builtins are REGISTERED rather than switched on, which is what brings the
- * refusal back inside: a registry whose unknown name is refused by a `default:` branch in
- * its caller does not know what it holds, so it cannot say so.
+ * Who answers a `generate:` name. `cuid2`, `uuid` and `nanoid` are registered like any
+ * other, so `Generators.resolve('ulid')` is refused here and lists the three.
+ * FR : pour qu'un `generate:` soit répondu par un registre, builtins compris.
+ * `Generators.register('ulid', ulid)` → `create: { generate: 'ulid' }` now resolves
  */
-export class Generators {
-  private static readonly registry = new Map<string, () => string>([
+export const Generators = new Registry<() => string>(
+  'generator',
+  'call Generators.register(name, fn)',
+  [
     ['cuid2', createId],
     ['uuid', () => globalThis.crypto.randomUUID()],
     ['nanoid', nanoid],
-  ]);
-
-  static register(name: string, fn: () => string): void {
-    this.registry.set(name, fn);
-  }
-
-  /** The generator this name stands for, refused by name when nothing does. */
-  static resolve(ref: GeneratorRef): () => string {
-    const found = this.registry.get(ref);
-    if (found) return found;
-    throw new Error(
-      `Unknown generator '${ref}' — register it with Generators.register('${ref}', fn). ` +
-      `This process answers ${[...this.registry.keys()].join(', ')}.`,
-    );
-  }
-
-  /** Whether a name is answered, for a caller that must not throw to find out. */
-  static answers(ref: GeneratorRef): boolean {
-    return this.registry.has(ref);
-  }
-}
+  ],
+);

package/src/axis/lifecycle/LifecycleAxis.ts

@@ -1,18 +1,18 @@
 import type { Axis } from '../Axis.js';
-import type { ValidationError } from '../../judge/result.js';
-import { admitWire } from '../../card/admission.js';
-import { isObject, oneOfTokens } from '../../judge/ValueForm.js';
+import type { ValidationError } from '../../validation.js';
+import { admitWire, oneOfTokens } from '../../projection/card/admission.js';
+import { isObject } from '../../lib/utils.js';
 import { CREATE_TOKENS, UPDATE_TOKENS, type LifecycleRules } from './Lifecycle.js';
 
 export const lifecycleAxis: Axis<LifecycleRules, LifecycleRules> = {
   slot: 'lifecycle',
 
-  judge(value, errors) {
+  validator(value, errors) {
     if (!isObject(value)) {
       errors.push({ path: 'lifecycle', message: `Expected an object — got ${JSON.stringify(value)}` });
       return;
     }
-    if (value.create !== undefined) judgeCreate(value.create, errors);
+    if (value.create !== undefined) validateCreate(value.create, errors);
     if (value.update !== undefined && !oneOfTokens(value.update, UPDATE_TOKENS)) {
       errors.push({
         path: 'lifecycle.update',
@@ -23,12 +23,17 @@ export const lifecycleAxis: Axis<LifecycleRules, LifecycleRules> = {
 
   describe: (value) => value,
   reconstruct: (wire) => {
-    admitWire(lifecycleAxis.judge, wire, 'lifecycle');
+    admitWire(lifecycleAxis.validator, wire, 'lifecycle');
     return wire;
   },
 };
 
-function judgeCreate(rule: unknown, errors: ValidationError[]): void {
+/**
+ * So the four legal ways to declare a creation are stated once, and anything else names them.
+ * FR : pour que les quatre façons de déclarer une création soient dites une fois.
+ * `create: 3` → `Expected 'now', 'optional', { value } or { generate } — got 3`
+ */
+function validateCreate(rule: unknown, errors: ValidationError[]): void {
   if (oneOfTokens(rule, CREATE_TOKENS)) return;
   if (isObject(rule)) {
     if ('value' in rule) return;

package/src/axis/lifecycle/apply.ts

@@ -1,38 +1,53 @@
 import { Lifecycle } from './Lifecycle.js';
 import { Generators } from './Generators.js';
 import { Clock } from './Clock.js';
-import { type Field, type Fields } from '../../fields/Field.js';
-
-type Row = Record<string, unknown>;
-
-export function applyCreate(fields: Fields, input: Row): Row {
-  const out: Row = { ...input };
+import { type Field, type Fields } from '../../field/Field.js';
+
+/**
+ * So every storage realizes a create the same way.
+ * FR : pour que chaque storage réalise une création de la même façon.
+ * `applyCreate({ id: primary(), createdAt: created() }, { title: 'a' })`
+ * → `id` generated, `createdAt` stamped, `title` untouched
+ */
+export function applyCreate(fields: Fields, input: Record<string, unknown>): Record<string, unknown> {
+  const values: Record<string, unknown> = { ...input };
   const instant = Clock.now();
 
   for (const [name, field] of Object.entries(fields) as [string, Field][]) {
-    if (name in out) continue;
+    if (name in values) continue;
     const rule = Lifecycle.of(field);
 
-    if (rule.create === 'now') out[name] = new Date(instant);
-    else if (rule.literal) out[name] = freshValue(rule.literal.value);
-    else if (rule.generator) out[name] = Generators.resolve(rule.generator)();
+    if (rule.create === 'now') values[name] = new Date(instant);
+    else if (rule.literal) values[name] = freshValue(rule.literal.value);
+    else if (rule.generator) values[name] = Generators.resolve(rule.generator)();
   }
 
-  return out;
+  return values;
 }
 
+/**
+ * So two rows created from one declared default never end up sharing the same object.
+ * FR : pour que deux lignes nées d'un même défaut ne partagent pas l'objet.
+ * `create: { value: [] }` → each instance gets its own array
+ */
 function freshValue(value: unknown): unknown {
   if (value === null || typeof value !== 'object') return value;
   return structuredClone(value);
 }
 
-export function applyUpdate(fields: Fields, patch: Row): Row {
-  const out: Row = { ...patch };
+/**
+ * So `updated()` is stamped by the storage, and no handler has to remember it.
+ * FR : pour qu'`updated()` soit estampé par le storage, pas par le handler.
+ * `applyUpdate(fields, { title: 'b' })` → `updatedAt` added, nothing else
+ */
+export function applyUpdate(fields: Fields, patch: Record<string, unknown>): Record<string, unknown> {
+  const values: Record<string, unknown> = { ...patch };
   const instant = Clock.now();
 
   for (const [name, field] of Object.entries(fields) as [string, Field][]) {
-    if (Lifecycle.of(field).stampedOnUpdate && !(name in out)) out[name] = new Date(instant);
+    if (Lifecycle.of(field).stampedOnUpdate && !(name in values))
+      values[name] = new Date(instant);
   }
 
-  return out;
+  return values;
 }

package/src/axis/role/Relation.ts

@@ -10,22 +10,23 @@ export interface Relation {
 }
 
 /**
- * How a relation is built — the one place a target becomes a thunk.
+ * How a relation is built — the one place a target becomes `() => Entity`.
  *
  * A target arrives as the class or as a function returning it, because a cycle between two
  * entities can only be written the second way. Recognised by FORM, `getFields` on the
- * value: a class answers it, a thunk does not.
+ * value: a class answers it, `() => Post` does not.
  */
 export const Relation = {
+  /** `() => Post` so two entities can point at each other. */
   one(target: EntityConstructor | (() => EntityConstructor), cascade?: boolean): Relation {
-    return { to: thunk(target), kind: 'one', onDelete: cascade ? 'cascade' : undefined };
+    return { to: normalizeTarget(target), kind: 'one', onDelete: cascade ? 'cascade' : undefined };
   },
 
   many(target: EntityConstructor | (() => EntityConstructor)): Relation {
-    return { to: thunk(target), kind: 'many' };
+    return { to: normalizeTarget(target), kind: 'many' };
   },
 };
 
-function thunk<E extends EntityConstructor>(target: E | (() => E)): () => E {
+function normalizeTarget<E extends EntityConstructor>(target: E | (() => E)): () => E {
   return 'getFields' in target ? () => target as E : (target as () => E);
 }

package/src/axis/role/Role.ts

@@ -1,39 +1,29 @@
-import { FieldGroup } from "../../constraint/FieldGroup.js";
-import { Unique } from "../../constraint/Unique.js";
-import type { EntityConstructor, Relation } from "./Relation.js";
+import type { EntityConstructor, Relation } from './Relation.js';
 
 export interface RoleRules {
   primary?: boolean;
   index?: boolean;
+  unique?: boolean;
   relation?: Relation;
-  rules?: readonly FieldGroup[];
 }
 
 export class Role implements RoleRules {
   readonly primary?: boolean;
   readonly index?: boolean;
+  readonly unique?: boolean;
   readonly relation?: Relation;
-  readonly rules?: readonly FieldGroup[];
 
-  private constructor(declared: RoleRules = {}) {
-    this.primary = declared.primary;
-    this.index = declared.index;
-    this.relation = declared.relation;
-    this.rules = declared.rules;
+  private constructor(rules: RoleRules = {}) {
+    this.primary = rules.primary;
+    this.index = rules.index;
+    this.unique = rules.unique;
+    this.relation = rules.relation;
   }
 
   static of(field: { role?: RoleRules }): Role {
     return new Role(field.role);
   }
 
-  /** A group written with no members means "this field": only the key it is declared under resolves it. */
-  static resolvedOn(role: RoleRules | undefined, key?: string): RoleRules | undefined {
-    let rules = FieldGroup.normalize(role?.rules, (members) => new Unique(members));
-    if (rules && key !== undefined && rules.some((group) => group.isSelf))
-      rules = rules.map((group) => group.resolvedOn(key));
-    return rules === role?.rules ? role : { ...role, rules };
-  }
-
   get isPrimary(): boolean {
     return this.primary === true;
   }
@@ -42,14 +32,20 @@ export class Role implements RoleRules {
     return this.index === true;
   }
 
+  /** A field unique on its own. A group spanning several belongs to the schema. */
+  get isUnique(): boolean {
+    return this.unique === true;
+  }
+
   get isCollection(): boolean {
-    return this.relation?.kind === "many";
+    return this.relation?.kind === 'many';
   }
 
   get isReference(): boolean {
-    return this.relation?.kind === "one";
+    return this.relation?.kind === 'one';
   }
 
+  /** Calls `() => Post` so no caller has to. */
   get target(): EntityConstructor | undefined {
     return this.relation?.to();
   }

package/src/axis/role/RoleAxis.ts

@@ -1,23 +1,20 @@
 import type { Axis, Resolver } from '../Axis.js';
-import { refuse } from '../../card/admission.js';
-import { isObject, oneOfTokens } from '../../judge/ValueForm.js';
-import type { ValidationError } from '../../judge/result.js';
+import { refuse, oneOfTokens } from '../../projection/card/admission.js';
+import { isObject, lowerFirst } from '../../lib/utils.js';
+import type { ValidationError } from '../../validation.js';
 import { ON_DELETE, RELATION_KINDS, type EntityConstructor, type Relation } from './Relation.js';
 import { type RoleRules } from './Role.js';
-import { FieldGroup } from '../../constraint/FieldGroup.js';
-import { Unique } from '../../constraint/Unique.js';
-import type { RoleDescriptor } from '../../card/Descriptor.js';
-import { lowerFirst } from '../../utils.js';
+import type { RoleDescriptor } from '../../projection/card/Descriptor.js';
 
 export const roleAxis: Axis<RoleRules, RoleDescriptor> = {
   slot: 'role',
 
-  judge(value, errors) {
+  validator(value, errors) {
     if (!isObject(value)) {
       errors.push({ path: 'role', message: `Expected an object — got ${JSON.stringify(value)}` });
       return;
     }
-    for (const flag of ['primary', 'index'] as const) {
+    for (const flag of ['primary', 'index', 'unique'] as const) {
       if (value[flag] !== undefined && typeof value[flag] !== 'boolean') {
         errors.push({
           path: `role.${flag}`,
@@ -25,48 +22,33 @@ export const roleAxis: Axis<RoleRules, RoleDescriptor> = {
         });
       }
     }
-    if (value.rules !== undefined) {
-      const legal =
-        Array.isArray(value.rules) &&
-        value.rules.every(
-          (rule) =>
-            rule instanceof FieldGroup ||
-            (Array.isArray(rule) && rule.every((member) => typeof member === 'string')),
-        );
-      if (!legal) {
-        errors.push({
-          path: 'role.rules',
-          message: 'Expected field groups, or the member lists they denote — string[][]',
-        });
-      }
-    }
-    if (value.relation !== undefined) judgeRelation(value.relation, errors);
+    if (value.relation !== undefined) validateRelation(value.relation, errors);
   },
 
+  /** A card carries the target's NAME: a class cannot cross a process boundary. */
   describe(role, key) {
-    const out: Mutable<RoleDescriptor> = {};
-    if (role.primary) out.primary = true;
-    const unique = (role.rules ?? []).filter((rule) => rule instanceof Unique);
-    if (unique.length) out.unique = unique.map((rule) => [...rule.resolvedOn(key).members]);
-    if (role.index) out.index = true;
+    const descriptor: Mutable<RoleDescriptor> = {};
+    if (role.primary) descriptor.primary = true;
+    if (role.unique) descriptor.unique = [[key]];
+    if (role.index) descriptor.index = true;
     if (role.relation) {
       const target = role.relation.to() as { name?: string };
-      out.relation = {
+      descriptor.relation = {
         to: lowerFirst(target.name ?? ''),
         kind: role.relation.kind,
         ...(role.relation.onDelete ? { onDelete: role.relation.onDelete } : {}),
       };
     }
-    return Object.keys(out).length ? out : undefined;
+    return Object.keys(descriptor).length ? descriptor : undefined;
   },
 
   reconstruct(wire, resolve?: Resolver) {
-    const out: RoleRules = {};
-    if (wire.primary) out.primary = true;
-    if (wire.unique?.length) out.rules = wire.unique.map((group) => new Unique(group));
-    if (wire.index) out.index = true;
+    const rules: RoleRules = {};
+    if (wire.primary) rules.primary = true;
+    if (wire.unique?.some((group) => group.length === 1)) rules.unique = true;
+    if (wire.index) rules.index = true;
     if (wire.relation) {
-      // `judge` cannot serve here: it demands a thunk where a card carries a name.
+      // `validator` cannot serve here: it demands `() => Post` where a card carries a name.
       if (!oneOfTokens(wire.relation.kind, RELATION_KINDS)) {
         refuse(
           `role.relation.kind is ${JSON.stringify(wire.relation.kind)}`,
@@ -80,17 +62,22 @@ export const roleAxis: Axis<RoleRules, RoleDescriptor> = {
         );
       }
       const name = wire.relation.to;
-      out.relation = {
+      rules.relation = {
         to: () => (resolve?.(name) ?? ({ name } as unknown)) as EntityConstructor,
         kind: wire.relation.kind as Relation['kind'],
         ...(wire.relation.onDelete ? { onDelete: wire.relation.onDelete as Relation['onDelete'] } : {}),
       } as RoleRules['relation'];
     }
-    return out;
+    return rules;
   },
 };
 
-function judgeRelation(relation: unknown, errors: ValidationError[]): void {
+/**
+ * So a relation is validated where `() => Post` is required — a card carries a name.
+ * FR : pour qu'une relation soit jugée là où `() => Post` est exigé, contrairement à une carte.
+ * `{ to: User, kind: 'one' }` → error `Expected a function returning the target entity, such as () => Post`
+ */
+function validateRelation(relation: unknown, errors: ValidationError[]): void {
   if (!isObject(relation)) {
     errors.push({ path: 'role.relation', message: `Expected an object — got ${JSON.stringify(relation)}` });
     return;
@@ -102,7 +89,7 @@ function judgeRelation(relation: unknown, errors: ValidationError[]): void {
     });
   }
   if (typeof relation.to !== 'function') {
-    errors.push({ path: 'role.relation.to', message: 'Expected a thunk returning the target entity' });
+    errors.push({ path: 'role.relation.to', message: 'Expected a function returning the target entity, such as () => Post' });
   }
   if (relation.onDelete !== undefined && !oneOfTokens(relation.onDelete, ON_DELETE)) {
     errors.push({

package/src/axis/shape/Formats.ts

@@ -1,3 +1,5 @@
+import { Registry } from '../../lib/Registry.js';
+
 export type StringFormat =
   | 'date-time'
   | 'date'
@@ -9,14 +11,10 @@ export type StringFormat =
 
 export type FormatPredicate = (value: string) => boolean;
 
-export class Formats {
-  private static readonly registry = new Map<string, FormatPredicate>();
-
-  static register(name: string, predicate: FormatPredicate): void {
-    this.registry.set(name, predicate);
-  }
-
-  static resolve(name: string): FormatPredicate | undefined {
-    return this.registry.get(name);
-  }
-}
+/**
+ * String formats the JSON Schema engine does not know. `find` answers `undefined` for
+ * `email` or `uuid`, which it validates on its own.
+ * FR : les formats de chaîne que le moteur ignore ; `find` rend `undefined` pour les siens.
+ * `Formats.register('siret', (v) => /^\d{14}$/.test(v))`
+ */
+export const Formats = new Registry<FormatPredicate>('format');