@mark1russell7/coeval 0.24.0 → 0.25.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.24.0",
+  "version": "0.25.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",
@@ -36,8 +36,8 @@
   ],
   "devDependencies": {
     "@mark1russell7/cue": "^2.1.1",
-    "@mark1russell7/rigor-bench": "^0.2.15",
-    "@mark1russell7/rigor-statistics": "^0.1.12",
+    "@mark1russell7/rigor-bench": "^0.2.29",
+    "@mark1russell7/rigor-statistics": "^0.1.16",
     "@types/node": "^26.6.4",
     "esbuild": "^0.28.2",
     "typescript": "^7.0.2",

package/src/agree.ts

@@ -1,7 +1,10 @@
 import { type Key, docEquals, equalWith } from "./doc.ts";
 import { type Context, isHostThing } from "./deref.ts";
-import { type EvalError, type Result, isStackOverflow, thrown } from "./errors.ts";
-import { type Effect, type Machine, type Perform, type Read, JOURNAL, evaluate, makeContext, prepare, run, sharedCopy } from "./evaluate.ts";
+import { type EvalError, type Result, describe, isStackOverflow, thrown } from "./errors.ts";
+import { type CheckOptions, typeCheck } from "./static.ts";
+import { isPrecise, member, typeText } from "./types.ts";
+import { boundariesOf } from "./typing.ts";
+import { type Effect, type Machine, type Perform, type Read, type TraceNode, JOURNAL, evaluate, makeContext, prepare, run, sharedCopy } from "./evaluate.ts";
 import { Held, isClosure } from "./formula.ts";
 import { type Definitions, reference, referenceRun } from "./reference.ts";
 import { type ReplaySettle, recorder, relay, replayer } from "./replay.ts";
@@ -392,6 +395,15 @@ function resolutions(reads: readonly Read[]): readonly Read[] {
   return reads.filter((read) => read.free && read.kept !== true);
 }
 
+/** This function gives the text of a value of a trace. It does not throw for a bigint or a record with a cycle. */
+function valueText(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? describe(value);
+  } catch {
+    return describe(value);
+  }
+}
+
 function pathText(path: readonly unknown[] | undefined): string {
   if (path === undefined) return "no read";
   try {
@@ -537,3 +549,94 @@ export async function agreeRun(machine: Machine, doc: unknown, context: Context
   }
   return compared === undefined ? { ok: true, result, effects: first.effects } : { ok: true, result, effects: first.effects, reads: compared };
 }
+
+/** The result of `agreeTypes`: the agreement of a check of types and a traced evaluation (STATIC.TYPES-AGREE). */
+export type TypeAgreement =
+  | {
+      readonly ok: true;
+      /** `false` when the document has an issue, or a value breaks a position of an imprecise type. The rule then tells nothing. */
+      readonly checked: boolean;
+      /** The number of the values of the trace that the rule examined. */
+      readonly values: number;
+    }
+  | {
+      readonly ok: false;
+      /** `value`: a value is not in the type of its place. `argument`: it is not in the type that its position needs. `error`: a type error of the kernel. */
+      readonly clause: "value" | "argument" | "error";
+      /** The keys of the place, as texts. */
+      readonly place: readonly string[];
+      readonly reason: string;
+    };
+
+/** The options of `agreeTypes`: the options of `check`, and `guards`. */
+export interface AgreeTypesOptions extends CheckOptions {
+  /** `true`: the evaluation tests each boundary (PLAN.GUARD). The rule then holds for each context. The default is `false`. */
+  readonly guards?: boolean;
+}
+
+/** The type errors of the kernel, by the evaluator that gives them (STATIC.TYPES-AGREE). */
+const TYPE_ERRORS: Readonly<Record<string, string>> = {
+  "formula.op": "#NAME?",
+  "formula.if": "#VALUE!",
+  "formula.and": "#VALUE!",
+  "formula.or": "#VALUE!",
+};
+
+/**
+ * This function examines the agreement rule for types (STATIC.TYPES-AGREE, D148). A document with no issue evaluates
+ * with a trace. Each value of the trace is a member of the type of its place. A value of a precise type is also a member
+ * of the type that its position needs. No document with precise parts gives a type error of the kernel.
+ *
+ * A language imports this function for its own property tests, with `agree`. A failure tells that a signature, a type
+ * rule, a cover or a root type does not hold. A value that breaks a position of an imprecise type ends the promise, and
+ * the result then has `checked: false` (TYPE.GRADUAL).
+ *
+ * @param machine - The world and the code of the evaluators, with their type rules.
+ * @param doc - The document.
+ * @param context - The context. Its roots are members of the root types.
+ * @param options - The options of `check`, with the root types, and `guards`.
+ * @returns The agreement, or the first place that breaks it.
+ */
+export function agreeTypes(machine: Machine, doc: unknown, context: Context = makeContext(), options: AgreeTypesOptions = {}): TypeAgreement {
+  const typing = typeCheck(machine, doc, options);
+  if (typing.issues.length > 0) return { ok: true, checked: false, values: 0 };
+  const keyOf = (path: readonly unknown[]): string => JSON.stringify(path.map(String));
+  const places = new Map(typing.places.map((item) => [keyOf(item.place), item]));
+  const domains = machine.domains;
+  const guards = options.guards === true ? boundariesOf(typing, domains) : undefined;
+  const given = { ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }), ...(guards === undefined ? {} : { guards }) };
+  const stack: TraceNode[] = [evaluate(machine, doc, context, given).trace];
+  const nodes: TraceNode[] = [];
+  while (stack.length > 0) {
+    const node = stack.pop() as TraceNode;
+    nodes.push(node);
+    stack.push(...node.children);
+  }
+  // A value that breaks a position of an imprecise type leaves the promise of each later type (K28).
+  for (const node of nodes) {
+    const place = places.get(keyOf(node.path));
+    if (place?.expected === undefined || !node.result.ok || isPrecise(place.type, domains)) continue;
+    if (!member(node.result.value, place.expected, domains)) return { ok: true, checked: false, values: 0 };
+  }
+  // The walk goes from the end, thus a part comes before the kind that reads it, and a finding names the origin.
+  let values = 0;
+  for (const node of nodes.reverse()) {
+    const place = places.get(keyOf(node.path));
+    if (place === undefined) continue;
+    const at = node.path.map(String);
+    if (!node.result.ok) {
+      const parts = node.children.map((child) => places.get(keyOf(child.path)));
+      const decided = node.children.every((child) => child.result.ok) && parts.every((part) => part?.expected !== undefined && isPrecise(part.type, domains));
+      const code = TYPE_ERRORS[node.answer.evaluator ?? ""];
+      if (decided && node.result.error.code === code) return { ok: false, clause: "error", place: at, reason: `The document gives ${code}, but it checks with no issue.` };
+      continue;
+    }
+    const value = node.result.value;
+    values += 1;
+    if (!member(value, place.type, domains)) return { ok: false, clause: "value", place: at, reason: `The value ${valueText(value)} is not a member of ${typeText(place.type)}.` };
+    if (place.expected !== undefined && !member(value, place.expected, domains)) {
+      return { ok: false, clause: "argument", place: at, reason: `The value ${valueText(value)} is not a member of the needed type ${typeText(place.expected)}.` };
+    }
+  }
+  return { ok: true, checked: true, values };
+}

