Vera is in **active development** at v0.0.155 — 810+ commits, 155 releases, 3,899 tests, 96% code coverage, 86 conformance programs, 34 examples, and a 13-chapter specification. See **[HISTORY.md](HISTORY.md)** for how the compiler was built.

3,899 tests, 86 conformance programs, 34 examples, 13 spec chapters.

| **Tests** | 3,899 across 32 files (~53,184 lines of test code; 3,869 passed + 16 stress, 14 skipped) |

| `test_codegen.py` | 1,111 | 18,861 | WASM compilation, arithmetic, Float64, Byte, arrays (incl. compound element types), ADTs, match (incl. nested patterns), generics, State\<T\>, Exn\<E\> handlers, control flow, strings, string escape sequences, IO (read\_line, read\_file, write\_file, args, exit, get\_env, sleep, time, stderr), bounds checking, quantifiers, assert/assume, refinement type aliases, pipe operator, string built-ins, built-in shadowing, parse\_nat Result, GC, Markdown host bindings, Regex host bindings, Map collection, Set collection, Decimal type, Json type, Html type, Http effect, Inference effect, Random effect, example round-trips, GC shadow stack overflow, **WASM tail-call optimization** (#517 — `return_call` emission for tail-position calls, 50K- and 1M-iteration stress, structural assertions on `return_call`/plain `call` boundary, **GC-aware TCO for allocating fns (#549 — `$gc_sp` restore before each `return_call`)**, postcondition-fallback regression (still reverts to plain `call`), analyzer unit tests covering Block-trailing / IfExpr-both-branches / MatchExpr-arm-bodies / let-value-NOT-marked / call-args-NOT-marked / ExprStmt-statement-NOT-marked / IfExpr-condition-NOT-marked / MatchExpr-scrutinee-NOT-marked) |

below `gc_heap_start` (~147 KiB) so the heap-range check

the in-heap field is always >= 2 GB, structurally outside

handles (>= 2 GB) and heap pointers (< 2 GB) are

guaranteed disjoint. Without this guard a 3+ GB heap

f"$alloc body. Without it, a >2 GB heap would let "

`read_json` would fall through to the warning + empty-

dict path (`json_serde.py` line 213), and

`json_stringify` would emit `{}` instead of the object.

# #578 invariant: raw_handle must be an unsigned 31-bit

# integer so ``raw_handle | 0x80000000`` round-trips

# cleanly through the unwrap mask ``& 0x7FFFFFFF`` and

# through ``_write_i32``'s 32-bit truncation. Both

# directions break silently outside [0, 0x80000000):

# - Negative ints have bit 31 set in two's complement,

# so `_write_i32` truncates and the unwrap returns a

# wrong handle.

# - Values >= 0x80000000 alias into the top half and

# collide with the tag-bit pattern.

# - Values >= 0x100000000 wrap on ``_write_i32`` and

# silently truncate to a wrong handle.

# Practical alloc counters are bounded well below 2^31

# — a 2B-handle session is wall-clock infeasible — but

# a silent round-trip failure is exactly the kind of

# latent corruption #578 itself sought to eliminate.

# Fail fast.

if not (

isinstance(raw_handle, int)

and 0 <= raw_handle < 0x80000000

):

raise RuntimeError(

f"#578: raw_handle={raw_handle!r} (kind={kind!r}, "

f"body_ptr={body_ptr!r}) is outside the valid "

f"range [0, 0x80000000); cannot tag for the "

f"conservative-scan disjointness invariant. "

f"Host-store handle counters must be unsigned "

f"31-bit integers. Either a counter overflowed, "

f"a negative sentinel flowed in, or a non-integer "

f"value flowed into _wrap_handle."

)

except Exception as exc: