@fougere/schema 0.5.0-alpha.1 → 0.7.0-alpha.0

package/dist/vocabulary/vocabulary.js

@@ -1,31 +1,41 @@
 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,iBAAiB,CAAC;AAClD,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 '../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,oBAAoB,CAAC;AAE3C,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAEpD,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 '../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,8BAA8B,CAAC;AAGxD,MAAM,CAAC,MAAM,SAAS,GAAqC,UAAU,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC7F,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;CAC3D,CAAC,CAAC,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.5.0-alpha.1",
+  "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.ts

@@ -0,0 +1,208 @@
+import { Boundary } from './axis/boundary/Boundary.js';
+import { type Fields } from './field/Field.js';
+import {
+  type CompositeUnique,
+  type EntityDeclarations,
+  type PreviousNames,
+} from './entity/EntityDeclarations.js';
+import { type EntityAdapters } from './entity/EntityAdapters.js';
+import { InputValidator } from './validator/InputValidator.js';
+import { SchemaDerivation } from './SchemaDerivation.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: 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>): Values<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>>;
+  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>;
+}
+
+export class Schema {
+  /** The one place a schema holds what it is. The readings below are its projections. */
+  static definition: SchemaDefinition = SchemaDefinition.of({ fields: {} });
+
+  static get fields(): Fields {
+    return this.definition.fields;
+  }
+  /** 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;
+  }
+  static get derivation(): SchemaDerivation | undefined {
+    return this.definition.derivation;
+  }
+  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;
+  }
+
+  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,
+      });
+    }
+  }
+
+  static getFields() {
+    return this.fields;
+  }
+  static getAdapters() {
+    return this.adapters;
+  }
+  static getUnique(): CompositeUnique<Fields> | undefined {
+    return this.definition.constraints.unique;
+  }
+  static getOpts() {
+    return this.opts;
+  }
+
+  static validate(input: unknown) {
+    return InputValidator.of(this.fields, this.opts).validate(input);
+  }
+
+  static from(data: 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) {
+        row[key] = value;
+        continue;
+      }
+      const decoded = Boundary.of(field).decode(value);
+      row[key] = 'error' in decoded ? value : decoded.value;
+    }
+    return row;
+  }
+
+  static get ['~standard'](): StandardSchemaV1.Props<Record<string, unknown>> {
+    const { fields, opts } = this;
+    return {
+      version: 1,
+      vendor: 'fougere',
+      validate(value: unknown) {
+        const verdict = InputValidator.of(fields, opts).validate(value);
+        if (verdict.success) return { value: verdict.data };
+        return {
+          issues: verdict.errors.map((e) => ({
+            message: e.message,
+            path: e.path && e.path !== '.' ? [{ key: e.path }] : undefined,
+          })),
+        };
+      },
+    };
+  }
+
+  static pick(...keys: string[]) {
+    return Schema.subclass(this.definition.pick(keys, this));
+  }
+
+  static omit(...keys: string[]) {
+    return Schema.subclass(this.definition.omit(keys, this));
+  }
+
+  static rename(mapping: Record<string, string>) {
+    return Schema.subclass(this.definition.rename(mapping, this));
+  }
+
+  static declares(declarations: EntityDeclarations<Fields>) {
+    return Schema.subclass(this.definition.declaring(declarations));
+  }
+
+  static anchor() {
+    return Schema.subclass(this.definition.anchoring());
+  }
+
+  static partial() {
+    return Schema.subclass(this.definition.patched(this));
+  }
+
+  static extend(extra: Fields) {
+    return Schema.subclass(this.definition.extended(extra, this));
+  }
+
+  static named(name: string) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
+      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.`,
+      );
+    }
+    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>>;
+  }
+
+  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.of(declaration),
+    ) as unknown as SchemaConstructor<TFields>;
+  }
+
+  private static subclass(definition: SchemaDefinition): SchemaConstructor<Fields> {
+    class Derived extends Schema {}
+    Derived.definition = definition;
+    Object.defineProperty(Derived, 'name', {
+      value: ANONYMOUS_SCHEMA_NAME,
+      configurable: true,
+    });
+    return Derived as unknown as SchemaConstructor<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/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 '../EntityDeclarations.js';
-import type { EntityAdapters } from '../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>>;
 }

package/src/axis/Axis.ts

@@ -1,12 +1,12 @@
 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 '../validation.js';
 
 export interface Axis<Declared = unknown, Wire = unknown> {
   readonly slot: 'role' | 'lifecycle' | 'boundary';
 
-  judge(value: unknown, errors: ValidationError[]): void;
+  validator(value: unknown, errors: ValidationError[]): void;
 
   describe(value: Declared, key: string): Wire | undefined;