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

package/src/projection/Visibility.ts

@@ -33,6 +33,28 @@ export class Visibility {
     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)) {

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';
@@ -126,11 +127,12 @@ 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];
+  for (const slot of Axes.names) {
+    const declared = (field as unknown as Record<string, unknown>)[slot];
     if (declared === undefined) continue;
-    const wire = axis.describe(declared, key);
-    if (wire !== undefined) extension[axis.slot] = wire;
+    const form = CardForms.find(slot);
+    const wire = form ? form.describe(declared, key) : declared;
+    if (wire !== undefined) extension[slot] = wire;
   }
   clean(extension);
   return Object.keys(extension).length ? (extension as FieldExtension) : undefined;
@@ -201,9 +203,10 @@ 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 slot of Axes.names) {
+    const wire = (extension as Record<string, unknown> | undefined)?.[slot];
+    const form = CardForms.find(slot);
+    if (wire !== undefined) axes[slot] = form ? form.reconstruct(wire, resolve) : wire;
   }
   return new Field({
     shape,
@@ -212,7 +215,7 @@ function reconstructField(
       property.description !== undefined
         ? { description: property.description }
         : undefined,
-  } as never);
+  } as never, key);
 }
 
 /**

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(slot, 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',

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 its own slot here, under its own name. */
+  [slot: string]: unknown;
 }

package/src/projection/card/RoleDescriptor.ts

@@ -1,7 +1,53 @@
-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';
 
+/** What a role becomes on a card: a target is a NAME there, and a unique is a group. */
 export type RoleDescriptor = Pick<RoleRules, 'primary' | 'index'> & {
   unique?: 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 = true;
+    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) 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/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.

package/src/validator/FieldDeclarationValidator.ts

@@ -1,9 +1,10 @@
-import { EXTENSION_AXES } from '../axis/Axis.js';
+import { Axes } from '../axis/Axes.js';
 import { Shapes } from '../axis/shape/Shape.js';
 import type { Field } from '../field/Field.js';
 import { isObject, shown } from '../lib/utils.js';
 import type { ValidationError } from '../lib/ValidationError.js';
 import type { ValidationResult } from '../lib/ValidationResult.js';
+import { JsonSchemaValidator } from './JsonSchemaValidator.js';
 
 export class FieldDeclarationValidator {
   private constructor(private readonly declaration: unknown) {}
@@ -36,23 +37,10 @@ export class FieldDeclarationValidator {
       });
     }
 
-    for (const axis of EXTENSION_AXES) {
-      const declared = declaration[axis.slot];
-      if (declared !== undefined) axis.validator(declared, errors);
-    }
+    errors.push(...JsonSchemaValidator.of(Axes.fieldFormat).refusalsOf(declaration, []));
 
-    if (declaration.meta !== undefined) {
-      if (!isObject(declaration.meta)) {
-        errors.push({
-          path: ['meta'],
-          message: `Expected an object — got ${shown(declaration.meta)}`,
-        });
-      } else if (
-        declaration.meta.description !== undefined &&
-        typeof declaration.meta.description !== 'string'
-      ) {
-        errors.push({ path: ['meta', 'description'], message: 'Expected a string' });
-      }
+    for (const [slot, axis] of Axes.entries) {
+      errors.push(...(axis.refusals?.(declaration[slot]) ?? []));
     }
 
     return errors.length

package/src/validator/FieldValueValidator.ts

@@ -1,16 +1,16 @@
-import { Validator, format as engineFormats } from '@cfworker/json-schema';
+import { format as engineFormats } from '@cfworker/json-schema';
 import { Boundary } from '../axis/boundary/Boundary.js';
 import { type FormatPredicate } from '../axis/shape/FormatPredicate.js';
-import { Formats } from '../axis/shape/Formats.js';
+import { StringFormats } from '../axis/shape/StringFormats.js';
 import { type Shape } from '../axis/shape/Shape.js';
 import { Shapes } from '../axis/shape/Shape.js';
 import type { Field } from '../field/Field.js';
 import type { Verdict } from '../lib/Verdict.js';
-import type { OutputUnit } from '@cfworker/json-schema';
 import { SchemaError } from '../SchemaError.js';
+import type { JsonSchema } from '../lib/JsonSchema.js';
+import { JsonSchemaValidator } from './JsonSchemaValidator.js';
 
 interface ShapePlan {
-  validator: Validator;
   custom?: FormatPredicate;
   formatName?: string;
 }
@@ -39,8 +39,10 @@ export class FieldValueValidator {
       }
     }
     const plan = FieldValueValidator.planFor(shape);
