@mark1russell7/coeval 0.16.0 → 0.17.0

package/build/index.d.ts

@@ -348,8 +348,31 @@ interface Context {
   readonly event: Thing;
   readonly caps: readonly Cap[];
 }
-/** The code of a `deref` evaluator: it answers one step of a path on a document of its kind. */
-type DerefCode = (doc: Envelope, key: Key) => Thing | undefined;
+/**
+ * The code of a `deref` evaluator: it answers one step of a path on a document of its kind. A field that holds
+ * `undefined` also gives `undefined`. The optional function `has` of the code tells the two cases apart
+ * (DEREF.KIND-UNDEFINED). A host gives the code a `has` with `Object.assign(code, { has })`.
+ */
+interface DerefCode {
+  /**
+   * This function answers one step on a document.
+   *
+   * @param doc - The document.
+   * @param key - The key of the step.
+   * @returns What the step reaches, or `undefined` when it reaches nothing.
+   */
+  (doc: Envelope, key: Key): Thing | undefined;
+  /**
+   * This optional function tells if a document has a field for a key. The kernel asks it only when the code gives
+   * `undefined`. Then `true` tells that the field holds `undefined`. A code without `has` reads `undefined` as a
+   * missing field, as a host thing does (DEREF.HOST-UNDEFINED).
+   *
+   * @param doc - The document.
+   * @param key - The key of the step.
+   * @returns `true` when the document has the field.
+   */
+  readonly has?: (doc: Envelope, key: Key) => boolean;
+}
 /**
  * The result of a step document: what it reached, or the reason of a failure. A failure can give its code, for
  * example `#REF!` for a position outside a space. The default code is `#N/A`.
@@ -370,13 +393,24 @@ interface WalkInput {
   readonly here: Thing;
   readonly context: Context;
   /**
-   * This function answers one step on a thing, through the ladder.
+   * This function answers one step on a thing, through the ladder. A field that holds `undefined` also gives
+   * `undefined`. The function `has` tells the two cases apart (DEREF.WALKER-UNDEFINED).
    *
    * @param thing - The thing.
    * @param key - The key.
    * @returns What the step reaches, or `undefined`.
    */
   deref(thing: Thing, key: Key): Thing | undefined;
+  /**
+   * This optional function tells if a step on a thing reaches a field, through the ladder. A walker needs it only
+   * when `deref` gives `undefined`. Then `true` tells that the field holds `undefined` (DEREF.WALKER-UNDEFINED).
+   * Each resolution of the kernel gives it. The function asks the ladder again, thus a host thing answers the step again.
+   *
+   * @param thing - The thing.
+   * @param key - The key.
+   * @returns `true` when the step reaches a field, also a field that holds `undefined`.
+   */
+  has?(thing: Thing, key: Key): boolean;
   /**
    * This optional function records one hop inside the walk (HOP.EACH-STEP). The resolution gives it only when it
    * records hops. The hop of the whole walk comes after these hops, as before.
@@ -564,6 +598,23 @@ 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[])[];
 }
 /**
  * The codec of a domain: it writes a member of the domain as JSON, and it reads the JSON again (D40). Both functions
@@ -628,9 +679,33 @@ export declare function member(value: unknown, type: ValueType, domains?: Readon
  *   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 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 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 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.
@@ -1542,9 +1617,12 @@ interface StaticRead {
   readonly address: boolean;
   /** The path of the reference: its root and its steps. */
   readonly path: readonly Json[];
-  /** The keys from the root document to the reference document, through the parts. */
+  /**
+   * The keys from the root document to the reference document, through the parts. A read of an equation has the
+   * place of the first document of its tree kind (FACTS.EQUATIONS).
+   */
   readonly place: readonly Key[];
-  /** The keys from the root JSON value to the reference document. */
+  /** The keys from the root JSON value to the reference document, or to the document of the kind for an equation. */
   readonly at: readonly Key[];
 }
 /** The static facts of one document (D24). They depend only on the document and the machine, not on a context. */
