@mark1russell7/coeval 0.3.2 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",

package/src/deref.ts

@@ -1,5 +1,6 @@
 import { type Envelope, type Json, type JsonRecord, type Key, type TypeRef, field, isEnvelope, isKey, isRecord, typePath } from "./doc.ts";
 import { type World, entriesAsJson, lookupKind } from "./world.ts";
+import type { ErrorCode } from "./errors.ts";
 
 /**
  * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
@@ -83,8 +84,11 @@ export interface Context {
 /** The code of a `deref` evaluator: it answers one step of a path on a document of its kind. */
 export type DerefCode = (doc: Envelope, key: Key) => Thing | undefined;
 
-/** The result of a step document: what it reached, or the reason of a failure. */
-export type WalkResult = { readonly ok: true; readonly thing: Thing } | { readonly ok: false; readonly reason: string };
+/**
+ * The result of a step document: what it reached, or the reason of a failure. A failure can give its code, for
+ * example `#REF!` for a position outside a space. The default code is `#N/A`.
+ */
+export type WalkResult = { readonly ok: true; readonly thing: Thing } | { readonly ok: false; readonly reason: string; readonly code?: ErrorCode };
 
 /** The input of a walker: the code of a step document, for example `nearest`. */
 export interface WalkInput {
@@ -134,13 +138,13 @@ export interface Hop {
   readonly by: HopBy;
 }
 
-/** The codes of a failed resolution. */
+/** The codes that a resolution gives itself. A walker can give another code for its failure. */
 export type ResolveCode = "#REF!" | "#NAME?" | "#N/A" | "#CYCLE!" | "#STEP?";
 
 /** The result of a resolution: what the path reached, with each hop, or an error with the hops before it. */
 export type Resolution =
   | { readonly ok: true; readonly thing: Thing; readonly hops: readonly Hop[] }
-  | { readonly ok: false; readonly code: ResolveCode; readonly reason: string; readonly hops: readonly Hop[] };
+  | { readonly ok: false; readonly code: ResolveCode | ErrorCode; readonly reason: string; readonly hops: readonly Hop[] };
 
 /** The options of a resolution. */
 export interface ResolveOptions {
@@ -333,7 +337,7 @@ export function resolve(nav: Navigator, ctx: Context, path: readonly unknown[],
   }
   const hops: Hop[] | undefined = options.hops === false ? undefined : [];
   const done = hops ?? NO_HOPS;
-  const failed = (code: ResolveCode, reason: string): Resolution => ({ ok: false, code, reason, hops: done });
+  const failed = (code: ResolveCode | ErrorCode, reason: string): Resolution => ({ ok: false, code, reason, hops: done });
   let collapses = 0;
   const adopt = nav.adopt ?? ((value: unknown): Thing => value);
 
@@ -399,7 +403,7 @@ export function resolve(nav: Navigator, ctx: Context, path: readonly unknown[],
             return reached === undefined ? undefined : adopt(reached.thing);
           },
         });
-        if (!result.ok) return failed("#N/A", result.reason);
+        if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
         here = adopt(result.thing);
         hops?.push({ step: envelope as Json, thing: here, by: "step" });
       }

package/src/evaluate.ts

@@ -1,5 +1,5 @@
 import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, typeName } from "./doc.ts";
-import { splitParts } from "./parts.ts";
+import { type Split, splitParts } from "./parts.ts";
 import { ask, type Answer } from "./ladder.ts";
 import { type Lookup, type Side, type World, lookupKind } from "./world.ts";
 import { type ErrorCode, type EvalError, type Result, fail, ok, placed, thrown, describe } from "./errors.ts";
@@ -207,6 +207,8 @@ export interface CompileInput {
    * @returns The value with the items.
    */
   fill(items: readonly unknown[]): unknown;
+  /** `true` when the position of the document declares an address. A reference there gives the thing, not its value. */
+  readonly address?: boolean;
 }
 
 /**
@@ -246,6 +248,8 @@ export interface EvalInput {
   readonly context: Context;
   /** The keys from the root document to this document. */
   readonly place: readonly Key[];