package/src/evaluate.ts

@@ -2,8 +2,8 @@ import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, isKey, ty
 import { type PartSlot, type Split, partsOf, pathMatches, scopesOf } from "./parts.ts";
 import { answerOf, ask, type Answer } from "./ladder.ts";
 import type { CapsRule, Kind, KindFacts, Side } from "./world.ts";
-import type { Domain } from "./types.ts";
-import type { TypeRule } from "./typing.ts";
+import { type Domain, type ValueType, member, typeText } from "./types.ts";
+import type { Boundary, TypeRule } from "./typing.ts";
 import type { StaticRead } from "./facts.ts";
 import { type ErrorCode, type EvalError, type Result, Failure, fail, ok, placed, thrown, describe } from "./errors.ts";
 import {
@@ -993,6 +993,8 @@ export interface PlanRunOptions {
 export interface RunOptions extends PlanRunOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
+  /** The boundaries that test their values (PLAN.GUARD). The default is none. */
+  readonly guards?: readonly Boundary[];
   /** The verb of `run`, for example `format`. The default is `eval` (VERB.PREPARE). */
   readonly verb?: string;
 }
@@ -1023,6 +1025,8 @@ export interface EvaluateOptions {
   readonly perform?: Perform;
   /** A list that gets each read, in the order of the resolutions (READS.RECORD). */
   readonly reads?: Read[];
+  /** The boundaries that test their values (PLAN.GUARD). The default is none. */
+  readonly guards?: readonly Boundary[];
 }
 
 /** The options of a resolution without a record of hops, and with one. One object of each serves each call. */
@@ -1700,6 +1704,11 @@ export interface PrepareOptions {
    * the code without the fold. A plan without folds ignores this option.
    */
   readonly fixed?: { readonly names?: Readonly<Record<string, unknown>> };
+  /**
+   * The boundaries of the document, from `boundariesOf` (PLAN.GUARD, D149). A value that is not a member of the type of
+   * its boundary gives `#VALUE!` at that place. The default is none, and a plan then has no test.
+   */
+  readonly guards?: readonly Boundary[];
 }
 
 /** A compiled document. It evaluates many times, and it does the work of the ladder one time. */
@@ -1740,6 +1749,8 @@ interface Compiler {
   readonly fold: boolean;
   /** The fixed names and their values, or `undefined` when the plan has none (PLAN.FIXED). */
   readonly fixed: Readonly<Record<string, unknown>> | undefined;
+  /** The types of the boundaries by their place, or `undefined` when the plan has no guard (PLAN.GUARD). */
+  readonly guards: ReadonlyMap<string, ValueType> | undefined;
   /** The runtime of the folds of this compilation. The first fold makes it. */
   probe?: Probe;
 }
@@ -1885,7 +1896,8 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     } catch (error) {
       return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
     }