@@ -1592,9 +1670,11 @@ interface FactsOptions {
  *
  * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
  *   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
- *   declares `reads` adds a read of each of its roots at each document of the kind.
+ *   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.
- * - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
+ * - `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.
  *
  * The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
@@ -1762,9 +1842,11 @@ interface Journal {
    *
    * @param all - The address of the `all`.
    * @param waiting - The indices of the items that wait.
+   * @param before - The number of the waits of this `all` that settled before this call. The kernel gives it, thus a
+   *   replayer keeps no state of a run (RUN.REPLAY-RUNS). An older copy of the kernel does not give it.
    * @returns The index of an item that waits, or `undefined` for the order of the host.
    */
-  readonly next?: (all: string, waiting: readonly number[]) => number | undefined;
+  readonly next?: (all: string, waiting: readonly number[], before?: number) => number | undefined;
 }
 /**
  * The runtime of one evaluation or run. Compiled code gets it with the context, and asks it to resolve paths and
@@ -2350,25 +2432,34 @@ export declare class MergeError extends Error {
    */
   constructor(conflicts: readonly MergeConflict[]);
 }
-/** What `extendDomain` adds to a domain: more parents, and the types of more steps. */
+/** What `extendDomain` adds to a domain: more parents, the types of more steps, and more covers. */
 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>>;
+  /**
+   * The covers to add (TYPE.FITS-COVER, D85). A cover that the domain has already does not change. The language that
+   * adds a cover keeps it true, because `fits` trusts it.
+   */
+  readonly covers?: readonly (readonly string[])[];
 }
 /**
- * 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`.
+ * 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).
+ * 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).
  *
  * 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.
+ * true. A new parent of a domain in a cover of another domain can make that cover false (D85). 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.
+ * @param more - The parents, the steps and the covers to add.
  * @returns The part, as a function of the merge before it.
  */
 export declare function extendDomain(name: string, more: DomainExtension): (prev: Machine) => MachinePart;