+  /** `true` when the position of the document declares an address. */
+  readonly address?: boolean;
   /**
    * This function resolves a path from the context of the document.
    *
@@ -847,7 +851,7 @@ function evaluatorOf(world: World, envelope: Envelope | undefined, found: Lookup
 /** The meta of a node of a compilation without a trace. Only a trace reads the meta of a node. */
 const NO_META: Meta = Object.freeze({ path: [], doc: { type: "?", value: null }, declared: false, answer: NO_ANSWER, side: "derive" });
 
-function compileNode(c: Compiler, value: unknown, place: readonly Key[], declared: string | undefined, depth: number): { readonly code: Code; readonly run: RunCode } {
+function compileNode(c: Compiler, value: unknown, place: readonly Key[], declared: string | undefined, depth: number, address = false): { readonly code: Code; readonly run: RunCode } {
   const envelope = isEnvelope(value) ? (value as Envelope) : undefined;
   const doc: Envelope = envelope ?? { type: declared ?? "?", value: value as Json };
   const meta0: Meta = c.traced ? { path: place.map(String), doc, declared: envelope === undefined, answer: NO_ANSWER, side: "derive" } : NO_META;
@@ -888,7 +892,7 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   }
   const parts: CompiledPart[] = split.parts.map((slot) => {
     const item = slot.item;
-    const compiled = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1);
+    const compiled = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1, slot.address === true);
     // The binding name is in the header of an envelope. Most parts have no name, thus the cheap test comes first.
     const header = typeof (item as { readonly name?: unknown } | null)?.name === "string" && isEnvelope(item) ? (item as { readonly name: string }).name : undefined;
     return header === undefined
@@ -905,41 +909,74 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     parts,
     place,
     machine: c.machine,
-    fill: (items) => (split.parts.length === 0 ? doc.value : split.fill(items)),
+    fill: fillOf(split, doc),
+    ...(address ? { address: true } : {}),
   };
   if (runner !== undefined) {
     const inner: RunCode = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
-    const run: RunCode = function* (ctx, rt) {
-      try {
-        return placed(yield* inner(ctx, rt), place);
-      } catch (error) {
-        return placed(thrown(error, `the runner ${name}`), place);
-      }
-    };
-    const code: Code = (ctx, rt) =>
-      rt.running
-        ? fail("#CALC!", `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`, { place })
-        : drive(run(ctx, rt));
-    return finish(c, meta, code, run);
+    const run = placedRun(inner, place, name);
+    return finish(c, meta, runnerCode(run, place, kindText), run);
   }
 
   const inner: Code = isCompiledEvaluator(evaluator as Evaluator)
     ? (evaluator as CompiledEvaluator).compile(input)
     : interpret(evaluator as EvalFn, input, split.fill);
-  const code: Code = (ctx, rt) => {
+  const code = placedCode(inner, place, name);
+  return finish(c, meta, code, runOf(code));
+}
+
+/*
+ * The helpers below make the closures that a plan keeps. Each one has its own small scope. A closure that a
+ * compilation made in its own scope keeps each variable of that scope that any closure there reads, for example
+ * the split of the value. Thus a plan with these helpers keeps only its code.
+ */
+
+/** This function gives the code of a document: the code of its evaluator, with the place of each error and of each exception. */
+function placedCode(inner: Code, place: readonly Key[], name: string): Code {
+  return (ctx, rt) => {
     try {
       return placed(inner(ctx, rt), place);
     } catch (error) {
       return placed(thrown(error, `the evaluator ${name}`), place);
     }
   };
-  return finish(c, meta, code, function* (ctx, rt) {
+}
+
+/** This function gives the steps of a runner, with the place of each error and of each exception. */
+function placedRun(inner: RunCode, place: readonly Key[], name: string): RunCode {
+  return function* (ctx, rt) {
+    try {
+      return placed(yield* inner(ctx, rt), place);
+    } catch (error) {
+      return placed(thrown(error, `the runner ${name}`), place);
+    }
+  };
+}
+
+/** This function gives the code of a runner in an evaluation: its steps, which cannot wait. */
+function runnerCode(run: RunCode, place: readonly Key[], kindText: string): Code {
+  return (ctx, rt) =>
+    rt.running
+      ? fail("#CALC!", `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`, { place })
+      : drive(run(ctx, rt));
+}
+
+/** This function gives the steps of a run of an evaluator. The code runs at the first step, and it does not wait. */
+function runOf(code: Code): RunCode {
+  return function* (ctx, rt) {
     return code(ctx, rt);
-  });
+  };
+}
+
+/** This function gives the fill of a compile input: the value with an item in the place of each part. */
+function fillOf(split: Extract<Split, { readonly ok: true }>, doc: Envelope): <P>(items: readonly P[]) => unknown {
+  return (items) => (split.parts.length === 0 ? doc.value : split.fill(items));
 }
 
