v0.1.716

The self-host parser and typer now support parameterized record, variant and alias declarations, including multiple type arguments. Record literals, field access, updates and patterns share their receiver's arguments while separate uses instantiate independently.

Field access and updates reject primitive, variant, opaque and unresolved receivers. Annotate lambda parameters when their record type is otherwise unknown. Aliases expand in annotations, fields, constructor payloads and extern signatures in declaration order. Substitution chains retain newer constraints, and module flattening preserves canonical bare type identity and declaration order.

Validation retains all 191 gates, nine groups and four build configurations: 3,178 full-toolchain tests, 251 parity programs, 100 handwritten self-host output lines on five execution paths, 28 required refusals on three typer paths, formatter round trips and a type-declaration bootstrap. Actual optimized browser modules are checked as well; all 15 existing Wasm size bands remain unchanged.

Assets: macOS arm64 and Linux x86_64, with SHA256SUMS. The Linux binary supports stock Ubuntu 24.04 and 26.04.

v0.1.715

The self-host Wasm compiler short-circuits && and ||, evaluating the left operand once and the right operand only when selected. Logical tail position is preserved in both the self-host and reference Wasm emitters; both execute 50,000 tail calls at the default Node stack limit.

Self-host type inference validates field sets for declared records, including empty records. Literals require every field exactly once. Access, updates and patterns reject unknown fields, while partial patterns and updates remain supported. Shape registration is shared by ordinary inference and annotation; compatibility for unregistered record ASTs remains unchanged.

Four mandatory fixtures verify 63 handwritten output lines through five execution paths. Nine malformed records must produce field diagnostics on three type-checking paths, and a valid record must still compile and execute. Bootstrap self-compilation also preserves skipped traps. The full-toolchain suite has 3,112 tests and the parity inventory has 251 programs; all 191 gates, nine groups and four build configurations remain required.

Linux x86_64 and macOS arm64 assets are provided with SHA256SUMS. Linux binaries are built on Ubuntu 24.04 and verified on stock Ubuntu 24.04 and 26.04.

v0.1.714

The Mere self-hosted parser, evaluator, typer, formatter and Wasm compiler support nested or-patterns and exact-byte string prefix patterns. Alternative bindings come from the first structural match before the guard runs; repeated names use the last binding in traversal order. Local let bindings retain their lexical scope, including when pattern names shadow outer variables. Length-aware string equality and literal interning preserve embedded NUL, and WAT emission escapes control and non-ASCII bytes. Two required fixtures verify 42 handwritten output lines through five paths, and the bootstrap fixpoint compares generated WAT byte for byte and executes its pattern program.

The reference interpreter, C, LLVM, Wasm, RV32 and RV64 support composable patterns, including nested choices, prefixes, aliases, duplicate names, top-level initialization and shadowing. The required pattern fixture has 114 handwritten answers. C, LLVM and Wasm retain linear output growth for independent choices.

Generated C FFI headers include borrowed callback closure types, including callbacks in monomorphic records and curried callbacks. Declaration-wide validation rejects unsupported callback ABIs and incomplete headers. Separate C compilation checks captured values, record and byte arguments, unit/curried callbacks and region scopes at O0/O2.

The complete Unicode normalization corpus runs in two bounded workers, retaining all 20,034 cases and six assertions per case. Formatter corpus gates run in downstream. All 191 required gates, nine integration groups and four build configurations remain enabled. The full-toolchain unit suite has 3,070 tests and the parity inventory has 251 programs.

CI, Pages and release jobs obtain opam through the official GitHub release API, avoiding failed public asset redirects. Require matching release sizes and SHA-256 digests plus detached GPG signatures from the setup action's expected primary key before atomically publishing its tool-cache entry. Pin the same setup action implementation and retain compiler caches, all 191 gates, nine groups and four build configurations. The assignment gate runs 17 bootstrap rejection controls and 32 workflow routing controls.

Linux x86_64 and macOS arm64 assets are provided with SHA256SUMS. Linux binaries are built on Ubuntu 24.04 and checked on stock Ubuntu 24.04 and 26.04.