-    const run = placedRun(inner, place, name);
+    const guard = guardOf(c, place);
+    const run = placedRun(guard === undefined ? inner : guardRun(inner, guard, c.machine.domains), place, name);
     return finish(c, meta, runnerCode(run, place, kindText), run);
   }
 
@@ -1895,8 +1907,9 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   } catch (error) {
     return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
   }
+  const guard = guardOf(c, place);
   // Code that cannot fail needs no place and no catch, and it does not read the context of its grant (PLAN.TOTAL).
-  const done = finish(c, meta, TOTAL.has(inner) ? inner : placedCode(inner, place, name), undefined);
+  const done = finish(c, meta, guard !== undefined ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), undefined);
   if (frees === undefined || kind === undefined || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
   const free = freeOf(doc, kind, split.parts, frees);
   if (free === undefined) return done;
@@ -2308,6 +2321,34 @@ function gated(rules: readonly CapsRule[], part: Compiled): Compiled {
  * This function gives the steps of a runner, with the place of each error and of each exception. The steps get the
  * context that its grant permits (CAP.NARROW-CODE).
  */
+/** This function gives the key of a place in the guards of a plan. */
+function guardKey(place: readonly Key[]): string {
+  return JSON.stringify(place.map(String));
+}
+
+/** This function gives the type of the boundary at a place, when the plan has one (PLAN.GUARD). */
+function guardOf(c: Compiler, place: readonly Key[]): ValueType | undefined {
+  return c.guards?.get(guardKey(place));
+}
+
+/** This function gives the result of a part of a boundary: a value that is not a member gives `#VALUE!` (PLAN.GUARD). */
+function guarded(result: Result, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): Result {
+  if (!result.ok || member(result.value, type, domains)) return result;
+  return fail("#VALUE!", `The value is not a member of ${typeText(type)}, the type of its boundary.`);
+}
+
+/** This function adds the test of a boundary to the code of a part. */
+function guardCode(inner: Code, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): Code {
+  return (ctx, rt) => guarded(inner(ctx, rt), type, domains);
+}
+
+/** This function adds the test of a boundary to the steps of a part. */
+function guardRun(inner: RunCode, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): RunCode {
+  return function* (ctx, rt) {
+    return guarded(yield* inner(ctx, rt), type, domains);
+  };
+}
+
 function placedRun(inner: RunCode, place: readonly Key[], name: string): RunCode {
   return function* (ctx, rt) {
     try {
@@ -2520,7 +2561,8 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
   const traced = options.trace === true;
   const fold = !traced && options.fold !== false;
   const fixed = fold ? fixedNamesOf(options.fixed?.names) : undefined;
-  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold, fixed };
+  const guards = options.guards === undefined || options.guards.length === 0 ? undefined : new Map(options.guards.map((each) => [guardKey(each.place), each.type]));
+  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold, fixed, guards };
   let root: Compiled;
   try {
     root = compileNode(c, doc, [], options.declaredType, 0);
@@ -2643,6 +2685,7 @@ export function evaluate(machine: Machine, doc: unknown, context: Context = make
     trace: true,
     ...(declaredType === undefined ? {} : { declaredType }),
     ...(given.verb === undefined ? {} : { verb: given.verb }),
+    ...(given.guards === undefined ? {} : { guards: given.guards }),
   });
   const ctx = rootContext(machine, context);
   const s = new Session(machine, ctx.caps, false, true, given.perform, undefined, undefined, readingOf(given.reads, ctx));
@@ -2665,6 +2708,7 @@ export async function run(machine: Machine, doc: unknown, context: Context = mak
   const plan = prepare(machine, doc, {
     trace: true,
     ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }),
+    ...(options.guards === undefined ? {} : { guards: options.guards }),
     ...(options.verb === undefined ? {} : { verb: options.verb }),
   });
   const ctx = rootContext(machine, context);

package/src/formula.ts

@@ -5,8 +5,8 @@ import { type CompiledPath, type Context, type Resolution, compilePath, valueOfT
 import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } from "./errors.ts";
 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 { Declared, PartType, TypeInput, TypeRule } from "./typing.ts";
+import { type Domain, type Proof, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeIssues, typeText } from "./types.ts";
+import type { Declared, PartType, Proven, TypeInput, TypeRule } from "./typing.ts";
 import { decodeDomain, domainTypeOf } from "./codec.ts";
 import { type StaticRead, factsOf } from "./facts.ts";
 
@@ -80,8 +80,7 @@ export interface FormulaProfile {
 
 /**
  * The signature of an operation: the value types of its parameters and of its result (TYPE.SIGNATURE). A parameter at
- * the end of `params` is optional when `undefined` is a member of its type, for example `unknown`. A later version can add a key, for example the type that a
- * true result proves.
+ * the end of `params` is optional when `undefined` is a member of its type, for example `unknown`. A later version can add a key.
  */
 export interface Signature {
   /** The types of the parameters, in order. */
@@ -90,8 +89,21 @@ export interface Signature {
   readonly rest?: ValueType;
   /** The type of the result. */
   readonly to: ValueType;
+  /**
+   * The type that a true result proves of the first argument, and a false result refutes (STATIC.OCCURRENCE). The
+   * operation gives a true result for each member of the type, and for no other value.
+   */
+  readonly proves?: ValueType;
+  /** `true` when a true result tells that the first argument has a value, and a false result that it has none. */
+  readonly present?: boolean;
 }
 
+/** The most proofs that one test keeps. A proof only adds knowledge, thus the check can leave one out. */
+const MAX_PROOFS = 32;
+
+/** The result of a test that proves nothing. */
+const NO_PROOFS: Proven = { yes: [], no: [] };
+
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED: unique symbol = /* @__PURE__ */ Symbol("skipped");
 
@@ -400,6 +412,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
         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}` });
+        if (sig.proves !== undefined) out.push({ at: [...at, "proves"], type: sig.proves, what: `proved type 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.` });
       });
@@ -407,7 +420,21 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     return out;
   };
   const logic = (word: "and" | "or"): TypeRule => ({
-    part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
+    usesProofs: true,
+    // A later term runs only after a term that did not decide, thus it reads the proof of that result (STATIC.OCCURRENCE-LOGIC).
+    part: (input, path) => {
+      const index = Number(path[0]);
+      const part = truthPart(input, `term ${index + 1} of ${word}`);
+      if (index === 0) return part;
+      const before = input.provenBy([index - 1]);
+      return { ...part, narrow: word === "and" ? before.yes : before.no, keep: true };
+    },
+    proves: (input) => {
+      const each = input.paths.map((path) => input.provenBy(path));
+      const all = (side: "yes" | "no"): readonly Proof[] => each.flatMap((proven) => proven[side]).slice(0, MAX_PROOFS);
+      const one = each.length === 1 ? (each[0] as Proven) : undefined;
+      return word === "and" ? { yes: all("yes"), no: one?.no ?? [] } : { yes: one?.yes ?? [], no: all("no") };
+    },
     synth: (input) => {
       if (!logicValue) return "bool";
       // With the logic "value", the result is the term that decided, or the last term.
@@ -420,6 +447,12 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     "formula.lit": { synth: (input) => valueType(input.doc.value) },
 
     "formula.ref": {
+      read: true,
+      reads: (input) => {
+        const path = input.doc.value;
+        if (input.address || !Array.isArray(path) || path.length === 0) return undefined;
+        return path.every((step): step is string => typeof step === "string") ? path : undefined;
+      },
       synth: (input, report) => {
         const path = input.doc.value;
         // An address gives a thing, not a value. The check gives #VALUE! for a path that is not a list.
@@ -541,9 +574,13 @@ 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" }] : []),
+      first: "test",
+      usesProofs: true,
       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` };
+        const proven = input.provenBy(["test"]);
+        const narrow = path[0] === "then" ? proven.yes : proven.no;
+        return isUnknown(input.expected, input.machine.domains) ? { narrow } : { expect: input.expected, what: `${String(path[0])} branch of if`, narrow };
       },
       synth: (input) => {
         const value = input.doc.value;
@@ -557,6 +594,25 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
 
     "formula.op": {
       declared: sigsDeclared,
+      proves: (input) => {
+        // Overloads select after the check of the arguments, thus only one signature proves.
+        const sigs = signatures(input)?.sigs;
+        const sig = sigs?.length === 1 ? (sigs[0] as Signature) : undefined;
+        if (sig === undefined || (sig.proves === undefined && sig.present !== true) || input.paths.length === 0) return NO_PROOFS;
+        const path = input.readOf(input.paths[0] as readonly Key[]);
+        if (path === undefined) return NO_PROOFS;
+        const yes: Proof[] = [];
+        const no: Proof[] = [];
+        if (sig.proves !== undefined && typeIssues(input.contract(sig.proves, `proved type of ops.${nameOf(input)}`), input.machine.domains).length === 0) {
+          yes.push({ path, fact: "is", type: sig.proves });
+          no.push({ path, fact: "not", type: sig.proves });
+        }
+        if (sig.present === true) {
+          yes.push({ path, fact: "present" });
+          no.push({ path, fact: "absent" });
+        }
+        return { yes, no };
+      },
       part: (input, path) => {
         const read = signatures(input);
         // Only one signature gives the types of the arguments before their check. Overloads select after it.

package/src/index.ts

@@ -79,6 +79,7 @@ export {
 } from "./world.ts";
 export {
   type DomainExtension,
+  type VerbEntries,
   type MachinePart,
   type MergeConflict,
   type MergePath,
@@ -197,6 +198,7 @@ export {
   STD_EVALUATORS,
   STD_MACHINE,
   STD_RUNNERS,
+  ifRunner,
   STD_WALKERS,
   STD_WORLD,
   WORLD_SYNTAX,
@@ -227,6 +229,7 @@ export {
 } from "./context.ts";
 export {
   type CheckOptions,
+  type DocChange,
   type DocVisit,
   type Issue,
   type RefUse,
@@ -237,6 +240,7 @@ export {
   type WorldOptions,
   check,
   checkWorld,
+  mapDocs,
   mapRefs,
   refsOf,
   typeCheck,
@@ -289,7 +293,7 @@ export {
   syntaxFormat,
 } from "./syntax.ts";
 export { type Definitions, type ReferenceOptions, type ReferenceRunOptions, STD_DEFINITIONS, formulaDefinitions, reference, referenceRun } from "./reference.ts";
-export { type AgreeOptions, type AgreeRunOptions, type Agreement, type Tier, type TierInput, type TierResult, agree, agreeRun, sameValue } from "./agree.ts";
+export { type AgreeOptions, type AgreeRunOptions, type Agreement, type AgreeTypesOptions, type TypeAgreement, agreeTypes, 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 PrintOptions, type ReadPrints, type ReadsCheck, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
@@ -345,6 +349,6 @@ export {
   replayer,
 } 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 Declared, type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE } from "./typing.ts";
+export { type Domain, type DomainCodec, type Proof, type TypeIssue, type ValueType, STD_DOMAINS, fits, join, member, typeIssues, typeText } from "./types.ts";
+export { type Boundary, type Declared, type PartType, type Proven, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE, boundariesOf } from "./typing.ts";
 export { type SampleOptions, type TypeReading, typeFromSamples, typeFromSchema } from "./providers.ts";