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

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

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

package/src/schema/Schema.ts

@@ -1,13 +1,13 @@
-import { Boundary } from '../axis/boundary/Boundary.js';
-import { type Fields } from '../fields/Field.js';
+import { Boundary } from './axis/boundary/Boundary.js';
+import { type Fields } from './fields/Field.js';
 import {
   type CompositeUnique,
   type EntityDeclarations,
   type PreviousNames,
-} from '../EntityDeclarations.js';
-import { EntityAdapterSet, type EntityAdapters } from '../EntityAdapters.js';
-import { FieldGroup } from '../constraint/FieldGroup.js';
-import { Unique } from '../constraint/Unique.js';
+} from '../entity/EntityDeclarations.js';
+import { EntityAdapterSet, type EntityAdapters } from '../entity/EntityAdapters.js';
+import { FieldGroup } from './fields/constraint/FieldGroup.js';
+import { Unique } from './fields/constraint/Unique.js';
 import { RowJudge } from '../judge/RowJudge.js';
 import { SchemaDerivation } from './SchemaDerivation.js';
 import { SchemaDefinition } from './SchemaDefinition.js';
@@ -15,50 +15,79 @@ import { type ValidateOptions } from '../judge/options.js';
 import type { StandardSchemaV1 } from '../projection/standard.js';
 import type { PartialRow, Row, SchemaView } from './SchemaView.js';
 