+
 function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown): Code {
   const { kind, typePath, doc, data, place } = input;
+  const address = input.address === true ? { address: true } : {};
   const compiled = input.parts;
   const hasParts = compiled.length > 0;
   return (ctx, rt) => {
@@ -958,6 +995,7 @@ function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly
       parts,
       context: ctx,
       place,
+      ...address,
       resolve: (path, options) => rt.resolve(ctx, path, options),
       effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place),
       fill: input.fill,
@@ -1021,16 +1059,21 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
     };
   }
   const compiled: CompiledPart = { key: "", path: [], code: root.code, run: root.run };
+  return planOf(machine, c.traced, compiled);
+}
+
+/** This function makes the object of a plan. Its closures keep only the machine and the compiled root. */
+function planOf(machine: Machine, traced: boolean, root: CompiledPart): Plan {
   return {
     machine,
-    traced: c.traced,
-    root: compiled,
+    traced,
+    root,
     evaluate(context: Context = makeContext(), evalOptions?: EvalOptions): Result {
-      const s = new Session(machine, false, c.traced, undefined, undefined, evalOptions?.effects);
+      const s = new Session(machine, false, traced, undefined, undefined, evalOptions?.effects);
       return root.code(rootContext(machine, context), s);
     },
     run(context: Context = makeContext(), runOptions: RunOptions = {}): Promise<Result> {
-      const s = new Session(machine, true, c.traced, runOptions.perform, runOptions.signal, undefined);
+      const s = new Session(machine, true, traced, runOptions.perform, runOptions.signal, undefined);
       return driveWaiting(root.run(rootContext(machine, context), s), runOptions.signal);
     },
   };

package/src/formula.ts

@@ -1,6 +1,6 @@
 import { type Json, isRecord } from "./doc.ts";
 import type { Kind, WorldEntry } from "./world.ts";
-import { valueOfThing } from "./deref.ts";
+import { type Context, type Resolution, valueOfThing } from "./deref.ts";
 import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } from "./errors.ts";
 import type { Code, CompileInput, CompiledEvaluator, CompiledPart, Evaluator, Machine } from "./evaluate.ts";
 
@@ -13,8 +13,8 @@ export type OpFn = (...args: never[]) => unknown;
  */
 export type LazyOp = (args: readonly (() => Result)[]) => Result;
 