-    const result = plan.validator.validate(value);
-    if (!result.valid) return refusalOf(result.errors);
+    const refusal = JsonSchemaValidator.of(shape as JsonSchema).refusalOf(value, []);
+    if (refusal) {
+      return refusal.path.length > 0 ? { message: refusal.message, path: refusal.path } : { message: refusal.message };
+    }
     if (plan.custom && typeof value === 'string' && !plan.custom(value)) {
       return { message: `String does not match format "${plan.formatName}".` };
     }
@@ -65,7 +67,6 @@ export class FieldValueValidator {
       const base = Shapes.of(shape).base;
       const formatName = base?.type === 'string' ? base.format : undefined;
       plan = {
-        validator: new Validator(shape as object, '2020-12', true),
         custom: formatName === undefined ? undefined : this.customFormatOf(formatName),
         formatName,
       };
@@ -75,39 +76,13 @@ export class FieldValueValidator {
   }
 
   private static customFormatOf(name: string): FormatPredicate | undefined {
-    const custom = Formats.find(name);
+    const custom = StringFormats.find(name);
     if (!custom && !(name in engineFormats)) {
       throw new SchemaError(
-        `Unknown format: '${name}'. Register it with Formats.register('${name}', …) — ` +
+        `Unknown format: '${name}'. Register it with StringFormats.register('${name}', …) — ` +
           `the engine validates ${Object.keys(engineFormats).length} formats natively and this is not one of them.`,
       );
     }
     return custom;
   }
 }
-
-/**
- * The engine states its refusals outermost first, so `errors[0]` on a nested shape is the
- * parent's `Property "street" does not match schema.` — true, and never the reason. The
- * DEEPEST one is the reason, and it is the one that says where.
- */
-function refusalOf(errors: readonly OutputUnit[]): Verdict {
-  const deepest = errors.reduce<OutputUnit | undefined>(
-    (held, one) => (held && depthOf(held) >= depthOf(one) ? held : one),
-    undefined,
-  );
-  if (!deepest) return { message: 'Invalid value' };
-  const path = locationOf(deepest.instanceLocation);
-
-  return path.length > 0 ? { message: deepest.error, path } : { message: deepest.error };
-}
-
-const depthOf = (unit: OutputUnit): number => locationOf(unit.instanceLocation).length;
-
-/** `#/city/zip` — a JSON Pointer fragment, and `~1`/`~0` are how it spells `/` and `~`. */
-const locationOf = (instanceLocation: string): string[] =>
-  instanceLocation
-    .replace(/^#/, '')
-    .split('/')
-    .filter(Boolean)
-    .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));

package/src/validator/JsonSchemaValidator.ts

