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

package/src/entity.ts

@@ -1,5 +1,5 @@
-import { type Fields } from './fields/Field.js';
-import { type EntityDeclarations } from './EntityDeclarations.js';
+import { type Fields } from './schema/fields/Field.js';
+import { type EntityDeclarations } from './entity/EntityDeclarations.js';
 import { Schema, type SchemaConstructor } from './schema/Schema.js';
 
 export function entity<TFields extends Fields>(

package/src/index.ts

@@ -1,31 +1,42 @@
-export { Field, type Fields } from './fields/Field.js';
-export { FieldSet } from './fields/FieldSet.js';
-export { type Shape, Anatomy } from './axis/shape/Shape.js';
-export { type StringFormat, type FormatPredicate, Formats } 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 './axis/boundary/Boundary.js';
-export { type Decoder, type Encoder, Boundaries } from './axis/boundary/Boundaries.js';
-export { type Meta } from './axis/Meta.js';
-export { FieldGroup } from './constraint/FieldGroup.js';
-export { Unique } from './constraint/Unique.js';
+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 {
+  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';
+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';
 
-export { Schema, ANONYMOUS_SCHEMA_NAME, type SchemaConstructor } from './schema/Schema.js';
+export {
+  Schema,
+  ANONYMOUS_SCHEMA_NAME,
+  type SchemaConstructor,
+} from './schema/Schema.js';
 export { SchemaDerivation } from './schema/SchemaDerivation.js';
-export { isObject } from './judge/ValueForm.js';
-export { Cases, type Case } from './judge/Cases.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 './EntityAdapters.js';
+export { type FougereEntityAdapters, type EntityAdapters } from './entity/EntityAdapters.js';
 export {
   type EntityDeclarations,
   type CompositeUnique,
   type PreviousNames,
-} from './EntityDeclarations.js';
-export { lowerFirst, upperFirst } from './utils.js';
+} from './entity/EntityDeclarations.js';
+export { lowerFirst, upperFirst, isObject } from './utils.js';
 
 export { primary } from './vocabulary/primary.js';
 export { text } from './vocabulary/text.js';
@@ -49,14 +60,36 @@ export { readOnly } from './vocabulary/readOnly.js';
 export { writeOnly } from './vocabulary/writeOnly.js';
 export { json } from './vocabulary/json.js';
 
-export { applyCreate, applyUpdate } from './axis/lifecycle/apply.js';
+export { applyCreate, applyUpdate } from './schema/axis/lifecycle/apply.js';
 export { Visibility } from './projection/Visibility.js';
-export { Card } from './card/Card.js';
-export { Bundle } from './card/Bundle.js';
-export type { Change, Diff, DiffOptions, SetDiff, SetDiffOptions, RenameCandidate, TypeSet } from './card/diff.js';
-export { EntityTypeSource, type EntityTypeSourceOptions } from './card/EntityTypeSource.js';
-export { FacadeTypeSource, type FacadeTypeSourceOptions, type OpDescriptor } from './card/FacadeTypeSource.js';
-export { type SchemaBundle, type SchemaDescriptor, type FieldDescriptor, type FieldExtension, type RoleDescriptor, type RelationDescriptor } from './card/Descriptor.js';
+export { Card } from './projection/card/Card.js';
+export { Bundle } from './projection/card/Bundle.js';
+export type {
+  Change,
+  Diff,
+  DiffOptions,
+  SetDiff,
+  SetDiffOptions,
+  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,
+  type FieldDescriptor,
+  type FieldExtension,
+  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';
 
@@ -66,4 +99,8 @@ 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 {
+  type ValidationError,
+  type ValidationResult,
+  type Checked,
+} from './judge/result.js';

package/src/judge/FieldJudge.ts

@@ -1,8 +1,8 @@
-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 '../schema/axis/Axis.js';
+import { Anatomy } from '../schema/axis/shape/Shape.js';
+import type { Field } from '../schema/fields/Field.js';
+import { isObject } from '../utils.js';
+import type { ValidationError, ValidationResult } from './result.js';
 
 export class FieldJudge {
   private constructor(private readonly declaration: unknown) {}
@@ -19,7 +19,7 @@ export class FieldJudge {
         success: false,
         errors: [
           {
-            path: ".",
+            path: '.',
             message: `Expected an object — got ${JSON.stringify(declaration)}`,
           },
         ],
@@ -30,7 +30,7 @@ export class FieldJudge {
 
     if (!Anatomy.is(declaration.shape)) {
       errors.push({
-        path: "shape",
+        path: 'shape',
         message: `Every field states a shape — got ${JSON.stringify(declaration.shape)}`,
       });
     }
@@ -43,14 +43,14 @@ export class FieldJudge {
     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' });
       }
     }
 

package/src/judge/RowJudge.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 { Field, Fields } from '../fields/Field.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, Fields } from '../schema/fields/Field.js';
 import type { ValidateOptions } from './options.js';
 import type { ValidationError, ValidationResult } from './result.js';
 import { ValueJudge } from './ValueJudge.js';

package/src/judge/ValueJudge.ts

@@ -1,7 +1,7 @@
 import { Validator, format as engineFormats } from '@cfworker/json-schema';
-import { Formats, type FormatPredicate } from '../axis/shape/Formats.js';
-import { Anatomy, type Shape } from '../axis/shape/Shape.js';
-import type { Field } from '../fields/Field.js';
+import { Formats, type FormatPredicate } from '../schema/axis/shape/Formats.js';
+import { Anatomy, type Shape } from '../schema/axis/shape/Shape.js';
+import type { Field } from '../schema/fields/Field.js';
 import type { Checked } from './result.js';
 
 interface ShapePlan {
@@ -24,7 +24,11 @@ export class ValueJudge {
     const base = Anatomy.of(shape).base;
     if (value !== null) {
       if (base?.type === 'object' && !base.properties) return { value };
-      if (base?.type === 'string' && base.format === 'date-time' && value instanceof Date) {
+      if (
+        base?.type === 'string' &&
+        base.format === 'date-time' &&
+        value instanceof Date
+      ) {
         return Number.isNaN(value.getTime()) ? { error: 'Invalid date' } : { value };
       }
       if (

package/src/{judge → projection}/Cases.ts

@@ -1,11 +1,11 @@
-import { Anatomy } 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 '../fields/Field.js';
+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 './RowJudge.js';
-import { RowRefusal } from './RowRefusal.js';
+import { RowJudge } from '../judge/RowJudge.js';
+import { RowRefusal } from '../judge/RowRefusal.js';
 
 /**
  * One input, and what the judge must answer.
@@ -50,14 +50,19 @@ function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
     if (shape.enum) out.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 });
-    if (typeof shape.maximum === 'number') out.push({ why: 'above maximum', value: shape.maximum + 1 });
+    if (typeof shape.minimum === 'number')
+      out.push({ why: 'below minimum', value: shape.minimum - 1 });
+    if (typeof shape.maximum === 'number')
+      out.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: [] });
     if (typeof shape.maxItems === 'number')
-      out.push({ why: 'more items than max', value: Array.from({ length: shape.maxItems + 1 }, () => null) });
+      out.push({
+        why: 'more items than max',
+        value: Array.from({ length: shape.maxItems + 1 }, () => null),
+      });
   }
   return out;
 }
@@ -69,9 +74,7 @@ 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 Case[]) {}
 
   static of(entity: SchemaView, valid: Record<string, unknown>): Cases {
     return new Cases(enumerate(entity, valid));
@@ -83,7 +86,10 @@ export class Cases {
    * 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'], result: { success: boolean; errors?: { path: string }[] }): boolean {
+  static holds(
+    expected: Case['expect'],
+    result: { success: boolean; errors?: { path: string }[] },
+  ): boolean {
     if (expected === 'accept') return result.success;
     if (result.success) return false;
     return (result.errors ?? []).some((error) => error.path === expected.reject);
@@ -106,8 +112,18 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
   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 key outside the contract', body: { ...valid, __unknown__: 'x' }, patch: false, expect: { reject: '__unknown__' } });
-  cases.push({ why: 'not an object at all', body: 'a string', patch: false, expect: { reject: '.' } });
+  cases.push({
+    why: 'a key outside the contract',
+    body: { ...valid, __unknown__: 'x' },
+    patch: false,
+    expect: { reject: '__unknown__' },
+  });
+  cases.push({
+    why: 'not an object at all',
+    body: 'a string',
+    patch: false,
+    expect: { reject: '.' },
+  });
 
   for (const [name, field] of Object.entries(fields) as [string, Field][]) {
     // A reference names a row that must exist; the caller supplied its id and we do not
@@ -121,17 +137,37 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
     }
 
     if (Boundary.of(field).readOnly) {
-      cases.push({ why: `${name} supplied although read-only`, body: withField(name, wrongTypeFor(field)), patch: false, expect: { reject: name } });
+      cases.push({
+        why: `${name} supplied although read-only`,
+        body: withField(name, wrongTypeFor(field)),
+        patch: false,
+        expect: { reject: name },
+      });
     }
 
     if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
-      cases.push({ why: `${name} supplied on an update`, body: { [name]: valid[name] ?? wrongTypeFor(field) }, patch: true, expect: { reject: name } });
+      cases.push({
+        why: `${name} supplied on an update`,
+        body: { [name]: valid[name] ?? wrongTypeFor(field) },
+        patch: true,
+        expect: { reject: name },
+      });
     }
 
     if (name in valid && !isRef) {
-      cases.push({ why: `${name} of the wrong type`, body: withField(name, wrongTypeFor(field)), patch: false, expect: { reject: name } });
+      cases.push({
+        why: `${name} of the wrong type`,
+        body: 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), patch: false, expect: { reject: name } });
+        cases.push({
+          why: `${name} ${why}`,
+          body: withField(name, value),
+          patch: false,
+          expect: { reject: name },
+        });
     }
   }
 

package/src/projection/SchemaOrCard.ts

@@ -1,7 +1,7 @@
-import type { Fields } from '../fields/Field.js';
+import type { Fields } from '../schema/fields/Field.js';
 import type { SchemaView } from '../schema/SchemaView.js';
-import type { SchemaDescriptor } from '../card/Descriptor.js';
-import { Card } from '../card/Card.js';
+import type { SchemaDescriptor } from './card/Descriptor.js';
+import { Card } from './card/Card.js';
 
 export type SchemaOrCard = SchemaView | SchemaDescriptor;
 

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 { 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 { Fields } from '../schema/fields/Field.js';
 
 export class Visibility {
   private constructor(private readonly fields: Fields) {}
@@ -37,7 +37,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 '../../schema/axis/Axis.js';
+import type { EntityConstructor } from '../../schema/axis/role/Relation.js';
+import { lowerFirst } from '../../utils.js';
+import type { SchemaView } from '../../schema/SchemaView.js';
 import { Card } from './Card.js';
 import type { SchemaBundle, SchemaDescriptor } from './Descriptor.js';
 import type { Diff, SetDiff, SetDiffOptions } from './diff.js';

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

@@ -1,11 +1,10 @@
-import { EXTENSION_AXES, EXTENSION_SLOTS, type Resolver } from '../axis/Axis.js';
+import { EXTENSION_AXES, EXTENSION_SLOTS, type Resolver } from '../../schema/axis/Axis.js';
 import { dequal } from 'dequal';
-import { clean } from '../utils.js';
-import { Field, type Fields } from '../fields/Field.js';
-import { isObject } from '../judge/ValueForm.js';
-import { RowJudge } from '../judge/RowJudge.js';
-import { Schema, type SchemaConstructor } from '../schema/Schema.js';
-import type { Row, SchemaView } from '../schema/SchemaView.js';
+import { clean, isObject } from '../../utils.js';
+import { Field, type Fields } from '../../schema/fields/Field.js';
+import { RowJudge } from '../../judge/RowJudge.js';
+import { Schema, type SchemaConstructor } from '../../schema/Schema.js';
+import type { Row, SchemaView } from '../../schema/SchemaView.js';
 import { refuse } from './admission.js';
 import type {
   DerivedFrom,
@@ -21,7 +20,10 @@ type FieldsOf<T> = { [K in keyof T]-?: Field<T[K]> };
 export class Card<T = Row<Fields>> {
   private constructor(readonly descriptor: SchemaDescriptor) {}
 
-  static fromSchema<TFields extends Fields>(schema: SchemaView<TFields>, name?: string): Card<Row<TFields>> {
+  static fromSchema<TFields extends Fields>(
+    schema: SchemaView<TFields>,
+    name?: string,
+  ): Card<Row<TFields>> {
     const fields = schema.getFields();
     const judge = RowJudge.of(fields);
     const properties: Record<string, FieldDescriptor> = {};
@@ -62,7 +64,8 @@ export class Card<T = Row<Fields>> {
   toSchema(resolve?: Resolver, name?: string): SchemaConstructor<FieldsOf<T>> {
     const descriptor = this.descriptor;
     const where = name ? `schema '${name}'` : 'this schema';
-    if (!isObject(descriptor)) refuse(`${where} is not an object`, 'A card carries one JSON Schema per door.');
+    if (!isObject(descriptor))
+      refuse(`${where} is not an object`, 'A card carries one JSON Schema per door.');
     const version = descriptor['x-fougere-version'];
     if (version !== 1) {
       refuse(
@@ -71,7 +74,10 @@ export class Card<T = Row<Fields>> {
       );
     }
     if (!isObject(descriptor.properties)) {
-      refuse(`${where} carries no \`properties\` object`, 'A schema is its fields; there is nothing to rebuild.');
+      refuse(
+        `${where} carries no \`properties\` object`,
+        'A schema is its fields; there is nothing to rebuild.',
+      );
     }
 
     const fields: Fields = {};
@@ -80,7 +86,8 @@ export class Card<T = Row<Fields>> {
     }
     const schema = Schema.of({ fields });
     const title = name ?? descriptor.title;
-    if (title) Object.defineProperty(schema, 'name', { value: title, configurable: true });
+    if (title)
+      Object.defineProperty(schema, 'name', { value: title, configurable: true });
     return schema as unknown as SchemaConstructor<FieldsOf<T>>;
   }
 
@@ -104,11 +111,13 @@ export class Card<T = Row<Fields>> {
         continue;
       }
 
-      if (now !== field) changes.push({ kind: 'renamed', from: field, to: now, field: target });
+      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 });
+      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 });
       }
@@ -122,12 +131,24 @@ export class Card<T = Row<Fields>> {
     }
 
     const claimed = new Set(Object.values(renamed));
-    const added = Object.keys(after).filter((field) => !(field in before) && !claimed.has(field));
+    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) });
+      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) });
+      changes.push({
+        kind: 'added',
+        field,
+        to: after[field],
+        required: requiredAfter.has(field),
+      });
     }
 
     return { changes, ambiguous: candidates(removed, added, before, after) };
@@ -160,18 +181,29 @@ function describeField(field: Field, key: string): FieldDescriptor {
 function originOf(schema: SchemaView): DerivedFrom | undefined {
   const { derivation } = schema;
   if (!derivation) return undefined;
-  const survived = Object.fromEntries(Object.entries(derivation.survived).map(([key, value]) => [key, value ?? null]));
+  const survived = Object.fromEntries(
+    Object.entries(derivation.survived).map(([key, value]) => [key, value ?? null]),
+  );
   return { from: derivation.sourceName, survived };
 }
 
 function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined {
-  const types = Array.isArray(property.type) ? property.type : property.type ? [property.type] : [];
+  const types = Array.isArray(property.type)
+    ? property.type
+    : property.type
+      ? [property.type]
+      : [];
   const base = types.find((type) => type !== 'null');
   if (base === undefined) return undefined;
   const type = property.type as Field['shape']['type'];
   if (base === 'array') {
     const items = property.items ? reconstructShape(property.items) : undefined;
-    return clean({ type, items, minItems: property.minItems, maxItems: property.maxItems }) as Field['shape'];
+    return clean({
+      type,
+      items,
+      minItems: property.minItems,
+      maxItems: property.maxItems,
+    }) as Field['shape'];
   }
   switch (base) {
     case 'string':
@@ -185,20 +217,32 @@ function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined
       }) as Field['shape'];
     case 'number':
     case 'integer':
-      return clean({ type, minimum: property.minimum, maximum: property.maximum }) as Field['shape'];
+      return clean({
+        type,
+        minimum: property.minimum,
+        maximum: property.maximum,
+      }) as Field['shape'];
     case 'boolean':
       return { type } as Field['shape'];
     default:
-      return clean({ type, properties: property.properties, required: property.required }) as Field['shape'];
+      return clean({
+        type,
+        properties: property.properties,
+        required: property.required,
+      }) as Field['shape'];
   }
 }
 
-function reconstructField(property: FieldDescriptor, key: string, resolve?: Resolver): Field {
+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.',
+      `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'];
@@ -210,13 +254,27 @@ function reconstructField(property: FieldDescriptor, key: string, resolve?: Reso
   return new Field({
     shape,
     ...axes,
-    meta: property.description !== undefined ? { description: property.description } : undefined,
+    meta:
+      property.description !== undefined
+        ? { description: property.description }
+        : undefined,
   } as never);
 }
 
-function restated(field: string, before: FieldExtension | undefined, after: FieldExtension | undefined): Change[] {
+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,
+    (axis) =>
+      ({
+        kind: 'restated',
+        field,
+        axis,
+        from: before?.[axis],
+        to: after?.[axis],
+      }) as Change,
   );
 }
 
@@ -245,7 +303,8 @@ function candidates(
   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 });
+      if (dequal(shapeOf(before[gone]), shapeOf(after[appeared])))
+        found.push({ removed: gone, added: appeared });
     }
   }
   const was = Object.keys(before);

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 '../../schema/axis/boundary/Boundary.js';
+import type { LifecycleRules } from '../../schema/axis/lifecycle/Lifecycle.js';
+import type { Relation } from '../../schema/axis/role/Relation.js';
+import type { RoleRules } from '../../schema/axis/role/Role.js';
+import type { Shape } from '../../schema/axis/shape/Shape.js';
 
 type JsonSchemaType =
   | 'string'

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

@@ -1,4 +1,4 @@
-import { upperFirst } from '../utils.js';
+import { upperFirst } from '../../utils.js';
 import type { FieldDescriptor, SchemaDescriptor } from './Descriptor.js';
 
 function typeOf(field: FieldDescriptor): string {

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

@@ -1,4 +1,4 @@
-import type { ValidationError } from '../judge/result.js';
+import type { ValidationError } from '../../judge/result.js';
 
 /** A card is refused by naming what is wrong AND the remedy — never by a bare throw. */
 export function refuse(what: string, fix: string): never {
@@ -23,3 +23,8 @@ export function admitWire(
     );
   }
 }
+
+export const oneOfTokens = <T extends readonly string[]>(
+  value: unknown,
+  tokens: T,
+): value is T[number] => typeof value === 'string' && (tokens as readonly string[]).includes(value);