@fougere/schema 0.12.0-alpha.0 → 0.12.2-alpha.0

package/src/lib/Registry.ts

@@ -1,24 +1,24 @@
 import { SchemaError } from '../SchemaError.js';
 
 export class Registry<T> {
-  private readonly entries: Map<string, T>;
+  private readonly held: Map<string, T>;
 
   constructor(
     private readonly label: string,
     private readonly hint?: string,
     entries?: Iterable<readonly [string, T]>,
   ) {
-    this.entries = new Map(entries);
+    this.held = new Map(entries);
   }
 
   register(name: string, value: T): T {
-    this.entries.set(name, value);
+    this.held.set(name, value);
 
     return value;
   }
 
   find(name: string): T | undefined {
-    return this.entries.get(name);
+    return this.held.get(name);
   }
 
   resolve(name: string, path?: string): T {
@@ -32,7 +32,15 @@ export class Registry<T> {
     );
   }
 
-  private get names(): string[] {
-    return [...this.entries.keys()];
+  get names(): string[] {
+    return [...this.held.keys()];
+  }
+
+  get entries(): [string, T][] {
+    return [...this.held];
+  }
+
+  get all(): T[] {
+    return [...this.held.values()];
   }
 }

package/src/lib/UnionToIntersection.ts

@@ -0,0 +1,10 @@
+/**
+ * What a union becomes when every member must hold at once — `A | B` → `A & B`, through the
+ * contravariance of a parameter position, which is the only place TypeScript folds a union.
+ * `Merged<[Post, Draft]>` and `ShapeKeywords` both need it, and each had written it out.
+ */
+export type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never) extends (
+  member: infer Held,
+) => void
+  ? Held
+  : never;

package/src/lib/ValidationResult.ts

@@ -9,3 +9,11 @@ export type ValidationResult<T> =
  * reason the value stays segmented: this one cannot be read back.
  */
 export const dotted = (path: readonly string[]): string => path.join('.');
+
+/** `#/city/zip` — a JSON Pointer fragment, and `~1`/`~0` are how it spells `/` and `~`. */
+export const locationOf = (instanceLocation: string): string[] =>
+  instanceLocation
+    .replace(/^#/, '')
+    .split('/')
+    .filter(Boolean)
+    .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));

package/src/lib/utils.ts

@@ -15,4 +15,8 @@ export function clean<T extends Record<string, unknown>>(obj: T): T {
 export const isObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
-export const shown = (value: unknown): string => JSON.stringify(value) ?? typeof value;
+export const isArrayOf = <T>(
+  values: readonly unknown[],
+  is: (value: unknown) => value is T,
+): values is readonly T[] => values.every(is);
+

package/src/projection/Cases.ts

@@ -16,6 +16,7 @@ import type { ValidationCase } from './ValidationCase.js';
 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';
 }
 
@@ -42,6 +43,11 @@ function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
       cases.push({ why: 'below minimum', value: shape.minimum - 1 });
     if (typeof shape.maximum === 'number')
       cases.push({ why: 'above maximum', value: shape.maximum + 1 });
+    if (shape.enum) {
+      const members = shape.enum.filter((value) => typeof value === 'number');
+
+      cases.push({ why: 'outside the stated set', value: Math.max(...members) + 1 });
+    }
   }
   if (shape?.type === 'array') {
     if (typeof shape.minItems === 'number' && shape.minItems > 0)
@@ -52,6 +58,7 @@ function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
         value: Array.from({ length: shape.maxItems + 1 }, () => null),
       });
   }
+
   return cases;
 }
 