-export const ANONYMOUS_SCHEMA_NAME = "Schema";
+export const ANONYMOUS_SCHEMA_NAME = 'Schema';
 
 export interface SchemaConstructor<TFields extends Fields> extends SchemaView<TFields> {
   new (data: PartialRow<TFields>): Row<TFields>;
-  readonly "~standard": StandardSchemaV1.Props<Record<string, unknown>, Row<TFields>>;
+  readonly '~standard': StandardSchemaV1.Props<Record<string, unknown>, Row<TFields>>;
   readonly derivation?: SchemaDerivation;
   readonly previous?: PreviousNames<TFields>;
   readonly anchored?: boolean;
   from(data: Record<string, unknown>): Row<TFields>;
-  pick<K extends string & keyof TFields>(...keys: K[]): SchemaConstructor<Pick<TFields, K>>;
-  omit<K extends string & keyof TFields>(...keys: K[]): SchemaConstructor<Omit<TFields, K>>;
+  pick<K extends string & keyof TFields>(
+    ...keys: K[]
+  ): SchemaConstructor<Pick<TFields, K>>;
+  omit<K extends string & keyof TFields>(
+    ...keys: K[]
+  ): SchemaConstructor<Omit<TFields, K>>;
   partial(): SchemaConstructor<TFields>;
   extend<E extends Fields>(extra: E): SchemaConstructor<TFields & E>;
   declares(declarations: EntityDeclarations<TFields>): SchemaConstructor<TFields>;
   anchor(): SchemaConstructor<TFields>;
   named(name: string): SchemaConstructor<TFields>;
-  rename(mapping: Partial<Record<string & keyof TFields, string>>): SchemaConstructor<Fields>;
+  rename(
+    mapping: Partial<Record<string & keyof TFields, string>>,
+  ): SchemaConstructor<Fields>;
 }
 
 export class Schema {
   /** The one place a schema holds what it is. The readings below are its projections. */
   static definition: SchemaDefinition = SchemaDefinition.stated({ fields: {} });
 
-  static get fields(): Fields { return this.definition.fields; }
-  static get adapters(): EntityAdapters<Fields> | undefined { return this.definition.adapters; }
-  static get opts(): ValidateOptions { return this.definition.opts; }
-  static get derivation(): SchemaDerivation | undefined { return this.definition.derivation; }
-  static get previous(): PreviousNames<Fields> | undefined { return this.definition.previous; }
-  static get anchored(): boolean { return this.definition.anchored; }
+  static get fields(): Fields {
+    return this.definition.fields;
+  }
+  static get adapters(): EntityAdapters<Fields> | undefined {
+    return this.definition.adapters;
+  }
+  static get opts(): ValidateOptions {
+    return this.definition.opts;
+  }
+  static get derivation(): SchemaDerivation | undefined {
+    return this.definition.derivation;
+  }
+  static get previous(): PreviousNames<Fields> | undefined {
+    return this.definition.previous;
+  }
+  static get anchored(): boolean {
+    return this.definition.anchored;
+  }
 
   constructor(data?: Record<string, unknown>) {
     if (!data) return;
     for (const [key, value] of Object.entries(data)) {
-      Object.defineProperty(this, key, { value, writable: true, enumerable: true, configurable: true });
+      Object.defineProperty(this, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
     }
   }
 
-  static getFields() { return this.fields; }
-  static getAdapters() { return this.adapters; }
+  static getFields() {
+    return this.fields;
+  }
+  static getAdapters() {
+    return this.adapters;
+  }
   static getUnique(): CompositeUnique<Fields> | undefined {
     const groups = FieldGroup.groupsOf(this.fields, Unique);
     return groups.length ? groups.map((group) => [...group.members]) : undefined;
   }
-  static getOpts() { return this.opts; }
+  static getOpts() {
+    return this.opts;
+  }
 
   static validate(input: unknown) {
     return RowJudge.of(this.fields, this.opts).check(input);
@@ -69,25 +98,28 @@ export class Schema {
     for (const [key, field] of Object.entries(this.fields)) {
       if (!(key in data)) continue;
       const value = data[key];
-      if (value === null || value === undefined) { out[key] = value; continue; }
+      if (value === null || value === undefined) {
+        out[key] = value;
+        continue;
+      }
       const decoded = Boundary.of(field).decode(value);
-      out[key] = "error" in decoded ? value : decoded.value;
+      out[key] = 'error' in decoded ? value : decoded.value;
     }
     return out;
   }
 
-  static get ["~standard"](): StandardSchemaV1.Props<Record<string, unknown>> {
+  static get ['~standard'](): StandardSchemaV1.Props<Record<string, unknown>> {
     const { fields, opts } = this;
     return {
       version: 1,
-      vendor: "fougere",
+      vendor: 'fougere',
       validate(value: unknown) {
         const result = RowJudge.of(fields, opts).check(value);
         if (result.success) return { value: result.data };
         return {
           issues: result.errors.map((e) => ({
             message: e.message,
-            path: e.path && e.path !== "." ? [{ key: e.path }] : undefined,
+            path: e.path && e.path !== '.' ? [{ key: e.path }] : undefined,
           })),
         };
       },
@@ -95,23 +127,25 @@ export class Schema {
   }
 
   static pick(...keys: string[]) {
-    assertKnownKeys("pick", keys, this.fields);
+    assertKnownKeys('pick', keys, this.fields);
     const picked: Fields = {};
     for (const key of keys) if (this.fields[key]) picked[key] = this.fields[key];
     return this.derive(picked, (k) => (keys.includes(k) ? k : undefined));
   }
 
   static omit(...keys: string[]) {
-    assertKnownKeys("omit", keys, this.fields);
+    assertKnownKeys('omit', keys, this.fields);
     const kept: Fields = {};
-    for (const [key, field] of Object.entries(this.fields)) if (!keys.includes(key)) kept[key] = field;
+    for (const [key, field] of Object.entries(this.fields))
+      if (!keys.includes(key)) kept[key] = field;
     return this.derive(kept, (k) => (keys.includes(k) ? undefined : k));
   }
 
   static rename(mapping: Record<string, string>) {
-    assertKnownKeys("rename", Object.keys(mapping), this.fields);
+    assertKnownKeys('rename', Object.keys(mapping), this.fields);
     const renamed: Fields = {};
-    for (const [key, field] of Object.entries(this.fields)) renamed[mapping[key] ?? key] = field;
+    for (const [key, field] of Object.entries(this.fields))
+      renamed[mapping[key] ?? key] = field;
     return this.derive(renamed, (k) => mapping[k] ?? k);
   }
 
@@ -121,7 +155,11 @@ export class Schema {
    */
   static declares(declarations: EntityDeclarations<Fields>) {
     const addressed = EntityAdapterSet.of(declarations.adapters)?.fieldNames ?? [];
-    assertKnownKeys("declares", [...addressed, ...Object.keys(declarations.previous ?? {})], this.fields);
+    assertKnownKeys(
+      'declares',
+      [...addressed, ...Object.keys(declarations.previous ?? {})],
+      this.fields,
+    );
 
     return Schema.subclass(this.definition.declaring(declarations));
   }
@@ -150,14 +188,18 @@ export class Schema {
       throw new Error(`named(): \`${name}\` is not a valid class name.`);
     }
     if (this.name !== ANONYMOUS_SCHEMA_NAME) {
-      throw new Error(`named(): \`${this.name}\` is already named by its class declaration.`);
+      throw new Error(
+        `named(): \`${this.name}\` is already named by its class declaration.`,
+      );
     }
-    Object.defineProperty(this, "name", { value: name, configurable: true });
+    Object.defineProperty(this, 'name', { value: name, configurable: true });
     return this;
   }
 
   static compose<T extends SchemaView[]>(...sources: T): SchemaConstructor<Merged<T>> {
-    return Schema.subclass(SchemaDefinition.merged(sources)) as unknown as SchemaConstructor<Merged<T>>;
+    return Schema.subclass(
+      SchemaDefinition.merged(sources),
+    ) as unknown as SchemaConstructor<Merged<T>>;
   }
 
   static of<TFields extends Fields>(stated: {
@@ -168,14 +210,19 @@ export class Schema {
     previous?: PreviousNames<TFields>;
     anchored?: boolean;
   }): SchemaConstructor<TFields> {
-    return Schema.subclass(SchemaDefinition.stated(stated)) as unknown as SchemaConstructor<TFields>;
+    return Schema.subclass(
+      SchemaDefinition.stated(stated),
+    ) as unknown as SchemaConstructor<TFields>;
   }
 
   /** The class a definition becomes. The one place a Schema subclass is born. */
   private static subclass(definition: SchemaDefinition): SchemaConstructor<Fields> {
     class Derived extends Schema {}
     Derived.definition = definition;
-    Object.defineProperty(Derived, "name", { value: ANONYMOUS_SCHEMA_NAME, configurable: true });
+    Object.defineProperty(Derived, 'name', {
+      value: ANONYMOUS_SCHEMA_NAME,
+      configurable: true,
+    });
     return Derived as unknown as SchemaConstructor<Fields>;
   }
 
@@ -188,10 +235,17 @@ function assertKnownKeys(operation: string, keys: string[], fields: Fields): voi
   const strangers = keys.filter((key) => !(key in fields));
   if (strangers.length === 0) return;
   throw new Error(
-    `${operation}(): unknown field ${strangers.map((s) => `\`${s}\``).join(", ")}. ` +
-      `This schema carries ${Object.keys(fields).join(", ")}.`,
+    `${operation}(): unknown field ${strangers.map((s) => `\`${s}\``).join(', ')}. ` +
+      `This schema carries ${Object.keys(fields).join(', ')}.`,
   );
 }
 
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type Merged<T extends SchemaView[]> = UnionToIntersection<T[number] extends { getFields(): infer F } ? F : Fields> & Fields;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+type Merged<T extends SchemaView[]> = UnionToIntersection<
+  T[number] extends { getFields(): infer F } ? F : Fields
+> &
+  Fields;

package/src/schema/SchemaDefinition.ts

@@ -1,7 +1,10 @@
-import { type Fields } from '../fields/Field.js';
-import { FieldSet } from '../fields/FieldSet.js';
-import { type EntityDeclarations, type PreviousNames } from '../EntityDeclarations.js';
-import { EntityAdapterSet, type EntityAdapters } from '../EntityAdapters.js';
+import { type Fields } from './fields/Field.js';
+import { FieldSet } from './fields/FieldSet.js';
+import {
+  type EntityDeclarations,
+  type PreviousNames,
+} from '../entity/EntityDeclarations.js';
+import { EntityAdapterSet, type EntityAdapters } from '../entity/EntityAdapters.js';
 import { SchemaDerivation } from './SchemaDerivation.js';
 import { type ValidateOptions } from '../judge/options.js';
 import type { SchemaView } from './SchemaView.js';
@@ -36,7 +39,12 @@ export class SchemaDefinition {
     anchored?: boolean;
   }): SchemaDefinition {
     return new SchemaDefinition(
-      said.fields, EntityAdapterSet.of(said.adapters)?.stated, said.opts ?? {}, said.previous, said.derivation, said.anchored ?? false,
+      said.fields,
+      EntityAdapterSet.of(said.adapters)?.stated,
+      said.opts ?? {},
+      said.previous,
+      said.derivation,
+      said.anchored ?? false,
     );
   }
 
@@ -60,7 +68,12 @@ export class SchemaDefinition {
    */
   anchoring(): SchemaDefinition {
     return new SchemaDefinition(
-      this.fields, this.adapters, this.opts, this.previous, this.derivation, true,
+      this.fields,
+      this.adapters,
+      this.opts,
+      this.previous,
+      this.derivation,
+      true,
     );
   }
 
@@ -68,9 +81,14 @@ export class SchemaDefinition {
    * `pick`, `omit` and `rename` are one gesture: the fields that remain, and what became
    * of each name. What each adapter was handed follows the same correspondence, and so does the origin.
    */
-  cut(fields: Fields, survives: (key: string) => string | undefined, root: SchemaView): SchemaDefinition {
+  cut(
+    fields: Fields,
+    survives: (key: string) => string | undefined,
+    root: SchemaView,
+  ): SchemaDefinition {
     const renamed: Fields = {};
-    for (const [key, field] of Object.entries(fields)) renamed[key] = field.rename(survives);
+    for (const [key, field] of Object.entries(fields))
+      renamed[key] = field.rename(survives);
     return new SchemaDefinition(
       renamed,
       EntityAdapterSet.of(this.adapters)?.cut(survives)?.stated,
@@ -84,14 +102,24 @@ export class SchemaDefinition {
   /** The same fields, judged as an update. */
   patched(root: SchemaView): SchemaDefinition {
     return new SchemaDefinition(
-      { ...this.fields }, this.adapters, { ...this.opts, patch: true }, undefined, this.origin(root), false,
+      { ...this.fields },
+      this.adapters,
+      { ...this.opts, patch: true },
+      undefined,
+      this.origin(root),
+      false,
     );
   }
 
   /** The added fields have no origin, so the derivation is unchanged: it speaks of the root. */
   extended(extra: Fields, root: SchemaView): SchemaDefinition {
     return new SchemaDefinition(
-      { ...this.fields, ...extra }, this.adapters, this.opts, undefined, this.origin(root), false,
+      { ...this.fields, ...extra },
+      this.adapters,
+      this.opts,
+      undefined,
+      this.origin(root),
+      false,
     );
   }
 
@@ -103,7 +131,9 @@ export class SchemaDefinition {
       Object.assign(fields, view.getFields());
       opts = { ...opts, ...view.getOpts() };
     }
-    const adapters = EntityAdapterSet.merged(views.map((view) => view.getAdapters()))?.stated;
+    const adapters = EntityAdapterSet.merged(
+      views.map((view) => view.getAdapters()),
+    )?.stated;
 
     return new SchemaDefinition(fields, adapters, opts, undefined, undefined, false);
   }

package/src/schema/SchemaDerivation.ts

@@ -1,4 +1,4 @@
-import { type Fields } from '../fields/Field.js';
+import { type Fields } from './fields/Field.js';
 import type { SchemaView } from './SchemaView.js';
 
 /**
@@ -18,7 +18,10 @@ export class SchemaDerivation {
 
   /** The first cut: every field of the origin still answers to its own name. */
   static first(source: SchemaView, fields: Fields): SchemaDerivation {
-    return new SchemaDerivation(source, Object.fromEntries(Object.keys(fields).map((key) => [key, key])));
+    return new SchemaDerivation(
+      source,
+      Object.fromEntries(Object.keys(fields).map((key) => [key, key])),
+    );
   }
 
   /** The same origin, seen through one more cut. */
@@ -26,7 +29,10 @@ export class SchemaDerivation {
     return new SchemaDerivation(
       this.source,
       Object.fromEntries(
-        Object.entries(this.survived).map(([origin, here]) => [origin, here === undefined ? undefined : survives(here)]),
+        Object.entries(this.survived).map(([origin, here]) => [
+          origin,
+          here === undefined ? undefined : survives(here),
+        ]),
       ),
     );
   }
@@ -43,7 +49,9 @@ export class SchemaDerivation {
   get anchor(): SchemaView {
     const source = this.source;
 
-    return source.anchored !== undefined || !source.derivation ? source : source.derivation.anchor;
+    return source.anchored !== undefined || !source.derivation
+      ? source
+      : source.derivation.anchor;
   }
 
   /**

package/src/schema/SchemaView.ts

@@ -1,6 +1,6 @@
-import type { Field, Fields } from '../fields/Field.js';
-import type { CompositeUnique, PreviousNames } from '../EntityDeclarations.js';
-import type { EntityAdapters } from '../EntityAdapters.js';
+import type { Field, Fields } from './fields/Field.js';
+import type { CompositeUnique, PreviousNames } from '../entity/EntityDeclarations.js';
+import type { EntityAdapters } from '../entity/EntityAdapters.js';
 import type { ValidationResult } from '../judge/result.js';
 import type { ValidateOptions } from '../judge/options.js';
 import type { SchemaDerivation } from './SchemaDerivation.js';

package/src/{axis → schema/axis}/Axis.ts

@@ -1,7 +1,7 @@
 import { roleAxis } from './role/RoleAxis.js';
 import { lifecycleAxis } from './lifecycle/LifecycleAxis.js';
 import { boundaryAxis } from './boundary/BoundaryAxis.js';
-import type { ValidationError } from '../judge/result.js';
+import type { ValidationError } from '../../judge/result.js';
 
 export interface Axis<Declared = unknown, Wire = unknown> {
   readonly slot: 'role' | 'lifecycle' | 'boundary';

package/src/{axis → schema/axis}/boundary/Boundary.ts

@@ -19,7 +19,10 @@ 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;
@@ -39,10 +42,19 @@ 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.decoder(rules.in.decode)
+          : identityDecoder,
+      encode:
+        typeof rules.out === 'object'
+          ? Boundaries.encoder(rules.out.encode)
+          : identityEncoder,
     });
   }
 
@@ -65,5 +77,4 @@ export class Boundary implements BoundaryRules {
   get writeOnly(): boolean {
     return this.out === 'closed';
   }
-
 }

package/src/{axis → schema/axis}/boundary/BoundaryAxis.ts

@@ -1,6 +1,6 @@
 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 '../../../utils.js';
 import type { BoundaryRef } from './Boundary.js';
 
 export const boundaryAxis: Axis<BoundaryRef, BoundaryRef> = {

package/src/{axis → schema/axis}/lifecycle/LifecycleAxis.ts

@@ -1,7 +1,7 @@
 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 '../../../judge/result.js';
+import { admitWire, oneOfTokens } from '../../../projection/card/admission.js';
+import { isObject } from '../../../utils.js';
 import { CREATE_TOKENS, UPDATE_TOKENS, type LifecycleRules } from './Lifecycle.js';
 
 export const lifecycleAxis: Axis<LifecycleRules, LifecycleRules> = {

package/src/{axis → schema/axis}/lifecycle/apply.ts

@@ -31,7 +31,8 @@ export function applyUpdate(fields: Fields, patch: Row): Row {
   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 out))
+      out[name] = new Date(instant);
   }
 
   return out;

package/src/{axis → schema/axis}/role/Role.ts

@@ -1,5 +1,5 @@
-import { FieldGroup } from "../../constraint/FieldGroup.js";
-import { Unique } from "../../constraint/Unique.js";
+import { FieldGroup } from "../../fields/constraint/FieldGroup.js";
+import { Unique } from "../../fields/constraint/Unique.js";
 import type { EntityConstructor, Relation } from "./Relation.js";
 
 export interface RoleRules {

package/src/{axis → schema/axis}/role/RoleAxis.ts

@@ -1,13 +1,12 @@
 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 '../../../utils.js';
+import type { ValidationError } from '../../../judge/result.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 { FieldGroup } from '../../fields/constraint/FieldGroup.js';
+import { Unique } from '../../fields/constraint/Unique.js';
+import type { RoleDescriptor } from '../../../projection/card/Descriptor.js';
 
 export const roleAxis: Axis<RoleRules, RoleDescriptor> = {
   slot: 'role',

package/src/{fields → schema/fields}/Field.ts

@@ -1,11 +1,11 @@
-import type { Shape } from "../axis/shape/Shape.js";
-import { Role, type RoleRules } from "../axis/role/Role.js";
-import type { LifecycleRules } from "../axis/lifecycle/Lifecycle.js";
-import type { BoundaryRef } from "../axis/boundary/Boundary.js";
-import type { Meta } from "../axis/Meta.js";
-import type { Axis } from "../axis/Axis.js";
-import { FieldJudge } from "../judge/FieldJudge.js";
-import { ValueJudge } from "../judge/ValueJudge.js";
+import type { Shape } from '../axis/shape/Shape.js';
+import { Role, type RoleRules } from '../axis/role/Role.js';
+import type { LifecycleRules } from '../axis/lifecycle/Lifecycle.js';
+import type { BoundaryRef } from '../axis/boundary/Boundary.js';
+import type { Meta } from '../axis/Meta.js';
+import type { Axis } from '../axis/Axis.js';
+import { FieldJudge } from '../../judge/FieldJudge.js';
+import { ValueJudge } from '../../judge/ValueJudge.js';
 
 export type Fields = Record<string, Field>;
 
@@ -13,7 +13,7 @@ export type Fields = Record<string, Field>;
 export type FieldName<TFields extends Fields> = Extract<keyof TFields, string>;
 
 /** The carrier, the three extension axes, the annotation — the five the judge reads. */
-export type FieldDeclaration = Pick<Field, "shape" | Axis["slot"] | "meta">;
+export type FieldDeclaration = Pick<Field, 'shape' | Axis['slot'] | 'meta'>;
 
 export class Field<T = unknown> {
   readonly shape: Shape;
@@ -29,8 +29,8 @@ export class Field<T = unknown> {
 
     if (!verdict.success) {
       throw new Error(
-        `${key ? `Field '${key}': ` : ""}` +
-          verdict.errors.map((e) => `${e.path}: ${e.message}`).join("; "),
+        `${key ? `Field '${key}': ` : ''}` +
+          verdict.errors.map((e) => `${e.path}: ${e.message}`).join('; '),
       );
     }
 
@@ -41,11 +41,11 @@ export class Field<T = unknown> {
     this.meta = init.meta;
 
     const create = this.lifecycle?.create;
-    if (typeof create === "object" && create !== null && "value" in create) {
+    if (typeof create === 'object' && create !== null && 'value' in create) {
       const checked = ValueJudge.of(this).check(create.value);
-      if ("error" in checked)
+      if ('error' in checked)
         throw new Error(
-          `${key ? `Field '${key}': ` : ""}the declared default ${JSON.stringify(create.value)} ` +
+          `${key ? `Field '${key}': ` : ''}the declared default ${JSON.stringify(create.value)} ` +
             `is not a legal value for it — ${checked.error}.`,
         );
     }
@@ -77,4 +77,3 @@ export class Field<T = unknown> {
     });
   }
 }
-

package/src/{fields → schema/fields}/FieldSet.ts

@@ -1,7 +1,7 @@
 import { Role } from '../axis/role/Role.js';
-import { FieldGroup } from '../constraint/FieldGroup.js';
-import { Unique } from '../constraint/Unique.js';
-import type { CompositeUnique } from '../EntityDeclarations.js';
+import { FieldGroup } from './constraint/FieldGroup.js';
+import { Unique } from './constraint/Unique.js';
+import type { CompositeUnique } from '../../entity/EntityDeclarations.js';
 import { Field, type FieldName, type Fields } from './Field.js';
 
 export class FieldSet<TFields extends Fields = Fields> {
@@ -21,7 +21,8 @@ export class FieldSet<TFields extends Fields = Fields> {
     unique?: CompositeUnique<TFields>,
   ): TFields {
     let fields: Fields = {};
-    for (const [key, field] of Object.entries(declared)) fields[key] = new Field(field, key);
+    for (const [key, field] of Object.entries(declared))
+      fields[key] = new Field(field, key);
     for (const group of unique ?? []) fields = new Unique(group).onto(fields);
     return fields as TFields;
   }
@@ -32,7 +33,7 @@ export class FieldSet<TFields extends Fields = Fields> {
    * `Role.of(field).isPrimary` answers about ONE field; this answers about a shape, which
    * is the question every reader actually had. It was the same three lines spelled five
    * times — a mirror's key, a form's row identity, GraphQL's node id, the DDL's primary
-   * key and the ORM's `findById` column — so a shape with two primaries meant whichever
+   * key and the storage's `findById` column — so a shape with two primaries meant whichever
    * one that loop happened to see first, five times over.
    *
    * The absence is answered and not defaulted: `'id'` is a fine fallback for a form and a
@@ -46,7 +47,7 @@ export class FieldSet<TFields extends Fields = Fields> {
     if (primaries.length > 1) {
       throw new Error(
         `FieldSet.primary: ${primaries.map((name) => JSON.stringify(name)).join(', ')} all declare ` +
-        '`primary`; a field set can have only one primary field.',
+          '`primary`; a field set can have only one primary field.',
       );
     }
 
@@ -56,7 +57,7 @@ export class FieldSet<TFields extends Fields = Fields> {
   get uniqueGroups(): CompositeUnique<TFields> | undefined {
     const groups = FieldGroup.groupsOf(this.fields, Unique);
     return groups.length
-      ? groups.map((group) => [...group.members]) as unknown as CompositeUnique<TFields>
+      ? (groups.map((group) => [...group.members]) as unknown as CompositeUnique<TFields>)
       : undefined;
   }
 }