@@ -2565,12 +2656,222 @@ export declare function partsOf(world: World, value: unknown, declaredType?: str
  */
 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";
+/**
+ * The grouping of a chain of one infix operator. `left` reads `a - b - c` as `(a - b) - c`, and `right` reads
+ * `a ^ b ^ c` as `a ^ (b ^ c)`. `none` refuses a chain. `flat` reads a chain as one document with each term.
+ */
+type SyntaxAssoc = "left" | "right" | "none" | "flat";
+/** One operator of a syntax profile. */
+interface SyntaxOperator {
+  /** The text of the operator, for example `+`, `<>` or `and`. A word operator is a plain name. */
+  readonly symbol: string;
+  /** The place of the operator. */
+  readonly fixity: SyntaxFixity;
+  /** The precedence. A larger number binds more tightly. */
+  readonly prec: number;
+  /** The grouping of a chain of an infix operator. The default is `left`. */
+  readonly assoc?: SyntaxAssoc;
+  /** The type of the document that the operator makes, with dots between the keys, for example `ops.add` or `and`. */
+  readonly kind: string;
+}
+/** The literal rules of a syntax profile. */
+interface SyntaxLiterals {
+  /** `false` removes the decimal numbers. The default is `true`. */
+  readonly numbers?: boolean;
+  /** `true` puts a minus sign right before a digit into the number, where a term starts. The default is `true`. */
+  readonly signed?: boolean;
+  /** The texts: the quote and the escape of a quote. `false` removes the texts. The default is `"` with backslashes. */
+  readonly strings?: false | {
+    readonly quote?: "\"" | "'";
+    readonly escape?: "backslash" | "double";
+  };
+  /** The words that are literals, with their values. The default is `true`, `false` and `null`. */
+  readonly words?: Readonly<Record<string, unknown>>;
+  /**
+   * The kinds of the data envelopes of a text, a number and a truth value, with dots between the keys (K159, D65). A
+   * literal in a place that takes a document gets its envelope. Such a place is the whole text, the document after a
+   * header name, or an argument that its form names in `wrap`. Thus `list(1)` gives `list(number(1))`, and `print`
+   * writes the envelope as the bare literal there. Without this field, a literal stays bare in each place.
+   */
+  readonly envelopes?: SyntaxEnvelopes;
+}
+/** The kinds of the data envelopes of the literals (K159, D65). A literal without a kind stays bare, for example `null`. */
+interface SyntaxEnvelopes {
+  /** The kind of a finite number, for example `number`. */
+  readonly number?: string;
+  /** The kind of a text, for example `text`. */
+  readonly text?: string;
+  /** The kind of a truth value, for example `bool`. */
+  readonly bool?: string;
+}
+/** A reference syntax that a pattern gives, for example the address `A1` of a cell. */
+interface SyntaxRefPattern {
+  /** The pattern of the text of a reference. The parser tries it before a name. */
+  readonly pattern: RegExp;
+  /** This function gives the path of the reference from its text. */
+  readonly read: (text: string) => readonly Key[];
+  /** This function gives the text of a path, or `undefined` when the pattern does not write the path. */
+  readonly write: (path: readonly unknown[]) => string | undefined;
+}
+/** The reference syntax of a syntax profile. */
+interface SyntaxRefs {
+  /** The root of a bare name. The default is `names`. Thus `x` is the path `["names", "x"]`. */
+  readonly bare?: string;
+  /** The roots that the text names first, for example `self.price`. The default is `self`, `world`, `event` and `caps`. */
+  readonly roots?: readonly string[];
+  /** `false` removes the field steps `a.b`. The default is `true`. */
+  readonly fields?: boolean;
+  /** The patterns of other references. */
+  readonly patterns?: readonly SyntaxRefPattern[];
+}
+/** A call form: a name with arguments in parentheses that makes a construct, for example `if(test, then, else)`. */
+interface SyntaxForm {
+  /**
+   * The name in the text: a plain name, or plain names with dots between them, for example `math.product` (K161). A
+   * name with dots needs the field steps of `refs.fields`, and its first key is not a word operator.
+   */
+  readonly name: string;
+  /** The type of the document, with dots between the keys. */
+  readonly kind: string;
+  /**
+   * The fields of the value, in the order of the arguments. Without them, the value is the list of the arguments. A
+   * form `named` permits only these keys, and without them it permits each key.
+   */
+  readonly fields?: readonly string[];
+  /** The smallest number of arguments. The default is the number of the fields, or `0`. Only `list` and `fields` read it. */
+  readonly min?: number;
+  /**
+   * The way that the arguments make the value (D63). The default is `fields` with fields, or `list`.
+   *
+   * - `list`: the value is the list of the arguments, for example `list(1, 2)`.
+   * - `fields`: the arguments go into the fields, in order, for example `if(test, then, else)`.
+   * - `named`: each argument is a key and a document, and the value is a record, for example `panel(width: 300)`.
+   * - `literal`: the one argument is a literal, and the value is its data, for example `text("big")`.
+   */
+  readonly args?: SyntaxFormArgs;
+  /**
+   * The arguments that take a document (K159, D65): `true` for each argument, or the names of some fields. A literal
+   * in such an argument gets its data envelope of `literals.envelopes`. Without that field, `wrap` changes nothing. A
+   * form `literal` takes no `wrap`, and a form `list` takes only `true`.
+   */
+  readonly wrap?: boolean | readonly string[];
+}
+/** The way that the arguments of a call form make the value of its document (D63). */
+type SyntaxFormArgs = "list" | "fields" | "named" | "literal";
+/** The call syntax of a syntax profile. */
+interface SyntaxCalls {
+  /** The operations that a call `name(args)` can name. `true` permits each name. The default is `true`. */
+  readonly ops?: boolean | readonly string[];
+  /** The call forms of constructs. A form wins over an operation with the same name. */
+  readonly forms?: readonly SyntaxForm[];
+  /** The text between two arguments. The default is `,`. */
+  readonly separator?: string;
+}
+/** The text of the header of a document (K157, D62). */
+interface SyntaxHeader {
+  /**
+   * The symbol between a name and its document, for example `=` in `total = 2 + 3`. The text gives the document the
+   * header `name`. Without the symbol, a document with a name has no text. The symbol is a group of symbols, and no
+   * infix or postfix operator is the symbol or the start of it.
+   */
+  readonly bind?: string;
+}
+/**
+ * The text syntax of a language (D41): an operator table, literal rules, reference syntax and call syntax. `parse`
+ * reads a text into a document, and `print` writes a document as text. The profile is data, thus a site, an editor
+ * and a language read the same rules.
+ */
+interface SyntaxProfile {
+  /** The operators. */
+  readonly operators?: readonly SyntaxOperator[];
+  /** The literal rules. */
+  readonly literals?: SyntaxLiterals;
+  /** The reference syntax. */
+  readonly refs?: SyntaxRefs;
+  /** The call syntax. */
+  readonly calls?: SyntaxCalls;
+  /** The text of the header of a document. */
+  readonly header?: SyntaxHeader;
+  /** The deepest nesting that `parse` accepts. The default is `256`. */
+  readonly maxDepth?: number;
+}
+/** A problem of a text: its character offset, its length and a message. */
+interface SyntaxIssue {
+  /** The 0-based character offset of the problem. */
+  readonly offset: number;
+  /** The number of characters of the problem. `0` marks a place between two characters. */
+  readonly length: number;
+  /** The message. */
+  readonly message: string;
+}
+/** The result of `parse`: a document, or the problems of the text. */
+type ParseResult = {
+  readonly ok: true;
+  readonly doc: Json;
+} | {
+  readonly ok: false;
+  readonly issues: readonly SyntaxIssue[];
+};
+/**
+ * The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
+ * `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
+ * `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs. The
+ * text `total = 2 + 3` gives the document the header name `total` (D62).
+ */
+export declare const STD_SYNTAX: SyntaxProfile;
+/**
+ * This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
+ * bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
+ *
+ * @param profile - The syntax profile.
+ * @param text - The text.
+ * @returns The document, or the issues of the text.
+ * @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
+ */
+export declare function parse(profile: SyntaxProfile, text: string): ParseResult;
+/**
+ * This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
+ * parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
+ *
+ * @param profile - The syntax profile.
+ * @param doc - The document.
+ * @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
+ * @throws {TypeError} The profile is not valid.
+ */
+export declare function print(profile: SyntaxProfile, doc: unknown): Result<string>;
+/**
+ * This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
+ * each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
+ * a kind entry of `format` still wins.
+ *
+ * @param profile - The syntax profile.
+ * @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.
  */
 export declare const STD_WORLD: World;
+/**
+ * The text syntax of the standard world (K162, D64). The syntax kit (D41) reads it, thus a host of `STD_WORLD` does
+ * not write its own profile. The operators `>`, `+` and `*` make `greater`, `add` and `multiply`. A call form makes
+ * each other kind, and `ref` uses the reference syntax of the kit.
+ *
+ * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
+ * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
+ * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
+ * does not write, for example `add(5)` (K163).
+ *
+ * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
+ * the formula kit.
+ */
+export declare const WORLD_SYNTAX: SyntaxProfile;
 /** The code of the evaluators of the standard world, by name. */
 export declare const STD_EVALUATORS: Readonly<Record<string, Evaluator>>;
 /** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
@@ -2812,6 +3113,9 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  *   `ext.domain`.
  * - `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
+ *   `if` and each term of `and` and `or` must fit it. Without it, the check accepts each type there. A profile without
+ *   `truthy` ignores it, because the default truth needs `bool`.
  * - `otherwise`: the value of an `if` without `else`. The default is `null`. A profile with this key gives its value,
  *   also `undefined`.
  * - `logic`: what `and` and `or` give: a truth value (the default), or the value that decided.
@@ -2829,13 +3133,15 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  *   overloads. An operation without a signature takes and gives `unknown` (TYPE.GRADUAL).
  *
  * 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.
+ * 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`.
  */
 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 truthy?: (value: unknown) => boolean | undefined;
+  readonly truthType?: ValueType;
   readonly otherwise?: unknown;
   readonly logic?: "boolean" | "value";
   readonly omit?: (error: EvalError) => boolean;
@@ -2994,151 +3300,6 @@ export declare function encodeValue(machine: Pick<Machine, "domains">, value: un
  */
 export declare function decodeValue(machine: Machine, doc: unknown): Result;
 //#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";
-/**
- * The grouping of a chain of one infix operator. `left` reads `a - b - c` as `(a - b) - c`, and `right` reads
- * `a ^ b ^ c` as `a ^ (b ^ c)`. `none` refuses a chain. `flat` reads a chain as one document with each term.
- */
-type SyntaxAssoc = "left" | "right" | "none" | "flat";
-/** One operator of a syntax profile. */
-interface SyntaxOperator {
-  /** The text of the operator, for example `+`, `<>` or `and`. A word operator is a plain name. */
-  readonly symbol: string;
-  /** The place of the operator. */
-  readonly fixity: SyntaxFixity;
-  /** The precedence. A larger number binds more tightly. */
-  readonly prec: number;
-  /** The grouping of a chain of an infix operator. The default is `left`. */
-  readonly assoc?: SyntaxAssoc;
-  /** The type of the document that the operator makes, with dots between the keys, for example `ops.add` or `and`. */
-  readonly kind: string;
-}
-/** The literal rules of a syntax profile. */
-interface SyntaxLiterals {
-  /** `false` removes the decimal numbers. The default is `true`. */
-  readonly numbers?: boolean;
-  /** `true` puts a minus sign right before a digit into the number, where a term starts. The default is `true`. */
-  readonly signed?: boolean;
-  /** The texts: the quote and the escape of a quote. `false` removes the texts. The default is `"` with backslashes. */
-  readonly strings?: false | {
-    readonly quote?: "\"" | "'";
-    readonly escape?: "backslash" | "double";
-  };
-  /** The words that are literals, with their values. The default is `true`, `false` and `null`. */
-  readonly words?: Readonly<Record<string, unknown>>;
-}
-/** A reference syntax that a pattern gives, for example the address `A1` of a cell. */
-interface SyntaxRefPattern {
-  /** The pattern of the text of a reference. The parser tries it before a name. */
-  readonly pattern: RegExp;
-  /** This function gives the path of the reference from its text. */
-  readonly read: (text: string) => readonly Key[];
-  /** This function gives the text of a path, or `undefined` when the pattern does not write the path. */
-  readonly write: (path: readonly unknown[]) => string | undefined;
-}
-/** The reference syntax of a syntax profile. */
-interface SyntaxRefs {
-  /** The root of a bare name. The default is `names`. Thus `x` is the path `["names", "x"]`. */
-  readonly bare?: string;
-  /** The roots that the text names first, for example `self.price`. The default is `self`, `world`, `event` and `caps`. */
-  readonly roots?: readonly string[];
-  /** `false` removes the field steps `a.b`. The default is `true`. */
-  readonly fields?: boolean;
-  /** The patterns of other references. */
-  readonly patterns?: readonly SyntaxRefPattern[];
-}
-/** A call form: a name with arguments in parentheses that makes a construct, for example `if(test, then, else)`. */
-interface SyntaxForm {
-  /** The name in the text. */
-  readonly name: string;
-  /** The type of the document, with dots between the keys. */
-  readonly kind: string;
-  /** The fields of the value, in the order of the arguments. Without them, the value is the list of the arguments. */
-  readonly fields?: readonly string[];
-  /** The smallest number of arguments. The default is the number of the fields, or `0`. */
-  readonly min?: number;
-}
-/** The call syntax of a syntax profile. */
-interface SyntaxCalls {
-  /** The operations that a call `name(args)` can name. `true` permits each name. The default is `true`. */
-  readonly ops?: boolean | readonly string[];
-  /** The call forms of constructs. A form wins over an operation with the same name. */
-  readonly forms?: readonly SyntaxForm[];
-  /** The text between two arguments. The default is `,`. */
-  readonly separator?: string;
-}
-/**
- * The text syntax of a language (D41): an operator table, literal rules, reference syntax and call syntax. `parse`
- * reads a text into a document, and `print` writes a document as text. The profile is data, thus a site, an editor
- * and a language read the same rules.
- */
-interface SyntaxProfile {
-  /** The operators. */
-  readonly operators?: readonly SyntaxOperator[];
-  /** The literal rules. */
-  readonly literals?: SyntaxLiterals;
-  /** The reference syntax. */
-  readonly refs?: SyntaxRefs;
-  /** The call syntax. */
-  readonly calls?: SyntaxCalls;
-  /** The deepest nesting that `parse` accepts. The default is `256`. */
-  readonly maxDepth?: number;
-}
-/** A problem of a text: its character offset, its length and a message. */
-interface SyntaxIssue {
-  /** The 0-based character offset of the problem. */
-  readonly offset: number;
-  /** The number of characters of the problem. `0` marks a place between two characters. */
-  readonly length: number;
-  /** The message. */
-  readonly message: string;
-}
-/** The result of `parse`: a document, or the problems of the text. */
-type ParseResult = {
-  readonly ok: true;
-  readonly doc: Json;
-} | {
-  readonly ok: false;
-  readonly issues: readonly SyntaxIssue[];
-};
-/**
- * The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
- * `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
- * `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs.
- */
-export declare const STD_SYNTAX: SyntaxProfile;
-/**
- * This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
- * bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
- *
- * @param profile - The syntax profile.
- * @param text - The text.
- * @returns The document, or the issues of the text.
- * @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
- */
-export declare function parse(profile: SyntaxProfile, text: string): ParseResult;
-/**
- * This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
- * parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
- *
- * @param profile - The syntax profile.
- * @param doc - The document.
- * @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
- * @throws {TypeError} The profile is not valid.
- */
-export declare function print(profile: SyntaxProfile, doc: unknown): Result<string>;
-/**
- * This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
- * each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
- * a kind entry of `format` still wins.
- *
- * @param profile - The syntax profile.
- * @returns The part for `mergeMachines`.
- */
-export declare function syntaxFormat(profile: SyntaxProfile): MachinePart;
-//#endregion
 //#region src/reference.d.ts
 /**
  * The definitional code of the reference, by evaluator name. The reference cannot read compiled code, thus each
@@ -3163,6 +3324,12 @@ interface ReferenceOptions {
    * each verb by the same rules (VERB.AGREE).
    */
   readonly verb?: string;
+  /**
+   * A list that gets each read of a resolution, in its order (REF.READS). A read has the shape of a read of a plan:
+   * the path, what it reached and the mark `free`. The reads of a closure and of an equation of a tree go in the
+   * same list. The reference adds no kept reads, because it has no static reads of a closure.
+   */
+  readonly reads?: Read[];
 }
 /** The options of a run of the reference: the options of an evaluation, with the host and a signal (REF.RUN). */
 interface ReferenceRunOptions extends ReferenceOptions {
@@ -3302,6 +3469,11 @@ type Agreement = {
   readonly ok: true;
   readonly result: Result;
   readonly effects: readonly Effect[];
+  /**
+   * The free reads of the plan that `agreeRun` compared with the reference run (RUN.AGREES-READS). It is absent
+   * when no read compared, for example in `agree`.
+   */
+  readonly reads?: readonly Read[];
 } | {
   readonly ok: false;
   readonly tier: Tier;
@@ -3360,6 +3532,13 @@ interface AgreeRunOptions extends Omit<AgreeOptions, "other" | "perform"> {
  * The rules of `agree` compare the results and the effects, with their addresses and outcomes. A tier must also
  * settle the waits of each `all` in the order of the plan, thus a replay keeps the order of the waits.
  *
+ * The reference run must also give the free reads of the plan, in their order (RUN.AGREES-READS). Another replay of
+ * the plan records these reads. A kept read does not compare. When the plan keeps each root, its reads are not known,
+ * and no read compares.
+ *
+ * One replayer of the log serves each tier and the replay for the reads (RUN.AGREES-ONE-REPLAYER). The replayer keeps
+ * no state of a run (RUN.REPLAY-RUNS), thus each tier replays the same log as with a replayer of its own.
+ *
  * @param machine - The world, the evaluators and the runners.
  * @param doc - The document.
  * @param context - The names and the capabilities at the root.
@@ -3383,8 +3562,10 @@ export declare function agreeRun(machine: Machine, doc: unknown, context?: Conte
  * - `C8`: compiled code gives the result of code that compiles again at the time of the evaluation.
  * - `local`: the code keeps no state from one call to the next.
  * - `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.
  */
-type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree";
+type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth";
 /** 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. */
@@ -3461,8 +3642,10 @@ interface ConformOptions {
  *
  * The checks follow the obligations C1 to C8 of `docs/SEMANTICS.md`. Two more checks follow the premises of the
  * simulation of the plan. The check `local` finds state that stays from one call to the next. The check `agree` compares
- * 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.
+ * 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).
  *
  * @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.
@@ -4218,12 +4401,21 @@ interface ReplayOptions {
    * value, because it does not wait. The default is `true`: an effect waits when it waited in the recorded run.
    */
   readonly wait?: boolean;
+  /**
+   * The rule of the host for two payloads that are not the same by `Object.is`: one of the run and one of the log.
+   * It works as the rule of `sameResult`. Its `undefined` gives the rules of `docEquals`. A log from `decodeLog` holds new copies
+   * of the members of a domain, for example of a time. The rule tells that two such copies are the same.
+   */
+  readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
 }
 /**
  * This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
  * Its log keeps each effect with its address, its kind, its payload and the outcome that the kernel gives it. The log
  * also keeps the order in which the waits of each `all` settle.
  *
+ * The recorder gives each call of its journal to the journal of the inner function, for example of a replayer. Thus a
+ * recording of a replay settles the waits in the order of the replayer, and it gives the same log (RUN.REPLAY-ORDER).
+ *
  * @param perform - The function of the host. Without it, each effect gives its payload, as in a run without a host.
  * @returns The function `perform` for the run, and the log.
  */
@@ -4233,13 +4425,172 @@ export declare function recorder(perform?: Perform): Recorder;
  * recorded error comes again with its code, its reason, its place and its cause. The waits of each `all` settle in the
  * recorded order. An effect that the log does not have at its address gives `#REPLAY!` (RUN.REPLAY-MISMATCH).
  *
- * A replayer keeps its place in the order of the waits, thus each run needs a new replayer.
+ * One replayer serves more than one run, also two runs at the same time (RUN.REPLAY-RUNS). The kernel tells the journal
+ * the number of the waits of each `all` that settled before, thus the replayer keeps no state of a run. When the
+ * recorded item of a wait does not wait in the run, that wait follows the order of the host.
  *
- * @param log - The log of a recorder.
- * @param options - `wait: false` for an evaluation.
+ * @param log - The log of a recorder, or of `decodeLog`.
+ * @param options - `wait: false` for an evaluation, and the rule of the host for payloads.
  * @returns The function `perform` for the replay.
  */
 export declare function replayer(log: ReplayLog, options?: ReplayOptions): Perform;
+/** The JSON form of a log (RUN.REPLAY-JSON). `encodeLog` writes it, and `decodeLog` reads it. */
+interface ReplayLogJson {
+  /** The version of the form. Only the version 1 exists. */
+  readonly version: 1;
+  readonly effects: readonly ReplayEntryJson[];
+  readonly settles: readonly ReplaySettle[];
+}
+/** The JSON form of one effect of a log. A value is a term document of `encodeValue` (D40). */
+interface ReplayEntryJson {
+  readonly address: string;
+  readonly kind: string;
+  /** The term document of the payload. The value `undefined` is `ext.undefined`. */
+  readonly payload: Json;
+  /** The JSON form of the outcome. It is absent when the recorded run stopped before the answer came. */
+  readonly outcome?: ReplayResultJson;
+  readonly waited: boolean;
+}
+/** The JSON form of an outcome: the term document of the value, or the JSON form of the error. */
+type ReplayResultJson = {
+  readonly ok: true;
+  readonly value: Json;
+} | {
+  readonly ok: false;
+  readonly error: ReplayErrorJson;
+};
+/** The JSON form of an error value. It has `cause`, `exception` or `causeParts` only when the error has a cause. */
+interface ReplayErrorJson {
+  readonly code: ErrorCode;
+  readonly reason: string;
+  readonly place?: readonly Key[];
+  /** The term document of the cause, when `encodeValue` writes the cause. */
+  readonly cause?: Json;
+  /** The JSON form of a cause that is an exception, when no domain with a codec holds it. */
+  readonly exception?: ReplayExceptionJson;
+  /**
+   * 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.
+   */
+  readonly causeParts?: ReplayCausePartsJson;
+  /** The names of the items of `causeParts` without a form, for example `cause.send`. This list is only a note. */
+  readonly dropped?: readonly string[];
+}
+/**
+ * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
+ * (D87). It is a list of parts, the part `record` or the part `share`, as a field in `parts` (D82, D88).
+ */
+type ReplayCausePartsJson = readonly ReplayPartsJson[] | {
+  readonly record: Readonly<Record<string, ReplayPartsJson>>;
+} | {
+  readonly share: number;
+};
+/**
+ * The JSON form of an exception (RUN.REPLAY-CAUSES, D76). The exceptions of an error and of their causes are a chain.
+ * The index 0 of the chain is the exception of the error. Each field after `message` is optional, thus a log of the
+ * version 1 without them stays correct.
+ */
+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`. */
+  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).
+   */
+  readonly parts?: Readonly<Record<string, ReplayPartsJson>>;
+  /**
+   * The names of the own fields without a form, and `cause` for a cause without a form. An item of a container has the
+   * name of the container, a dot and its key or index, for example `errors.1` or `cause.send`. This list is only a note:
+   * `decodeLog` does not give these fields back.
+   */
+  readonly dropped?: readonly string[];
+  /**
+   * The own fields of the standard classes that are not enumerable (RUN.REPLAY-HIDDEN, D77): `errors` of an
+   * `AggregateError`, `error` and `suppressed` of a `SuppressedError`. A list is a list of parts.
+   */
+  readonly hidden?: Readonly<Record<string, ReplayPartsJson>>;
+  /** The term document of the cause, when `encodeValue` writes the cause. */
+  readonly cause?: Json;
+  /** The JSON form of a cause that is an exception, when no domain with a codec holds it. */
+  readonly exception?: ReplayExceptionJson;
+  /** The index in the chain of an earlier exception that is the cause. Thus a cycle of causes stays exact. */
+  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`.
+   */
+  readonly causeParts?: ReplayCausePartsJson;
+}
+/**
+ * The JSON form of one value of a field in `parts` or `hidden` (D77, D78, D82). It is a term document, an exception, a
+ * loop, a record of parts, or a share (D88). The walk is depth
+ * first: the fields in `parts` in their order, the hidden fields, then the cause. The mark `dropped` keeps the place of
+ * an item of a list without a form, and `decodeLog` gives a hole there.
+ *
+ * The part `share` is a list or a record of parts that an earlier place of the walk holds (RUN.REPLAY-SHARED, D88). Its
+ * index counts the lists and the records of parts in the order of the walk. Thus `decodeLog` gives one object for both places.
+ */
+type ReplayPartJson = {
+  readonly value: Json;
+} | {
+  readonly exception: ReplayExceptionJson;
+} | {
+  readonly loop: number;
+} | {
+  readonly record: Readonly<Record<string, ReplayPartsJson>>;
+} | {
+  readonly share: number;
+} | {
+  readonly dropped: true;
+};
+/**
+ * The JSON form of a value in `parts`, in `hidden` or in a record of parts (D82). It is one part, or a list of them. A
+ * list in a list is a JSON list in a JSON list, thus the rule is the same at each depth.
+ */
+type ReplayPartsJson = ReplayPartJson | readonly ReplayPartsJson[];
+/**
+ * This function writes a log as JSON (RUN.REPLAY-JSON, D75). Then `JSON.stringify` gives the text of a golden file.
+ *
+ * - Each payload and each value of an outcome is a term document of `encodeValue`. Thus `NaN`, `-0` and `undefined`
+ *   stay exact, and a member of a domain with a codec is `ext.domain`.
+ * - An error keeps its code, its reason, its place and its cause. A cause that `encodeValue` cannot write and that is
+ *   an exception keeps its name and its message in the field `exception`.
+ * - An exception also keeps its own fields that `encodeValue` writes, and the chain of its causes (RUN.REPLAY-CAUSES).
+ *   The list `dropped` names each other own field. A cause that is an earlier exception of the chain is its index in `loop`.
+ * - An exception keeps the hidden fields of the standard classes in `hidden`, for example `errors` of an
+ *   `AggregateError` (RUN.REPLAY-HIDDEN, D77). Each exception in them has the rule of a cause.
+ * - An enumerable field without a term document that is an exception, a list or a plain record is in `parts`
+ *   (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.
+ * - 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.
+ * - An outcome that the log does not have stays absent.
+ *
+ * @param machine - The machine of the run, or only its domains.
+ * @param log - The log of a recorder.
+ * @returns The JSON form. `decodeLog` gives the log again.
+ * @throws {TypeError} A value has no term document, for example a closure, a host thing, a symbol, or a value that no
+ *   domain with a codec holds. The message names the effect and its address. A part of an exception is not a refusal.
+ */
+export declare function encodeLog(machine: Pick<Machine, "domains">, log: ReplayLog): ReplayLogJson;
+/**
+ * This function reads the JSON form of a log again (RUN.REPLAY-JSON). It reads each term document with the formula kit
+ * and the domains of the machine. A cause in the field `exception` becomes an exception with that name and message.
+ * The exception gets its fields and the chain of its causes again, also a cycle (RUN.REPLAY-CAUSES). A list gets a
+ * hole at the place of the mark `dropped`, thus each later item keeps its index (D78). Each share of a list or a record
+ * gives the same object (RUN.REPLAY-SHARED).
+ *
+ * @param machine - The machine of the run, or only its domains.
+ * @param data - The JSON form, for example from `JSON.parse` of a golden file.
+ * @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. */
@@ -4289,5 +4640,5 @@ interface SampleOptions {
  */
 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, ReplayEntry, ReplayLog, ReplayOptions, 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, SyntaxFixity, SyntaxForm, 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, 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 };
 //# sourceMappingURL=index.d.ts.map