tla-checker 0.3.2

package/README.md

@@ -0,0 +1,262 @@
+# tla-rs
+
+A TLA+ model checker and interactive exploration tool written in Rust.
+
+tla-rs verifies TLA+ specifications by exploring all reachable states, checking invariants, and reporting counterexamples. Beyond pass/fail checking, it provides an interactive TUI for stepping through state spaces, scenario-driven exploration, property satisfaction analytics with depth breakdowns, and parameter sweeps for sensitivity analysis. The core library compiles to WebAssembly, so it can be embedded in browser applications. It's designed as a lightweight alternative to the official TLC model checker for specs that fit its supported subset.
+
+## Installation
+
+```bash
+cargo build --release
+```
+
+The binary will be at `target/release/tla`.
+
+## Quick Start
+
+```bash
+tla spec.tla
+tla spec.tla -c 'N=5' -c 'Procs={"p1","p2","p3"}'
+tla spec.tla -c 'Proc={"a","b","c"}' --symmetry Proc
+tla spec.tla --config model.cfg
+tla spec.tla --quick    # limit to 10,000 states
+tla spec.tla -i         # interactive TUI
+```
+
+Constants accept integers (`42`), booleans (`TRUE`), strings (`"hello"`), and sets (`{1,2,3}`).
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-c NAME=VALUE` | Set a constant value |
+| `-s CONST` | Enable symmetry reduction for a constant |
+| `--config PATH` | Load TLC-style cfg file (auto-discovers `Spec.cfg` next to `Spec.tla`) |
+| `--max-states N` | Maximum states to explore (default: 1000000) |
+| `--max-depth N` | Maximum trace depth (default: 100) |
+| `-q` | Quick exploration (limit: 10,000 states) |
+| `--export-dot FILE` | Export state graph to DOT format |
+| `--dot-mode MODE` | DOT mode: `full`, `trace`, `clean` (default), `choices` |
+| `--allow-deadlock` | Allow states with no successors |
+| `--check-liveness` | Check liveness and fairness properties |
+| `--continue` | Continue past invariant violations |
+| `--count-satisfying NAME` | Count states satisfying a definition (repeatable) |
+| `--sweep NAME=V1;V2;...` | Sweep a constant across values, compare results |
+| `--scenario TEXT` | Explore a specific scenario (or `@file`) |
+| `-i` | Interactive TUI exploration mode |
+| `--json` | JSON output |
+| `-v` | Verbose output (depth breakdowns, etc.) |
+
+## Configuration Files
+
+tla-rs supports TLC-compatible `.cfg` files. If `Spec.cfg` exists next to `Spec.tla`, it is loaded automatically. Use `--config PATH` to specify an explicit path.
+
+```
+CONSTANT RM = {rm1, rm2, rm3}
+INIT TPInit
+NEXT TPNext
+INVARIANT TPTypeOK
+CHECK_DEADLOCK TRUE
+```
+
+Supported directives: `INIT`/`NEXT`, `SPECIFICATION` (temporal formula in `Init /\ [][Next]_vars` form), `CONSTANT`/`CONSTANTS`, `INVARIANT`/`INVARIANTS`, `PROPERTY`/`PROPERTIES`, `SYMMETRY`, and `CHECK_DEADLOCK`. CLI flags override cfg values.
+
+## Scenarios
+
+Drive the checker along specific execution paths using TLA+ expressions:
+
+```bash
+tla spec.tla --scenario "step: count' = count + 1
+step: count' = count + 1
+step: count' = count + 1"
+```
+
+Or load from a file with `--scenario @scenario.txt`. Each `step:` line is a TLA+ predicate over current (unprimed) and next (primed) state variables.
+
+```
+step: x' > x                    # x increases
+step: "s1" \in active'          # s1 becomes active
+step: pc'["p1"] = "critical"    # p1 enters critical section
+```
+
+## Analytics
+
+These flags are for understanding *how* a protocol fails, not just *whether* it fails.
+
+Without `--continue`, the checker stops at the first violation. With it, all violations are collected and counted per-invariant across the full state space:
+
+```bash
+tla spec.tla --allow-deadlock --continue
+```
+
+`--count-satisfying` measures what fraction of reachable states satisfy a predicate. Add `--verbose` to get per-depth breakdowns showing at which exploration depth violations start appearing:
+
+```bash
+tla spec.tla --allow-deadlock --continue \
+  --count-satisfying InvSafety --verbose
+```
+
+`--sweep` varies a constant across multiple values and produces a comparison table, useful for sensitivity analysis:
+
+```bash
+tla spec.tla --sweep 'N=2;3;4;5' --count-satisfying Inv --allow-deadlock
+```
+
+`--json` returns structured data including `properties` array with `depth_breakdown` per property.
+
+### The C-3PO Example
+
+C-3PO famously calculates "the possibility of successfully navigating an asteroid field is approximately 3,720 to 1." The spec `examples/c3po_asteroid_field.tla` models the Empire Strikes Back asteroid chase: variable-damage asteroid impacts, TIE fighter attacks, TIEs getting destroyed by asteroids, hiding in the space slug's cave, mynock damage, escaping the exogorth's mouth, and the only real escape — attaching to a Star Destroyer's hull and floating away with the garbage. No hyperspace: the hyperdrive is dead.
+
+The `Density` constant controls asteroid damage range (1..Density). Higher values create more damage variants per action, biasing the state space toward destruction.
+
+```bash
+tla examples/c3po_asteroid_field.tla -c 'Density=3' \
+  --allow-deadlock --continue \
+  --count-satisfying InvNeverTellMeTheOdds \
+  --count-satisfying Escaped --verbose
+```
+
+The depth breakdown shows destruction starting early and escape requiring a long sequence of correct decisions — surviving asteroids, hiding in the cave, taking mynock damage, escaping the slug, then waiting for all TIE fighters to be destroyed before drifting onto a Star Destroyer's hull.
+
+## Interactive Mode
+
+Launch the TUI with `-i` to step through state spaces manually. You can select and take transitions, backtrack, evaluate expressions in a REPL, trace variable changes across history, test hypotheses against all visited states, and toggle guard condition display. Actions with many variable changes expand inline so you can see exactly what each transition does.
+
+![Interactive mode — navigating the C-3PO asteroid field spec](falcon-escape.gif)
+
+Key bindings: `↑`/`↓` select actions, `Enter` takes the selected action, `→`/`Space` expands grouped changes, `←` collapses, `b` backtracks, `e` opens the REPL, `t` shows variable trace, `h` tests a hypothesis, `g` toggles guards, `w` random walks N steps, `u` steps until a condition holds, `s`/`l` save/load traces, `r` resets to initial state, `q` quits.
+
+```bash
+tla examples/c3po_asteroid_field.tla -c 'Density=3' --allow-deadlock -i
+```
+
+## Supported TLA+ Subset
+
+tla-rs implements the Naturals, Integers, Sequences, FiniteSets, TLC, Bags, and Bits standard modules. See `SYNTAX_STATUS.md` for the full operator-by-operator coverage table.
+
+The supported operator categories: logic (`/\`, `\/`, `~`, `=>`), comparison, arithmetic, sets (`\in`, `\union`, `\intersect`, `SUBSET`, `UNION`), functions (`[x \in S |-> e]`, `DOMAIN`, `EXCEPT`, `@@`), quantifiers (`\E`, `\A`, `CHOOSE`), records, tuples/sequences, `IF-THEN-ELSE`, `CASE`, `LET-IN`, primed variables, `UNCHANGED`, transitive closure, module instances (`INSTANCE` with qualified calls), and Unicode equivalents for all operators.
+
+### Module Instances
+
+Specs can use `INSTANCE` to import and compose modules:
+
+```tla
+---- MODULE pingpong ----
+LOCAL INSTANCE Naturals
+
+VARIABLES server_to_client, client_to_server
+
+Data == [message: {"ping"}] \cup [message: {"pong"}]
+
+ServerToClientChannel(Id) == INSTANCE MChannel WITH channels <- server_to_client
+ClientToServerChannel(Id) == INSTANCE MChannel WITH channels <- client_to_server
+
+Next ==
+    \/ \E id \in ClientIds: ServerToClientChannel(id)!Send([message |-> "ping"])
+    \/ \E id \in ClientIds: ClientToServerChannel(id)!Recv([message |-> "pong"])
+====
+```
+
+Both static (`Alias == INSTANCE M WITH ...`) and parameterized (`Alias(p) == INSTANCE M WITH ...`) instances are supported. Library modules without Init/Next work as expected. The module file must be in the same directory as the spec.
+
+### Spec Structure
+
+```tla
+---- MODULE Example ----
+EXTENDS Naturals
+
+CONSTANT N
+VARIABLES x, y
+
+Init == x = 0 /\ y = 0
+
+Next ==
+    \/ (x < N /\ x' = x + 1 /\ y' = y)
+    \/ (y < N /\ x' = x /\ y' = y + 1)
+
+TypeOK == x \in 0..N /\ y \in 0..N
+Inv == x + y <= 2 * N
+====
+```
+
+Invariants are detected by naming convention: definitions starting with `Inv`, `TypeOK`, or `NotSolved` are automatically checked.
+
+## Output
+
+On success:
+```
+Model checking complete. No errors found.
+
+  States explored: 1331
+  Transitions: 3630
+  Max depth: 31
+  Time: 0.019s
+```
+
+On invariant violation, you get a counterexample trace with state diffs marking changed variables. On deadlock, a trace to the deadlock state with a suggestion to use `--allow-deadlock`. Parse errors show source locations, and undefined variables suggest similar names.
+
+## State Graph Visualization
+
+```bash
+tla spec.tla --export-dot graph.dot
+tla spec.tla --export-dot graph.dot --dot-mode full
+dot -Tpng graph.dot -o graph.png
+```
+
+Four export modes are available via `--dot-mode`:
+
+| Mode | Description |
+|------|-------------|
+| `clean` (default) | All nodes, no self-loops, parallel edges merged into single labeled edges |
+| `full` | All nodes and all edges including self-loops, each edge separate |
+| `trace` | Only counterexample trace nodes and edges (falls back to full if no trace) |
+| `choices` | Trace path plus alternative transitions at each trace state; non-trace nodes shown dashed, alternative edges gray/dashed (falls back to full if no trace) |
+
+Error states are highlighted in red. Trace edges are red and thick in all modes.
+
+## WebAssembly
+
+The core library compiles to WASM for browser embedding:
+
+```bash
+cargo make wasm
+```
+
+This produces a `pkg/` directory with the WASM module and JS bindings. The WASM API provides `check_spec`, `check_spec_with_config`, `check_spec_with_cfg`, and `check_spec_with_options` — all returning JSON results with success status, state count, error traces, and optional DOT graph output.
+
+The `check_spec_with_options` API accepts a JSON options object:
+
+```js
+const result = JSON.parse(check_spec_with_options(specSource, JSON.stringify({
+  constants: { N: 3 },
+  max_states: 10000,
+  max_depth: 50,
+  allow_deadlock: true,
+  export_dot: true,
+  dot_mode: "choices",   // "full", "trace", "clean" (default), "choices"
+  cfg_source: "INIT Init\nNEXT Next\n"
+})));
+
+if (result.dot) {
+  // DOT graph string: "digraph StateGraph { ... }"
+}
+```
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `constants` | object | Constant values (`{"N": 3, "Procs": ["a","b"]}`) |
+| `cfg_source` | string | TLC-style cfg file contents |
+| `max_states` | number | Maximum states to explore |
+| `max_depth` | number | Maximum trace depth |
+| `allow_deadlock` | bool | Allow states with no successors |
+| `export_dot` | bool | Include DOT graph in result |
+| `dot_mode` | string | DOT export mode: `full`, `trace`, `clean` (default), `choices` |
+
+## Limitations
+
+`Nat` and `Int` are bounded (-100 to 100 by default). Temporal operators `[]`, `<>`, `~>` are parsed but cannot be evaluated directly — use `--check-liveness` for fairness/liveness properties via SCC analysis. Unbounded quantifiers (`\E x : P` without `\in S`) and `Seq(S)` enumeration are not supported. Recursive operators must be declared with `RECURSIVE`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "tla-checker",
+  "version": "0.3.2",
+  "type": "module",
+  "description": "A TLA+ model checker compiled to WebAssembly",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fabracht/tla-rs.git"
+  },
+  "main": "tla_checker.js",
+  "types": "tla_checker.d.ts",
+  "files": [
+    "tla_checker_bg.wasm",
+    "tla_checker.js",
+    "tla_checker.d.ts",
+    "tla_checker_bg.wasm.d.ts"
+  ],
+  "keywords": [
+    "tla",
+    "model-checking",
+    "formal-verification",
+    "wasm"
+  ],
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/tla_checker.d.ts

@@ -0,0 +1,46 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function check_spec(spec_source: string, constants_json: string): string;
+
+export function check_spec_with_cfg(spec_source: string, cfg_source: string, constants_json: string, max_states: number, max_depth: number, allow_deadlock: boolean, export_dot: boolean): string;
+
+export function check_spec_with_config(spec_source: string, constants_json: string, max_states: number, max_depth: number, allow_deadlock: boolean, export_dot: boolean): string;
+
+export function check_spec_with_options(spec_source: string, options_json: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly check_spec: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly check_spec_with_cfg: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly check_spec_with_config: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly check_spec_with_options: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/tla_checker.js

@@ -0,0 +1,305 @@
+/* @ts-self-types="./tla_checker.d.ts" */
+
+/**
+ * @param {string} spec_source
+ * @param {string} constants_json
+ * @returns {string}
+ */
+export function check_spec(spec_source, constants_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(spec_source, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(constants_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.check_spec(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} spec_source
+ * @param {string} cfg_source
+ * @param {string} constants_json
+ * @param {number} max_states
+ * @param {number} max_depth
+ * @param {boolean} allow_deadlock
+ * @param {boolean} export_dot
+ * @returns {string}
+ */
+export function check_spec_with_cfg(spec_source, cfg_source, constants_json, max_states, max_depth, allow_deadlock, export_dot) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(spec_source, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(cfg_source, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(constants_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.check_spec_with_cfg(retptr, ptr0, len0, ptr1, len1, ptr2, len2, max_states, max_depth, allow_deadlock, export_dot);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred4_0 = r0;
+        deferred4_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {string} spec_source
+ * @param {string} constants_json
+ * @param {number} max_states
+ * @param {number} max_depth
+ * @param {boolean} allow_deadlock
+ * @param {boolean} export_dot
+ * @returns {string}
+ */
+export function check_spec_with_config(spec_source, constants_json, max_states, max_depth, allow_deadlock, export_dot) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(spec_source, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(constants_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.check_spec_with_config(retptr, ptr0, len0, ptr1, len1, max_states, max_depth, allow_deadlock, export_dot);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} spec_source
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function check_spec_with_options(spec_source, options_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(spec_source, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.check_spec_with_options(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+    }
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+    };
+    return {
+        __proto__: null,
+        "./tla_checker_bg.js": import0,
+    };
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('tla_checker_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/tla_checker_bg.wasm.d.ts

@@ -0,0 +1,11 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const check_spec: (a: number, b: number, c: number, d: number, e: number) => void;
+export const check_spec_with_cfg: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+export const check_spec_with_config: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const check_spec_with_options: (a: number, b: number, c: number, d: number, e: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;