@@ -0,0 +1,142 @@
+import { Validator, type OutputUnit } from '@cfworker/json-schema';
+import type { JsonSchema } from '../lib/JsonSchema.js';
+import { isObject } from '../lib/utils.js';
+import type { ValidationError } from '../lib/ValidationError.js';
+import { locationOf } from '../lib/ValidationResult.js';
+
+/**
+ * The one door onto the engine: a field's value against its shape, a declaration against the
+ * format of its key. 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 JsonSchemaValidator {
+  private static readonly held = new WeakMap<JsonSchema, JsonSchemaValidator>();
+
+  private first?: Validator;
+  private every?: Validator;
+
+  private constructor(private readonly schema: JsonSchema) {}
+
+  static of(schema: JsonSchema): JsonSchemaValidator {
+    let validator = this.held.get(schema);
+
+    if (!validator) {
+      validator = new JsonSchemaValidator(schema);
+      this.held.set(schema, validator);
+    }
+
+    return validator;
+  }
+
+  /** `refusalOf({ update: 'maybe' }, ['lifecycle'])` → `lifecycle.update: Instance does not match any of ["now","forbidden"].` */
+  refusalOf(value: unknown, path: readonly string[]): ValidationError | undefined {
+    this.first ??= new Validator(this.schema, '2020-12', true);
+
+    const refused = refusedBy(this.first, value);
+
+    if (!Array.isArray(refused)) return under(path, refused);
+    if (!refused.length) return undefined;
+
+    const reasons = named(refused);
+
+    return at(path, reasons.length ? deepestOf(reasons) : refused[0]);
+  }
+
+  /**
+   * One refusal per key, so a declaration hears every fault at once. It reads through an engine
+   * of its own: the other stops at the first, which is what a single value wants.
+   */
+  refusalsOf(value: unknown, path: readonly string[]): ValidationError[] {
+    this.every ??= new Validator(this.schema, '2020-12', false);
+
+    const refused = refusedBy(this.every, value);
+
+    if (!Array.isArray(refused)) return [under(path, refused)];
+    if (!refused.length) return [];
+
+    const faults = [...byKey(named(refused)).values()];
+
+    return faults.length ? faults.map((units) => at(path, deepestOf(units))) : [at(path, refused[0])];
+  }
+}
+
+/** What it refused on, or the member JSON cannot hold — the engine throws on one rather than refusing. */
+function refusedBy(engine: Validator, value: unknown): OutputUnit[] | ValidationError {
+  const json = stated(value);
+
+  try {
+    const verdict = engine.validate(json);
+
+    return verdict.valid ? [] : verdict.errors;
+  } catch {
+    const where = unreadableIn(json) ?? { path: [], value: json };
+
+    return { path: where.path, message: `Expected a JSON value — got ${typeof where.value}` };
+  }
+}
+
+/** `False boolean schema` names nothing: the unit above it carries the offending key. */
+const named = (units: readonly OutputUnit[]): OutputUnit[] =>
+  units.filter((unit) => unit.keyword !== 'false');
+
+/** The engine states its refusals outermost first: the deepest says where, the last one is why. */
+function deepestOf(units: readonly OutputUnit[]): OutputUnit {
+  return units.reduce((held, unit) => (depthOf(held) > depthOf(unit) ? held : unit));
+}
+
+/**
+ * The units of one fault, addressed by the key they happened under. A unit on the value ITSELF
+ * points at a key when another one is deeper — `Property "lifecycle" does not match schema.` —
+ * so it is kept only when it is all there is.
+ */
+function byKey(units: readonly OutputUnit[]): Map<string, OutputUnit[]> {
+  const held = new Map<string, OutputUnit[]>();
+
+  for (const unit of units) {
+    const key = locationOf(unit.instanceLocation)[0] ?? '';
+    held.set(key, [...(held.get(key) ?? []), unit]);
+  }
+
+  if (held.size > 1) held.delete('');
+
+  return held;
+}
+
+const at = (path: readonly string[], unit: OutputUnit): ValidationError => ({
+  path: [...path, ...locationOf(unit.instanceLocation)],
+  message: unit.error,
+});
+
+const under = (path: readonly string[], refusal: ValidationError): ValidationError => ({
+  path: [...path, ...refusal.path],
+  message: refusal.message,
+});
+
+const depthOf = (unit: OutputUnit): number => locationOf(unit.instanceLocation).length;
+
+/** A key set to `undefined` states nothing, as in JSON — and the engine refuses to read one. */
+function stated(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(stated);
+
+  if (!isObject(value)) return value;
+
+  const present = Object.entries(value).filter(([, member]) => member !== undefined);
+
+  return Object.fromEntries(present.map(([key, member]) => [key, stated(member)]));
+}
+
+/** Where the engine stopped: a function, a symbol or a bigint is not a value JSON holds. */
+function unreadableIn(
+  value: unknown,
+  path: readonly string[] = [],
+): { path: readonly string[]; value: unknown } | undefined {
+  if (['function', 'symbol', 'bigint'].includes(typeof value)) return { path, value };
+
+  if (Array.isArray(value)) {
+    return value.flatMap((member, index) => unreadableIn(member, [...path, String(index)]) ?? [])[0];
+  }
+
+  if (!isObject(value)) return undefined;
+
+  return Object.entries(value).flatMap(([key, member]) => unreadableIn(member, [...path, key]) ?? [])[0];
+}

package/src/vocabulary/vocabulary.ts

@@ -1,9 +1,9 @@
 import { Field } from '../field/Field.js';
-import { EXTENSION_SLOTS } from '../axis/Axis.js';
+import { Axes } from '../axis/Axes.js';
 import { dequal } from 'dequal';
 import { SchemaError } from '../SchemaError.js';
 