-/** The code of an extension: it gives the value of the data of an extension document. */
-export type ExtFn = (data: Json) => Result;
+/** The code of an extension: it gives the value of the data of an extension document, in the context of the document. */
+export type ExtFn = (data: Json, context: Context) => Result;
 
 /**
  * The rules of one formula language: its operations, and the rules that differ between languages.
@@ -30,6 +30,8 @@ export type ExtFn = (data: Json) => Result;
  * - `omit`: the errors that leave a field out of a `record`, as an absent value.
  * - `missing`: the values that a reference cannot give. Such a value gives `#N/A`.
  * - `check`: a check of the value of an operation, for example "a number must be finite".
+ * - `combine`: the error of two or more failed parts of an operation, a `record` or a `list`. With it, each part
+ *   evaluates, and one failed part gives its own error. Without it, the first error stops the evaluation.
  */
 export interface FormulaProfile {
   readonly ops?: Readonly<Record<string, OpFn>> | ((name: string) => OpFn | undefined);
@@ -41,8 +43,12 @@ export interface FormulaProfile {
   readonly omit?: (error: EvalError) => boolean;
   readonly missing?: (value: unknown) => boolean;
   readonly check?: (value: unknown, op: string) => Result | undefined;
+  readonly combine?: (errors: readonly EvalError[]) => EvalError;
 }
 
+/** The mark of a field that the profile leaves out of a record. */
+const SKIPPED: unique symbol = Symbol("skipped");
+
 /** The value of a name whose binding failed. A reference to the name gives the error. */
 export class Held {
   constructor(readonly error: EvalError) {}
@@ -97,6 +103,17 @@ function compiled(compile: (input: CompileInput) => Code): CompiledEvaluator {
   return { compile };
 }
 
+/** This function evaluates parts in order. It gives the value of each part, or the first error. */
+function valuesOf(parts: readonly CompiledPart[], ctx: Context, rt: Parameters<Code>[1]): unknown[] | Failed {
+  const values = new Array<unknown>(parts.length);
+  for (let index = 0; index < parts.length; index += 1) {
+    const result = (parts[index] as CompiledPart).code(ctx, rt);
+    if (!result.ok) return result;
+    values[index] = result.value;
+  }
+  return values;
+}
+
 function partsOf(value: unknown): Readonly<Record<string, CompiledPart>> {
   return isRecord(value) ? (value as unknown as Readonly<Record<string, CompiledPart>>) : {};
 }
@@ -168,6 +185,22 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
     return Object.hasOwn(ops, name) ? ops[name] : undefined;
   };
   const notTruth = (what: string): Failed => fail("#VALUE!", `The ${what} must give a truth value.`);
+  const combine = profile.combine;
+  /** This function evaluates each part. Without `combine`, the first error stops it. A field that `omit` skips is absent. */
+  const collect = (parts: readonly CompiledPart[], ctx: Context, rt: Parameters<Code>[1], skip?: (error: EvalError) => boolean): (readonly unknown[]) | Failed => {
+    const values = new Array<unknown>(parts.length);
+    let errors: EvalError[] | undefined;
+    for (let index = 0; index < parts.length; index += 1) {
+      const result = (parts[index] as CompiledPart).code(ctx, rt);
+      if (result.ok) values[index] = result.value;
+      else if (skip !== undefined && skip(result.error)) values[index] = SKIPPED;
+      else if (combine === undefined) return result;
+      else (errors ??= []).push(result.error);
+    }
+    // The errors exist only with combine, so the second test only narrows the type.
+    if (errors === undefined || combine === undefined) return values;
+    return { ok: false, error: errors.length === 1 ? (errors[0] as EvalError) : combine(errors) };
+  };
 
   return {
     "formula.lit": compiled(({ doc }) => {
@@ -175,7 +208,7 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
       return () => result;
     }),
 
-    "formula.ref": compiled(({ doc }) => {
+    "formula.ref": compiled(({ doc, parts, fill, address }) => {
       const path = doc.value;
       if (!Array.isArray(path) || path.length === 0) {
         const bad = fail("#VALUE!", 'The value of ref is a path: a list that starts with a root, for example ["names", "a"].');
@@ -183,17 +216,37 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
       }
       // A path through a name whose binding failed gives the error of the binding.
       const head = path[0] === "names" && typeof path[1] === "string" ? path[1] : undefined;
+      const give = (found: Resolution): Result => {
+        if (!found.ok) return fail(found.code, found.reason);
+        // An address gives what the path reaches: a host thing stays a thing.
+        if (address === true) return ok(found.thing);
+        const reached = valueOfThing(found.thing);
+        if (reached instanceof Held) return { ok: false, error: reached.error };
+        if (missing !== undefined && missing(reached)) return fail("#N/A", "The path reaches no value.");
+        return ok(reached);
+      };
+      // The step documents of a path are its parts when the kind ref has a deep shape. They evaluate first, in order.
+      const computed = parts.length > 0;
       return (ctx, rt) => {
         if (head !== undefined && Object.hasOwn(ctx.names, head)) {
           const bound = ctx.names[head];
           if (bound instanceof Held) return { ok: false, error: bound.error };
         }
-        const found = rt.resolve(ctx, path);
-        if (!found.ok) return fail(found.code, found.reason);
-        const value = valueOfThing(found.thing);
-        if (value instanceof Held) return { ok: false, error: value.error };
-        if (missing !== undefined && missing(value)) return fail("#N/A", "The path reaches no value.");
-        return ok(value);
+        if (!computed) return give(rt.resolve(ctx, path));
+        const steps = valuesOf(parts, ctx, rt);
+        return Array.isArray(steps) ? give(rt.resolve(ctx, fill(steps) as readonly unknown[])) : steps;
+      };
+    }),
+
+    "formula.step": compiled(({ doc, parts, fill }) => {
+      // A step document without parts is its own value. A step document with parts gets the result of each part.
+      if (parts.length === 0) {
+        const same = ok(doc);
+        return () => same;
+      }
+      return (ctx, rt) => {
+        const values = valuesOf(parts, ctx, rt);
+        return Array.isArray(values) ? ok({ ...doc, value: fill(values) as Json }) : values;
       };
     }),
 
@@ -201,6 +254,19 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
       const fields = partsOf(value);
       const keys = Object.keys(fields);
       const codes = keys.map((key) => (fields[key] as CompiledPart).code);
+      if (combine !== undefined) {
+        // With combine, each field evaluates, and two failed fields give one error.
+        const parts = keys.map((key) => fields[key] as CompiledPart);
+        return (ctx, rt) => {
+          const values = collect(parts, ctx, rt, omit);
+          if (!Array.isArray(values)) return values as Failed;
+          const out: Record<string, unknown> = {};
+          keys.forEach((key, index) => {
+            if (values[index] !== SKIPPED) setOwn(out, key, values[index]);
+          });
+          return ok(out);
+        };
+      }
       return (ctx, rt) => {
         const out: Record<string, unknown> = {};
         for (let index = 0; index < keys.length; index += 1) {
@@ -216,13 +282,8 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
     }),
 
     "formula.list": compiled(({ parts }) => (ctx, rt) => {
-      const out = new Array<unknown>(parts.length);
-      for (let index = 0; index < parts.length; index += 1) {
-        const result = (parts[index] as CompiledPart).code(ctx, rt);
-        if (!result.ok) return result;
-        out[index] = result.value;
-      }
-      return ok(out);
+      const values = collect(parts, ctx, rt);
+      return Array.isArray(values) ? ok(values) : (values as Failed);
     }),
 
     "formula.let": compiled(({ value }) => {
@@ -340,6 +401,17 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
       }
       const done = (out: unknown): Result => (check === undefined ? ok(out) : (check(out, name) ?? ok(out)));
       const failed = (error: unknown): Result => thrown(error, `the operation ${name}`);
+      if (combine !== undefined) {
+        return (ctx, rt) => {
+          const values = collect(parts, ctx, rt);
+          if (!Array.isArray(values)) return values as Failed;
+          try {
+            return done(fn(...values));
+          } catch (error) {
+            return failed(error);
+          }
+        };
+      }
       if (parts.length === 1) {
         const [a] = parts as readonly [CompiledPart];
         return (ctx, rt) => {
@@ -389,9 +461,9 @@ export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record
         const unknown = fail("#NAME?", `The language has no extension ${name}.`);
         return () => unknown;
       }
-      return () => {
+      return (ctx) => {
         try {
-          return handler(doc.value);
+          return handler(doc.value, ctx);
         } catch (error) {
           return thrown(error, `the extension ${name}`);
         }

package/src/parts.ts

@@ -1,4 +1,4 @@
-import { type Json, type Key, isEnvelope, isRecord } from "./doc.ts";
+import { type Json, type Key, docEquals, isEnvelope, isRecord, typeName, typePath } from "./doc.ts";
 import type { Shape } from "./world.ts";
 
 /** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
@@ -9,6 +9,8 @@ export interface PartSlot {
   readonly key: string;
   readonly item: Json;
   readonly of?: string;
+  /** `true` when the position of the part declares an address: a reference there gives what its path reaches. */
+  readonly address?: true;
 }
 
 type Template =
@@ -54,6 +56,27 @@ function hasSlots(template: Template): boolean {
   return template.t !== "data";
 }
 
+/** This function gives the reason why a value is not data of a shape, or `undefined` when it is. */
+function dataFault(spec: Extract<Shape, { readonly shape: "text" | "number" | "one" }>, item: Json): string | undefined {
+  if (spec.shape === "text") return typeof item === "string" ? undefined : "The value must be a text.";
+  if (spec.shape === "one") return spec.values.some((value) => docEquals(value, item)) ? undefined : `The value must be one of ${JSON.stringify(spec.values)}.`;
+  if (typeof item !== "number") return "The value must be a number.";
+  if (spec.whole === true && !Number.isInteger(item)) return "The value must be a whole number.";
+  if (spec.min !== undefined && !(item >= spec.min)) return `The value must be ${String(spec.min)} or more.`;
+  if (spec.max !== undefined && !(item <= spec.max)) return `The value must be ${String(spec.max)} or less.`;
+  return undefined;
+}
+
+/** This function stops a split when a part has a type that its position does not permit. */
+function kindFault(kinds: readonly (readonly Key[])[], item: Json, of: string | undefined, path: readonly Key[]): void {
+  const type = isEnvelope(item) ? typePath(item.type) : of === undefined ? undefined : [of];
+  const fits = type !== undefined && kinds.some((kind) => kind.length <= type.length && kind.every((key, index) => String(key) === String(type[index])));
+  if (fits) return;
+  const names = kinds.map((kind) => kind.join(".")).join(", ");
+  const what = isEnvelope(item) ? `The kind ${typeName(item.type)} is not permitted here.` : "A value without an envelope is not permitted here.";
+  throw new Bad(`${what} The permitted kinds are ${names}.`, path);
+}
+
 /**
  * This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
  * the static kit use the same split, thus each one sees the same parts.
@@ -66,8 +89,8 @@ export function splitParts(shape: Shape | undefined, value: Json): Split {
   // A value without parts is data: the split needs no template.
   if (shape === undefined || shape.shape === "none") return { ok: true, parts: NO_SLOTS, data: value, fill: () => value };
   const parts: PartSlot[] = [];
-  const slot = (item: Json, path: readonly Key[], of: string | undefined): Template => {
-    parts.push({ path, key: path.join("."), item, ...(of === undefined ? {} : { of }) });
+  const slot = (item: Json, path: readonly Key[], of: string | undefined, address = false): Template => {
+    parts.push({ path, key: path.join("."), item, ...(of === undefined ? {} : { of }), ...(address ? { address: true as const } : {}) });
     return { t: "slot", index: parts.length - 1 };
   };
 
@@ -86,12 +109,25 @@ export function splitParts(shape: Shape | undefined, value: Json): Split {
 
   const walk = (spec: Shape | undefined, item: Json, path: readonly Key[]): Template => {
     if (spec === undefined || spec.shape === "none") return { t: "data", value: item };
-    if (spec.shape === "term") return slot(item, path, spec.of);
+    if (spec.shape === "text" || spec.shape === "number" || spec.shape === "one") {
+      const reason = dataFault(spec, item);
+      if (reason !== undefined) throw new Bad(reason, path);
+      return { t: "data", value: item };
+    }
+    if (spec.shape === "term") {
+      if (spec.kinds !== undefined) kindFault(spec.kinds, item, spec.of, path);
+      return slot(item, path, spec.of, spec.address === true);
+    }
     if (spec.shape === "deep") return deep(item, path, spec.of);
     if (spec.shape === "list") {
       if (!Array.isArray(item)) throw new Bad("The value must be a list.", path);
+      const list = item as readonly Json[];
+      if (spec.distinct === true) {
+        const twice = list.findIndex((child, index) => list.slice(0, index).some((before) => docEquals(before, child)));
+        if (twice !== -1) throw new Bad("The items of the list must be different.", [...path, twice]);
+      }
       const each: Shape = spec.item ?? { shape: "term", ...(spec.of === undefined ? {} : { of: spec.of }) };
-      return { t: "list", items: (item as readonly Json[]).map((child, index) => walk(each, child, [...path, index])) };
+      return { t: "list", items: list.map((child, index) => walk(each, child, [...path, index])) };
     }
     if (!isRecord(item)) throw new Bad("The value must be a record.", path);
     if (spec.shape === "map") {
@@ -106,6 +142,7 @@ export function splitParts(shape: Shape | undefined, value: Json): Split {
       : (spec.fields as Readonly<Record<string, Shape>>);
     const fields: (readonly [string, Template])[] = [];
     for (const key of Object.keys(item)) {
+      if (spec.closed === true && !Object.hasOwn(named, key)) throw new Bad(`The field ${key} is not a field of this kind.`, [...path, key]);
       const fieldShape = Object.hasOwn(named, key) ? named[key] : spec.rest;
       fields.push([key, walk(fieldShape, item[key] as Json, [...path, key])]);
     }