Pinned CI tool downloads verify release API sizes and SHA-256 digests before extraction. The installer falls back to official API endpoints when public redirects fail, retaining checksum, version and program checks before atomic replacement.

v0.1.713

Resource with-expressions now require a present close field to have type unit -> unit. The checker substitutes record type arguments before constraining and generalizing the resource, so parameterized resources and wrappers preserve the contract. Invalid close values are rejected consistently by the interpreter, checker and every compiled target.

RV32 and RV64 support with-expressions, including single acquisition, LIFO cleanup and preservation of the body result. Existing failure behavior is preserved: cleanup follows normal return and does not provide exception finalization. Wasm close-field accesses use the current eight-byte value layout, and LLVM uses instantiated record aggregates and the i64 unit calling convention.

The README execution gate runs in the containers group while retaining its full-suite rerun. All 191 gates, nine integration groups and four build configurations remain required. Runtime oracles require resource scopes and factory values to execute at both RISC-V widths.

Linux x86_64 and macOS arm64 assets are provided with SHA256SUMS. Linux binaries are built on Ubuntu 24.04 and checked on stock Ubuntu 24.04 and 26.04.

v0.1.712

Wasm now supports unannotated builtin factory values when their uses resolve to one concrete return type, including aliases and nested scopes. Native C also fixes factory adapter declaration order and lexical bindings in with-expressions.

The new snapshot API copies immutable plain data so it can survive explicit Map or Vec compaction and recycling. Arguments are evaluated once in the caller's scope. Containers, functions, borrows and capabilities are rejected recursively; unresolved snapshot wrappers and aliases remain monomorphic to preserve that bound.

Hosted RISC-V execution is partitioned across existing CI groups while retaining all-mode coverage, output comparisons, named refusals and known-difference freshness checks. All 191 required gates remain enforced. Lifetime negative controls and snapshot regression checks cover recycling, ASan/UBSan, copy-removal failures and type refusals.

Assets are provided for Linux x86_64 and macOS arm64. Linux binaries are built on Ubuntu 24.04 and checked on stock Ubuntu 24.04 and 26.04. SHA256SUMS accompanies the verified assets.

v0.1.711

Add addressed UDP send and receive to the shared C/LLVM native socket runtime through sock_sendto and sock_recvfrom. Numeric IPv4/IPv6 sender metadata, binary and empty packets, flags, arena bounds and thread-local errno are covered by the loopback gate. A zero-capacity receive without sender metadata reports EAGAIN; queued packets retain their sender.

Reduce C Map storage when replacing a list with its existing tail, and size a compacted map's first arena block to its live entries. Deterministic capacity checks reject controls that restore either former allocation policy. The Map suffix fixture also checks a copied snapshot across replacement and compaction.

Update the code-generation guide, tutorial and collection example to describe implemented backends and concrete builtin factory values. Retain phase tables as implementation history, use the maintained Wasm host runner, and document the existing C compaction boundary for uncopied reads on the running stack.

Validation includes 2,946 tests, 248 parity programs, all 188 required CI gates, native UDP checks, and Map capacity and sanitizer checks. Distribution binaries are built for macOS arm64 and Linux x86_64; the Linux binary is checked on stock Ubuntu 24.04 and 26.04.

v0.1.710

Fix inferred types of returned closures passed through aliases. Coroutine factories now compile on C and LLVM without an explicit Coro[unit] parameter annotation. Type specialization also respects nested bindings of the same name and propagates newly concrete uses through producers.

Add regressions for ordinary and sized coroutines, once-only factory effects, region copies, and aliased closures accepting record, tuple, function and SIMD arguments. The parity corpus now contains 247 programs.

Update host I/O documentation to match current read_lines, env_var and Wasm stderr support. File parity checks include empty files and final newlines.

Configure Linux package downloads before OCaml setup, using the official HTTPS Ubuntu archive, including indirect mirror lists, with bounded requests while preserving existing opam caches. All 187 required gates and four build configurations remain enabled.

Validation includes 2,946 tests, four-backend parity fixtures, compiler sanitizer checks, and type-processing scaling checks.