@@ -64,8 +71,8 @@ function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
 export class Cases {
   private constructor(readonly all: readonly ValidationCase[]) {}
 
-  static of(entity: SchemaView, valid: Record<string, unknown>): Cases {
-    return new Cases(enumerate(entity, valid));
+  static of(schema: SchemaView, valid: Record<string, unknown>): Cases {
+    return new Cases(enumerate(schema, valid));
   }
 
   static holds(
@@ -74,6 +81,7 @@ export class Cases {
   ): boolean {
     if (expected === 'accept') return result.success;
     if (result.success) return false;
+
     return (result.errors ?? []).some((error) => rejected(error.path) === expected.reject);
   }
 
@@ -92,8 +100,8 @@ export class Cases {
  * FR : lit les quatre axes plutôt qu'une liste tenue à la main : un cas existe parce qu'un
  * champ déclare la règle qu'il casse.
  */
-function enumerate(entity: SchemaView, valid: Record<string, unknown>): ValidationCase[] {
-  const fields = entity.getFields();
+function enumerate(schema: SchemaView, valid: Record<string, unknown>): ValidationCase[] {
+  const fields = schema.getFields();
   const validator = InputValidator.of(fields);
 
   return [
@@ -124,13 +132,13 @@ function aboutField(
   const withField = (value: unknown) => ({ ...valid, [name]: value });
   const cases: ValidationCase[] = [];
 
-  if (validator.onAbsent(field) === null && name in valid) {
+  if (validator.requires(field) && 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) {
+  if (Boundary.of(field).readOnly()) {
     cases.push({
       why: `${name} supplied although read-only`,
       input: withField(wrongTypeFor(field)),
@@ -139,7 +147,16 @@ function aboutField(
     });
   }
 
-  if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
+  if (Role.of(field).isCollection()) {
+    cases.push({
+      why: `${name} supplied although the other side carries it`,
+      input: withField([]),
+      patch: false,
+      expect: { reject: name },
+    });
+  }
+
+  if (Lifecycle.of(field).immutable() && !Role.of(field).isPrimary()) {
     cases.push({
       why: `${name} supplied on an update`,
       input: { [name]: valid[name] ?? wrongTypeFor(field) },
@@ -150,7 +167,7 @@ function aboutField(
 
   // A reference names a row that must exist; the caller supplied its id and we do not
   // get to invent a second one, so the only case we can state about it is the bound one.
-  if (name in valid && !Role.of(field).isReference) {
+  if (name in valid && !Role.of(field).isReference()) {
     cases.push({
       why: `${name} of the wrong type`,
       input: withField(wrongTypeFor(field)),

package/src/projection/Visibility.ts

@@ -15,30 +15,54 @@ export class Visibility {
     const result: Fields = {};
     for (const [name, field] of Object.entries(this.fields)) {
       const role = Role.of(field);
-      if (role.isPrimary) continue;
-      if (Lifecycle.of(field).stampedAtCreate) continue;
-      if (role.isCollection) continue;
-      if (Boundary.of(field).readOnly) continue;
+      if (role.isPrimary()) continue;
+      if (Lifecycle.of(field).stampedAtCreate()) continue;
+      if (role.isCollection()) continue;
+      if (Boundary.of(field).readOnly()) continue;
       result[name] = field;
     }
+
     return result;
   }
 
   get output(): Fields {
     const result: Fields = {};
     for (const [name, field] of Object.entries(this.fields)) {
-      if (Boundary.of(field).writeOnly) continue;
+      if (Boundary.of(field).writeOnly()) continue;
       result[name] = field;
     }
+
     return result;
   }
 
+  /**
+   * The dual of `encode`, read where a caller RECEIVES a row.
+   *
+   * `date-time` means a `Date` on both sides, and only the outgoing half was ever applied: a
+   * handler answered `new Date(0)`, the facade encoded it, and the caller was handed
+   * `"1970-01-01T00:00:00.000Z"` while its type said `Date` — locally as well as across a wire.
+   *
+   * It converts and never judges: what arrives was validated where it was produced, so a value
+   * the codec refuses is kept as it came rather than replaced or thrown over.
+   */
+  decode(record: Record<string, unknown>): Record<string, unknown> {
+    const out: Record<string, unknown> = { ...record };
+    for (const [key, field] of Object.entries(this.fields)) {
+      const value = record[key];
+      if (!(key in record) || value === null || value === undefined) continue;
+      const verdict = Boundary.of(field).decode(value);
+      if ('value' in verdict) out[key] = verdict.value;
+    }
+
+    return out;
+  }
+
   encode(record: Record<string, unknown>): Record<string, unknown> {
     const out: Record<string, unknown> = { ...record };
     for (const [key, field] of Object.entries(this.fields)) {
       if (!(key in record)) continue;
       const boundary = Boundary.of(field);
-      if (boundary.writeOnly) {
+      if (boundary.writeOnly()) {
         delete out[key];
         continue;
       }
@@ -46,6 +70,7 @@ export class Visibility {
       if (value === null || value === undefined) continue;
       out[key] = boundary.encode(value);
     }
+
     return out;
   }
 }

package/src/projection/card/Bundle.ts

@@ -56,6 +56,7 @@ export class Bundle {
       byName[name.toLowerCase()] = schema as unknown as EntityConstructor;
       schemas[name] = schema;
     }
+
     return schemas;
   }
 
@@ -72,6 +73,7 @@ export class Bundle {
       );
       if (diff.changes.length > 0 || diff.ambiguous.length > 0) entities[name] = diff;
     }
+
     return {
       entitiesAdded: Object.keys(after).filter((name) => !(name in before)),
       entitiesRemoved: Object.keys(before).filter((name) => !(name in after)),

package/src/projection/card/Card.ts

@@ -1,4 +1,5 @@
-import { EXTENSION_AXES } from '../../axis/Axis.js';
+import { Axes } from '../../axis/Axes.js';
+import { CardForms } from './CardForms.js';
 import { type Resolver } from '../../axis/Resolver.js';
 import { clean, isObject } from '../../lib/utils.js';
 import { Field } from '../../field/Field.js';
@@ -38,10 +39,11 @@ export class Card<T = Values<Fields>> {
     const required: string[] = [];
     for (const [key, field] of Object.entries(fields)) {
       properties[key] = describeField(field, key);
-      if (validator.onAbsent(field) === null) required.push(key);
+      if (validator.requires(field)) required.push(key);
     }
-    for (const group of schema.getUnique() ?? [])
-      for (const member of group) carryGroup(properties[member], group);
+    for (const kind of ['unique', 'index'] as const)
+      for (const group of (kind === 'unique' ? schema.getUnique() : schema.getIndex()) ?? [])
+        for (const member of group) carryGroup(properties[member], kind, group);
 
     const descriptor: SchemaDescriptor = {
       type: 'object',
@@ -55,6 +57,7 @@ export class Card<T = Values<Fields>> {
 
     const origin = originOf(schema);
     if (origin) descriptor['x-fougere-derived'] = origin;
+
     return new Card<Values<TFields>>(descriptor);
   }
 
@@ -94,7 +97,7 @@ export class Card<T = Values<Fields>> {
     }
 
     const fields: Fields = {};
-    const groups: string[][] = [];
+    const groups: { unique: string[][]; index: string[][] } = { unique: [], index: [] };
     for (const [key, property] of Object.entries(descriptor.properties)) {
       if (!isObject(property)) {
         refuse(
@@ -103,13 +106,15 @@ export class Card<T = Values<Fields>> {
         );
       }
       fields[key] = reconstructField(property, key, resolve);
-      for (const group of property['x-fougere']?.role?.unique ?? [])
-        if (group.length > 1) groups.push([...group]);
+      for (const kind of ['unique', 'index'] as const)
+        for (const group of property['x-fougere']?.role?.[kind] ?? [])
+          if (group.length > 1) groups[kind].push([...group]);
     }
     const schema = Schema.of({ fields, constraints: SchemaConstraints.of(groups) });
     const title = name ?? descriptor.title;
     if (title)
       Object.defineProperty(schema, 'name', { value: title, configurable: true });
+
     return schema as unknown as SchemaConstructor<FieldsOf<T>>;
   }
 
@@ -126,13 +131,13 @@ export class Card<T = Values<Fields>> {
  */
 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;
+  for (const [name, declared] of Object.entries(field.axes)) {
+    const form = CardForms.find(name);
+    const wire = form ? form.describe(declared, key) : declared;
+    if (wire !== undefined) extension[name] = wire;
   }
   clean(extension);
+
   return Object.keys(extension).length ? (extension as FieldExtension) : undefined;
 }
 
@@ -140,9 +145,9 @@ 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;
 }
 
@@ -157,6 +162,7 @@ function originOf(schema: SchemaView): DerivedFrom | undefined {
   const nameOf = Object.fromEntries(
     Object.entries(derivation.nameOf).map(([key, value]) => [key, value ?? null]),
   );
+
   return { from: derivation.sourceName, nameOf };
 }
 
@@ -175,7 +181,7 @@ function reconstructShape(property: FieldDescriptor): Field['shape'] | 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;
+  const { 'x-fougere': _extension, ...shape } = property;
   if (shape.items) shape.items = reconstructShape(shape.items) as FieldDescriptor;
 
   return clean(shape) as Field['shape'];
@@ -201,18 +207,13 @@ function reconstructField(
   admitPatterns(shape, `Field '${key}'`);
   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);
+  for (const name of Axes.names) {
+    const wire = (extension as Record<string, unknown> | undefined)?.[name];
+    const form = CardForms.find(name);
+    if (wire !== undefined) axes[name] = form ? form.reconstruct(wire, resolve) : wire;
   }
-  return new Field({
-    shape,
-    ...axes,
-    meta:
-      property.description !== undefined
-        ? { description: property.description }
-        : undefined,
-  } as never);
+
+  return new Field({ shape, ...axes } as never, key);
 }
 
 /**
@@ -222,10 +223,11 @@ function reconstructField(
  */
 function carryGroup(
   property: FieldDescriptor | undefined,
+  kind: 'unique' | 'index',
   group: readonly string[],
 ): void {
   if (!property) return;
-  const extension = (property['x-fougere'] ??= {}) as { role?: { unique?: string[][] } };
+  const extension = (property['x-fougere'] ??= {}) as { role?: Record<string, string[][]> };
   const role = (extension.role ??= {});
-  (role.unique ??= []).push([...group]);
+  (role[kind] ??= []).push([...group]);
 }

package/src/projection/card/CardForm.ts

@@ -0,0 +1,8 @@
+import type { Resolver } from '../../axis/Resolver.js';
+
+/** How a card writes what an axis declared, and reads it back — stated by the card, not the axis. */
+export interface CardForm<Declared = unknown, Wire = unknown> {
+  describe(value: Declared, key: string): Wire | undefined;
+
+  reconstruct(wire: Wire, resolve?: Resolver): Declared;
+}

package/src/projection/card/CardForms.ts

@@ -0,0 +1,13 @@
+import { Registry } from '../../lib/Registry.js';
+import type { CardForm } from './CardForm.js';
+import { roleOnCard } from './RoleDescriptor.js';
+
+/**
+ * The axes a card writes differently from their declaration. An axis absent here travels as
+ * itself, which is what `lifecycle`, `boundary` and anything registered from outside do.
+ * FR : les axes qu'une carte écrit autrement que déclarés ; les autres voyagent tels quels.
+ * `CardForms.register('tenancy', tenancyOnCard)`
+ */
+export const CardForms = new Registry<CardForm>('card form', 'call CardForms.register(name, form)', [
+  ['role', roleOnCard as CardForm],
+]);

package/src/projection/card/Change.ts

@@ -1,5 +1,5 @@
-import type { BoundaryRef } from '../../axis/boundary/BoundaryRef.js';
-import type { LifecycleRules } from '../../axis/lifecycle/LifecycleRules.js';
+import type { BoundaryRef } from '../../axis/boundary/Boundary.js';
+import type { LifecycleRules } from '../../axis/lifecycle/Lifecycle.js';
 import type { FieldDescriptor } from './FieldDescriptor.js';
 import type { RoleDescriptor } from './RoleDescriptor.js';
 import type { TypeSet } from './TypeSet.js';

package/src/projection/card/Diff.ts

@@ -1,5 +1,5 @@
 import { dequal } from 'dequal';
-import { EXTENSION_SLOTS } from '../../axis/Axis.js';
+import { Axes } from '../../axis/Axes.js';
 import type { FieldDescriptor } from './FieldDescriptor.js';
 import type { FieldExtension } from './FieldExtension.js';
 
@@ -93,7 +93,7 @@ function restated(
   before: FieldExtension | undefined,
   after: FieldExtension | undefined,
 ): Change[] {
-  return EXTENSION_SLOTS.filter((axis) => !dequal(before?.[axis], after?.[axis])).map(
+  return Axes.names.filter((axis) => !dequal(before?.[axis], after?.[axis])).map(
     (axis) =>
       ({
         kind: 'restated',
@@ -107,6 +107,7 @@ function restated(
 
 function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
   const { 'x-fougere': _extension, description: _description, ...shape } = descriptor;
+
   return shape as Record<string, unknown>;
 }
 
@@ -118,6 +119,7 @@ function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
 function typesOf(descriptor: FieldDescriptor): TypeSet {
   const type = descriptor.type;
   if (type === undefined) return [];
+
   return (Array.isArray(type) ? [...type] : [type]).sort();
 }
 
@@ -128,6 +130,7 @@ function typesOf(descriptor: FieldDescriptor): TypeSet {
  */
 function boundsOf(descriptor: FieldDescriptor): Record<string, unknown> {
   const { type: _type, ...rest } = shapeOf(descriptor);
+
   return rest;
 }
 
@@ -153,5 +156,6 @@ function candidates(
   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));
 }

package/src/projection/card/FieldExtension.ts

@@ -1,9 +1,12 @@
-import type { BoundaryRef } from '../../axis/boundary/BoundaryRef.js';
-import type { LifecycleRules } from '../../axis/lifecycle/LifecycleRules.js';
+import type { BoundaryRef } from '../../axis/boundary/Boundary.js';
+import type { LifecycleRules } from '../../axis/lifecycle/Lifecycle.js';
 import type { RoleDescriptor } from './RoleDescriptor.js';
 
 export interface FieldExtension {
   role?: RoleDescriptor;
   lifecycle?: LifecycleRules;
   boundary?: BoundaryRef;
+
+  /** An axis registered from outside writes here, under its own name. */
+  [axis: string]: unknown;
 }

package/src/projection/card/RoleDescriptor.ts

@@ -1,7 +1,58 @@
-import type { RoleRules } from '../../axis/role/RoleRules.js';
-import type { RelationDescriptor } from './RelationDescriptor.js';
+import type { EntityConstructor } from '../../axis/role/EntityConstructor.js';
+import type { Relation } from '../../axis/role/Relation.js';
+import type { RoleRules } from '../../axis/role/Role.js';
+import type { Resolver } from '../../axis/Resolver.js';
+import { lowerFirst } from '../../lib/utils.js';
+import type { CardForm } from './CardForm.js';
 
-export type RoleDescriptor = Pick<RoleRules, 'primary' | 'index'> & {
+/**
+ * What a role becomes on a card: a target is a NAME there, and `unique` and `index` are both
+ * GROUPS — the field says `true`, the card says which names go together, since a group of
+ * several belongs to no single field.
+ */
+export type RoleDescriptor = Pick<RoleRules, 'primary'> & {
   unique?: string[][];
+  index?: string[][];
   relation?: RelationDescriptor;
 };
+
+export type RelationDescriptor = Pick<Relation, 'kind' | 'onDelete'> & { to: string };
+
+type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+
+/** A card carries the target's NAME: a class cannot cross a process boundary. */
+export const roleOnCard: CardForm<RoleRules, RoleDescriptor> = {
+  describe(role, key) {
+    const descriptor: Mutable<RoleDescriptor> = {};
+    if (role.primary) descriptor.primary = true;
+    if (role.unique) descriptor.unique = [[key]];
+    if (role.index) descriptor.index = [[key]];
+    if (role.relation) {
+      const target = role.relation.to() as { name?: string };
+      descriptor.relation = {
+        to: lowerFirst(target.name ?? ''),
+        kind: role.relation.kind,
+        ...(role.relation.onDelete ? { onDelete: role.relation.onDelete } : {}),
+      };
+    }
+
+    return Object.keys(descriptor).length ? descriptor : undefined;
+  },
+
+  reconstruct(wire, resolve?: Resolver) {
+    const rules: Mutable<RoleRules> = {};
+    if (wire.primary) rules.primary = true;
+    if (wire.unique?.some((group) => group.length === 1)) rules.unique = true;
+    if (wire.index?.some((group) => group.length === 1)) rules.index = true;
+    if (wire.relation) {
+      const name = wire.relation.to;
+      rules.relation = {
+        to: () => (resolve?.(name) ?? ({ name } as unknown)) as EntityConstructor,
+        kind: wire.relation.kind,
+        ...(wire.relation.onDelete ? { onDelete: wire.relation.onDelete } : {}),
+      };
+    }
+
+    return rules;
+  },
+};

package/src/projection/card/ShapeKeywords.ts

@@ -1,7 +1,7 @@
 import type { Shape } from '../../axis/shape/Shape.js';
+import type { UnionToIntersection } from '../../lib/UnionToIntersection.js';
 
 type KeywordsOf<S> = S extends unknown ? Partial<Omit<S, 'type' | 'items' | 'properties'>> : never;
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 
 /** Every keyword any shape may carry, flattened — what a descriptor records of one. */
 export type ShapeKeywords = UnionToIntersection<KeywordsOf<Shape>>;

package/src/projection/card/admission.ts

@@ -1,6 +1,4 @@
-import type { ValidationError } from '../../lib/ValidationError.js';
 import { Shapes } from '../../axis/shape/Shape.js';
-import { dotted } from '../../lib/ValidationResult.js';
 import { SchemaError } from '../../SchemaError.js';
 
 /**
@@ -12,37 +10,6 @@ export function refuse(what: string, fix: string): never {
   throw new SchemaError(`This card cannot be read: ${what}.\n  ${fix}`);
 }
 
-/**
- * Runs a card's axis through the validator a hand-written field goes through, so there is
- * one judge and not two.
- * FR : passe l'axe d'une carte par le juge d'un champ écrit à la main : un juge, pas deux.
- * `{ update: 'maybe' }` → `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) => `${dotted(e.path)}: ${e.message}`).join('; ')}`,
-      'A card states an axis the way a declaration does.',
-    );
-  }
-}
-
-/**
- * Checks a token against the list that declares it, never against a copy written here.
- * FR : vérifie un mot contre la liste qui le déclare, jamais contre une copie locale.
- * `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);
-
 /**
  * Compiles every `pattern` at the facade, so a bad one is refused here and not at the first row.
  * FR : compile chaque `pattern` à la porte : un mauvais est refusé ici, pas au premier row.