-const MEMBER_SLOTS = [...EXTENSION_SLOTS, 'meta'] as const;
+const memberSlots = (): string[] => [...Axes.names, 'meta'];
 
 /**
  * Builds a `rule/` word, which states members on the field it receives.
@@ -26,12 +26,14 @@ export type FieldWord = (field: Field<any>) => Field<any>;
  */
 function merge(name: string, field: Field, given: Partial<Field>): Partial<Field> {
   const merged: Record<string, unknown> = {};
+  const stated = given as Record<string, unknown>;
+  const held = field as unknown as Record<string, unknown>;
   if ('shape' in given) merged.shape = given.shape;
 
-  for (const slot of MEMBER_SLOTS) {
-    const members = given[slot];
+  for (const slot of memberSlots()) {
+    const members = stated[slot];
     if (members === undefined) continue;
-    const already = field[slot] as Record<string, unknown> | undefined;
+    const already = held[slot] as Record<string, unknown> | undefined;
     if (typeof members !== 'object' || members === null || typeof already !== 'object') {
       merged[slot] = members;
       continue;

package/dist/axis/boundary/BoundaryAxis.d.ts

@@ -1,4 +0,0 @@
-import type { Axis } from '../Axis.js';
-import type { BoundaryRef } from './BoundaryRef.js';
-export declare const boundaryAxis: Axis<BoundaryRef, BoundaryRef>;
-//# sourceMappingURL=BoundaryAxis.d.ts.map

package/dist/axis/boundary/BoundaryAxis.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryAxis.d.ts","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryAxis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CA0BvD,CAAC"}

package/dist/axis/boundary/BoundaryAxis.js

@@ -1,30 +0,0 @@
-import { admitWire } from '../../projection/card/admission.js';
-import { isObject, shown } from '../../lib/utils.js';
-export const boundaryAxis = {
-    slot: 'boundary',
-    validator(value, errors) {
-        if (typeof value === 'string')
-            return;
-        if (!isObject(value)) {
-            errors.push({
-                path: ['boundary'],
-                message: `Expected an alias name or { in, out } — got ${shown(value)}`,
-            });
-            return;
-        }
-        for (const [side, verb] of [['in', 'decode'], ['out', 'encode']]) {
-            const rule = value[side];
-            if (rule === undefined || rule === 'closed')
-                continue;
-            if (!isObject(rule) || typeof rule[verb] !== 'string') {
-                errors.push({ path: ['boundary', side], message: `Expected 'closed' or { ${verb}: <name> }` });
-            }
-        }
-    },
-    describe: (value) => value,
-    reconstruct: (wire) => {
-        admitWire(boundaryAxis.validator, wire, 'boundary');
-        return wire;
-    },
-};
-//# sourceMappingURL=BoundaryAxis.js.map

package/dist/axis/boundary/BoundaryAxis.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryAxis.js","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryAxis.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGrD,MAAM,CAAC,MAAM,YAAY,GAAmC;IAC1D,IAAI,EAAE,UAAU;IAEhB,SAAS,CAAC,KAAK,EAAE,MAAM;QACrB,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO;QACtC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,CAAC,UAAU,CAAC;gBAClB,OAAO,EAAE,+CAA+C,KAAK,CAAC,KAAK,CAAC,EAAE;aACvE,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAU,EAAE,CAAC;YAC1E,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ;gBAAE,SAAS;YACtD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACtD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,0BAA0B,IAAI,YAAY,EAAE,CAAC,CAAC;YACjG,CAAC;QACH,CAAC;IACH,CAAC;IAED,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IAC1B,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE;QACpB,SAAS,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC"}

package/dist/axis/boundary/BoundaryRef.d.ts

@@ -1,3 +0,0 @@
-import type { BoundaryRules } from './BoundaryRules.js';
-export type BoundaryRef = 'isoDate' | (string & {}) | BoundaryRules;
-//# sourceMappingURL=BoundaryRef.d.ts.map

package/dist/axis/boundary/BoundaryRef.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryRef.d.ts","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,aAAa,CAAC"}

package/dist/axis/boundary/BoundaryRef.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BoundaryRef.js.map

package/dist/axis/boundary/BoundaryRef.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryRef.js","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryRef.ts"],"names":[],"mappings":""}

package/dist/axis/boundary/BoundaryRules.d.ts

@@ -1,9 +0,0 @@
-export interface BoundaryRules {
-    in?: 'closed' | {
-        decode: string;
-    };
-    out?: 'closed' | {
-        encode: string;
-    };
-}
-//# sourceMappingURL=BoundaryRules.d.ts.map

package/dist/axis/boundary/BoundaryRules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryRules.d.ts","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryRules.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,EAAE,CAAC,EAAE,QAAQ,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,GAAG,CAAC,EAAE,QAAQ,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACrC"}

package/dist/axis/boundary/BoundaryRules.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BoundaryRules.js.map

package/dist/axis/boundary/BoundaryRules.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundaryRules.js","sourceRoot":"","sources":["../../../src/axis/boundary/BoundaryRules.ts"],"names":[],"mappings":""}

package/dist/axis/lifecycle/Clock.d.ts

@@ -1,10 +0,0 @@
-export declare class Clock {
-    private static reading;
-    static now(): number;
-    /**
-     *
-     * @returns function to restore the clock
-     */
-    static freeze(at: number | Date): () => void;
-}
-//# sourceMappingURL=Clock.d.ts.map

package/dist/axis/lifecycle/Clock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../../../src/axis/lifecycle/Clock.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAC,OAAO,CAA0B;IAEhD,MAAM,CAAC,GAAG,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,IAAI,CAS3C;CACF"}