@mark1russell7/coeval 0.16.0 → 0.17.0

package/src/types.ts

@@ -59,6 +59,23 @@ export interface Domain {
    * standard extension `ext.domain`. A domain without a codec has no such document.
    */
   readonly codec?: DomainCodec;
+  /**
+   * The full list of the members of the domain, when the domain holds few values, for example `true` and `false` of
+   * `bool` (TYPE.FITS-FINITE). `fits` reads it: a base type with a list fits a type that holds each member of the list.
+   * The language keeps the list complete: each member of the domain is in the list. A value that fails a test of the
+   * domain does not count. The check reads a list of at most 64 values.
+   */
+  readonly values?: readonly unknown[];
+  /**
+   * The covers of the domain (TYPE.FITS-COVER, D85). A cover is a list of domains under this domain, and its domains
+   * together hold each member of this domain. An example is a domain of negative numbers and a domain of the other
+   * numbers as a cover of `number`. `fits` reads it: a base type fits a union when each domain of a cover fits it.
+   *
+   * A split of a record also narrows a field of the domain to each domain of a cover (D90).
+   * The language keeps each cover true, and `fits` trusts it, as it trusts `values`. A cover that is empty, or that
+   * names this domain or a name that is not under it, does not count.
+   */
+  readonly covers?: readonly (readonly string[])[];
 }
 
 /**
@@ -94,10 +111,10 @@ export interface TypeIssue {
  * A machine that does not name one of these domains gets it from this table.
  */
 export const STD_DOMAINS: Readonly<Record<string, Domain>> = {
-  null: { is: (value) => value === null, summary: "The value null." },
+  null: { is: (value) => value === null, values: [null], summary: "The value null." },
   // JSON has no undefined, thus a document holds it as ext.undefined (D48). The domain has no codec: the codec of values writes undefined first.
-  undefined: { is: (value) => value === undefined, summary: "The value undefined. A document holds it as the extension ext.undefined." },
-  bool: { is: (value) => typeof value === "boolean", summary: "A truth value: true or false." },
+  undefined: { is: (value) => value === undefined, values: [undefined], summary: "The value undefined. A document holds it as the extension ext.undefined." },
+  bool: { is: (value) => typeof value === "boolean", values: [true, false], summary: "A truth value: true or false." },
   number: { is: (value) => typeof value === "number", summary: "A number of the host, also NaN, an infinity and -0." },
   text: { is: (value) => typeof value === "string", summary: "A text." },
 };
