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

package/dist/vocabulary/vocabulary.js

@@ -1,31 +1,41 @@
-import { EXTENSION_SLOTS } from '../schema/axis/Axis.js';
+import { EXTENSION_SLOTS } from '../axis/Axis.js';
 import { dequal } from 'dequal';
 const MEMBER_SLOTS = [...EXTENSION_SLOTS, 'meta'];
+/**
+ * So a word is one statement about a field, not a rebuilt field.
+ * FR : pour qu'un mot soit une affirmation sur un champ, pas un champ reconstruit.
+ * `vocabulary('indexed', () => ({ role: { index: true } }))`
+ */
 export function vocabulary(name, states) {
     return (field) => field.with(merge(name, field, states(field)));
 }
-function merge(name, field, stated) {
-    const out = {};
-    if ('shape' in stated)
-        out.shape = stated.shape;
+/**
+ * So two words that state the same member differently refuse instead of one winning.
+ * FR : pour que deux mots contredisant un même membre refusent, plutôt qu'un l'emporte.
+ * `readOnly(writeOnly(text()))` → both close a different side, so both apply
+ */
+function merge(name, field, given) {
+    const merged = {};
+    if ('shape' in given)
+        merged.shape = given.shape;
     for (const slot of MEMBER_SLOTS) {
-        const members = stated[slot];
+        const members = given[slot];
         if (members === undefined)
             continue;
-        const held = field[slot];
-        if (typeof members !== 'object' || members === null || typeof held !== 'object') {
-            out[slot] = members;
+        const already = field[slot];
+        if (typeof members !== 'object' || members === null || typeof already !== 'object') {
+            merged[slot] = members;
             continue;
         }
         for (const [member, value] of Object.entries(members)) {
-            const previous = held?.[member];
+            const previous = already?.[member];
             if (previous === undefined || dequal(previous, value))
                 continue;
             throw new Error(`vocabulary: \`${name}\` states ${slot}.${member} = ${JSON.stringify(value)}, but the ` +
                 `field already states ${JSON.stringify(previous)}. Apply one or the other, not both.`);
         }
-        out[slot] = { ...held, ...members };
+        merged[slot] = { ...already, ...members };
     }
-    return out;
+    return merged;
 }
 //# sourceMappingURL=vocabulary.js.map

package/dist/vocabulary/vocabulary.js.map

@@ -1 +1 @@
-{"version":3,"file":"vocabulary.js","sourceRoot":"","sources":["../../src/vocabulary/vocabulary.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,YAAY,GAAG,CAAC,GAAG,eAAe,EAAE,MAAM,CAAU,CAAC;AAE3D,MAAM,UAAU,UAAU,CACxB,IAAY,EACZ,MAAwC;IAExC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC;AAID,SAAS,KAAK,CAAC,IAAY,EAAE,KAAY,EAAE,MAAsB;IAC/D,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,IAAI,OAAO,IAAI,MAAM;QAAE,GAAG,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAEhD,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,OAAO,KAAK,SAAS;YAAE,SAAS;QACpC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAwC,CAAC;QAChE,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAChF,GAAG,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;YACpB,SAAS;QACX,CAAC;QACD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACtD,MAAM,QAAQ,GAAG,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;YAChC,IAAI,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAAE,SAAS;YAChE,MAAM,IAAI,KAAK,CACb,iBAAiB,IAAI,aAAa,IAAI,IAAI,MAAM,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,YAAY;gBACrF,wBAAwB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,qCAAqC,CACxF,CAAC;QACJ,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC;IACtC,CAAC;IACD,OAAO,GAAqB,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"vocabulary.js","sourceRoot":"","sources":["../../src/vocabulary/vocabulary.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,YAAY,GAAG,CAAC,GAAG,eAAe,EAAE,MAAM,CAAU,CAAC;AAE3D;;;;GAIG;AACH,MAAM,UAAU,UAAU,CACxB,IAAY,EACZ,MAAwC;IAExC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC;AAID;;;;GAIG;AACH,SAAS,KAAK,CAAC,IAAY,EAAE,KAAY,EAAE,KAAqB;IAC9D,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,IAAI,OAAO,IAAI,KAAK;QAAE,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAEjD,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,OAAO,KAAK,SAAS;YAAE,SAAS;QACpC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAwC,CAAC;QACnE,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YACnF,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;YACvB,SAAS;QACX,CAAC;QACD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACtD,MAAM,QAAQ,GAAG,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;YACnC,IAAI,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAAE,SAAS;YAChE,MAAM,IAAI,KAAK,CACb,iBAAiB,IAAI,aAAa,IAAI,IAAI,MAAM,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,YAAY;gBACrF,wBAAwB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,qCAAqC,CACxF,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,MAAwB,CAAC;AAClC,CAAC"}

package/dist/vocabulary/writeOnly.d.ts

@@ -1,3 +1,8 @@
-import { Field } from '../schema/fields/Field.js';
+import { Field } from '../field/Field.js';
+/**
+ * So a secret leaves no response, the dual of `readOnly` on the same axis.
+ * FR : pour qu'un secret ne reparte dans aucune réponse, dual de `readOnly`.
+ * `writeOnly(text())` → `boundary.out` is `'closed'`
+ */
 export declare const writeOnly: <T>(field: Field<T>) => Field<T>;
 //# sourceMappingURL=writeOnly.d.ts.map

package/dist/vocabulary/writeOnly.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeOnly.d.ts","sourceRoot":"","sources":["../../src/vocabulary/writeOnly.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAKtD,CAAC"}
+{"version":3,"file":"writeOnly.d.ts","sourceRoot":"","sources":["../../src/vocabulary/writeOnly.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAKtD,CAAC"}

package/dist/vocabulary/writeOnly.js

@@ -1,5 +1,10 @@
 import { vocabulary } from './vocabulary.js';
-import { Boundary } from '../schema/axis/boundary/Boundary.js';
+import { Boundary } from '../axis/boundary/Boundary.js';
+/**
+ * So a secret leaves no response, the dual of `readOnly` on the same axis.
+ * FR : pour qu'un secret ne reparte dans aucune réponse, dual de `readOnly`.
+ * `writeOnly(text())` → `boundary.out` is `'closed'`
+ */
 export const writeOnly = vocabulary('writeOnly', (field) => ({
     boundary: Boundary.declared(field).with({ out: 'closed' }),
 }));

package/dist/vocabulary/writeOnly.js.map

@@ -1 +1 @@
-{"version":3,"file":"writeOnly.js","sourceRoot":"","sources":["../../src/vocabulary/writeOnly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAG/D,MAAM,CAAC,MAAM,SAAS,GAAqC,UAAU,CACnE,WAAW,EACX,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACV,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;CAC3D,CAAC,CACH,CAAC"}
+{"version":3,"file":"writeOnly.js","sourceRoot":"","sources":["../../src/vocabulary/writeOnly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAGxD;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAqC,UAAU,CACnE,WAAW,EACX,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACV,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;CAC3D,CAAC,CACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fougere/schema",
-  "version": "0.6.0-alpha.0",
+  "version": "0.7.0-alpha.0",
   "description": "The entity and its 4 axes — shape, role, lifecycle, boundary. Subject-owned judgments, edge-safe.",
   "keywords": [
     "fougere",

package/src/{schema/Schema.ts → Schema.ts}

@@ -1,29 +1,27 @@
 import { Boundary } from './axis/boundary/Boundary.js';
-import { type Fields } from './fields/Field.js';
+import { type Fields } from './field/Field.js';
 import {
   type CompositeUnique,
   type EntityDeclarations,
   type PreviousNames,
-} 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';
+} from './entity/EntityDeclarations.js';
+import { type EntityAdapters } from './entity/EntityAdapters.js';
+import { InputValidator } from './validator/InputValidator.js';
 import { SchemaDerivation } from './SchemaDerivation.js';
-import { SchemaDefinition } from './SchemaDefinition.js';
-import { type ValidateOptions } from '../judge/options.js';
-import type { StandardSchemaV1 } from '../projection/standard.js';
-import type { PartialRow, Row, SchemaView } from './SchemaView.js';
+import { SchemaDefinition, type SchemaConstraints } from './SchemaDefinition.js';
+import { type ValidateOptions } from './validator/InputValidator.js';
+import type { StandardSchemaV1 } from './projection/standard.js';
+import type { PartialValues, Values, SchemaView } from './SchemaView.js';
 
 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>>;
+  new (data: PartialValues<TFields>): Values<TFields>;
+  readonly '~standard': StandardSchemaV1.Props<Record<string, unknown>, Values<TFields>>;
   readonly derivation?: SchemaDerivation;
   readonly previous?: PreviousNames<TFields>;
   readonly anchored?: boolean;
-  from(data: Record<string, unknown>): Row<TFields>;
+  from(data: Record<string, unknown>): Values<TFields>;
   pick<K extends string & keyof TFields>(
     ...keys: K[]
   ): SchemaConstructor<Pick<TFields, K>>;
@@ -42,13 +40,14 @@ export interface SchemaConstructor<TFields extends Fields> extends SchemaView<TF
 
 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 definition: SchemaDefinition = SchemaDefinition.of({ fields: {} });
 
   static get fields(): Fields {
     return this.definition.fields;
   }
-  static get adapters(): EntityAdapters<Fields> | undefined {
-    return this.definition.adapters;
+  /** An entry survives every derivation that kept its field: `Post.pick('body').adapters`. */
+  static get adapters(): EntityAdapters<Fields> {
+    return this.definition.adapterSet.adapters;
   }
   static get opts(): ValidateOptions {
     return this.definition.opts;
@@ -59,6 +58,7 @@ export class Schema {
   static get previous(): PreviousNames<Fields> | undefined {
     return this.definition.previous;
   }
+  /** An anchor holds rows of its own; a derivation borrows them. */
   static get anchored(): boolean {
     return this.definition.anchored;
   }
@@ -82,30 +82,29 @@ export class Schema {
     return this.adapters;
   }
   static getUnique(): CompositeUnique<Fields> | undefined {
-    const groups = FieldGroup.groupsOf(this.fields, Unique);
-    return groups.length ? groups.map((group) => [...group.members]) : undefined;
+    return this.definition.constraints.unique;
   }
   static getOpts() {
     return this.opts;
   }
 
   static validate(input: unknown) {
-    return RowJudge.of(this.fields, this.opts).check(input);
+    return InputValidator.of(this.fields, this.opts).validate(input);
   }
 
   static from(data: Record<string, unknown>) {
-    const out: Record<string, unknown> = {};
+    const row: Record<string, unknown> = {};
     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;
+        row[key] = value;
         continue;
       }
       const decoded = Boundary.of(field).decode(value);
-      out[key] = 'error' in decoded ? value : decoded.value;
+      row[key] = 'error' in decoded ? value : decoded.value;
     }
-    return out;
+    return row;
   }
 
   static get ['~standard'](): StandardSchemaV1.Props<Record<string, unknown>> {
@@ -114,10 +113,10 @@ export class Schema {
       version: 1,
       vendor: 'fougere',
       validate(value: unknown) {
-        const result = RowJudge.of(fields, opts).check(value);
-        if (result.success) return { value: result.data };
+        const verdict = InputValidator.of(fields, opts).validate(value);
+        if (verdict.success) return { value: verdict.data };
         return {
-          issues: result.errors.map((e) => ({
+          issues: verdict.errors.map((e) => ({
             message: e.message,
             path: e.path && e.path !== '.' ? [{ key: e.path }] : undefined,
           })),
@@ -127,50 +126,21 @@ export class Schema {
   }
 
   static pick(...keys: string[]) {
-    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));
+    return Schema.subclass(this.definition.pick(keys, this));
   }
 
   static omit(...keys: string[]) {
-    assertKnownKeys('omit', keys, this.fields);
-    const kept: Fields = {};
-    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));
+    return Schema.subclass(this.definition.omit(keys, this));
   }
 
   static rename(mapping: Record<string, string>) {
-    assertKnownKeys('rename', Object.keys(mapping), this.fields);
-    const renamed: Fields = {};
-    for (const [key, field] of Object.entries(this.fields))
-      renamed[mapping[key] ?? key] = field;
-    return this.derive(renamed, (k) => mapping[k] ?? k);
+    return Schema.subclass(this.definition.rename(mapping, this));
   }
 
-  /**
-   * Everything a schema states about ITSELF, available wherever a schema is. `entity(fields, …)`
-   * is this same gesture at the declaration site; the fields do not move, so neither does the type.
-   */
   static declares(declarations: EntityDeclarations<Fields>) {
-    const addressed = EntityAdapterSet.of(declarations.adapters)?.fieldNames ?? [];
-    assertKnownKeys(
-      'declares',
-      [...addressed, ...Object.keys(declarations.previous ?? {})],
-      this.fields,
-    );
-
     return Schema.subclass(this.definition.declaring(declarations));
   }
 
-  /**
-   * This schema holds rows of its own — every entity is one, and a derivation says so.
-   *
-   * An anchor is where a walk STOPS: `derivation.anchor` climbs to the nearest one, and what
-   * is cut from an anchor roots on it. Two anchors are two entities that happen to share a
-   * shape, never a hierarchy — nothing here subtypes, so a relation between them is `ref()`.
-   */
   static anchor() {
     return Schema.subclass(this.definition.anchoring());
   }
@@ -202,20 +172,20 @@ export class Schema {
     ) as unknown as SchemaConstructor<Merged<T>>;
   }
 
-  static of<TFields extends Fields>(stated: {
+  static of<TFields extends Fields>(declaration: {
     fields: TFields;
     derivation?: SchemaDerivation;
     adapters?: EntityAdapters<TFields>;
     opts?: ValidateOptions;
     previous?: PreviousNames<TFields>;
     anchored?: boolean;
+    constraints?: SchemaConstraints;
   }): SchemaConstructor<TFields> {
     return Schema.subclass(
-      SchemaDefinition.stated(stated),
+      SchemaDefinition.of(declaration),
     ) 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;
@@ -225,19 +195,6 @@ export class Schema {
     });
     return Derived as unknown as SchemaConstructor<Fields>;
   }
-
-  private static derive(fields: Fields, survives: (key: string) => string | undefined) {
-    return Schema.subclass(this.definition.cut(fields, survives, this));
-  }
-}
-
-function assertKnownKeys(operation: string, keys: string[], fields: Fields): void {
-  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(', ')}.`,
-  );
 }
 
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (

package/src/SchemaDefinition.ts

@@ -0,0 +1,257 @@
+import { type Fields } from './field/Field.js';
+import { FieldSet, deduplicated } from './field/FieldSet.js';
+import {
+  type CompositeUnique,
+  type EntityDeclarations,
+  type PreviousNames,
+} from './entity/EntityDeclarations.js';
+import { type EntityAdapters } from './entity/EntityAdapters.js';
+import { EntityAdapterSet } from './entity/EntityAdapterSet.js';
+import { SchemaDerivation } from './SchemaDerivation.js';
+import { type ValidateOptions } from './validator/InputValidator.js';
+import type { SchemaView } from './SchemaView.js';
+
+/**
+ * What a schema constrains beyond any single field.
+ *
+ * `unique` is the one member today. It sits under an owner rather than beside `fields`
+ * and `opts` because the next rule spanning two fields — a check, an exclusion — is a
+ * member here, not an eighth positional argument in a list that has already lost one.
+ */
+export interface SchemaConstraints<TFields extends Fields = Fields> {
+  readonly unique?: CompositeUnique<TFields>;
+}
+
+/**
+ * Everything a definition is made of, every member required.
+ *
+ * A transformation states what it keeps AND what it clears — `previous: undefined` and
+ * `anchored: false` are the two a derivation decides, and positionally they were an
+ * `undefined` and a `false` a reader had to count arguments to name.
+ */
+interface SchemaState {
+  fields: Fields;
+  adapterSet: EntityAdapterSet;
+  opts: ValidateOptions;
+  previous: PreviousNames<Fields> | undefined;
+  derivation: SchemaDerivation | undefined;
+  anchored: boolean;
+  constraints: SchemaConstraints;
+}
+
+/** The keys a derivation keeps, in the order it keeps them, under the names they take. */
+type Renaming = ReadonlyMap<string, string>;
+
+/**
+ * Everything a schema IS, apart from being a class whose instances are rows.
+ *
+ * The members used to be that many statics assigned side by side, and every derivation
+ * re-threaded them by hand — which is how one of them came to be dropped from a list
+ * without anyone noticing. A transformation here returns a COMPLETE definition or it does
+ * not compile, so no gesture can mix the fields of one with the options of another.
+ *
+ * Internal: it is not exported from the package and never appears on `SchemaConstructor`.
+ * A user derives with `Order.pick(…)`, never `Order.definition.pick(…)`.
+ */
+export class SchemaDefinition {
+  readonly fields: Fields;
+  readonly adapterSet: EntityAdapterSet;
+  readonly opts: ValidateOptions;
+  readonly previous: PreviousNames<Fields> | undefined;
+  readonly derivation: SchemaDerivation | undefined;
+  readonly anchored: boolean;
+  readonly constraints: SchemaConstraints;
+
+  private constructor(state: SchemaState) {
+    this.fields = state.fields;
+    this.adapterSet = state.adapterSet;
+    this.opts = state.opts;
+    this.previous = state.previous;
+    this.derivation = state.derivation;
+    this.anchored = state.anchored;
+    this.constraints = state.constraints;
+  }
+
+  /** Built complete or not at all — no static assigned on the side. */
+  static of(declaration: {
+    fields: Fields;
+    adapters?: EntityAdapters<Fields>;
+    opts?: ValidateOptions;
+    previous?: PreviousNames<Fields>;
+    derivation?: SchemaDerivation;
+    anchored?: boolean;
+    constraints?: SchemaConstraints;
+  }): SchemaDefinition {
+    return new SchemaDefinition({
+      fields: declaration.fields,
+      adapterSet: EntityAdapterSet.of(declaration.adapters),
+      opts: declaration.opts ?? {},
+      previous: declaration.previous,
+      derivation: declaration.derivation,
+      anchored: declaration.anchored ?? false,
+      constraints: declaration.constraints ?? {},
+    });
+  }
+
+  declaring(declarations: EntityDeclarations<Fields>): SchemaDefinition {
+    const addressed = EntityAdapterSet.of(declarations.adapters).fieldNames;
+    this.assertKnown('declares', [
+      ...addressed,
+      ...Object.keys(declarations.previous ?? {}),
+    ]);
+    const declared = FieldSet.declaring(this.fields, declarations.unique);
+
+    return new SchemaDefinition({
+      fields: declared.fields,
+      adapterSet: EntityAdapterSet.merged([
+        this.adapterSet,
+        EntityAdapterSet.of(declarations.adapters),
+      ]),
+      opts: this.opts,
+      previous: declarations.previous ?? this.previous,
+      derivation: this.derivation,
+      anchored: this.anchored,
+      constraints:
+        declarations.unique === undefined ? this.constraints : { unique: declared.unique },
+    });
+  }
+
+  anchoring(): SchemaDefinition {
+    return new SchemaDefinition({
+      fields: this.fields,
+      adapterSet: this.adapterSet,
+      opts: this.opts,
+      previous: this.previous,
+      derivation: this.derivation,
+      anchored: true,
+      constraints: this.constraints,
+    });
+  }
+
+  pick(keys: readonly string[], root: SchemaView): SchemaDefinition {
+    this.assertKnown('pick', keys);
+
+    return this.renaming(new Map(keys.map((key) => [key, key])), root);
+  }
+
+  omit(keys: readonly string[], root: SchemaView): SchemaDefinition {
+    this.assertKnown('omit', keys);
+    const kept = Object.keys(this.fields).filter((key) => !keys.includes(key));
+
+    return this.renaming(new Map(kept.map((key) => [key, key])), root);
+  }
+
+  rename(mapping: Record<string, string>, root: SchemaView): SchemaDefinition {
+    this.assertKnown('rename', Object.keys(mapping));
+    const here = Object.keys(this.fields).map((key) => [key, mapping[key] ?? key] as const);
+
+    return this.renaming(new Map(here), root);
+  }
+
+  /**
+   * `pick`, `omit` and `rename` are one gesture, and the renaming IS that gesture: the
+   * fields it keeps and everything else addressed by field name are both read from it.
+   */
+  private renaming(kept: Renaming, root: SchemaView): SchemaDefinition {
+    const fields: Fields = {};
+    for (const [from, to] of kept) {
+      const field = this.fields[from];
+      if (field) fields[to] = field;
+    }
+    const nameOf = (key: string) => kept.get(key);
+
+    return new SchemaDefinition({
+      fields,
+      adapterSet: this.adapterSet.rename(nameOf),
+      opts: this.opts,
+      previous: undefined,
+      derivation: this.origin(root).rename(nameOf),
+      anchored: false,
+      constraints: this.constraintsRenamed(nameOf),
+    });
+  }
+
+  /** One member gone and the group is gone: it constrained a pair that no longer exists. */
+  private constraintsRenamed(
+    transform: (key: string) => string | undefined,
+  ): SchemaConstraints {
+    if (!this.constraints.unique) return this.constraints;
+    const kept: string[][] = [];
+    for (const group of this.constraints.unique) {
+      const renamed = group.map(transform);
+      if (renamed.every((key): key is string => key !== undefined)) kept.push(renamed);
+    }
+
+    return { unique: deduplicated(kept) as CompositeUnique<Fields> | undefined };
+  }
+
+  patched(root: SchemaView): SchemaDefinition {
+    return new SchemaDefinition({
+      fields: { ...this.fields },
+      adapterSet: this.adapterSet,
+      opts: { ...this.opts, patch: true },
+      previous: undefined,
+      derivation: this.origin(root),
+      anchored: false,
+      constraints: this.constraints,
+    });
+  }
+
+  /** An added field does not pretend to come from the root, which never declared it. */
+  extended(extra: Fields, root: SchemaView): SchemaDefinition {
+    return new SchemaDefinition({
+      fields: { ...this.fields, ...extra },
+      adapterSet: this.adapterSet,
+      opts: this.opts,
+      previous: undefined,
+      derivation: this.origin(root),
+      anchored: false,
+      constraints: this.constraints,
+    });
+  }
+
+  /** Several schemas fold into one, which has no single origin to point at. */
+  static merged(views: readonly SchemaView[]): SchemaDefinition {
+    const fields: Fields = {};
+    let opts: ValidateOptions = {};
+    const groups: (readonly string[])[] = [];
+    for (const view of views) {
+      Object.assign(fields, view.getFields());
+      opts = { ...opts, ...view.getOpts() };
+      groups.push(...(view.getUnique() ?? []));
+    }
+
+    return new SchemaDefinition({
+      fields,
+      adapterSet: EntityAdapterSet.merged(
+        views.map((view) => EntityAdapterSet.of(view.getAdapters())),
+      ),
+      opts,
+      previous: undefined,
+      derivation: undefined,
+      anchored: false,
+      constraints: { unique: deduplicated(groups) as CompositeUnique<Fields> | undefined },
+    });
+  }
+
+  /**
+   * So a gesture naming a field that does not exist says so, and lists what there is.
+   * FR : pour qu'un geste nommant un champ inexistant le dise, et énumère ce qui existe.
+   * `pick('titel')` → `pick(): unknown field \`titel\`. This schema carries id, title, body.`
+   */
+  private assertKnown(operation: string, keys: readonly string[]): void {
+    const strangers = keys.filter((key) => !(key in this.fields));
+    if (strangers.length === 0) return;
+
+    throw new Error(
+      `${operation}(): unknown field ${strangers.map((s) => `\`${s}\``).join(', ')}. ` +
+        `This schema carries ${Object.keys(this.fields).join(', ')}.`,
+    );
+  }
+
+  private origin(root: SchemaView): SchemaDerivation {
+    if (!this.anchored && this.derivation) return this.derivation;
+
+    return SchemaDerivation.first(root, this.fields);
+  }
+}

package/src/SchemaDerivation.ts

@@ -0,0 +1,44 @@
+import { type Fields } from './field/Field.js';
+import type { SchemaView } from './SchemaView.js';
+
+/**
+ * The origin is the ROOT: `Post.pick(a, b).omit(b)` answers `Post`, never the intermediate.
+ */
+export class SchemaDerivation {
+  private constructor(
+    readonly source: SchemaView,
+    readonly nameOf: Readonly<Record<string, string | undefined>>,
+  ) {}
+
+  static first(source: SchemaView, fields: Fields): SchemaDerivation {
+    return new SchemaDerivation(
+      source,
+      Object.fromEntries(Object.keys(fields).map((key) => [key, key])),
+    );
+  }
+
+  rename(transform: (key: string) => string | undefined): SchemaDerivation {
+    return new SchemaDerivation(
+      this.source,
+      Object.fromEntries(
+        Object.entries(this.nameOf).map(([origin, here]) => [
+          origin,
+          here === undefined ? undefined : transform(here),
+        ]),
+      ),
+    );
+  }
+
+  get sourceName(): string {
+    return this.source.name;
+  }
+
+  /** Whose rows this one borrows, however many cuts away: `Post.pick('t').omit('t')` → `Post`. */
+  get anchor(): SchemaView {
+    const source = this.source;
+
+    return source.anchored !== undefined || !source.derivation
+      ? source
+      : source.derivation.anchor;
+  }
+}

package/src/{schema/SchemaView.ts → SchemaView.ts}

@@ -1,15 +1,15 @@
-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 { Field, Fields } from './field/Field.js';
+import type { CompositeUnique, PreviousNames } from './entity/EntityDeclarations.js';
+import type { EntityAdapters } from './entity/EntityAdapters.js';
+import type { ValidationResult } from './validation.js';
+import type { ValidateOptions } from './validator/InputValidator.js';
 import type { SchemaDerivation } from './SchemaDerivation.js';
 
-export type Row<TFields extends Fields> = {
+export type Values<TFields extends Fields> = {
   [K in keyof TFields]: TFields[K] extends Field<infer T> ? T : never;
 };
 
-export type PartialRow<TFields extends Fields> = Partial<Row<TFields>>;
+export type PartialValues<TFields extends Fields> = Partial<Values<TFields>>;
 
 export interface SchemaView<TFields extends Fields = Fields> {
   readonly name: string;
@@ -20,8 +20,8 @@ export interface SchemaView<TFields extends Fields = Fields> {
   /** Does it hold rows of its own? False on a derivation means an answer. */
   readonly anchored?: boolean;
   getFields(): TFields;
-  getAdapters(): EntityAdapters<TFields> | undefined;
+  getAdapters(): EntityAdapters<TFields>;
   getUnique(): CompositeUnique<TFields> | undefined;
   getOpts(): ValidateOptions;
-  validate(input: unknown): ValidationResult<Row<TFields>>;
+  validate(input: unknown): ValidationResult<Values<TFields>>;
 }