@mark1russell7/coeval 0.17.0 → 0.19.0

package/build/index.d.ts

@@ -1,4 +1,3 @@
-//#region src/doc.d.ts
 /** A JSON value. A document is JSON. */
 type Json = null | boolean | number | string | readonly Json[] | {
   readonly [key: string]: Json;
@@ -159,8 +158,6 @@ export declare function fromJson(value: unknown): Envelope | undefined;
  * @returns `true` when the values are equal.
  */
 export declare function docEquals(a: unknown, b: unknown): boolean;
-//#endregion
-//#region src/errors.d.ts
 /** The codes that the kernel gives. */
 type KernelCode = "#KIND?" | "#NOEVAL" | "#PART?" | "#NAME?" | "#REF!" | "#N/A" | "#CYCLE!" | "#STEP?" | "#VALUE!" | "#NUM!" | "#ARGS" | "#CAP!" | "#CALC!" | "#DEPTH!" | "#ABORT" | "#REPLAY!" | "#TYPE!";
 /** The code of an error value. A language can add its own codes. Each code starts with `#`. */
@@ -254,8 +251,6 @@ export declare function thrown(error: unknown, who: string): Failed;
  * @returns The text.
  */
 export declare function describe(value: unknown): string;
-//#endregion
-//#region src/deref.d.ts
 /**
  * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
  * global symbol, thus two copies of the kernel in one program know the things of each other.
@@ -537,8 +532,6 @@ export declare function resolve(nav: Navigator, ctx: Context, path: readonly unk
  * @returns The value.
  */
 export declare function valueOfThing(thing: Thing): unknown;
-//#endregion
-//#region src/types.d.ts
 /**
  * A value type: a set of values that a result can have, as a JSON term.
  *
@@ -605,6 +598,12 @@ interface Domain {
    * domain does not count. The check reads a list of at most 64 values.
    */
   readonly values?: readonly unknown[];
+  /**
+   * Some members of the domain for the tests of `conforms`, for example `0` and `-1` of `number` (D99). The checks
+   * `truth` and `cover` add the samples of each domain to the palette. A sample that fails a test of a type does not
+   * count. The list is not a full list of the members, thus `fits` does not read it.
+   */
+  readonly samples?: 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
@@ -612,7 +611,7 @@ interface Domain {
    *
    * 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.
+   * names this domain or a name that is not under it, does not count. `conforms` tests each cover from samples (D94).
    */
   readonly covers?: readonly (readonly string[])[];
 }
@@ -694,16 +693,18 @@ export declare function member(value: unknown, type: ValueType, domains?: Readon
  *   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`.
+ *   its line splits into the domains of a 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 the
+ *   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ * - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+ *   is the order of the line, then the order of the covers of each domain.
  *
  * 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 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
+ * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
+ * failed tries of covers take from these 64 records too. 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.
  *
@@ -760,8 +761,6 @@ export declare function typeText(type: ValueType): string;
  * @returns The problems. A term comes before its parts, and the parts keep their order.
  */
 export declare function typeIssues(type: unknown, domains?: Readonly<Record<string, Domain>>): readonly TypeIssue[];
-//#endregion
-//#region src/world.d.ts
 /** The two sides of evaluation. `derive` is pure. `run` causes effects in order. */
 type Side = "derive" | "run";
 /**
@@ -1125,8 +1124,6 @@ export declare function kindDocument(name: string, kind: Kind): Envelope;
  * @returns `true` when the value has verbs.
  */
 export declare function looksLikeKind(value: unknown): boolean;
-//#endregion
-//#region src/ladder.d.ts
 /** The rungs of the ladder, in the order that a question visits them. */
 export declare const RUNGS: readonly ["own", "kind", "default"];
 /** One rung of the ladder. */
@@ -1209,8 +1206,6 @@ export declare function kindNamed(world: World, name: TypeRef): Kind | undefined
  * @returns The answer, with the record of each rung that the question visited.
  */
 export declare function ask(world: World, doc: Header, verb: string, options?: AskOptions): Answer;
-//#endregion
-//#region src/static.d.ts
 /** One document that a walk visits. */
 interface DocVisit {
   /** The keys from the root document to this document, through the parts. It is the place of an error. */
@@ -1435,34 +1430,63 @@ export declare function typeCheck(machine: Machine, doc: unknown, options?: Chec
 /**
  * A problem of a world that `checkWorld` finds before a document exists (STATIC.COVERAGE). Each document of the
  * kind gives this problem for the verb, thus `check` with the verb finds it too.
+ *
+ * With the option `types`, a problem can also be a bad value type of the machine (TYPE.WORLD, D110). Such a problem has
+ * the code `#TYPE!` and the keys of the bad term in `at`.
  */
 interface WorldIssue {
-  /** The code of the problem. `#NOEVAL`: no rung of the ladder gives an evaluator for the verb. */
-  readonly code: "#NOEVAL";
-  /** The keys of the kind from the root of the world. For a fallback kind, the keys of its namespace. */
+  /**
+   * The code of the problem. `#NOEVAL`: no rung of the ladder gives an evaluator for the verb. `#TYPE!`: a value type
+   * of the machine is not correct, or a declaration of types cannot be true.
+   */
+  readonly code: "#NOEVAL" | "#TYPE!";
+  /**
+   * The keys of the kind from the root of the world. For a fallback kind, the keys of its namespace. For a type of a
+   * domain or of a type rule, the list is empty.
+   */
   readonly kind: readonly Key[];
   /** `true` for the fallback kind of a namespace or of the world. */
   readonly fallback?: true;
-  /** The verb without an evaluator. */
+  /** The verb without an evaluator. A type issue has the verb `eval`, because the value types describe `eval` (D25). */
   readonly verb: string;
+  /** For a type issue of a domain: the name of the domain in `Machine.domains`. */
+  readonly domain?: string;
+  /** For a type issue of a type rule: the name of its evaluator in `Machine.evaluators`. */
+  readonly evaluator?: string;
+  /**
+   * For a type issue: the keys of the bad term in the kind, the domain or the declarations of the rule. An example is
+   * `["parts", "item", "expect"]`, or `["sigs", "add", 1, "params", 0]`.
+   */
+  readonly at?: readonly Key[];
   readonly reason: string;
 }
+/** The options of `checkWorld`. */
+interface WorldOptions {
+  /**
+   * With `true`, the check also examines each value type of the machine (TYPE.WORLD, D110). It reads the contracts of
+   * the kinds, the domains and the declarations of the type rules. The default is `false`.
+   */
+  readonly types?: boolean;
+}
 /**
  * This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
  * verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
  * evaluator for the verb, thus the check gives the same proof of coverage as a type system.
  *
  * The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
- * world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+ * world. It does not follow an alias, because the kind of an alias has its own place. Without the option `types`, the
+ * check reads only the world.
+ *
+ * With the option `types`, the check also examines each value type of the machine (TYPE.WORLD, D110). These issues
+ * have the code `#TYPE!`, and they come after the issues of the verbs.
  *
  * @param machine - The machine, for its world.
  * @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+ * @param options - The option `types`.
  * @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
  *   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
  */
-export declare function checkWorld(machine: Machine, verbs: readonly string[]): readonly WorldIssue[];
-//#endregion
-//#region src/typing.d.ts
+export declare function checkWorld(machine: Machine, verbs: readonly string[], options?: WorldOptions): readonly WorldIssue[];
 /** What a type rule gets for one document. */
 interface TypeInput {
   /** The keys of the kind of the document, after each alias. */
@@ -1582,7 +1606,32 @@ interface TypeRule {
    * @returns The type of the document.
    */
   readonly synth: (input: TypeInput, report: (problem: TypeProblem) => void) => ValueType;
+  /**
+   * This function lists the declarations that the rule reads, for example the signatures of a formula profile
+   * (TYPE.WORLD, D110). `checkWorld` with the option `types` examines each one before a document exists. A rule
+   * without this function declares nothing.
+   *
+   * @returns The value types that the rule reads, and the problems that the rule finds in its declarations.
+   */
+  readonly declared?: () => readonly Declared[];
 }
+/**
+ * One declaration of a type rule (TYPE.WORLD, D110). It is a value type that the rule reads, with what it is. Or it is
+ * a problem that the rule finds in a declaration, for example an overload that the check does not select at any time.
+ */
+type Declared = {
+  /** The keys of the declaration in the declarations of the rule, for example `["sigs", "add", "to"]`. */
+  readonly at: readonly Key[];
+  /** The value type. `checkWorld` examines it with `typeIssues`. */
+  readonly type: unknown;
+  /** What the type is, for the reason of an issue, for example "result of a signature of ops.add". */
+  readonly what: string;
+} | {
+  /** The keys of the declaration in the declarations of the rule. */
+  readonly at: readonly Key[];
+  /** The reason of the problem. */
+  readonly problem: string;
+};
 /** The type of one document of a check of types. */
 interface Typed {
   /** The keys from the root document to the document. */
@@ -1594,8 +1643,6 @@ interface Typed {
   /** The type that the position of the document needs, when it needs one. */
   readonly expected?: ValueType;
 }
-//#endregion
-//#region src/facts.d.ts
 /**
  * One read of a document: a free reference, with its marks (FACTS.READS). A plan resolves the path of the reference
  * when it evaluates the reference. The static read covers each path that the plan resolves there (FACTS.SOUND). A
@@ -1632,9 +1679,12 @@ interface DocFacts {
    * here. The roots that a kind declares in `reads` are here too, each one at the place of its document.
    */
   readonly reads: readonly StaticRead[];
-  /** `"run"` when one kind of the document is on the run side (FACTS.SIDE). */
+  /** `"run"` when one kind of the document is on the run side for the verb of the facts (FACTS.SIDE, FACTS.VERB-SIDE). */
   readonly side: Side;
-  /** The kinds of the effects that the contracts declare, as texts with dots, each one time (FACTS.EFFECTS). */
+  /**
+   * The kinds of the effects that the contracts declare for the verb of the facts, as texts with dots, each one time
+   * (FACTS.EFFECTS, FACTS.VERB-EFFECTS).
+   */
   readonly effects: readonly string[];
   /**
    * `true` when each kind of the document declares `pure`, and the document has no effect and is not volatile. Then
@@ -1651,8 +1701,10 @@ interface FactsOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
   /**
-   * The verb whose evaluators the facts describe, as in `prepare`. The default is `eval`. The contract of a kind
-   * describes the code of `eval` only. For another verb, only the hook `facts` describes the code (FACTS.VERB).
+   * The verb whose evaluators the facts describe, as in `prepare`. The default is `eval`. The marks `pure`,
+   * `volatile` and `lazy` of a contract describe the code of `eval` only. For another verb, only the hook `facts`
+   * describes the code (FACTS.VERB). The side and the effects come from the entry of the verb in `verbEffects`
+   * (FACTS.VERB-EFFECTS, D111).
    */
   readonly verb?: string;
   /**
@@ -1673,7 +1725,7 @@ interface FactsOptions {
  *   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
  *   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
  *   of a rung is not one of them, because it is not free (READS.EQUATION).
- * - `side` and `effects`: from the contract of each kind.
+ * - `side` and `effects`: from the contract of each kind, for the verb of the facts.
  * - `pure`: each kind declares `pure`, also in an equation, and the document has no effect and is not volatile.
  * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
  *
@@ -1682,9 +1734,11 @@ interface FactsOptions {
  * entry. Thus a document with an own entry for another evaluator is not pure, and each of its parts is lazy. The
  * hook can still answer for that evaluator.
  *
- * The option `verb` names the verb whose code the facts describe (FACTS.VERB). A contract describes the code of
- * `eval`, thus the rule of an own entry applies to each document for another verb. The side and the effects come
- * from the contracts for each verb.
+ * The option `verb` names the verb whose code the facts describe (FACTS.VERB). The marks of a contract describe the
+ * code of `eval`, thus the rule of an own entry applies to each document for another verb. For another verb, the
+ * effects are the effects that the entry of the verb in `verbEffects` declares (FACTS.VERB-EFFECTS, D111). A kind is
+ * on the run side for that verb when its entry declares an effect (FACTS.VERB-SIDE). A kind without an entry for the
+ * verb adds no effect, as in `check` (FACTS.VERB-UNDECLARED). Its code is still not pure without an answer of the hook.
  *
  * A read is one resolution of its path. A reference that the resolution reaches and follows is a part of that read
  * (DEREF.COLLAPSE), not a separate read. The facts depend only on the document and the machine. Thus a host computes
@@ -1696,8 +1750,6 @@ interface FactsOptions {
  * @returns The facts.
  */
 export declare function factsOf(machine: Machine, doc: unknown, options?: FactsOptions): DocFacts;
-//#endregion
-//#region src/evaluate.d.ts
 /**
  * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
  * the world.
@@ -2391,8 +2443,6 @@ export declare function flatten(trace: TraceNode): readonly TraceNode[];
  * @returns The errors, in the order of their start.
  */
 export declare function failures(trace: TraceNode): readonly EvalError[];
-//#endregion
-//#region src/merge.d.ts
 /** The keys from a part of a merge to one of its entries, for example `["kinds", "ref"]`. */
 type MergePath = readonly Key[];
 /**
@@ -2447,8 +2497,8 @@ interface DomainExtension {
 /**
  * This function makes a part of a merge that adds parents, steps or covers 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, summary, codec and list of values, and it names `["domains", name]`
- * in `replaces` (D17).
+ * (`prev`). It gives a copy with the same test, summary, codec, list of values and samples, and it names
+ * `["domains", name]` in `replaces` (D17).
  * A domain of the kernel that the earlier parts do not name comes from `STD_DOMAINS`.
  *
  * An extension does not change the codec. Thus each member keeps its document (D80).
@@ -2531,8 +2581,6 @@ export declare function restrictWorld(world: World, paths: readonly MergePath[])
  * @returns The machine without the entries.
  */
 export declare function restrictMachine(machine: Machine, paths: readonly MergePath[]): Machine;
-//#endregion
-//#region src/classify.d.ts
 /** A shape proposes a kind for each document that has all of its fields. */
 interface Shape$1 {
   readonly name: string;
@@ -2567,8 +2615,6 @@ export declare function classify(shapes: readonly Shape$1[], value: Json): Class
  * @returns The envelope.
  */
 export declare function tag(value: Json, kind: string): Envelope;
-//#endregion
-//#region src/parts.d.ts
 /** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
 interface PartSlot {
   /** The keys from the value of the document to the part. */
@@ -2655,8 +2701,6 @@ export declare function partsOf(world: World, value: unknown, declaredType?: str
  * @returns `true` when the path matches.
  */
 export declare function pathMatches(path: readonly Key[], pattern: readonly Key[]): boolean;
-//#endregion
-//#region src/syntax.d.ts
 /** The place of an operator: before its term, between two terms, or after its term. */
 type SyntaxFixity = "prefix" | "infix" | "postfix";
 /**
@@ -2851,8 +2895,6 @@ export declare function print(profile: SyntaxProfile, doc: unknown): Result<stri
  * @returns The part for `mergeMachines`.
  */
 export declare function syntaxFormat(profile: SyntaxProfile): MachinePart;
-//#endregion
-//#region src/stdlib.d.ts
 /**
  * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
  * Each kind names an evaluator for `eval` and a view for `view`. The site draws each document with its view.
@@ -2886,6 +2928,50 @@ interface AttributeTrace {
   /** The rung that answered. It is `undefined` when no rung answered. */
   readonly by?: AttributeRung;
 }
+/** The answer of the ladder for one attribute of one node (TREE.CELL, D108). */
+interface AttributeAnswer {
+  /** The result of the attribute. It is `undefined` when no rung answered. */
+  readonly result: Result | undefined;
+  /** The rung that answered. It is `undefined` when no rung answered. */
+  readonly by: AttributeRung | undefined;
+}
+/**
+ * This function gives the memo cell of one attribute of one node, for a host that keeps its cells between evaluations
+ * (TREE.CELL, D108). The kit uses it at each demand of an attribute in an evaluation.
+ *
+ * The array `place` is one object for each document of a plan, and it stays the same across the evaluations of that
+ * plan. A new plan gives new arrays. Thus a host keeps its cells by the identity of `place` and by `attribute`.
+ * A host that keeps its cells by the keys of `place` can give a stale answer after a change of the document.
+ *
+ * The function gives the answer of `compute`, or a kept answer. A host with signals gives a computed signal: a change
+ * of its store then makes only the attributes that read the store compute again. Each demand gives a new `compute`, and
+ * a cell that computes again uses the last one.
+ *
+ * The kit marks an attribute in evaluation before it uses the cell. Thus a cycle gives `#CYCLE!` before it reaches the
+ * cell again. An exception of the function that `compute` did not throw gives `#CYCLE!` with the chain of the demands.
+ *
+ * @param place - The keys from the root document to the document of the node.
+ * @param attribute - The name of the attribute.
+ * @param compute - The function that visits the rungs of the ladder.
+ * @returns The answer.
+ */
+type AttributeCell = (place: readonly Key[], attribute: string, compute: () => AttributeAnswer) => AttributeAnswer;
+/** The options of the tree kit (D108). */
+interface TreeOptions {
+  /**
+   * The memo cells of the host (TREE.CELL). The default is a plain memo for each node and attribute, for one
+   * evaluation (TREE.MEMO).
+   */
+  readonly cell?: AttributeCell;
+}
+/**
+ * This function gives the code of the kind of a node of the decorated tree, with the options of the host. A host puts
+ * the code at the name `tree.node` of its machine. Without a cell, the code is the standard code.
+ *
+ * @param options - The options, for example the memo cells of the host.
+ * @returns The code.
+ */
+export declare function treeNodeEvaluator(options?: TreeOptions): Evaluator;
 /**
  * This function gives the record of the demand of an attribute of a node of the decorated tree (TREE.RUNGS). The
  * record holds the rungs that the demand visited, and the rung that answered. An explorer draws the ladder with it.
@@ -2942,8 +3028,6 @@ export declare const STD_RUNNERS: Readonly<Record<string, Runner>>;
 export declare const STD_MACHINE: Machine;
 /** The capabilities of the examples at the root: the two effects of the standard world. */
 export declare const STD_CAPS: readonly string[];
-//#endregion
-//#region src/order.d.ts
 /** One step of a sequence: its name, the names of the earlier steps that it reads, and if it has an effect. */
 interface StepSpec {
   readonly id: string;
@@ -2998,8 +3082,6 @@ export declare function isAllowedOrder(steps: readonly StepSpec[], order: readon
  * @returns The layers, first to last. Each layer keeps the written order.
  */
 export declare function layers(steps: readonly StepSpec[]): readonly (readonly string[])[];
-//#endregion
-//#region src/context.d.ts
 /** The parts of a context. A term can reach outside itself only through these parts. */
 export declare const PARTS: readonly ["self", "names", "world", "event", "caps"];
 /** One part of a context. */
@@ -3043,8 +3125,6 @@ interface Construct {
 }
 /** Six constructs that show the range of the context. */
 export declare const CONSTRUCTS: readonly Construct[];
-//#endregion
-//#region src/effects.d.ts
 /** The options of `effectsOf`. */
 interface EffectsOptions {
   /** The type of a bare root value. */
@@ -3090,8 +3170,6 @@ export declare function effectsOf(machine: Machine, doc: unknown, options?: Effe
  * @returns The issues, in the order of the body.
  */
 export declare function checkLatent(machine: Machine, declared: readonly Cap[], body: unknown, options?: Omit<EffectsOptions, "caps">): readonly Issue[];
-//#endregion
-//#region src/formula.d.ts
 /** An operation of a formula language: a function of the values of its arguments. */
 type OpFn = (...args: never[]) => unknown;
 /**
@@ -3111,6 +3189,8 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  * - `lazy`: the operations that evaluate their arguments themselves.
  * - `ext`: the extensions of the namespace `ext`, by their name. The kit has `ext.undefined`, `ext.number` and
  *   `ext.domain`.
+ * - `extTypes`: the value type of each extension of `ext`, by its name, for a check of types (TYPE.EXT, D103). An
+ *   extension without an entry gives `unknown` (TYPE.GRADUAL). An entry for a standard extension has no effect.
  * - `truthy`: the truth of a value for `if`, `and` and `or`. `undefined` is an error `#VALUE!`. The default
  *   accepts only `true` and `false`.
  * - `truthType`: the value type of a truth for the own `truthy`, for a check of types (TYPE.TRUTH, D81). A test of
@@ -3134,12 +3214,13 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  *
  * A check of types trusts the signatures. Each operation must give a member of the result of each signature that
  * its arguments match. The hook `check` must keep each result in that type. The function `truthy` must give a truth
- * for each member of `truthType`.
+ * for each member of `truthType`. Each extension must give a member of its type in `extTypes`.
  */
 interface FormulaProfile {
   readonly ops?: Readonly<Record<string, OpFn>> | ((name: string) => OpFn | undefined);
   readonly lazy?: Readonly<Record<string, LazyOp>>;
   readonly ext?: Readonly<Record<string, ExtFn>>;
+  readonly extTypes?: Readonly<Record<string, ValueType>>;
   readonly truthy?: (value: unknown) => boolean | undefined;
   readonly truthType?: ValueType;
   readonly otherwise?: unknown;
@@ -3261,8 +3342,6 @@ export declare function formulaFacts(profile?: FormulaProfile): (path: readonly
  * @throws {MergeError} The language and the kit have a conflict.
  */
 export declare function formulaMachine(profile?: FormulaProfile, more?: MachinePart): Machine;
-//#endregion
-//#region src/codec.d.ts
 /** The domains of a machine, by their names. */
 type Domains = Readonly<Record<string, Domain>> | undefined;
 /**
@@ -3281,7 +3360,8 @@ export declare function decodeDomain(data: Json, domains: Domains): Result;
  *
  * - A value that JSON writes exactly stays as it is. A literal with the shape of an envelope goes into `lit`.
  * - `NaN`, an infinity and `-0` become `ext.number`, and `undefined` becomes `ext.undefined`.
- * - A member of a domain with a codec becomes `ext.domain`. The domains go in the order of their names.
+ * - A member of a domain with a codec becomes `ext.domain`. The codec of a domain under another domain comes first
+ *   (EXT.SPECIFIC, D109). The order of the names decides between unrelated domains.
  * - A list or a plain record with such a value becomes the construct `list` or `record`.
  *
  * @param machine - The machine, or only its domains.
@@ -3299,8 +3379,6 @@ export declare function encodeValue(machine: Pick<Machine, "domains">, value: un
  * @returns The value, or the error of the evaluation.
  */
 export declare function decodeValue(machine: Machine, doc: unknown): Result;
-//#endregion
-//#region src/reference.d.ts
 /**
  * The definitional code of the reference, by evaluator name. The reference cannot read compiled code, thus each
  * compiled evaluator or runner of a machine needs a definition here. A function evaluator needs none.
@@ -3386,8 +3464,6 @@ export declare const STD_DEFINITIONS: Definitions;
  * @returns The definitions, by evaluator name.
  */
 export declare function formulaDefinitions(profile?: FormulaProfile): Definitions;
-//#endregion
-//#region src/agree.d.ts
 /**
  * A tier that `agree` compares with the plan.
  *
@@ -3546,8 +3622,6 @@ interface AgreeRunOptions extends Omit<AgreeOptions, "other" | "perform"> {
  * @returns The result of the plan, or the first tier that disagrees and the reason.
  */
 export declare function agreeRun(machine: Machine, doc: unknown, context?: Context, options?: AgreeRunOptions): Promise<Agreement>;
-//#endregion
-//#region src/conform.d.ts
 /**
  * An obligation that `conforms` checks. `C1` to `C8` are the obligations of host code in `docs/SEMANTICS.md`. `local`
  * and `agree` are two premises of the simulation of the plan (SIM-PLAN).
@@ -3564,8 +3638,10 @@ export declare function agreeRun(machine: Machine, doc: unknown, context?: Conte
  * - `agree`: compiled code gives the result of its definition for the reference interpreter.
  * - `truth`: the own `truthy` of a formula profile gives `true` or `false` for each member of its `truthType` (D86).
  *   Only `formula.if`, `formula.and` and `formula.or` of the formula kit get this check.
+ * - `cover`: each sample of a covered domain of the machine is in one domain of each cover of the domain (D94). Each
+ *   evaluator and each runner gets this check, because `fits` trusts the covers for each program.
  */
-type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth";
+type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth" | "cover";
 /** The probe of a finding: the document, the result of each probe part, the capabilities and the handler. */
 interface ConformProbe {
   /** The text of the type of the document. */
@@ -3645,7 +3721,8 @@ interface ConformOptions {
  * compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
  * means that each probe conforms.
  *
- * The check `truth` tests the declared truth of a formula profile (D86).
+ * The check `truth` tests the declared truth of a formula profile (D86). The check `cover` tests the covers of the
+ * domains of the machine from samples (D94).
  *
  * @param machine - The machine with the code and the world of the kinds.
  * @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
@@ -3655,8 +3732,6 @@ interface ConformOptions {
  * @throws {Error} The machine has no code with the name, or no kind names it and the options give no types.
  */
 export declare function conforms(machine: Machine, name: string, options?: ConformOptions): readonly Finding[];
-//#endregion
-//#region src/same.d.ts
 /**
  * This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
  * work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
@@ -3678,8 +3753,6 @@ export declare function conforms(machine: Machine, name: string, options?: Confo
  * @returns `true` when the results are the same.
  */
 export declare function sameResult(a: Result<unknown>, b: Result<unknown>, equal?: (a: unknown, b: unknown) => boolean | undefined): boolean;
-//#endregion
-//#region src/reads.d.ts
 /** The answer of `verifyReads`: the old result stays valid, or the first read that reaches another thing. */
 type ReadsCheck = {
   readonly same: true;
@@ -3691,7 +3764,38 @@ type ReadsCheck = {
   readonly read: Read;
   /** What the path of that read reaches in the new context. */
   readonly now: Result;
+  /**
+   * `true` when the read reaches the same thing by `sameResult`, but the print of that thing changed
+   * (READS.IN-PLACE). Only the option `prints` gives this mark.
+   */
+  readonly inPlace?: true;
 };
+/** The options of `printReads` (READS.IN-PLACE, D112). */
+interface PrintOptions {
+  /**
+   * The most entries in the print of one value. Each value, each field name and each mark counts as one entry. A
+   * larger value gets no print, and `verifyReads` then gives its read as changed. The default is 10000.
+   */
+  readonly limit?: number;
+  /**
+   * The stamp of the host for an object, for example the version of a host thing. A stamp other than `undefined`
+   * takes the place of the fields of that object in the print. A stamp compares with `Object.is`.
+   *
+   * @param value - An object of the value of a read.
+   * @returns The stamp, or `undefined` for the walk of the fields.
+   */
+  readonly stamp?: (value: object) => unknown;
+}
+/**
+ * The prints of a list of reads, from `printReads`. `verifyReads` takes them with the option `prints`. The prints
+ * keep their options, thus the verification walks each value with the same rules.
+ */
+interface ReadPrints {
+  /** The print of each read, at the index of the read. A read without an object in its value has no print. */
+  readonly prints: readonly (readonly unknown[] | undefined)[];
+  /** The options of the prints. */
+  readonly options: PrintOptions;
+}
 /** The options of `verifyReads`. */
 interface VerifyOptions {
   /**
@@ -3703,7 +3807,31 @@ interface VerifyOptions {
    * @returns `true` when the two things are the same, or `undefined` for the rules of `sameResult`.
    */
   readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
+  /**
+   * The prints of the reads, from `printReads` after the evaluation (READS.IN-PLACE). When the prints are given, a
+   * read that reaches the same thing also compares its print. Thus a change in place of a host value is a changed
+   * read. Without the prints, the verification does no work for them.
+   */
+  readonly prints?: ReadPrints;
 }
+/**
+ * This function gives the prints of the values of a list of reads (READS.IN-PLACE, D112). A host starts it after
+ * the evaluation, and it gives the prints to `verifyReads` with the option `prints`.
+ *
+ * - The print of a value walks its lists, its plain records and the own enumerable fields of each other object. A
+ *   date adds its time, and a map or a set adds its entries.
+ * - A read that is not free, a read that reached an error and a read with a primitive value get no print.
+ * - A cycle ends, because the walk visits each object one time.
+ * - A value with more entries than the limit gets no print. `verifyReads` then gives that read as changed.
+ *
+ * The walk does not see the state in a closure or a private field. It does not see a field with a symbol name, a
+ * field that is not enumerable or the value of a getter. A host gives a stamp for such an object, for example its version.
+ *
+ * @param reads - The reads of the evaluation, from the option `reads`.
+ * @param options - The limit and the stamp of the host.
+ * @returns The prints, for the option `prints` of `verifyReads`.
+ */
+export declare function printReads(reads: readonly Read[], options?: PrintOptions): ReadPrints;
 /**
  * This function tells if an old result stays valid in a new context (READS.VERIFY, D26). It resolves the path of
  * each free read again, in the order of the list, and it compares what the path reaches with `sameResult`. It stops at
@@ -3719,17 +3847,16 @@ interface VerifyOptions {
  *   extension of a profile can read outside `resolve`. The schedule asks `factsOf` first.
  *
  * The values of the context must not change in place, as PLAN.CACHE says for the documents. A value that changed in
- * place is the same object, thus the function cannot see the change.
+ * place is the same object, thus `sameResult` cannot see the change. The option `prints` finds such a change
+ * (READS.IN-PLACE). The prints come from `printReads` after the evaluation, and the answer then has the mark `inPlace`.
  *
  * @param target - The machine of the evaluation, or its plan.
  * @param reads - The reads of the evaluation, from the option `reads`.
  * @param context - The new context.
- * @param options - The rule of the host for two things.
+ * @param options - The rule of the host for two things, and the prints of the reads.
  * @returns `{ same: true }` when each free read reaches the same thing, or else the first changed read.
  */
 export declare function verifyReads(target: Machine | Plan, reads: readonly Read[], context: Context, options?: VerifyOptions): ReadsCheck;
-//#endregion
-//#region src/durable.d.ts
 /** The two epochs of a host (DURABLE.EPOCHS). Each epoch counts the changes of its level. */
 interface Epochs {
   /** The count of the changes of the structure: a new machine, or an edit of a document. */
@@ -3760,6 +3887,11 @@ interface DurableOptions {
   readonly volatile?: FactsOptions["volatile"];
   /** The rule of the host for two things, as in `verifyReads`. */
   readonly equal?: VerifyOptions["equal"];
+  /**
+   * The check of changes in place (READS.IN-PLACE, D112). With it, the cache keeps the prints of the reads of each
+   * pure document, and a verification compares them. `true` gives the default limit. Without it, the cache makes no prints.
+   */
+  readonly inPlace?: true | PrintOptions;
 }
 /**
  * A cache of plans, facts and results with two levels of durability (D30). A host or a schedule tells the cache each
@@ -3830,15 +3962,14 @@ interface Durable {
  *   and each result (DURABLE.STRUCTURE).
  *
  * The host keeps two promises. In one data epoch, the context of a key gives the same data. The values of a
- * context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say.
+ * context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say. The option `inPlace`
+ * finds a change in place of a value that a pure document read (READS.IN-PLACE).
  *
  * @param machine - The machine of the first structure epoch.
- * @param options - The type of a bare root value, the verb, the volatile reads and the rule of the host for two things.
+ * @param options - The type of a bare root value, the verb, the volatile reads, the rule of the host and the check of changes in place.
  * @returns The cache.
  */
 export declare function durable(machine: Machine, options?: DurableOptions): Durable;
-//#endregion
-//#region src/schedule.d.ts
 /** One edge of a graph of nodes: a static read of a node from the document of another node (SCHED.EDGES). */
 interface NodeEdge {
   /**
@@ -3993,8 +4124,6 @@ export declare function edgesOf(facts: DocFacts): readonly NodeEdge[];
  * @returns The schedule.
  */
 export declare function schedule(machine: Machine, options?: ScheduleOptions): Schedule;
-//#endregion
-//#region src/generate.d.ts
 /** A source of random numbers with a seed. The same seed gives the same numbers. */
 interface Random {
   /** This function gives a number from 0 up to 1, without 1. */
@@ -4074,8 +4203,6 @@ export declare function typesOf(world: World): readonly (readonly Key[])[];
  * @returns The document, as JSON.
  */
 export declare function generate(world: World, options: GenerateOptions): unknown;
-//#endregion
-//#region src/meaning.d.ts
 /**
  * The smallest interface of the engine of a host that `agreeSchedule` examines (SCHED.AGREES). The demand schedule of
  * `schedule` has this interface.
@@ -4256,8 +4383,6 @@ type ScheduleAgreement = {
  * @returns What the harness reached, or the first read whose answer differs from the answer from scratch.
  */
 export declare function agreeSchedule(engine: ScheduleEngineFactory, options?: AgreeScheduleOptions): ScheduleAgreement;
-//#endregion
-//#region src/graph.d.ts
 /** One edge of a graph of nodes: a read of a node by another node. `NodeEdge` of a schedule is such an edge. */
 interface GraphEdge<Id> {
   /** The node that the read reaches. It is `undefined` when the read can reach each node (GRAPH.UNKNOWN). */
@@ -4357,8 +4482,79 @@ export declare function necessary<Id>(graph: NodeGraph<Id>, observed: Iterable<I
  * @returns The cycles, deepest first.
  */
 export declare function cycles<Id>(graph: NodeGraph<Id>): readonly GraphCycle<Id>[];
-//#endregion
-//#region src/replay.d.ts
+/** One vertex of the graph of attribute instances: one attribute of one node of the decorated tree (D107). */
+interface AttributeVertex {
+  /** The name of the vertex: the JSON text of the place of the node with the name of the attribute after it. */
+  readonly id: string;
+  /** The place of the document of the node. */
+  readonly place: readonly Key[];
+  readonly attribute: string;
+  /** The text of the type of the node. */
+  readonly type: string;
+}
+/** One read of an attribute by the code of another attribute (D107). */
+interface AttributeEdge {
+  /** The vertex that the read reaches. It is `undefined` when only the run knows it: the read depends on a value. */
+  readonly from: string | undefined;
+  /** The vertex whose code makes the read. */
+  readonly to: string;
+  /** `true` when only a lazy part reaches the read, or when an earlier rung can answer first (FACTS.LAZY). */
+  readonly lazy: boolean;
+  /** The place of the reference document. A read of a rung has the place of the node. */
+  readonly place: readonly Key[];
+}
+/** One cycle of the graph of attribute instances (D107). */
+interface AttributeCycle {
+  /** The vertices of the cycle, in the order of the graph. */
+  readonly vertices: readonly string[];
+  /** `true` when the eager reads with a known source close the cycle (GRAPH.CYCLE). */
+  readonly certain: boolean;
+}
+/** The graph of attribute instances of a document (TREE.GRAPH). */
+interface AttributeGraph {
+  /** The vertices, by name, in the order of the document. */
+  readonly vertices: ReadonlyMap<string, AttributeVertex>;
+  /** The edges, in the order of the code of each vertex. */
+  readonly edges: readonly AttributeEdge[];
+  /** The graph for the analysis of `graph.ts`: each vertex with the vertices that it reads. */
+  readonly graph: NodeGraph<string>;
+  /** The edges with an unknown source. The check of the cycles is not complete for them: only the run knows them. */
+  readonly unknown: readonly AttributeEdge[];
+  /** The cycles of the graph, deepest first. */
+  readonly cycles: readonly AttributeCycle[];
+}
+/** The options of `attributeGraph`. */
+interface AttributeGraphOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+}
+/**
+ * This function gives the name of a vertex of the graph of attribute instances. The name is the JSON text of the
+ * place of the node, with the name of the attribute after it.
+ *
+ * @param place - The place of the document of the node.
+ * @param attribute - The name of the attribute.
+ * @returns The name of the vertex.
+ */
+export declare function attributeVertexId(place: readonly Key[], attribute: string): string;
+/**
+ * This function gives the graph of attribute instances of a document (TREE.GRAPH, R3 P5, D107). It has one vertex for
+ * each attribute of each node of the decorated tree. It has one edge for each read of the code of an attribute.
+ *
+ * - A path from `self` reads the attribute of the node. `self.parent` goes to the parent node.
+ * - The step `nearest` with the key `parent` depends only on the structure, thus it goes to a node of the document.
+ * - The rungs of the ladder read too: `names.prev` of `down` reads the previous sibling, and a fold reads each child.
+ * - A read that depends on the value of an attribute gets an edge with an unknown source.
+ *
+ * The walk is the walk of `check`, with its rules for the self of each document (D106). The evaluator of the kernel
+ * does not use the graph (D3).
+ *
+ * @param machine - The world and the code of the evaluators.
+ * @param doc - The document, as JSON.
+ * @param options - The type of a bare root value.
+ * @returns The vertices, the edges, the graph for the analysis, the reads that only the run knows and the cycles.
+ */
+export declare function attributeGraph(machine: Machine, doc: unknown, options?: AttributeGraphOptions): AttributeGraph;
 /** One effect of a log: its address, its request and its outcome. */
 interface ReplayEntry {
   /** The address of the effect (RUN.ADDRESS), for example `1#0` or `all0.1/1#0`. */
@@ -4471,7 +4667,8 @@ interface ReplayErrorJson {
   /**
    * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
    * (RUN.REPLAY-CAUSE-PARTS, D87). It is a list of parts, the part `record` or the part `share`. The index 0 of `loop` is its
-   * first exception, and the index 0 of `share` is its first list or record.
+   * first exception, and the index 0 of `share` is its first list or record. Since D101, a list or a record cause that
+   * holds a container at two places is also `causeParts` (RUN.REPLAY-SHARED-VALUES).
    */
   readonly causeParts?: ReplayCausePartsJson;
   /** The names of the items of `causeParts` without a form, for example `cause.send`. This list is only a note. */
@@ -4494,13 +4691,18 @@ type ReplayCausePartsJson = readonly ReplayPartsJson[] | {
 interface ReplayExceptionJson {
   readonly name: string;
   readonly message: string;
-  /** The term documents of the own fields of the exception that `encodeValue` writes, for example `code` or `errno`. */
+  /**
+   * The term documents of the own fields of the exception that `encodeValue` writes, for example `code` or `errno`. A list
+   * or a plain record that two places of the error share is in `parts` (RUN.REPLAY-SHARED-VALUES, D101).
+   */
   readonly fields?: Readonly<Record<string, Json>>;
   /**
    * The own enumerable fields without a term document that are an exception, a list or a plain record (RUN.REPLAY-FIELDS,
    * D78, D82). An example is a list `errors` on an `Error`. A list is a list of parts, and a record is the part `record`.
    * Each exception in them has the rule of a cause. A container without a form in it is a name in `dropped`. A container
    * that an earlier place holds is the part `share` (D88).
+   *
+   * Since D101, a shared container with a term document is in `parts` too, and so is each container that holds it.
    */
   readonly parts?: Readonly<Record<string, ReplayPartsJson>>;
   /**
@@ -4522,7 +4724,8 @@ interface ReplayExceptionJson {
   readonly loop?: number;
   /**
    * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
-   * (RUN.REPLAY-CAUSE-PARTS, D87). Each exception in it has the rule of a cause, also a `loop`.
+   * (RUN.REPLAY-CAUSE-PARTS, D87). Each exception in it has the rule of a cause, also a `loop`. Since D100, a list or a
+   * record without an exception is also `causeParts` when an item has a form (RUN.REPLAY-CAUSE-ITEMS).
    */
   readonly causeParts?: ReplayCausePartsJson;
 }
@@ -4568,8 +4771,12 @@ type ReplayPartsJson = ReplayPartJson | readonly ReplayPartsJson[];
  *   (RUN.REPLAY-FIELDS, D78, D82). An item of a list without a form is the mark `dropped` at its place.
  * - A cause without a term document that is a list or a plain record with an exception is in `causeParts`
  *   (RUN.REPLAY-CAUSE-PARTS, D87). The rule is the same for the cause of an exception and of an error value.
+ * - The cause of an exception is also in `causeParts` without an exception in it, when an item has a form
+ *   (RUN.REPLAY-CAUSE-ITEMS, D100). Each item without a form is a name in `dropped`, for example `cause.send`.
  * - A list or a record of parts that an earlier place of one error holds is the part `share` with its index
  *   (RUN.REPLAY-SHARED, D88). This rule also covers a container that holds itself.
+ * - A list or a plain record with a term document that two places of one error share is a container of parts
+ *   (RUN.REPLAY-SHARED-VALUES, D101). Each later place is a share. A member of a domain stays a term document.
  * - An outcome that the log does not have stays absent.
  *
  * @param machine - The machine of the run, or only its domains.
@@ -4591,8 +4798,6 @@ export declare function encodeLog(machine: Pick<Machine, "domains">, log: Replay
  * @returns The log for `replayer`, or `#VALUE!` with the place of the first field that it cannot read.
  */
 export declare function decodeLog(machine: Pick<Machine, "domains">, data: unknown): Result<ReplayLog>;
-//#endregion
-//#region src/providers.d.ts
 /** The type that a provider reads, and the problems of the reading. Each problem tells what the type does not test. */
 interface TypeReading {
   readonly type: ValueType;
@@ -4639,6 +4844,5 @@ interface SampleOptions {
  * @returns The type.
  */
 export declare function typeFromSamples(values: readonly unknown[], options?: SampleOptions): ValueType;
-//#endregion
-export type { AgreeOptions, AgreeRunOptions, AgreeScheduleOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AttributeDeclaration, AttributeRung, AttributeTrace, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, Random, Read, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayCausePartsJson, ReplayEntry, ReplayEntryJson, ReplayErrorJson, ReplayExceptionJson, ReplayLog, ReplayLogJson, ReplayOptions, ReplayPartJson, ReplayPartsJson, ReplayResultJson, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleAgreement, ScheduleAgreementCounts, ScheduleCounts, ScheduleEngine, ScheduleEngineFactory, ScheduleEngineStart, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepSpec, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxEnvelopes, SyntaxFixity, SyntaxForm, SyntaxFormArgs, SyntaxHeader, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldIssue, WorldPart };
+export type { AgreeOptions, AgreeRunOptions, AgreeScheduleOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AttributeAnswer, AttributeCell, AttributeCycle, AttributeDeclaration, AttributeEdge, AttributeGraph, AttributeGraphOptions, AttributeRung, AttributeTrace, AttributeVertex, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Declared, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, PrintOptions, Random, Read, ReadPrints, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayCausePartsJson, ReplayEntry, ReplayEntryJson, ReplayErrorJson, ReplayExceptionJson, ReplayLog, ReplayLogJson, ReplayOptions, ReplayPartJson, ReplayPartsJson, ReplayResultJson, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleAgreement, ScheduleAgreementCounts, ScheduleCounts, ScheduleEngine, ScheduleEngineFactory, ScheduleEngineStart, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepSpec, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxEnvelopes, SyntaxFixity, SyntaxForm, SyntaxFormArgs, SyntaxHeader, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TreeOptions, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldIssue, WorldOptions, WorldPart };
 //# sourceMappingURL=index.d.ts.map