v0.1.709

Fix C allocation alignment for SIMD values captured by closures or stored in references, recursive values, vectors, maps, lists, views, and coroutine environments. Region block payloads and relocated buffers now honor the allocated type, while scalar allocation accounting retains its existing behavior. The allocation probe also records typed allocations and alignment padding.

Add full UBSan regressions for SIMD storage, allocator growth, forwarded accounting, and concurrent allocation, with three negative controls. Add a SIMD closure parity fixture covering the interpreter, C, LLVM, and Wasm backends.

Bound dependency setup in the build matrix, integration groups, Pages, and Release workflows. Dependency installation retries once; cancellation and command lookup failures stop immediately. All 187 required CI gates remain enabled.

Validation includes 2,946 tests, a 246-program parity inventory, and compiler checks with Clang, GCC 14, and GCC 15.

v0.1.708

Changes since v0.1.704:

• Reject overflowing bytes_slice ranges as catchable language failures on the interpreter, C, LLVM and Wasm. Check the remaining length before copying, and validate Wasm arguments before narrowing. Integer-limit regression coverage also checks substring, bytes, ByteBuf, Vec and resumed string search, including RV32/RV64.
• Check complete SIMD spans without overflowing the index in the interpreter, generated runtimes and range-versioning guards. Prove range-guard arithmetic before admitting unchecked loops, including wrapped products between endpoints. Return immediately from rejected Wasm SIMD accesses so caught failures cannot continue into memory reads or writes.
• Add str_index_from haystack needle offset across all backends. It returns the first matching byte position at or after the offset, or -1. Negative offsets begin at zero; an empty needle matches through the end of the haystack.
• Align ListBuf refusal behaviour: LLVM reports an already-frozen builder before ownership; RISC-V enforces the builder's creation region for pushes. Shared buffer contract checks cover reads, writes, snapshots, freezing, argument effects and region recovery.
• Improve string equality by checking lengths first, and avoid region accounting work unless requested.
• Keep all 187 CI checks across nine groups while installing QEMU and the RISC-V disassembler only in their own group. Bound network setup with timeouts and retries, and retain checks for missing required tools and unwired gates.

The source includes 2,946 unit checks and 245 parity programs. CI checks the Linux x86_64 binary on stock Ubuntu 24.04 and 26.04 and the macOS arm64 binary on its native runner.

Download the binary for your platform together with SHA256SUMS and verify its checksum. The installer verifies the checksum, exact version and a smoke program before replacing an existing installation.

v0.1.704

Changes since v0.1.698

• The interpreter claims released OwnedVec storage atomically, so only one domain can acquire it. Ordinary Vec shared-bit updates also use atomics.
• Vec conversions, traversals, failed bounds checks and file output now mark previously missed foreign reads on the affected interpreter, C and LLVM paths, including empty vectors.
• LLVM Map iteration marks reads for both hashed and linear layouts, including empty and fully deleted Maps. C region-loop copies mark the Maps and Vecs they read, including nested containers, while their copies retain independent storage and ownership.
• Wasm's linear Map lookup raises a catchable missing-key failure. Map iteration propagates failures from either callback stage and stops before visiting later entries.
• C and Wasm guarded matches preserve the remaining arms correctly. Curried closures avoid repeated body emission, and LLVM IR containing musttail calls builds with optimizations enabled.
• Generated C on macOS reuses same-size mapped blocks through a cache bounded to 256 blocks and 16 MiB.
• CI now requires 185 integration checks, including common Vec and Map read/failure matrices with explicit expected results and negative controls.

Programs that relied on writing a Vec or Map after another thread read it may now fail on paths whose runtime checks were previously missing. Give mutable storage one owner and exchange messages over Channels; independent immutable snapshots remain shareable.

The hand-written documentation includes inventories of Vec read boundaries and Map read boundaries, including backend support limits.

Downloads

Prebuilt binaries are available for Linux x86_64 and macOS arm64. SHA256SUMS contains their SHA-256 digests. The installer verifies the checksum, version and execution before replacing an existing binary.

Full changelog