@mark1russell7/coeval 0.6.3 → 0.7.1

package/src/merge.ts

@@ -1,6 +1,7 @@
 import { type Key, docEquals, isRecord } from "./doc.ts";
 import type { DerefCode, Walker } from "./deref.ts";
 import type { Evaluator, Machine, Runner } from "./evaluate.ts";
+import { type Domain, type ValueType, STD_DOMAINS } from "./types.ts";
 import { type Kind, type World, type WorldEntry, isAlias, isKind, isNamespace } from "./world.ts";
 
 /** The keys from a part of a merge to one of its entries, for example `["kinds", "ref"]`. */
@@ -54,6 +55,7 @@ export class MergeError extends Error {
 }
 
 type Known = NonNullable<Machine["known"]>;
+type Facts = NonNullable<Machine["facts"]>;
 
 const NONE: ReadonlySet<string> = /* @__PURE__ */ new Set();
 
@@ -85,6 +87,56 @@ function same(a: unknown, b: unknown): boolean {
   return Object.is(a, b) || docEquals(defined(a), defined(b));
 }
 
+/**
+ * Two domains are the same when they are one object. They are also the same when they have the same test `is`,
+ * parents, summary and steps. Thus two languages that give one test under one name give one domain.
+ */
+function sameDomain(a: Domain, b: Domain): boolean {
+  return a === b || (a.is === b.is && same(a.under ?? [], b.under ?? []) && a.summary === b.summary && same(a.steps ?? {}, b.steps ?? {}));
+}
+
+/** What `extendDomain` adds to a domain: more parents, and the types of more steps. */
+export interface DomainExtension {
+  /** The names of the parents to add. A member of the domain then also passes the test of each new parent. */
+  readonly under?: readonly string[];
+  /** The types of the steps to add. A step with the key of an earlier step replaces its type. */
+  readonly steps?: Readonly<Record<string, ValueType>>;
+}
+
+/**
+ * This function makes a part of a merge that adds parents or steps to a domain of an earlier part (TYPE.PARENTS). An
+ * example is a domain of another language. The part reads the domain from the merge before it (`prev`). It gives a
+ * copy with the same test and summary, and it names `["domains", name]` in `replaces` (D17). A domain of the kernel
+ * that the earlier parts do not name comes from `STD_DOMAINS`.
+ *
+ * A new parent adds its test to the domain (TYPE.MEMBER). Thus `fits` stays sound, but a value that fails the test of
+ * the parent is no longer a member. The language that adds the parent keeps the signatures of the other language
+ * true. A name without a domain gives an empty part, and `typeIssues` reports each use of that name.
+ *
+ * @param name - The name of the domain.
+ * @param more - The parents and the steps to add.
+ * @returns The part, as a function of the merge before it.
+ */
+export function extendDomain(name: string, more: DomainExtension): (prev: Machine) => MachinePart {
+  return (prev) => {
+    const found = own(prev.domains, name) ?? own(STD_DOMAINS, name);
+    if (typeof found !== "object" || found === null || typeof found.is !== "function") return {};
+    // A domain can be an instance of a class, thus the copy reads each field by its name.
+    const under = [...(found.under ?? [])];
+    for (const parent of more.under ?? []) if (parent !== name && !under.includes(parent)) under.push(parent);
+    const steps = { ...found.steps, ...more.steps };
+    const domain: Domain = {
+      is: found.is,
+      ...(under.length === 0 ? {} : { under }),
+      ...(found.summary === undefined ? {} : { summary: found.summary }),
+      ...(Object.keys(steps).length === 0 ? {} : { steps }),
+    };
+    const domains: Record<string, Domain> = {};
+    setOwn(domains, name, domain);
+    return { domains, replaces: [["domains", name]] };
+  };
+}
+
 /** Two lists of roots are the same when they hold the same roots, in any order. */
 function sameRoots(a: unknown, b: unknown): boolean {
   if (!Array.isArray(a) || !Array.isArray(b)) return same(a, b);
@@ -246,7 +298,7 @@ export function mergeWorlds(...parts: readonly (WorldPart | ((prev: World) => Wo
 }
 
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
-const TABLES = /* @__PURE__ */ new Set(["world", "evaluators", "runners", "derefs", "walkers", "known", "replaces"]);
+const TABLES = /* @__PURE__ */ new Set(["world", "evaluators", "runners", "derefs", "walkers", "domains", "known", "facts", "replaces"]);
 
 interface MachineDraft {
   readonly world: WorldDraft;
@@ -254,7 +306,9 @@ interface MachineDraft {
   runners?: Record<string, Runner>;
   derefs?: Record<string, DerefCode>;
   walkers?: Record<string, Walker>;
+  domains?: Record<string, Domain>;
   readonly hooks: { readonly part: number; readonly known: Known }[];
+  readonly factHooks: { readonly part: number; readonly facts: Facts }[];
   /** The last part that replaced the code of each evaluator name. */
   readonly replaced: Map<string, number>;
   readonly rest: Record<string, unknown>;
@@ -282,8 +336,30 @@ function composeKnown(hooks: readonly { readonly part: number; readonly known: K
   };
 }
 
+/**
+ * This function composes the hooks `facts` in the order of their parts. The first answer that is not `undefined`
+ * wins. A hook does not answer for a name whose code a later part replaces (D24).
+ */
+function composeFacts(hooks: readonly { readonly part: number; readonly facts: Facts }[], replaced: ReadonlyMap<string, number>): Facts | undefined {
+  const first = hooks[0];
+  if (first === undefined) return undefined;
+  if (hooks.length === 1 && replaced.size === 0) return first.facts;
+  const list = [...hooks];
+  const last = new Map(replaced);
+  return (path, code) => {
+    const after = last.get(code);
+    for (const hook of list) {
+      if (after !== undefined && hook.part < after) continue;
+      const answer = hook.facts(path, code);
+      if (answer !== undefined) return answer;
+    }
+    return undefined;
+  };
+}
+
 function machineOf(draft: MachineDraft): Machine {
   const known = composeKnown(draft.hooks, draft.replaced);
+  const facts = composeFacts(draft.factHooks, draft.replaced);
   return {
     ...draft.rest,
     world: worldOf(draft.world),
@@ -291,7 +367,9 @@ function machineOf(draft: MachineDraft): Machine {
     ...(draft.runners === undefined ? {} : { runners: { ...draft.runners } }),
     ...(draft.derefs === undefined ? {} : { derefs: { ...draft.derefs } }),
     ...(draft.walkers === undefined ? {} : { walkers: { ...draft.walkers } }),
+    ...(draft.domains === undefined ? {} : { domains: { ...draft.domains } }),
     ...(known === undefined ? {} : { known }),
+    ...(facts === undefined ? {} : { facts }),
   };
 }
 
@@ -344,9 +422,11 @@ function checkHidden(m: Merger, draft: MachineDraft): void {
  *
  * - The worlds merge with the rules of `mergeWorlds`. The paths of their conflicts start with `"world"`.
  * - The tables `evaluators`, `runners`, `derefs` and `walkers` merge name by name. A function is equal only to itself.
+ * - The table `domains` merges name by name. Two domains with the same test, parents and summary give one domain (D22).
  * - The evaluator and the runner of a name are its code. A replacement of the name replaces both.
  * - A runner hides the evaluator of its name. Thus one part must give both, or the merge gives a conflict.
  * - The hooks `known` compose in the order of the parts. A hook does not answer for a name that a later part replaces.
+ *   The hooks `facts` compose the same way, and the first answer that is not `undefined` wins.
  * - Each other field, for example `permits`, `adopt`, `roots`, `plain` or `maxDepth`, is one value. Two different
  *   values are a conflict. An absent field has no value.
  *
@@ -359,7 +439,7 @@ function checkHidden(m: Merger, draft: MachineDraft): void {
  */
 export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine) => MachinePart))[]): Machine {
   const m = new Merger();
-  const draft: MachineDraft = { world: { kinds: {}, defaults: {} }, evaluators: {}, hooks: [], replaced: new Map(), rest: {}, parts: [] };
+  const draft: MachineDraft = { world: { kinds: {}, defaults: {} }, evaluators: {}, hooks: [], factHooks: [], replaced: new Map(), rest: {}, parts: [] };
   parts.forEach((input, index) => {
     const part = typeof input === "function" ? input(machineOf(draft)) : input;
     draft.parts.push(part);
@@ -374,7 +454,12 @@ export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine)
       const walkers = (draft.walkers ??= {});
       for (const name of Object.keys(part.walkers)) mergeLeaf(m, walkers, name, part.walkers[name], ["walkers", name], index, replaces, Object.is, "Two parts give two different walkers for this name.");
     }
+    if (part.domains !== undefined) {
+      const domains = (draft.domains ??= {});
+      for (const name of Object.keys(part.domains)) mergeLeaf(m, domains, name, part.domains[name], ["domains", name], index, replaces, sameDomain, "Two parts give two different domains for this base type.");
+    }
     if (part.known !== undefined && !draft.hooks.some((hook) => hook.known === part.known)) draft.hooks.push({ part: index, known: part.known });
+    if (part.facts !== undefined && !draft.factHooks.some((hook) => hook.facts === part.facts)) draft.factHooks.push({ part: index, facts: part.facts });
     const fields = part as Readonly<Record<string, unknown>>;
     for (const key of Object.keys(fields)) {
       if (TABLES.has(key)) continue;
@@ -440,7 +525,7 @@ export function restrictWorld(world: World, paths: readonly MergePath[]): World
 }
 
 /** The tables of the code of a machine, as the paths of a restriction name them. */
-const CODE_TABLES = ["evaluators", "runners", "derefs", "walkers"] as const;
+const CODE_TABLES = ["evaluators", "runners", "derefs", "walkers", "domains"] as const;
 
 /**
  * This function removes entries from a machine, for a language that restricts another language. A path names an
@@ -448,7 +533,7 @@ const CODE_TABLES = ["evaluators", "runners", "derefs", "walkers"] as const;
  *
  * - A path that starts with `"world"` removes an entry of the world, with the rules of `restrictWorld`.
  * - `["evaluators", name]` or `["runners", name]` removes the code of the name: its evaluator and its runner.
- * - `["derefs", name]` and `["walkers", name]` remove one entry of their tables.
+ * - `["derefs", name]`, `["walkers", name]` and `["domains", name]` remove one entry of their tables.
  *
  * A path that names no entry changes nothing. The function does not change the machine. An own entry names an
  * evaluator directly, thus only a machine without the code of a name refuses each document that names it.
@@ -464,6 +549,7 @@ export function restrictMachine(machine: Machine, paths: readonly MergePath[]):
     runners: machine.runners === undefined ? undefined : { ...machine.runners },
     derefs: machine.derefs === undefined ? undefined : { ...machine.derefs },
     walkers: machine.walkers === undefined ? undefined : { ...machine.walkers },
+    domains: machine.domains === undefined ? undefined : { ...machine.domains },
   };
   for (const path of paths) {
     const [table, name, ...rest] = path.map(String);
@@ -482,5 +568,6 @@ export function restrictMachine(machine: Machine, paths: readonly MergePath[]):
     ...(tables.runners === undefined ? {} : { runners: tables.runners as NonNullable<Machine["runners"]> }),
     ...(tables.derefs === undefined ? {} : { derefs: tables.derefs as NonNullable<Machine["derefs"]> }),
     ...(tables.walkers === undefined ? {} : { walkers: tables.walkers as NonNullable<Machine["walkers"]> }),
+    ...(tables.domains === undefined ? {} : { domains: tables.domains as NonNullable<Machine["domains"]> }),
   };
 }

package/src/parts.ts

@@ -1,5 +1,6 @@
 import { type Envelope, type Json, type Key, docEquals, isEnvelope, isRecord, typeName, typePath } from "./doc.ts";
 import { type Kind, type Shape, type World, lookupKind } from "./world.ts";
+import type { ValueType } from "./types.ts";
 
 /** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
 export interface PartSlot {
@@ -11,6 +12,8 @@ export interface PartSlot {
   readonly of?: string;
   /** `true` when the position of the part declares an address: a reference there gives what its path reaches. */
   readonly address?: true;
+  /** The value type that the shape declares for the part (`expect`). Only a check of types reads it. */
+  readonly expect?: ValueType;
 }
 
 type Template =
@@ -56,6 +59,11 @@ function hasSlots(template: Template): boolean {
   return template.t !== "data";
 }
 
+/** This function gives the shape of a part with the default type `of` and the value type `expect` of its container. */
+function termOf(of: string | undefined, expect: ValueType | undefined): Shape {
+  return { shape: "term", ...(of === undefined ? {} : { of }), ...(expect === undefined ? {} : { expect }) };
+}
+
 /** This function tells if a shape holds only data: no value of the shape can hold a part. */
 function isData(shape: Shape): boolean {
   return shape.shape === "none" || shape.shape === "text" || shape.shape === "number" || shape.shape === "one";
@@ -94,19 +102,26 @@ 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, address = false): Template => {
-    parts.push({ path, key: path.join("."), item, ...(of === undefined ? {} : { of }), ...(address ? { address: true as const } : {}) });
+  const slot = (item: Json, path: readonly Key[], of: string | undefined, address = false, expect?: ValueType): Template => {
+    parts.push({
+      path,
+      key: path.join("."),
+      item,
+      ...(of === undefined ? {} : { of }),
+      ...(address ? { address: true as const } : {}),
+      ...(expect === undefined ? {} : { expect }),
+    });
     return { t: "slot", index: parts.length - 1 };
   };
 
-  const deep = (item: Json, path: readonly Key[], of: string | undefined): Template => {
-    if (isEnvelope(item)) return slot(item, path, of);
+  const deep = (item: Json, path: readonly Key[], of: string | undefined, expect: ValueType | undefined): Template => {
+    if (isEnvelope(item)) return slot(item, path, of, false, expect);
     if (Array.isArray(item)) {
-      const items = (item as readonly Json[]).map((child, index) => deep(child, [...path, index], of));
+      const items = (item as readonly Json[]).map((child, index) => deep(child, [...path, index], of, expect));
       return items.some(hasSlots) ? { t: "list", items } : { t: "data", value: item };
     }
     if (isRecord(item)) {
-      const fields = Object.keys(item).map((key) => [key, deep(item[key] as Json, [...path, key], of)] as const);
+      const fields = Object.keys(item).map((key) => [key, deep(item[key] as Json, [...path, key], of, expect)] as const);
       return fields.some(([, child]) => hasSlots(child)) ? { t: "record", fields } : { t: "data", value: item };
     }
     return { t: "data", value: item };
@@ -121,9 +136,9 @@ export function splitParts(shape: Shape | undefined, value: Json): Split {
     }
     if (spec.shape === "term") {
       if (spec.kinds !== undefined) kindFault(spec.kinds, item, spec.of, path);
-      return slot(item, path, spec.of, spec.address === true);
+      return slot(item, path, spec.of, spec.address === true, spec.expect);
     }
-    if (spec.shape === "deep") return deep(item, path, spec.of);
+    if (spec.shape === "deep") return deep(item, path, spec.of, spec.expect);
     if (spec.shape === "list") {
       if (!Array.isArray(item)) throw new Bad("The value must be a list.", path);
       const list = item as readonly Json[];
@@ -131,21 +146,21 @@ export function splitParts(shape: Shape | undefined, value: Json): Split {
         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 }) };
+      const each: Shape = spec.item ?? termOf(spec.of, spec.expect);
       const items = list.map((child, index) => walk(each, child, [...path, index]));
       // A list of data is data, also when it is empty. Only a list that can hold parts gives null in the data.
       return isData(each) ? { t: "data", value: item } : { t: "list", items };
     }
     if (!isRecord(item)) throw new Bad("The value must be a record.", path);
     if (spec.shape === "map") {
-      const each: Shape = spec.item ?? { shape: "term", ...(spec.of === undefined ? {} : { of: spec.of }) };
+      const each: Shape = spec.item ?? termOf(spec.of, spec.expect);
       return { t: "record", fields: Object.keys(item).map((key) => [key, walk(each, item[key] as Json, [...path, key])] as const) };
     }
     for (const name of spec.required ?? []) {
       if (!Object.hasOwn(item, name)) throw new Bad(`The field ${name} is missing.`, path);
     }
     const named: Readonly<Record<string, Shape>> = Array.isArray(spec.fields)
-      ? Object.fromEntries((spec.fields as readonly string[]).map((name) => [name, { shape: "term", ...(spec.of === undefined ? {} : { of: spec.of }) } as Shape]))
+      ? Object.fromEntries((spec.fields as readonly string[]).map((name) => [name, termOf(spec.of, spec.expect)]))
       : (spec.fields as Readonly<Record<string, Shape>>);
     const fields: (readonly [string, Template])[] = [];
     for (const key of Object.keys(item)) {

package/src/providers.ts

@@ -0,0 +1,286 @@
+import { type Json, type Key, docEquals, isRecord } from "./doc.ts";
+import { type TypeIssue, type ValueType, isUnknown, join, member } from "./types.ts";
+
+/*
+ * Type providers (R5 P4, D28). A provider makes a value type from data that a host already has: a JSON Schema or
+ * sample values. A host gives such a type to a root of a check, for example the schema of a store for `world`.
+ */
+
+/** The type that a provider reads, and the problems of the reading. Each problem tells what the type does not test. */
+export interface TypeReading {
+  readonly type: ValueType;
+  readonly issues: readonly TypeIssue[];
+}
+
+/** The deepest schema that `typeFromSchema` reads. A deeper schema reads as `unknown`. */
+const MAX_SCHEMA_DEPTH = 256;
+
+/** The keywords that describe a schema and do not test a value. The reading ignores them without an issue. */
+const NOTES: ReadonlySet<string> = /* @__PURE__ */ new Set([
+  "$schema",
+  "$id",
+  "$anchor",
+  "$comment",
+  "$defs",
+  "definitions",
+  "title",
+  "description",
+  "default",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+]);
+
+/** The keywords that the reading reads. Each other keyword gives an issue and tests nothing. */
+const READ: ReadonlySet<string> = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "anyOf", "oneOf"]);
+
+/**
+ * The keywords that can permit more values than the other keywords permit. Older drafts ignore each keyword beside
+ * `$ref`, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
+ */
+const WIDENING: ReadonlySet<string> = /* @__PURE__ */ new Set(["$ref", "$dynamicRef", "$recursiveRef", "nullable"]);
+
+/** The base type of each name of the keyword `type`. */
+const BASES: Readonly<Record<string, ValueType>> = { null: "null", boolean: "bool", number: "number", integer: "number", string: "text" };
+
+/** This function sets an own field of a new record. Only the key `__proto__` needs `defineProperty`. */
+function setOwn(target: Record<string, unknown>, key: string, value: unknown): void {
+  if (key === "__proto__") Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  else target[key] = value;
+}
+
+/** The union of types: the join of each type, or `never` for no type. */
+function unionOf(types: readonly ValueType[]): ValueType {
+  return types.reduce<ValueType>((all, type) => join(all, type), "never");
+}
+
+/** The state of one reading of a schema: the issues that it found. */
+class SchemaReader {
+  readonly issues: TypeIssue[] = [];
+
+  issue(at: readonly Key[], reason: string): void {
+    this.issues.push({ at, reason });
+  }
+
+  /** This method reads one schema. */
+  read(schema: unknown, at: readonly Key[], depth: number): ValueType {
+    if (depth > MAX_SCHEMA_DEPTH) {
+      this.issue(at, `The schema is deeper than ${MAX_SCHEMA_DEPTH} levels. The type reads it as unknown.`);
+      return "unknown";
+    }
+    if (schema === true) return "unknown";
+    if (schema === false) return "never";
+    if (!isRecord(schema)) {
+      this.issue(at, "A schema is a record or a truth value. The type reads this value as unknown.");
+      return "unknown";
+    }
+    let widens = false;
+    for (const key of Object.keys(schema)) {
+      if (READ.has(key) || NOTES.has(key)) continue;
+      if (WIDENING.has(key)) {
+        this.issue([...at, key], `The type does not read the keyword ${key}. Thus it reads the schema as unknown.`);
+        widens = true;
+      } else {
+        this.issue([...at, key], `The type does not read the keyword ${key}. It does not test what the keyword tests.`);
+      }
+    }
+    if (widens) return "unknown";
+    // A schema is the conjunction of its keywords. The reading keeps one of them, and each one alone holds each value.
+    const sides: { readonly key: string; readonly type: ValueType }[] = [];
+    if (Object.hasOwn(schema, "type")) sides.push({ key: "type", type: this.byType(schema, at, depth) });
+    else if (["properties", "required", "additionalProperties", "items"].some((key) => Object.hasOwn(schema, key)) && !["enum", "const", "anyOf", "oneOf"].some((key) => Object.hasOwn(schema, key))) {
+      this.issue(at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+      if (!Object.hasOwn(schema, key)) continue;
+      const items = schema[key];
+      if (!Array.isArray(items)) {
+        this.issue([...at, key], `The value of ${key} is a list of schemas.`);
+        continue;
+      }
+      // A union holds each value of oneOf too. It does not test that only one schema fits.
+      sides.push({ key, type: unionOf(items.map((item, index) => this.read(item, [...at, key, index], depth + 1))) });
+    }
+    // A finite set of values meets each other keyword exactly: the type keeps each value that each side holds.
+    const values = this.values(schema, at);
+    if (values !== undefined) return { one: values.filter((value) => sides.every((side) => member(value, side.type))) };
+    const known = sides.filter((side) => !isUnknown(side.type, undefined));
+    const kept = known[0];
+    if (kept === undefined) return "unknown";
+    for (const side of known.slice(1)) this.issue([...at, side.key], `The type reads the keyword ${kept.key}, and not the keyword ${side.key}.`);
+    return kept.type;
+  }
+
+  /** This method reads `enum` and `const`: the values that the schema permits, or `undefined` without them. */
+  values(schema: Readonly<Record<string, unknown>>, at: readonly Key[]): Json[] | undefined {
+    let values: Json[] | undefined;
+    if (Object.hasOwn(schema, "enum")) {
+      if (Array.isArray(schema["enum"])) values = [...(schema["enum"] as Json[])];
+      else this.issue([...at, "enum"], "The value of enum is a list of JSON values.");
+    }
+    if (Object.hasOwn(schema, "const")) {
+      const one = schema["const"] as Json;
+      values = values === undefined ? [one] : values.filter((value) => docEquals(value, one));
+    }
+    return values;
+  }
+
+  /** This method reads the keyword `type` with the keywords of an object and of an array. */
+  byType(schema: Readonly<Record<string, unknown>>, at: readonly Key[], depth: number): ValueType {
+    const raw = schema["type"];
+    const names = typeof raw === "string" ? [raw] : Array.isArray(raw) ? raw : undefined;
+    if (names === undefined) {
+      this.issue([...at, "type"], "The value of type is a text or a list of texts.");
+      return "unknown";
+    }
+    const types: ValueType[] = [];
+    for (const [index, name] of names.entries()) {
+      const where = typeof raw === "string" ? [...at, "type"] : [...at, "type", index];
+      if (name === "object") types.push(this.object(schema, at, depth));
+      else if (name === "array") types.push(this.array(schema, at, depth));
+      else if (typeof name === "string" && Object.hasOwn(BASES, name)) {
+        if (name === "integer") this.issue(where, "The type reads integer as number. It does not test that the number is whole.");
+        types.push(BASES[name] as ValueType);
+      } else {
+        this.issue(where, `The type ${String(name)} is not a type of JSON Schema. The type reads it as unknown.`);
+        return "unknown";
+      }
+    }
+    return unionOf(types);
+  }
+
+  /** This method reads an object: its properties, the properties that it needs and the other properties. */
+  object(schema: Readonly<Record<string, unknown>>, at: readonly Key[], depth: number): ValueType {
+    const fields: Record<string, ValueType> = {};
+    const properties = schema["properties"] ?? {};
+    if (isRecord(properties)) {
+      for (const key of Object.keys(properties)) setOwn(fields, key, this.read(properties[key], [...at, "properties", key], depth + 1));
+    } else {
+      this.issue([...at, "properties"], "The value of properties is a record of schemas.");
+    }
+    const required = schema["required"] ?? [];
+    const needed = Array.isArray(required) ? required.filter((key): key is string => typeof key === "string") : [];
+    if (!Array.isArray(required) || needed.length !== required.length) this.issue([...at, "required"], "The value of required is a list of texts.");
+    // A property that `required` names without a schema can hold each value.
+    for (const key of needed) if (!Object.hasOwn(fields, key)) setOwn(fields, key, "unknown");
+    const optional = Object.keys(fields).filter((key) => !needed.includes(key));
+    const other = schema["additionalProperties"];
+    // Each property that a pattern names is permitted too, thus the record is closed only without patterns.
+    let closed = other === false && !Object.hasOwn(schema, "patternProperties");
+    if (other !== undefined && other !== true && other !== false) {
+      this.issue([...at, "additionalProperties"], "The type reads additionalProperties with a schema as an open record. The other fields can hold each value.");
+      closed = false;
+    }
+    return { record: fields, ...(optional.length === 0 ? {} : { optional }), ...(closed ? { closed: true } : {}) };
+  }
+
+  /** This method reads an array: the schema of its items. */
+  array(schema: Readonly<Record<string, unknown>>, at: readonly Key[], depth: number): ValueType {
+    const items = schema["items"];
+    if (items === undefined) return { list: "unknown" };
+    // With prefixItems, the keyword items covers only the items after the prefix.
+    if (Object.hasOwn(schema, "prefixItems") || Array.isArray(items)) {
+      this.issue([...at, "items"], "The type does not read the items of a tuple. It reads a list of unknown items.");
+      return { list: "unknown" };
+    }
+    return { list: this.read(items, [...at, "items"], depth + 1) };
+  }
+}
+
+/**
+ * This function makes a value type from a JSON Schema (TYPE.SCHEMA). A host uses it for the type of a root, for
+ * example the schema of a store for `world`. It reads this subset:
+ *
+ * - `type`: `null`, `boolean`, `number`, `integer` (as `number`), `string`, `object` and `array`, or a list of them.
+ * - `properties`, `required` and `additionalProperties` give a record. `false` closes it, and a property that is not
+ *   in `required` is optional.
+ * - `items` gives a list. `enum` and `const` give `one`. `anyOf` and `oneOf` give a union.
+ *
+ * The type holds each value that the schema accepts. Each keyword that the function does not read tests nothing, as
+ * `unknown`, and the issues name it. Examples are `minimum`, `pattern` and `allOf`. A schema with `$ref` or `nullable`
+ * reads as `unknown`, because these keywords can permit more values. A schema with more than one of `type`, `anyOf`
+ * and `oneOf` gives the type of the first, and an issue for each other. The function does not throw.
+ *
+ * @param schema - The schema, as JSON.
+ * @returns The type, and the problems of the reading with their keys in the schema.
+ */
+export function typeFromSchema(schema: unknown): TypeReading {
+  const reader = new SchemaReader();
+  try {
+    return { type: reader.read(schema, [], 0), issues: reader.issues };
+  } catch (error) {
+    // A getter of a host value can throw. The reading then gives the top.
+    reader.issue([], `The schema cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+    return { type: "unknown", issues: reader.issues };
+  }
+}
+
+/** The options of `typeFromSamples`. */
+export interface SampleOptions {
+  /** `true`: the samples show each field, thus each record type is closed. The default is `false`. */
+  readonly closed?: boolean;
+}
+
+/** The deepest sample that `typeFromSamples` reads. A deeper value gives `unknown`. */
+const MAX_SAMPLE_DEPTH = 256;
+
+/** This function gives the type of a group of sample values at one depth. */
+function samplesAt(values: readonly unknown[], closed: boolean, depth: number): ValueType {
+  if (depth > MAX_SAMPLE_DEPTH) return values.length === 0 ? "never" : "unknown";
+  const types: ValueType[] = [];
+  const bases = new Set<string>();
+  const items: unknown[] = [];
+  const records: Readonly<Record<string, unknown>>[] = [];
+  let lists = false;
+  for (const value of values) {
+    if (value === null) bases.add("null");
+    else if (typeof value === "boolean") bases.add("bool");
+    else if (typeof value === "number") bases.add("number");
+    else if (typeof value === "string") bases.add("text");
+    else if (Array.isArray(value)) {
+      lists = true;
+      // A hole of a list holds undefined, thus a loop by index reads it too.
+      for (let index = 0; index < value.length; index += 1) items.push(value[index]);
+    } else if (isRecord(value)) records.push(value);
+    // A value without a type of the kernel, for example a function or undefined, has each type.
+    else return "unknown";
+  }
+  for (const base of ["null", "bool", "number", "text"]) if (bases.has(base)) types.push(base);
+  if (lists) types.push({ list: samplesAt(items, closed, depth + 1) });
+  if (records.length > 0) {
+    // All records join into one record. A field that a record does not have is optional.
+    const keys: string[] = [];
+    for (const record of records) for (const key of Object.keys(record)) if (!keys.includes(key)) keys.push(key);
+    const fields: Record<string, ValueType> = {};
+    const optional: string[] = [];
+    for (const key of keys) {
+      const found = records.filter((record) => Object.hasOwn(record, key));
+      if (found.length < records.length) optional.push(key);
+      setOwn(fields, key, samplesAt(found.map((record) => record[key]), closed, depth + 1));
+    }
+    types.push({ record: fields, ...(optional.length === 0 ? {} : { optional }), ...(closed ? { closed: true } : {}) });
+  }
+  return types.length === 1 ? (types[0] as ValueType) : unionOf(types);
+}
+
+/**
+ * This function infers a value type from sample values (TYPE.SAMPLES), as a type provider of F# does. A host uses it
+ * for the type of a root, for example from some events.
+ *
+ * - `null`, a truth value, a number and a text give their base types, not their values.
+ * - The items of each list join into one type of items.
+ * - All records join into one record with each key of the samples. A key that a record does not have is optional.
+ * - Values of different forms give a union, as `join` gives. No samples give `never`.
+ * - A value without a type of the kernel, for example a function, gives `unknown`.
+ *
+ * Each sample is a member of the type. A record is open, because samples do not show that a field cannot exist. With
+ * `closed: true`, each record is closed, and a reference to a field that no sample has gives `#TYPE!`.
+ *
+ * @param values - The sample values.
+ * @param options - `closed: true` closes each record type.
+ * @returns The type.
+ */
+export function typeFromSamples(values: readonly unknown[], options: SampleOptions = {}): ValueType {
+  return samplesAt(values, options.closed === true, 0);
+}