Signatures, Storage, Surfaces

This release is about signatures, storage, and surfaces. Crypto you can trust. Bytes you can read out of a file nobody shipped a tool for. Industrial fieldbus nobody updates. Outdoor tracks people actually care about. And a compiler pass that turns a pipeline into a literal.

◉ Uniqueness, still enforced

Five paths, all verified 404 before any byte shipped.

- lateralus-stdlib/crypto/ed25519.ltl — RFC 8032 Ed25519 sign/verify - lateralus-stdlib/db/sqlite_btree.ltl — SQLite 3 page/B-tree reader - lateralus-examples/niche/modbus_rtu.ltl — Modbus RTU codec + client - lateralus-examples/niche/gpx_tracks.ltl — GPX reader/writer + stats - lateralus-compiler/pass/const_fold.ltl — pipeline-aware const folding

◉ 1. Ed25519, written the way the RFC reads

Every entry point follows RFC 8032 nomenclature — keypair(seed), sign(seed, public, message), verify(public, message, signature) — and the internal structure mirrors ref10: Edwards-curve addition in extended coordinates, SHA-512 for hashing, a constant-time scalar multiplication for signing, and a split-file layout so the algorithm file reads like the RFC and the field arithmetic lives in a support module.

◉ 2. SQLite at the page level

You have a 4 GiB .sqlite file and something is wrong with it. You don't want a SQL engine, you want to see the pages. db/sqlite_btree.ltl reads the 100-byte file header, decodes every B-tree page kind (InteriorTable 0x05, LeafTable 0x0D, and friends), parses SQLite's nine-byte varint, and exposes walk_table(bytes, root_page, header) as an iterator of (rowid, payload) pairs. Forensics, schema archaeology, and corruption triage in one 200-line module.

◉ 3. Modbus RTU — the protocol that refuses to die, part II

1979 called and wants its protocol back. Every solar inverter, VFD, and HVAC controller still speaks Modbus RTU: a slave address, a function code, some data, and a little-endian CRC-16 with polynomial 0xA001. This release ships the codec for function codes 0x01..0x10, CRC-16 handrolled, exception responses decoded, and a Transport = fn([Byte]) -> Result<[Byte], String> abstraction that lets you drop in an RS-485 driver, a TCP bridge, or a mock for tests without touching the protocol layer.

let client = |bytes| rs485::send_recv(port, bytes, timeout)
let regs   = request(client,
                     Request::ReadHoldingRegisters {
                         address: 1, start: 0, count: 10 })?

◉ 4. GPX, the outdoors format

niche/gpx_tracks.ltl parses GPX 1.1 — waypoints, routes, tracks, extensions for HR/cadence — and ships a stats() function that computes haversine distance, duration, moving time against a configurable threshold, total ascent and descent (counting only positive/negative elevation deltas), average and max speed, and average heart rate. Perfect for turning a ride export into a ride report in five lines.

◉ 5. Pipelines fold to literals

The compiler pass in this release makes the following true: if every stage of a pipeline is pure and every non-pipeline argument is a literal, the whole expression becomes a literal in the IR.

[1, 2, 3] |> map(|x| x * x) |> sum()
// compiles to the literal `14`

fold_expr walks every Expr::BinOp, Expr::If, Expr::Match, Expr::Call, and Expr::Pipeline and collapses the ones it can prove pure. The shortlist of allowed stdlib functions (iter::map, iter::filter, iter::sum, iter::len, math::abs) is the conservative default; user code opts in with #[const] and gets evaluated in a CTFE sandbox. The pass reports how many expressions it folded, so benchmarks can see the effect in a build log.

◉ Pattern holds

Twenty-five modules across five releases, zero duplicates, 100% push success. The ecosystem now has primitives for borrow-checking, LSP, GraphQL, WASM, HTTP, capability tracking, FASTA, Game Boy ROMs, LoRa, MIDI, CAN, EXIF, SNMP, macros, PostScript, Ed25519, SQLite, Modbus, GPX, and pipeline-folding. That's wider than most first-year ecosystems ever get.