tla-ts 0.0.1 → 0.0.3-dev.763cc71

package/README.md

@@ -3,14 +3,14 @@
 [![version](https://img.shields.io/npm/v/tla-ts?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/tla-ts)
 [![downloads](https://img.shields.io/npm/dt/tla-ts.svg?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/tla-ts)
 
-A TLA+ model checker in TypeScript, **2.4× faster than TLC**.
+tla-ts is a drop-in replacement for [TLC](https://github.com/tlaplus/tlaplus) that's **2× faster**.
 
-tla-ts checks TLA+ specs with the same verdicts, error traces, and state counts as TLC. It runs in Node and in the browser without a JVM. Try it in the [playground](https://tla-ts.aidenybai.com).
+TLA+ lets you write formal models of a system, and TLC model checks them. But TLC is written in Java and needs the JVM. tla-ts runs anywhere JavaScript runs, such as the browser, Node, and Bun. Try it in the [playground](https://tla-ts.aidenybai.com).
 
 ```ts
 import { check } from "tla-ts";
 
-const result = check({
+const result = await check({
   source: `---- MODULE Counter ----
 EXTENDS Naturals
 VARIABLE x
@@ -30,34 +30,76 @@ result.status; // "invariant-violation"
 npm install tla-ts
 ```
 
-## Usage
+## Command line
+
+The `tla-ts` command takes TLC's options and prints TLC's output. `tla-ts prove` takes tlapm's options and prints tlapm's output.
+
+### Check a spec
+
+To check a spec, pass its path:
 
 ```shell
 npx tla-ts Spec.tla
-npx tla-ts Spec.tla -config Other.cfg -deadlock
-npx tla-ts Spec.tla -workers auto
 ```
 
-Without `-config`, tla-ts reads the `.cfg` file next to the spec. `-deadlock` turns off deadlock checking. `-workers` checks on several threads, one per core with `auto`. Output and exit codes follow TLC:
+tla-ts reads the configuration from `Spec.cfg` next to the spec. It exits with the exit code TLC uses for the same result.
+
+You can pass several paths, or a glob such as `"specs/*.tla"`. tla-ts checks each spec in turn and exits with the exit code of the first spec that fails. A glob skips each module that has no `.cfg` next to it, so it doesn't check helper modules that other specs import. tla-ts never skips a path that you pass by name. If you pass a `.cfg` path, tla-ts checks the `.tla` file with the same name.
+
+The options are:
+
+- `-config <Spec.cfg>`: read the configuration from this file. You can use it only when you check one spec.
+- `-deadlock`: don't report deadlocks.
+- `-lncheck final`: check liveness once, after the search ends.
+- `-seed <num>`: seed `RandomElement` and the `Randomization` module. The default is 0.
+- `-workers <count|auto>`: search with this number of worker threads. `auto` uses one thread per core. The default is 1.
+
+TLC can replace a module's operators with Java methods, and tla-ts reads the same files. If the spec's directory has `Module.class`, tla-ts replaces each operator in `Module` with the public static method that has the same name and arity.
+
+### Generate proof obligations
+
+A proof obligation is one claim that a backend prover must prove. `tla-ts prove -N` prints the obligations of a module, as `tlapm -N` does. It doesn't run a prover. For example, this command prints every obligation in `Module.tla` with its text:
+
+```shell
+npx tla-ts prove -N --toolbox 0 0 --printallobs Module.tla
+```
+
+With `--toolbox` or `--line`, tla-ts writes the messages of the TLA+ Toolbox protocol to stderr, as tlapm does. If you pass a tlapm option that isn't in this list, tla-ts prints an error:
+
+- `--toolbox <start> <end>`: print Toolbox messages for the proofs from line `start` to line `end`. `0 0` selects the whole module.
+- `--line <num>`: print Toolbox messages for the proof at this line.
+- `--printallobs`: print the text of each obligation.
+- `--summary`: print the number of obligations in each module, and list its missing and omitted proofs. You don't need `-N` with `--summary`.
+- `--strict`: report missing proofs, omitted proofs and a selected range with no obligations as errors.
+- `-I <directory>`: search this directory for modules.
+
+tla-ts searches for modules in the same order as tlapm:
 
-| Exit code | Meaning                      |
-| --------: | ---------------------------- |
-|         0 | No error found               |
-|        10 | An assumption is false       |
-|        11 | Deadlock                     |
-|        12 | Invariant or property broken |
-|        13 | Liveness violation           |
+1. The directory of each module you pass, the last one first.
+2. The current directory.
+3. The standard library of tlapm, which has the `TLAPS` module. tla-ts searches it only if `tlapm` is on your `PATH`.
+4. The `-I` directories, the last one first.
+
+### Prove with tlapm
+
+tla-ts doesn't include a prover. Without `-N` or `--summary`, `tla-ts prove` runs [tlapm](https://github.com/tlaplus/tlapm) from your `PATH`:
+
+```shell
+npx tla-ts prove Module.tla
+```
+
+tla-ts expands the globs and passes every argument to tlapm, so all of tlapm's options work. tlapm sends the obligations to its provers, and tla-ts exits with the exit code of tlapm. If `tlapm` isn't on your `PATH`, tla-ts prints an error and exits with code 1.
 
 ## API reference
 
 ### `check`
 
-Checks a spec against a TLC configuration and returns the result. It explores every reachable state breadth-first, as TLC does.
+Checks a spec against a TLC configuration and resolves to the result.
 
 ```ts
 import { check } from "tla-ts";
 
-const result = check({
+const result = await check({
   source: specSource,
   config: configSource,
   loadModule: (name) => modules[name],
@@ -65,36 +107,33 @@ const result = check({
 });
 ```
 
-Options:
-
-- `source`: the TLA+ module to check
-- `config`: a TLC configuration, as source text or as the result of `parseConfig`
-- `loadModule`: maps a module name to its source, for modules other than the standard modules
-- `onPrint`: receives the output of `Print` and `PrintT`, which defaults to `console.log`
-- `readFile` and `writeFile`: let the Json module read and write files. Without them, it has no file access
+| Option                  | Description                                                                              |
+| ----------------------- | ---------------------------------------------------------------------------------------- |
+| `source`                | The TLA+ module to check                                                                 |
+| `config`                | A TLC configuration, as text or as the result of `parseConfig`                           |
+| `loadModule`            | Returns the source of a module that isn't a standard module                              |
+| `loadClass`             | Returns a compiled Java class that overrides a module's operators with constants         |
+| `onPrint`               | Receives the output of `Print` and `PrintT`. Defaults to `console.log`                   |
+| `onPause`               | Runs when `TLCSet("pause", TRUE)` pauses checking, which resumes when it returns         |
+| `readFile`, `writeFile` | Read and write files for the Json module                                                 |
+| `seed`                  | A `bigint` seed. Defaults to `0n`, and matches TLC run with the same `-seed` and `-fp 0` |
+| `workers`               | The number of worker threads. Defaults to 1                                              |
 
-The result has `status`, `violation`, `generatedStates`, `distinctStates`, and `depth`. `status` is `"success"`, `"assumption-violation"`, `"invariant-violation"`, `"property-violation"`, `"liveness-violation"`, or `"deadlock"`. `violation` holds the name of what failed and the trace that reaches it. For a liveness violation, `violation.loopStart` is the trace index where the lasso loops back.
+The result has these fields:
 
-`check` supports:
-
-- **Standard modules**: Naturals, Integers, Sequences, FiniteSets, TLC, Bags, Reals, RealTime, Toolbox, and the community modules TLCExt, Json, and Randomization
-- **Modules**: `EXTENDS`, nested modules, and `INSTANCE` with `WITH` substitutions, `LAMBDA` substitutions for operator parameters, named instances, parameterized instances, and instances inside `LET`
-- **Configuration**: `INIT`, `NEXT`, `SPECIFICATION`, `CONSTANTS`, `INVARIANTS`, `PROPERTIES`, `CONSTRAINTS`, `ACTION_CONSTRAINTS`, `SYMMETRY`, `VIEW`, `POSTCONDITION`, `CHECK_DEADLOCK`, and `_POSSIBLE` properties
-- **Properties**: invariants, `[][A]_v`, and every temporal formula TLC accepts, checked through TLC's tableau construction under the fairness and temporal conjuncts of the specification
-- **Subexpression references**: selectors such as `F(2)!3`, `Op!<<`, `Op!>>`, `Op!:`, `Op!@`, and `Op!(x)`, labels such as `Op!lab`, and names of `THEOREM` formulas
-- **TLC semantics**: 32-bit integer overflow errors, `ENABLED`, `TLCGet` and `TLCSet` with TLC's counters and registers, and TLC's enumeration order for `CHOOSE` and quantifiers
+- `status`: `"success"`, `"deadlock"`, `"assumption-violation"`, `"invariant-violation"`, `"property-violation"`, `"liveness-violation"`, `"postcondition-violation"`, or `"error"`.
+- `violation`: the `name` of what failed and the `trace` that reaches it. `loopStart` marks where a liveness counterexample loops back.
+- `failure`: the message and trace when `status` is `"error"`.
+- `generatedStates`, `distinctStates`, and `depth`: TLC's state counts.
 
-### `checkInParallel`
+Workers run in Node, Bun, Deno, and the browser, and deduplicate states by 64-bit fingerprint as TLC does. `check` runs on the calling thread for specs with liveness properties or impure operators such as `Print`. After a violation, it reruns there to return the exact trace.
 
-Checks a spec on several worker threads and resolves to the same result as `check`. It takes the options of `check` plus `workers`, and runs in Node, Bun, Deno, and the browser.
-
-```ts
-import { checkInParallel } from "tla-ts";
-
-const result = await checkInParallel({ source: specSource, config: configSource, workers: 4 });
-```
+`check` supports:
 
-Workers deduplicate states by 64-bit fingerprint, as TLC does. When a run finds a violation, or the spec uses liveness properties or impure operators such as `Print`, `checkInParallel` falls back to `check` and returns its exact result and trace.
+- **Modules**: the standard modules, TLCExt, Json, and Randomization, plus `EXTENDS`, `INSTANCE`, and `LAMBDA`.
+- **Configuration**: `CONSTANTS`, `INIT`, `NEXT`, `SPECIFICATION`, invariants, properties, constraints, `SYMMETRY`, `VIEW`, `ALIAS`, `POSTCONDITION`, `CHECK_DEADLOCK`, and `_POSSIBLE`.
+- **Properties**: invariants and every temporal formula TLC accepts, checked through TLC's tableau construction.
+- **TLC semantics**: 32-bit integer overflow, `TLCGet` and `TLCSet`, subexpression references such as `Op!2`, and TLC's enumeration order for `CHOOSE` and quantifiers.
 
 ### `parseModule`
 
@@ -116,7 +155,7 @@ import { check, parseConfig } from "tla-ts";
 
 const config = parseConfig(configSource);
 config.checkDeadlock = false;
-check({ source: specSource, config });
+await check({ source: specSource, config });
 ```
 
 ### `formatValue`

package/dist/index.cjs

@@ -6,4 +6,4 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./transfer.cjs"),t=require("./parallel.cjs");exports.TlaConfigError=e.v,exports.TlaError=e.y,exports.TlaEvaluationError=e.b,exports.TlaSyntaxError=e.x,exports.TlaUnsupportedError=e.S,exports.check=e.o,exports.checkInParallel=t.t,exports.formatValue=e.g,exports.parseConfig=e._,exports.parseModule=e.d;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./transfer.cjs"),t=require("./parallel.cjs");exports.TlaConfigError=e.k,exports.TlaError=e.A,exports.TlaEvaluationError=e.j,exports.TlaSyntaxError=e.N,exports.TlaUnsupportedError=e.P,exports.check=t.t,exports.formatValue=e.C,exports.parseConfig=e.D,exports.parseModule=e._;

package/dist/index.d.cts

@@ -12,10 +12,22 @@ interface LocalResolution {
 interface SourceLocation {
   line: number;
   column: number;
+  range?: SourceRange;
+}
+interface SourceRange {
+  module: string;
+  start: SourceLocation;
+  end: SourceLocation;
 }
 interface NumberExpression {
   kind: "Number";
   value: number;
+  text?: string;
+  location: SourceLocation;
+}
+interface DecimalExpression {
+  kind: "Decimal";
+  text: string;
   location: SourceLocation;
 }
 interface StringExpression {
@@ -33,6 +45,7 @@ interface ApplyExpression {
   kind: "Apply";
   operator: string;
   args: Expression[];
+  argumentCounts?: number[];
   location: SourceLocation;
   resolution?: LocalResolution;
 }
@@ -50,6 +63,7 @@ interface LambdaExpression {
 interface JunctionExpression {
   kind: "And" | "Or";
   operands: Expression[];
+  isBulleted?: boolean;
   location: SourceLocation;
 }
 interface PrimeExpression {
@@ -110,6 +124,7 @@ interface QuantifierExpression {
 }
 interface UnboundedQuantifierExpression {
   kind: "UnboundedQuantifier";
+  quantifier: "Forall" | "Exists";
   names: string[];
   isTemporal?: boolean;
   body: Expression;
@@ -249,16 +264,18 @@ interface SubexpressionExpression {
   selectors: Selector[];
   location: SourceLocation;
 }
-type Expression = NumberExpression | StringExpression | IdentifierExpression | ApplyExpression | OperatorReferenceExpression | LambdaExpression | JunctionExpression | PrimeExpression | UnchangedExpression | EnabledExpression | IfExpression | CaseExpression | LetExpression | QuantifierExpression | UnboundedQuantifierExpression | ChooseExpression | SetEnumerationExpression | SetFilterExpression | SetMapExpression | TupleExpression | FunctionConstructionExpression | FunctionSetExpression | RecordExpression | ExceptExpression | ExceptAtExpression | FunctionApplicationExpression | FieldAccessExpression | ProductExpression | TemporalExpression | ActionExpression | FairnessExpression | LabelExpression | SubexpressionExpression;
+type Expression = NumberExpression | DecimalExpression | StringExpression | IdentifierExpression | ApplyExpression | OperatorReferenceExpression | LambdaExpression | JunctionExpression | PrimeExpression | UnchangedExpression | EnabledExpression | IfExpression | CaseExpression | LetExpression | QuantifierExpression | UnboundedQuantifierExpression | ChooseExpression | SetEnumerationExpression | SetFilterExpression | SetMapExpression | TupleExpression | FunctionConstructionExpression | FunctionSetExpression | RecordExpression | ExceptExpression | ExceptAtExpression | FunctionApplicationExpression | FieldAccessExpression | ProductExpression | TemporalExpression | ActionExpression | FairnessExpression | LabelExpression | SubexpressionExpression;
 interface OperatorParam {
   name: string;
   arity: number;
+  location?: SourceLocation;
 }
 interface OperatorDefinition {
   kind: "Operator";
   name: string;
   params: OperatorParam[];
   body: Expression;
+  bodyRange?: SourceRange;
   isLocal: boolean;
   isRecursive: boolean;
   location: SourceLocation;
@@ -276,6 +293,7 @@ type Definition = OperatorDefinition | FunctionDefinition;
 interface Declaration {
   name: string;
   arity: number;
+  location: SourceLocation;
 }
 interface Assumption {
   name: string | undefined;
@@ -295,21 +313,139 @@ interface Instance {
   substitutions: InstanceSubstitution[];
   isLocal: boolean;
   location: SourceLocation;
+  instanceRange: SourceRange;
+  definitionRange?: SourceRange;
 }
-interface OuterScope {
-  extends: string[];
-  symbols: Declaration[];
+interface NewSymbol {
+  kind: "NewSymbol";
+  name: string;
+  arity: number;
+  level: "Constant" | "Variable" | "State" | "Action" | "Temporal";
+  set: Expression | undefined;
+  location: SourceLocation;
+}
+interface AssumeProve {
+  kind: "AssumeProve";
+  assumptions: (Expression | NewSymbol | AssumeProve)[];
+  conclusion: Expression;
+  location: SourceLocation;
+}
+type Fact = Expression | {
+  kind: "ModuleFact";
+  name: string;
+  location: SourceLocation;
+};
+interface UseOrHide {
+  kind: "Use" | "Hide";
+  isOnly: boolean;
+  facts: Fact[];
+  defs: Fact[];
+  keyword: SourceRange;
+  location: SourceLocation;
 }
+type Proof = {
+  kind: "Obvious" | "Omitted";
+  keyword: SourceRange;
+  location: SourceLocation;
+} | {
+  kind: "By";
+  isOnly: boolean;
+  facts: Fact[];
+  defs: Fact[];
+  keyword: SourceRange;
+  location: SourceLocation;
+} | {
+  kind: "Steps";
+  level: number;
+  steps: ProofStep[];
+  location: SourceLocation;
+};
+interface DefineStep {
+  kind: "Define";
+  definitions: (Definition | Instance)[];
+  location: SourceLocation;
+}
+type StepBody = UseOrHide | Instance | DefineStep | {
+  kind: "Have";
+  expression: Expression;
+} | {
+  kind: "Take";
+  names: string[];
+  bounds: Bound[];
+} | {
+  kind: "Witness";
+  expressions: Expression[];
+} | {
+  kind: "Pick";
+  names: string[];
+  bounds: Bound[];
+  body: Expression;
+} | {
+  kind: "Case";
+  expression: Expression;
+} | {
+  kind: "Assert";
+  isSuffices: boolean;
+  statement: Expression | AssumeProve;
+} | {
+  kind: "Qed";
+};
+interface ProofStep {
+  name: string | undefined;
+  token: string;
+  body: StepBody;
+  head: SourceRange;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+interface Theorem {
+  name: string | undefined;
+  statement: Expression | AssumeProve;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+type ModuleUnit = {
+  kind: "Constants";
+  declarations: Declaration[];
+} | {
+  kind: "Variables";
+  declarations: Declaration[];
+} | {
+  kind: "Recursive";
+  declarations: Declaration[];
+} | {
+  kind: "Definition";
+  definition: Definition;
+} | {
+  kind: "Instance";
+  instance: Instance;
+} | {
+  kind: "Assumption";
+  assumption: Assumption;
+} | {
+  kind: "Theorem";
+  theorem: Theorem;
+} | {
+  kind: "Use";
+  use: UseOrHide;
+} | {
+  kind: "Module";
+  module: Module;
+};
 interface Module {
   name: string;
-  outer: OuterScope | undefined;
   modules: Module[];
   extends: string[];
+  extendsRanges: SourceRange[];
   constants: Declaration[];
-  variables: string[];
+  variables: Declaration[];
   definitions: Definition[];
   instances: Instance[];
   assumptions: Assumption[];
+  location: SourceLocation;
+  theorems: Theorem[];
+  uses: UseOrHide[];
+  units: ModuleUnit[];
 }
 type ConfigValue = {
   kind: "Number";
@@ -351,13 +487,39 @@ interface ModelConfig {
   checkDeadlock: boolean;
   symmetry: string | undefined;
   view: string | undefined;
+  alias: string | undefined;
   postconditions: string[];
   possible: string[];
+  periodic: string | undefined;
+  rlReward: string | undefined;
 }
 export declare const parseConfig: (source: string) => ModelConfig;
+export declare class TlaError extends Error {
+  constructor(message: string, cause?: unknown);
+}
+interface SyntaxFailure {
+  reason: string;
+  line: number;
+  column: number;
+  isEnd: boolean;
+}
+export declare class TlaSyntaxError extends TlaError {
+  failure: SyntaxFailure | undefined;
+  constructor(message: string, cause?: unknown, failure?: SyntaxFailure);
+}
+export declare class TlaConfigError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaEvaluationError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaUnsupportedError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
 interface ModelValue {
   kind: "ModelValue";
   name: string;
+  type: string | undefined;
 }
 interface SetValue {
   kind: "Set";
@@ -365,12 +527,17 @@ interface SetValue {
   hash: number;
   fingerprint: number;
 }
+interface MixedSetValue {
+  kind: "MixedSet";
+  elements: Value[];
+}
 interface FunctionValue {
   kind: "Function";
   domain: Value[];
   range: Value[];
   hash: number;
   fingerprint: number;
+  writtenKeys: Value[] | undefined;
 }
 interface IntervalValue {
   kind: "Interval";
@@ -414,58 +581,76 @@ interface FilteredSetValue {
   base: Value;
   test: (element: Value) => boolean;
 }
+interface UnionValue {
+  kind: "Union";
+  base: Value;
+}
+interface LazyFunctionParameter {
+  name: string;
+  domain: Value;
+}
+interface LazyFunctionSource {
+  parameters: LazyFunctionParameter[];
+  body: string;
+}
 interface LazyFunctionValue {
   kind: "LazyFunction";
   domain: Value;
   apply: (argument: Value) => Value;
+  source?: LazyFunctionSource;
 }
-type Value = boolean | number | string | ModelValue | SetValue | FunctionValue | IntervalValue | InfiniteSetValue | SubsetValue | FunctionSetValue | RecordSetValue | ProductSetValue | SequenceSetValue | SetOperationValue | FilteredSetValue | LazyFunctionValue;
-export declare const formatValue: (value: Value, isExpanded?: boolean) => string;
+type Value = boolean | number | string | ModelValue | SetValue | MixedSetValue | FunctionValue | IntervalValue | InfiniteSetValue | SubsetValue | FunctionSetValue | RecordSetValue | ProductSetValue | SequenceSetValue | SetOperationValue | FilteredSetValue | UnionValue | LazyFunctionValue;
+export declare const formatValue: (value: Value, isStrict?: boolean, isNormalized?: boolean) => string;
 interface CheckOptions {
   source: string;
   config: string | ModelConfig;
   loadModule?: (name: string) => string | undefined;
+  loadClass?: (name: string) => Uint8Array | undefined;
   onPrint?: (text: string) => void;
+  onPause?: () => void;
   readFile?: (path: string) => string | undefined;
   writeFile?: (path: string, content: string) => void;
+  seed?: bigint;
+  workers?: number;
+  livenessCheck?: "default" | "final";
 }
-type CheckStatus = "success" | "assumption-violation" | "invariant-violation" | "property-violation" | "liveness-violation" | "postcondition-violation" | "deadlock";
+type CheckStatus = "success" | "assumption-violation" | "invariant-violation" | "property-violation" | "liveness-violation" | "postcondition-violation" | "deadlock" | "error";
 interface TraceStep {
   action: string | undefined;
+  label: string | undefined;
   state: Record<string, Value>;
 }
 interface Violation {
   name: string;
   trace: TraceStep[];
   loopStart: number | undefined;
+  loopLabel?: string;
   message?: string;
+  counts?: string;
+  unwitnessed?: Postcondition;
+}
+interface Postcondition {
+  name: string;
+  message: string;
+  counts?: string;
+}
+interface EvaluationFailure {
+  message: string;
+  trace: TraceStep[];
+  initialState: Record<string, Value> | undefined;
+  exitCode: number;
 }
 interface CheckResult {
   status: CheckStatus;
   violation: Violation | undefined;
+  failure: EvaluationFailure | undefined;
   generatedStates: number;
   distinctStates: number;
+  queuedStates: number;
   depth: number;
+  outDegrees: number[] | undefined;
+  fingerprintDistance: bigint | undefined;
 }
-export declare const check: (options: CheckOptions) => CheckResult;
-export declare class TlaError extends Error {
-  constructor(message: string, cause?: unknown);
-}
-export declare class TlaSyntaxError extends TlaError {
-  constructor(message: string, cause?: unknown);
-}
-export declare class TlaConfigError extends TlaError {
-  constructor(message: string, cause?: unknown);
-}
-export declare class TlaEvaluationError extends TlaError {
-  constructor(message: string, cause?: unknown);
-}
-export declare class TlaUnsupportedError extends TlaError {
-  constructor(message: string, cause?: unknown);
-}
-interface ParallelCheckOptions extends CheckOptions {
-  workers: number;
-}
-export declare const checkInParallel: (options: ParallelCheckOptions) => Promise<CheckResult>;
+export declare const check: (options: CheckOptions) => Promise<CheckResult>;
 export declare const parseModule: (source: string) => Module;
-export type { CheckOptions, CheckResult, CheckStatus, ConfigValue, ConstantAssignment, ModelConfig, Module, ParallelCheckOptions, Substitution, TraceStep, Value, Violation };
+export type { CheckOptions, CheckResult, CheckStatus, ConfigValue, ConstantAssignment, EvaluationFailure, ModelConfig, Module, Substitution, TraceStep, Value, Violation };