@mark1russell7/coeval 0.18.0 → 0.19.0

package/package.json

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

package/src/codec.ts

@@ -1,7 +1,7 @@
 import { type Json, isEnvelope, isRecord } from "./doc.ts";
 import { type Result, describe, fail, ok } from "./errors.ts";
 import { type Machine, makeContext, prepare } from "./evaluate.ts";
-import { type Domain, type DomainCodec, domainOf, member } from "./types.ts";
+import { type Domain, type DomainCodec, domainOf, lineOf, member } from "./types.ts";
 
 /*
  * The codec of the values that JSON cannot write (K140, D40). A document holds such a value as a standard extension:
@@ -71,7 +71,7 @@ function setOwn(target: Record<string, Json>, key: string, value: Json): void {
 /** The state of one call of `encodeValue`. */
 interface Encoder {
   readonly domains: Domains;
-  /** The domains with a codec, in the order of their names. */
+  /** The domains with a codec, in the order of `codecOrder`. */
   readonly codecs: readonly (readonly [string, DomainCodec])[];
   /** The answer of `isJson` for each container that it examined. */
   readonly json: WeakMap<object, boolean>;
@@ -151,7 +151,8 @@ function encodeTerm(value: unknown, encoder: Encoder): Json {
  *
  * - 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.
@@ -161,15 +162,34 @@ function encodeTerm(value: unknown, encoder: Encoder): Json {
  */
 export function encodeValue(machine: Pick<Machine, "domains">, value: unknown): Json {
   const domains = machine.domains;
+  return encodeTerm(value, { domains, codecs: codecOrder(domains), json: new WeakMap(), open: new Set() });
+}
+
+/**
+ * This function gives the domains with a codec in the order of `encodeValue` (EXT.SPECIFIC, D109). The depth of a
+ * domain is the count of the other domains with a codec in its line. A deeper domain comes first, and the order of the
+ * names decides between domains of the same depth (EXT.TIE). Thus a domain comes before each domain with a codec above it.
+ */
+function codecOrder(domains: Domains): readonly (readonly [string, DomainCodec])[] {
   const codecs: (readonly [string, DomainCodec])[] = [];
-  if (domains !== undefined) {
-    for (const name of Object.keys(domains).sort()) {
-      const domain = domainOf(name, domains);
-      const codec = domain === undefined ? undefined : codecOf(domain);
-      if (codec !== undefined) codecs.push([name, codec]);
-    }
+  if (domains === undefined) return codecs;
+  let parents = false;
+  for (const name of Object.keys(domains).sort()) {
+    const domain = domainOf(name, domains);
+    const codec = domain === undefined ? undefined : codecOf(domain);
+    if (domain === undefined || codec === undefined) continue;
+    codecs.push([name, codec]);
+    if (Array.isArray(domain.under)) parents = true;
+  }
+  // Without a parent of a domain with a codec, each depth is zero, thus the order of the names stays.
+  if (!parents) return codecs;
+  const depth = new Map<string, number>();
+  for (const [name] of codecs) {
+    const line = lineOf(name, domains);
+    depth.set(name, codecs.filter(([other]) => other !== name && line.has(other)).length);
   }
-  return encodeTerm(value, { domains, codecs, json: new WeakMap(), open: new Set() });
+  // The sort is stable, thus the order of the names stays between domains of the same depth.
+  return codecs.sort(([a], [b]) => (depth.get(b) as number) - (depth.get(a) as number));
 }
 
 /**

package/src/durable.ts

@@ -2,7 +2,7 @@ import type { Context } from "./deref.ts";
 import type { Result } from "./errors.ts";
 import { type Machine, type Plan, type PrepareOptions, type Read, prepare } from "./evaluate.ts";
 import { type DocFacts, type FactsOptions, factsOf } from "./facts.ts";
-import { type VerifyOptions, verifyReads } from "./reads.ts";
+import { type PrintOptions, type ReadPrints, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
 
 /*
  * Two levels of durability (R4 P7, D30). The plan and the facts of a document depend only on the structure: the
@@ -42,6 +42,11 @@ export 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;
 }
 
 /**
@@ -154,10 +159,11 @@ function byDocument<T>(make: (doc: unknown) => T): (doc: unknown) => T {
  *   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 function durable(machine: Machine, options: DurableOptions = {}): Durable {
@@ -167,6 +173,9 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
   };
   const factsOptions: FactsOptions = { ...prepareOptions, ...(options.volatile === undefined ? {} : { volatile: options.volatile }) };
   const verifyOptions: VerifyOptions = options.equal === undefined ? {} : { equal: options.equal };
+  const printOptions: PrintOptions | undefined = options.inPlace === true ? {} : options.inPlace;
+  // The prints of the reads of each entry, only with the option `inPlace`. Thus an entry keeps its shape (PLAN.LEAN).
+  const printsOf = printOptions === undefined ? undefined : new WeakMap<Entry, ReadPrints>();
   const counts = { compiles: 0, facts: 0, evaluations: 0, verifications: 0, reuses: 0 };
   const results = new Map<unknown, Entry>();
   let current = machine;
@@ -205,7 +214,8 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
         }
         if (entry.reads !== undefined) {
           counts.verifications += 1;
-          if (verifyReads(plan, entry.reads, context, verifyOptions).same) {
+          const prints = printsOf?.get(entry);
+          if (verifyReads(plan, entry.reads, context, prints === undefined ? verifyOptions : { ...verifyOptions, prints }).same) {
             entry.data = epochs.data;
             counts.reuses += 1;
             return entry.result;
@@ -217,7 +227,9 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
       counts.evaluations += 1;
       const result = plan.evaluate(context, reads === undefined ? undefined : { reads });
       // A list that grows by push keeps room for more reads. A copy of a short list is smaller (PLAN.LEAN).
-      results.set(key, { plan, result, reads: reads === undefined ? undefined : reads.length === 0 ? NO_READS : reads.slice(), data: epochs.data });
+      const made: Entry = { plan, result, reads: reads === undefined ? undefined : reads.length === 0 ? NO_READS : reads.slice(), data: epochs.data };
+      results.set(key, made);
+      if (printsOf !== undefined && made.reads !== undefined) printsOf.set(made, printReads(made.reads, printOptions));
       return result;
     },
     changeData() {

package/src/facts.ts

@@ -1,5 +1,5 @@
 import { type Json, type Key, isEnvelope, isKey } from "./doc.ts";
-import { type Kind, type LazyRule, type Side, type World, equationType, lookupKind } from "./world.ts";
+import { type Kind, type KindFacts, type LazyRule, type Side, type World, equationType, lookupKind } from "./world.ts";
 import { answerOf } from "./ladder.ts";
 import { pathMatches, splitParts } from "./parts.ts";
 import { type Root, ROOTS, isRef } from "./deref.ts";
@@ -43,9 +43,12 @@ export 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
@@ -63,8 +66,10 @@ export 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;
   /**
@@ -92,7 +97,7 @@ function tight<T>(list: readonly T[]): readonly T[] {
 }
 
 /** What a document gives to its parts: its own lazy mark, and the lazy rules of its kind for the parts. */
-interface Above {
+export interface Above {
   readonly lazy: boolean;
   readonly rules: readonly LazyRule[] | typeof EACH | undefined;
   /** The position of each part among the parts that a rule `after` covers. It is made at the first need. */
@@ -136,7 +141,7 @@ function positionOf(above: Above, parent: DocVisit, rule: LazyRule, slot: readon
 }
 
 /** This function tells if the lazy rules of a document cover one of its parts. */
-function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean {
+export function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean {
   const rules = above.rules;
   if (rules === undefined) return false;
   if (rules === EACH) return true;
@@ -148,6 +153,32 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
   return false;
 }
 
+/** The code of a document for the facts: the answer of the hook, and the lazy rules that the code gives its parts. */
+export interface CodeFacts {
+  /** `true` when the contract of the kind describes the code. */
+  readonly described: boolean;
+  /** The answer of the hook `facts` of the machine for the code. */
+  readonly answer: KindFacts | undefined;
+  /** The lazy rules of the parts (FACTS.LAZY). Code that the contract and the hook do not describe makes each part lazy. */
+  readonly rules: Above["rules"];
+}
+
+/**
+ * This function gives the code of a document of a kind for the facts (FACTS.LAZY). `factsOf` and the graph of
+ * attribute instances read the lazy rules with this one function (D107).
+ *
+ * @param machine - The world and the hook `facts`.
+ * @param v - The visit of the document.
+ * @param kind - The kind of the document.
+ * @param verb - The verb whose code the facts describe.
+ * @returns The answer of the hook and the lazy rules.
+ */
+export function codeFactsOf(machine: Machine, v: DocVisit, kind: Kind, verb: string): CodeFacts {
+  const code = codeOf(machine.world, v.declared ? undefined : v.doc.own, kind, verb, "eval");
+  const answer = code.name === undefined ? undefined : machine.facts?.(v.typePath ?? [], code.name);
+  return { described: code.described, answer, rules: code.described ? (answer?.lazy ?? kind.lazy) : (answer?.lazy ?? EACH) };
+}
+
 /**
  * This function gives the static facts of a document, for a schedule (R4 P2, D24). It walks the document one time,
  * by the contracts of its kinds:
@@ -157,7 +188,7 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
  *   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.
  *
@@ -166,9 +197,11 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
  * 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
@@ -220,17 +253,15 @@ export function factsOf(machine: Machine, doc: unknown, options: FactsOptions =
           above.set(v, { lazy, rules: undefined });
           return undefined;
         }
-        const code = codeOf(world, v.declared ? undefined : v.doc.own, kind, verb, "eval");
-        const answer = code.name === undefined ? undefined : hook?.(v.typePath ?? [], code.name);
+        const { described, answer, rules } = codeFactsOf(machine, v, kind, verb);
+        above.set(v, { lazy, rules });
         let roots: readonly Root[] | undefined;
-        if (code.described) {
+        if (described) {
           note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
-          above.set(v, { lazy, rules: answer?.lazy ?? kind.lazy });
           roots = answer?.reads ?? kind.reads;
         } else {
           // The contract of the kind does not describe this code. Only the hook can.
           note(answer?.pure, answer?.volatile);
-          above.set(v, { lazy, rules: answer?.lazy ?? EACH });
           roots = answer?.reads;
         }
         // The code of the kind resolves each of these roots as a whole, at the place of its document (FACTS.KIND-READS).
@@ -239,13 +270,18 @@ export function factsOf(machine: Machine, doc: unknown, options: FactsOptions =
           if (node !== undefined && root === "self") continue;
           add({ root, keys: NONE, exact: true, lazy, address: false, path: [root], place: tight(place.place), at: tight(place.at) });
         }
+        // check and effectsOf read the declared effects with the same function (D27). The verb of the facts selects the
+        // declaration: effects for eval, and the entry of verbEffects for another verb (D49, D111).
+        const declared = declaredEffects(v, verb);
+        // The field side gives the side of eval. For another verb, a declared effect needs a runner, as in check, thus
+        // the run side (FACTS.VERB-SIDE).
+        const runs = verb === "eval" ? kind.side === "run" : declared.length > 0;
         // An equation evaluates without capabilities, thus an effect in it never reaches the host. It is still not pure.
-        if (kind.side === "run") {
+        if (runs) {
           if (node === undefined) side = "run";
           else pure = false;
         }
-        // check and effectsOf read the declared effects with the same function (D27).
-        for (const keys of declaredEffects(v)) {
+        for (const keys of declared) {
           if (node !== undefined) {
             pure = false;
             continue;

package/src/formula.ts

@@ -5,7 +5,7 @@ import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } f
 import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled, totalCode } from "./evaluate.ts";
 import { type MachinePart, mergeMachines } from "./merge.ts";
 import { type Domain, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeIssues, typeText } from "./types.ts";
-import type { PartType, TypeInput, TypeRule } from "./typing.ts";
+import type { Declared, PartType, TypeInput, TypeRule } from "./typing.ts";
 import { decodeDomain, domainTypeOf } from "./codec.ts";
 import { type StaticRead, factsOf } from "./facts.ts";
 
@@ -235,6 +235,12 @@ function isSignature(value: unknown): value is Signature {
   return typeof value === "object" && value !== null && Array.isArray((value as { readonly params?: unknown }).params) && Object.hasOwn(value, "to");
 }
 
+/** This function tells if two signatures have the same parameters and the same rest parameter. */
+function sameParams(a: Signature, b: Signature): boolean {
+  if (!docEquals(a.params, b.params)) return false;
+  return a.rest === undefined ? b.rest === undefined : b.rest !== undefined && docEquals(a.rest, b.rest);
+}
+
 /** This function gives the text of a signature, for the reason of an issue. */
 function signatureText(sig: Signature): string {
   const params = sig.params.map(typeText);
@@ -325,6 +331,32 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     }
     return { sigs, bad: sigs.length !== raw.length };
   };
+  /**
+   * The declarations of the signatures, for `checkWorld` (TYPE.WORLD, D110). Only a record of signatures lists them.
+   * An overload with the parameters of an earlier overload is a problem: the earlier one always fits first.
+   */
+  const sigsDeclared = (): readonly Declared[] => {
+    const sigs = profile.sigs;
+    if (sigs === undefined || typeof sigs === "function") return [];
+    const out: Declared[] = [];
+    for (const name of Object.keys(sigs)) {
+      const raw: unknown = sigs[name];
+      const list: readonly unknown[] = Array.isArray(raw) ? raw : [raw];
+      list.forEach((sig, index) => {
+        const at: readonly Key[] = Array.isArray(raw) ? ["sigs", name, index] : ["sigs", name];
+        if (!isSignature(sig)) {
+          out.push({ at, problem: `A signature of ops.${name} is not a record with params and to. The check does not read it.` });
+          return;
+        }
+        sig.params.forEach((param, position) => out.push({ at: [...at, "params", position], type: param, what: `parameter ${position + 1} of a signature of ops.${name}` }));
+        if (sig.rest !== undefined) out.push({ at: [...at, "rest"], type: sig.rest, what: `rest parameter of a signature of ops.${name}` });
+        out.push({ at: [...at, "to"], type: sig.to, what: `result of a signature of ops.${name}` });
+        const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
+        if (earlier >= 0) out.push({ at, problem: `The overload ${index + 1} of ops.${name} has the parameters of the overload ${earlier + 1}. Thus the check never selects it.` });
+      });
+    }
+    return out;
+  };
   const logic = (word: "and" | "or"): TypeRule => ({
     part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
     synth: (input) => {
@@ -456,6 +488,8 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     },
 
     "formula.if": {
+      // The rule of if declares the truth type of the profile, thus one bad truth type gives one issue in checkWorld.
+      declared: () => (declared ? [{ at: ["truthType"], type: truth, what: "truth type of the profile" }] : []),
       part: (input, path) => {
         if (path[0] === "test") return truthPart(input, "test of if");
         return isUnknown(input.expected, input.machine.domains) ? {} : { expect: input.expected, what: `${String(path[0])} branch of if` };
@@ -471,6 +505,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     "formula.or": logic("or"),
 
     "formula.op": {
+      declared: sigsDeclared,
       part: (input, path) => {
         const read = signatures(input);
         // Only one signature gives the types of the arguments before their check. Overloads select after it.
@@ -510,6 +545,15 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     },
 
     "formula.ext": {
+      declared: () => {
+        const types = profile.extTypes;
+        const own = profile.ext;
+        if (types === undefined || own === undefined) return [];
+        // Only the type of an own extension counts. An entry for a standard extension has no effect (D103).
+        return Object.keys(types)
+          .filter((name) => Object.hasOwn(own, name))
+          .map((name) => ({ at: ["extTypes", name], type: types[name], what: `type of ext.${name} in extTypes` }));
+      },
       synth: (input) => {
         const name = nameOf(input);
         const own = profile.ext !== undefined && Object.hasOwn(profile.ext, name);

package/src/index.ts

@@ -164,9 +164,12 @@ export {
   run,
 } from "./evaluate.ts";
 export {
+  type AttributeAnswer,
+  type AttributeCell,
   type AttributeRung,
   type AttributeTrace,
   type NearestOptions,
+  type TreeOptions,
   ATTRIBUTE_RUNGS,
   STD_CAPS,
   STD_EVALUATORS,
@@ -178,6 +181,7 @@ export {
   attributeTrace,
   nearestWalker,
   placeOf,
+  treeNodeEvaluator,
 } from "./stdlib.ts";
 export {
   type Edge,
@@ -208,6 +212,7 @@ export {
   type WalkOptions,
   type WalkProblem,
   type WorldIssue,
+  type WorldOptions,
   check,
   checkWorld,
   mapRefs,
@@ -259,7 +264,7 @@ export { type Definitions, type ReferenceOptions, type ReferenceRunOptions, STD_
 export { type AgreeOptions, type AgreeRunOptions, type Agreement, type Tier, type TierInput, type TierResult, agree, agreeRun, sameValue } from "./agree.ts";
 export { type ConformOptions, type ConformProbe, type Finding, type Obligation, conforms } from "./conform.ts";
 export { sameResult } from "./same.ts";
-export { type ReadsCheck, type VerifyOptions, verifyReads } from "./reads.ts";
+export { type PrintOptions, type ReadPrints, type ReadsCheck, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
 export { type Durable, type DurableCounts, type DurableOptions, type Epochs, durable } from "./durable.ts";
 export {
   type NodeEdge,
@@ -281,6 +286,15 @@ export {
   agreeSchedule,
 } from "./meaning.ts";
 export { type GraphCycle, type GraphEdge, type GraphNode, type GraphOptions, type NodeGraph, components, cycles, heights, necessary, nodeLayers } from "./graph.ts";
+export {
+  type AttributeCycle,
+  type AttributeEdge,
+  type AttributeGraph,
+  type AttributeGraphOptions,
+  type AttributeVertex,
+  attributeGraph,
+  attributeVertexId,
+} from "./instances.ts";
 export {
   type Recorder,
   type ReplayCausePartsJson,
@@ -302,5 +316,5 @@ export {
 } from "./replay.ts";
 export { type GenerateOptions, type Random, generate, random, typesOf } from "./generate.ts";
 export { type Domain, type DomainCodec, type TypeIssue, type ValueType, STD_DOMAINS, fits, join, member, typeIssues, typeText } from "./types.ts";
-export { type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE } from "./typing.ts";
+export { type Declared, type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE } from "./typing.ts";
 export { type SampleOptions, type TypeReading, typeFromSamples, typeFromSchema } from "./providers.ts";