@@ -105,6 +122,15 @@ export const STD_DOMAINS: Readonly<Record<string, Domain>> = {
 /** The deepest term that a value type can have. A deeper term reads as `unknown`, thus a check stays total. */
 const MAX_TYPE_DEPTH = 256;
 
+/** The most values that the finite rule of `fits` reads for one type (TYPE.FITS-FINITE). A type with more values is not finite for the rule. */
+const MAX_FINITE_VALUES = 64;
+
+/** The most domains of covers that the cover rule of `fits` tests for one type (TYPE.FITS-COVER). A larger test gives `false`. */
+const MAX_COVER_STEPS = 64;
+
+/** The most records that one split of `fits` builds, with each split inside its work (TYPE.FITS-PATH, D89). A larger split gives `false`. */
+const MAX_SPLIT_RECORDS = 64;
+
 /** The keys that each term permits beside its own key. */
 const TERM_KEYS: Readonly<Record<string, readonly string[]>> = {
   list: ["list"],
@@ -269,6 +295,7 @@ function recordFits(
   domains: Readonly<Record<string, Domain>> | undefined,
   depth: number,
   gradual: boolean,
+  budget: SplitBudget | undefined,
 ): boolean {
   if (b.closed && (!a.closed || Object.keys(a.fields).some((key) => !Object.hasOwn(b.fields, key)))) return false;
   for (const key of Object.keys(b.fields)) {
@@ -276,7 +303,7 @@ function recordFits(
     const needed = !b.optional.has(key);
     if (Object.hasOwn(a.fields, key)) {
       if (needed && a.optional.has(key)) return false;
-      if (!fitsAt(a.fields[key], want, domains, depth, gradual)) return false;
+      if (!fitsAt(a.fields[key], want, domains, depth, gradual, true, budget)) return false;
     } else if (needed) {
       return false;
     } else if (!a.closed && formOf(want, domains).t !== "top") {
@@ -287,27 +314,403 @@ function recordFits(
   return true;
 }
 
+/** This function adds a value to a list of distinct values, by `docEquals`. */
+function addValue(out: unknown[], value: unknown): void {
+  if (!out.some((item) => docEquals(item, value))) out.push(value);
+}
+
+/**
+ * This function gives the values of a base type with a finite list. It reads the list of the first domain of the line
+ * with at most 64 values, and it keeps only the members of the type. Thus the list of a parent serves each domain under it.
+ */
+function baseValues(name: string, domains: Readonly<Record<string, Domain>> | undefined): readonly unknown[] | undefined {
+  const domain = domainOf(name, domains);
+  if (domain === undefined) return undefined;
+  const line = Array.isArray(domain.values) || !Array.isArray(domain.under) ? [name] : lineOf(name, domains);
+  for (const each of line) {
+    const values: unknown = domainOf(each, domains)?.values;
+    if (!Array.isArray(values) || values.length > MAX_FINITE_VALUES) continue;
+    const out: unknown[] = [];
+    // A hole of the list holds undefined, thus a loop by index reads it too.
+    for (let index = 0; index < values.length; index += 1) if (inDomain(values[index], name, domains)) addValue(out, values[index]);
+    return out;
+  }
+  return undefined;
+}
+
+/** This function gives a copy of a record with one more field. */
+function withField(record: Readonly<Record<string, unknown>>, key: string, value: unknown): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const name of Object.keys(record)) setOwn(out, name, record[name]);
+  setOwn(out, key, value);
+  return out;
+}
+
+/**
+ * This function gives the members of a record type, when they are few. A record with a needed field without members
+ * has no members. Only a closed record with a finite list for each field has a finite list.
+ */
+function recordValues(form: Extract<Form, { readonly t: "record" }>, domains: Readonly<Record<string, Domain>> | undefined, depth: number): readonly unknown[] | undefined {
+  let out: readonly Record<string, unknown>[] = [{}];
+  let finite = form.closed;
+  for (const key of Object.keys(form.fields)) {
+    const values = valuesOf(form.fields[key], domains, depth);
+    const optional = form.optional.has(key);
+    if (values === undefined) {
+      finite = false;
+      continue;
+    }
+    if (values.length === 0 && !optional) return [];
+    if (!finite) continue;
+    if (out.length * (values.length + (optional ? 1 : 0)) > MAX_FINITE_VALUES) {
+      // The list is too long, but a later needed field without members can still empty the record.
+      finite = false;
+      continue;
+    }
+    out = out.flatMap((record) => [...(optional ? [record] : []), ...values.map((value) => withField(record, key, value))]);
+  }
+  return finite ? out : undefined;
+}
+
+/**
+ * This function gives a list of the members of a type, when the type has at most 64 members (TYPE.FITS-FINITE). Each
+ * other type gives `undefined`. Such a type is `unknown`, a base type without a finite list, or a function type. A
+ * list that can hold an item and an open record with members are also such types.
+ */
+function valuesOf(type: unknown, domains: Readonly<Record<string, Domain>> | undefined, depth: number): readonly unknown[] | undefined {
+  if (depth > MAX_TYPE_DEPTH) return undefined;
+  const form = formOf(type, domains);
+  const next = depth + 1;
+  switch (form.t) {
+    case "bottom":
+      return [];
+    case "base":
+      return baseValues(form.name, domains);
+    case "list":
+      return valuesOf(form.item, domains, next)?.length === 0 ? [[]] : undefined;
+    case "record":
+      return recordValues(form, domains, next);
+    case "one":
+    case "union": {
+      const out: unknown[] = [];
+      const items: readonly unknown[] = form.t === "one" ? form.values : form.members;
+      for (const item of items) {
+        const values = form.t === "one" ? [item] : valuesOf(item, domains, next);
+        if (values === undefined) return undefined;
+        for (const value of values) addValue(out, value);
+        if (out.length > MAX_FINITE_VALUES) return undefined;
+      }
+      return out;
+    }
+    default:
+      return undefined;
+  }
+}
+
+/** This function gives the members of a type at one depth, for `membersOf`. */
+function membersAt(type: unknown, domains: Readonly<Record<string, Domain>> | undefined, samples: readonly unknown[], depth: number): readonly unknown[] {
+  const finite = valuesOf(type, domains, depth);
+  if (finite !== undefined) return finite;
+  const form = formOf(type, domains);
+  if (form.t !== "union" || depth > MAX_TYPE_DEPTH) return samples.filter((sample) => member(sample, type as ValueType, domains));
+  const out: unknown[] = [];
+  for (const item of form.members) for (const value of membersAt(item, domains, samples, depth + 1)) addValue(out, value);
+  return out;
+}
+
+/**
+ * This function gives members of a type for a test of a declaration (D86). A type with at most 64 members gives each
+ * member, from the lists `values` of its domains (TYPE.FITS-FINITE). A union gives the members of each of its types.
+ * Each other type gives the samples that are its members. The kernel does not export the function.
+ *
+ * @param type - The type.
+ * @param domains - The domains of the machine.
+ * @param samples - The values to test when the type has no full list of members.
+ * @returns Distinct members of the type.
+ */
+export function membersOf(type: ValueType, domains: Readonly<Record<string, Domain>> | undefined, samples: readonly unknown[]): readonly unknown[] {
+  return membersAt(type, domains, samples, 0);
+}
+
+/** This function holds the rules of the shapes of `fits`: base types, lists, records and functions. */
+function shapeFits(a: Form, b: Form, domains: Readonly<Record<string, Domain>> | undefined, next: number, gradual: boolean, budget: SplitBudget | undefined): boolean {
+  if (a.t === "base") return b.t === "base" && lineOf(a.name, domains).has(b.name);
+  if (a.t === "list") return b.t === "list" && fitsAt(a.item, b.item, domains, next, gradual, true, budget);
+  if (a.t === "record") return b.t === "record" && recordFits(a, b, domains, next, gradual, budget);
+  if (a.t !== "fn" || b.t !== "fn" || a.params.length > b.params.length) return false;
+  // A function fits when it accepts each argument of the expected type, and when its result fits.
+  return a.params.every((param, index) => fitsAt(b.params[index], param, domains, next, gradual, true, budget)) && fitsAt(a.to, b.to, domains, next, gradual, true, budget);
+}
+
 /**
  * This function is the relation `fits` at one depth of two types. The order of its tests is the order of the rules of
  * `fits`. Without `gradual`, `unknown` is only the top: it fits only `unknown`. The join uses this strict form.
+ *
+ * When the rules of the shapes refuse a type with few members, the finite rule tests each member (TYPE.FITS-FINITE).
+ * The cover rule and the split rule come after it. Without `finite`, the call skips these three rules. The members of
+ * a union in `expected` get such calls, because the call for the union tests `found` against the full union.
+ *
+ * The budget is the budget of the outer split, when the call is part of the work of a split (TYPE.FITS-PATH, D89).
  */
-function fitsAt(found: unknown, expected: unknown, domains: Readonly<Record<string, Domain>> | undefined, depth: number, gradual = true): boolean {
+function fitsAt(
+  found: unknown,
+  expected: unknown,
+  domains: Readonly<Record<string, Domain>> | undefined,
+  depth: number,
+  gradual = true,
+  finite = true,
+  budget?: SplitBudget,
+): boolean {
   if (depth > MAX_TYPE_DEPTH) return true;
   const a = formOf(found, domains);
   const b = formOf(expected, domains);
   const next = depth + 1;
   if (b.t === "top" || a.t === "bottom") return true;
   if (a.t === "top") return gradual;
-  if (a.t === "union") return a.members.every((item) => fitsAt(item, expected, domains, next, gradual));
+  if (a.t === "union") return a.members.every((item) => fitsAt(item, expected, domains, next, gradual, true, budget));
   if (a.t === "one") return a.values.every((item) => memberAt(item, expected, domains, next));
-  if (b.t === "bottom") return false;
-  if (b.t === "union") return b.members.some((item) => fitsAt(found, item, domains, next, gradual));
-  if (a.t === "base") return b.t === "base" && lineOf(a.name, domains).has(b.name);
-  if (a.t === "list") return b.t === "list" && fitsAt(a.item, b.item, domains, next, gradual);
-  if (a.t === "record") return b.t === "record" && recordFits(a, b, domains, next, gradual);
-  if (b.t !== "fn" || a.params.length > b.params.length) return false;
-  // A function fits when it accepts each argument of the expected type, and when its result fits.
-  return a.params.every((param, index) => fitsAt(b.params[index], param, domains, next, gradual)) && fitsAt(a.to, b.to, domains, next, gradual);
+  if (b.t === "union" ? b.members.some((item) => fitsAt(found, item, domains, next, gradual, false, budget)) : b.t !== "bottom" && shapeFits(a, b, domains, next, gradual, budget)) return true;
+  if (!finite || a.t === "fn") return false;
+  // The finite rule: a type with few members fits when each member is a member of `expected`.
+  const values = valuesOf(found, domains, next);
+  if (values !== undefined) return values.every((value) => memberAt(value, expected, domains, next));
+  // The cover rule: a base type fits when each domain of a cover of its line fits (D85).
+  if (a.t === "base") return (b.t === "union" || b.t === "one") && lineCovered(a.name, expected, domains, depth, gradual, undefined);
+  // The split rule: an open record, or a closed record with too many members, splits over a union or a `one` (D84, D89).
+  return a.t === "record" && (b.t === "union" || (b.t === "one" && a.closed)) && splitFits(found, a, expected, domains, depth, gradual, budget);
+}
+
+/** The state of the cover rule for one type: the result for each domain whose covers it tested, and the steps that are left. */
+interface CoverState {
+  readonly held: Map<string, boolean>;
+  left: number;
+}
+
+/**
+ * This function is the cover rule of `fits` (TYPE.FITS-COVER, D85). A base type fits when a domain of its line has a
+ * cover, and each domain of the cover fits `expected`. The function makes the state at the first domain with covers.
+ */
+function lineCovered(name: string, expected: unknown, domains: Readonly<Record<string, Domain>> | undefined, depth: number, gradual: boolean, state: CoverState | undefined): boolean {
+  let now = state;
+  for (const each of lineOf(name, domains)) {
+    if (!Array.isArray(domainOf(each, domains)?.covers)) continue;
+    now ??= { held: new Map(), left: MAX_COVER_STEPS };
+    if (covered(each, expected, domains, depth, gradual, now)) return true;
+  }
+  return false;
+}
+
+/**
+ * This function tells if a cover of one domain holds the domain in `expected`. A cover that is empty, or that names
+ * the domain or a name that is not under it, does not count. Each domain of a cover costs one step, and the rule
+ * stops after 64 steps.
+ */
+function covered(name: string, expected: unknown, domains: Readonly<Record<string, Domain>> | undefined, depth: number, gradual: boolean, state: CoverState): boolean {
+  const known = state.held.get(name);
+  if (known !== undefined) return known;
+  // A domain on the way gives false until its cover holds, thus a cycle of covers ends.
+  state.held.set(name, false);
+  const covers: unknown = domainOf(name, domains)?.covers;
+  if (!Array.isArray(covers)) return false;
+  for (const cover of covers as readonly unknown[]) {
+    if (!Array.isArray(cover) || cover.length === 0) continue;
+    let held = true;
+    for (const part of cover as readonly unknown[]) {
+      state.left -= 1;
+      if (state.left < 0) return false;
+      if (typeof part !== "string" || part === name || !lineOf(part, domains).has(name) || !partFits(part, expected, domains, depth, gradual, state)) {
+        held = false;
+        break;
+      }
+    }
+    if (held) {
+      state.held.set(name, true);
+      return true;
+    }
+  }
+  return false;
+}
+
+/** This function tells if a domain of a cover fits `expected`. It tries the rules of the shapes, the finite rule and its own covers. */
+function partFits(part: string, expected: unknown, domains: Readonly<Record<string, Domain>> | undefined, depth: number, gradual: boolean, state: CoverState): boolean {
+  if (fitsAt(part, expected, domains, depth, gradual, false)) return true;
+  const values = valuesOf(part, domains, depth + 1);
+  if (values !== undefined) return values.every((value) => memberAt(value, expected, domains, depth + 1));
+  return lineCovered(part, expected, domains, depth, gradual, state);
+}
+
+/**
+ * A field that the split rule can split: the path of keys to it, its cases, and if the field is optional. A value
+ * split has the members of the field type. A type split has case types: the domains of a cover, or the members of a
+ * union (TYPE.FITS-SPLIT-TYPE, D90).
+ */
+interface Split {
+  readonly path: readonly string[];
+  readonly values?: readonly unknown[];
+  readonly types?: readonly ValueType[];
+  readonly optional: boolean;
+}
+
+/** The records that a split can still build. The outer split makes it, and each split inside its work takes from it (D89). */
+interface SplitBudget {
+  left: number;
+}
+
+/**
+ * This function gives the fields that the split rule can split, in the order of the split (TYPE.FITS-PATH, D89). The
+ * fields of the record come first, in the order of the keys. Then the paths of the next depth follow, and so on. A path
+ * goes into a field only when the field is a record without a finite list. A field with a finite list of two or more
+ * cases is a split. An optional field also has the absent case.
+ *
+ * The type splits follow each value split, in the same order (D90). A base type with a valid cover in its line splits
+ * into the domains of the cover. A union without a finite list splits into its members. The prefix is the path of `a`.
+ */
+function splitsOf(
+  a: Extract<Form, { readonly t: "record" }>,
+  domains: Readonly<Record<string, Domain>> | undefined,
+  depth: number,
+  prefix: readonly string[] = [],
+): readonly Split[] {
+  const out: Split[] = [];
+  const later: Split[] = [];
+  let level: { readonly path: readonly string[]; readonly form: Extract<Form, { readonly t: "record" }> }[] = [{ path: prefix, form: a }];
+  for (let at = depth + 1; level.length > 0 && at <= MAX_TYPE_DEPTH; at += 1) {
+    const deeper: typeof level = [];
+    for (const { path, form } of level) {
+      for (const key of Object.keys(form.fields)) {
+        const values = valuesOf(form.fields[key], domains, at);
+        const optional = form.optional.has(key);
+        if (values !== undefined) {
+          if (values.length + (optional ? 1 : 0) > 1) out.push({ path: [...path, key], values, optional });
+          continue;
+        }
+        const inner = formOf(form.fields[key], domains);
+        if (inner.t === "record") deeper.push({ path: [...path, key], form: inner });
+        else if (inner.t === "union") later.push({ path: [...path, key], types: inner.members, optional });
+        else if (inner.t === "base") {
+          const cover = coverOf(inner.name, domains, false);
+          if (cover !== undefined) later.push({ path: [...path, key], types: cover, optional });
+        }
+      }
+    }
+    level = deeper;
+  }
+  return later.length === 0 ? out : [...out, ...later];
+}
+
+/** This function tells if a cover of a domain is valid by the line rule of D85. Such a cover is not empty, and each name in it is a domain under the domain. */
+function validCover(name: string, cover: unknown, domains: Readonly<Record<string, Domain>> | undefined): cover is readonly string[] {
+  return Array.isArray(cover) && cover.length > 0 && (cover as readonly unknown[]).every((part) => typeof part === "string" && part !== name && lineOf(part, domains).has(name));
+}
+
+/**
+ * This function gives the cover of a base type for a type split (D90). The cover is the first valid cover of the first
+ * domain in the line with a valid cover. With `own`, only the domain of the type itself counts. Each other type gives
+ * `undefined`.
+ */
+function coverOf(name: string, domains: Readonly<Record<string, Domain>> | undefined, own: boolean): readonly string[] | undefined {
+  for (const each of own ? [name] : lineOf(name, domains)) {
+    const covers: unknown = domainOf(each, domains)?.covers;
+    if (!Array.isArray(covers)) continue;
+    for (const cover of covers as readonly unknown[]) if (validCover(each, cover, domains)) return cover;
+  }
+  return undefined;
+}
+
+/**
+ * This function gives the splits of a case of a type split, at the path of the case (D90). A case with a finite list
+ * splits by its members. A base type splits by a cover of its own domain, because the covers of its parents hold it
+ * already. A union splits by its members, and a record splits by the paths into its fields.
+ */
+function againOf(type: ValueType, path: readonly string[], domains: Readonly<Record<string, Domain>> | undefined, depth: number): readonly Split[] {
+  const at = depth + path.length;
+  const values = valuesOf(type, domains, at);
+  if (values !== undefined) return values.length > 1 ? [{ path, values, optional: false }] : [];
+  const form = formOf(type, domains);
+  if (form.t === "record") return splitsOf(form, domains, at, path);
+  if (form.t === "union") return [{ path, types: form.members, optional: false }];
+  const cover = form.t === "base" ? coverOf(form.name, domains, true) : undefined;
+  return cover === undefined ? [] : [{ path, types: cover, optional: false }];
+}
+
+/**
+ * This function gives a copy of a record type with one field narrowed at a path. A case type replaces the field. The
+ * absent case removes the field of a closed record, and it gives an optional field of type `never` in an open record.
+ */
+function narrowAt(type: unknown, path: readonly string[], at: number, narrowed: ValueType | undefined, domains: Readonly<Record<string, Domain>> | undefined): ValueType {
+  const form = formOf(type, domains);
+  const key = path[at];
+  if (form.t !== "record" || key === undefined) return type as ValueType;
+  const last = at + 1 === path.length;
+  const fields: Record<string, ValueType> = {};
+  for (const name of Object.keys(form.fields)) {
+    if (name !== key) setOwn(fields, name, form.fields[name] as ValueType);
+    else if (!last) setOwn(fields, name, narrowAt(form.fields[name], path, at + 1, narrowed, domains));
+    else if (narrowed !== undefined) setOwn(fields, name, narrowed);
+    else if (!form.closed) setOwn(fields, name, "never");
+  }
+  // A case at the field makes it needed. The absent case of an open record keeps it optional.
+  const optional = [...form.optional].filter((name) => !last || name !== key || (narrowed === undefined && !form.closed));
+  return { record: fields, ...(optional.length === 0 ? {} : { optional }), ...(form.closed ? { closed: true } : {}) };
+}
+
+/**
+ * This function is the split rule of `fits` (TYPE.FITS-FINITE, D84, TYPE.FITS-PATH, D89). A record type fits when each
+ * record of its split fits. A split takes the first field in the order of `splitsOf`. Each member of the field gives a
+ * record with the field narrowed to that member. An optional field also gives a record without the field. A type split
+ * narrows the field to each case type instead (TYPE.FITS-SPLIT-TYPE, D90).
+ *
+ * A record of the split that does not fit splits the next such field. A record of a type split first splits its case
+ * again, at the same path. One budget of 64 records serves the outer split and each split inside its work, at each
+ * depth. Thus nested splits do not multiply the work.
+ */
+function splitFits(
+  found: unknown,
+  a: Extract<Form, { readonly t: "record" }>,
+  expected: unknown,
+  domains: Readonly<Record<string, Domain>> | undefined,
+  depth: number,
+  gradual: boolean,
+  budget: SplitBudget | undefined,
+): boolean {
+  const splits = splitsOf(a, domains, depth);
+  if (splits.length === 0) return false;
+  return casesFit(found as ValueType, a.closed, splits, 0, expected, domains, depth, gradual, budget ?? { left: MAX_SPLIT_RECORDS });
+}
+
+/** This function tells if each record of the split of one field fits `expected`. It splits the next field for a record that does not fit. */
+function casesFit(
+  type: ValueType,
+  closed: boolean,
+  splits: readonly Split[],
+  index: number,
+  expected: unknown,
+  domains: Readonly<Record<string, Domain>> | undefined,
+  depth: number,
+  gradual: boolean,
+  budget: SplitBudget,
+): boolean {
+  const split = splits[index];
+  if (split === undefined) return false;
+  const types: readonly ValueType[] = split.values?.map((value) => ({ one: [value as Json] })) ?? split.types ?? [];
+  const cases: ValueType[] = types.map((each) => narrowAt(type, split.path, 0, each, domains));
+  if (split.optional) cases.push(narrowAt(type, split.path, 0, undefined, domains));
+  for (const [at, record] of cases.entries()) {
+    budget.left -= 1;
+    if (budget.left < 0) return false;
+    // The rules of the shapes first, then the finite rule for a closed record, then the split of the next field.
+    if (fitsAt(record, expected, domains, depth, gradual, false, budget)) continue;
+    const values = closed ? valuesOf(record, domains, depth + 1) : undefined;
+    if (values !== undefined) {
+      if (values.every((value) => memberAt(value, expected, domains, depth + 1))) continue;
+      return false;
+    }
+    // A case of a type split splits again at its path, before the next split (D90).
+    const again = split.types !== undefined && at < split.types.length ? againOf(split.types[at] as ValueType, split.path, domains, depth) : [];
+    const rest = again.length === 0 ? splits : [...again, ...splits.slice(index + 1)];
+    if (!casesFit(record, closed, rest, again.length === 0 ? index + 1 : 0, expected, domains, depth, gradual, budget)) return false;
+  }
+  return true;
 }
 
 /**
@@ -325,9 +728,33 @@ function fitsAt(found: unknown, expected: unknown, domains: Readonly<Record<stri
  *   field is `unknown`.
  * - A function fits when it has the same or fewer parameters, each expected parameter fits its parameter, and its
  *   result fits.
+ * - The finite rule comes after these rules (TYPE.FITS-FINITE). A type with at most 64 members fits when each member
+ *   is a member of `expected`. Thus `bool` fits `{ "one": [true, false] }`.
+ * - A base type has few members when its domain or a parent declares `values`, as `null`, `undefined` and `bool` do.
+ *   A union, a `one`, a closed record of such types and a list of `never` also have few members.
+ * - The cover rule comes next (TYPE.FITS-COVER, D85). A base type fits a union or a `one` when each domain of a cover
+ *   fits. The cover is in `covers` of a domain of its line. Each domain of a cover is under the covered
+ *   domain. Thus a cover of `number` by `neg` and `nonneg` gives `number` a fit against `neg | nonneg`.
+ * - The split rule comes last (D84). An open record, or a closed record with more than 64 members, splits a field with
+ *   few members over a union. A closed record also splits over a `one`. Each record of the split narrows the field to
+ *   one member, and each record must fit.
+ *   Thus `{ "record": { "a": "bool" } }` fits a union of a record for each value of `a`.
+ * - A split also narrows a field of a record in a field, by its path (TYPE.FITS-PATH, D89). The fields of the record
+ *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
+ *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
+ * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
+ *   its line splits into the domains of the first such cover. A field of a union without a finite list splits into its
+ *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only a
+ *   cover of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ *
+ * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
+ * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
+ * or a false cover makes the relation unsound for that domain.
  *
- * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types. It is not
- * complete. For example, `bool` does not fit `{ "one": [true, false] }`. The function does not throw.
+ * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. A
+ * type split uses one cover of a field, not each cover of its line. A domain without `values` gets no finite rule, and
+ * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
+ * covers. The function does not throw.
  *
  * @param found - The type that a part has.
  * @param expected - The type that the position needs.