Calx

**Plan:** `P7.3` in [Phase 7](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-7-plugin-host-native-calx-first-then-wasm) In plugin builds, the compiler adds cheap budget checks at loop back-edges, so a runaway native plugin can be stopped without a sandbox.

**Plan:** `P7.10` in [Phase 7](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-7-plugin-host-native-calx-first-then-wasm) Calx emits C and clang compiles C to wasm32, so a plugin that stays inside the host API should build both ways from one source.

`std.fs.read_link(path) -> String ! FsError`: what a symbolic link points to, unresolved, as Java's `Files.readSymbolicLink` gives it.

**Plan:** [Phase 9](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-9-plugin-sdk-tooling-and-docs-site) The Calx side of Phase 9.

`Handle<T>` refers to an object in a slot map.

`Shared<T>` holds data that many iterations of a `parallel for` read at the same time, without copying it into each one.

`parallel for` over the values of a slot map or a map, and on a thread pool the program chooses rather than the default one.

Values of different types together: `dyn` interfaces, associated types, and interfaces for the operators.

A list whose capacity grows exactly as `java.util.ArrayList`'s does, for code that must match Java's capacities.

A plugin's panic stops that plugin and nothing else, and all of its memory is freed when it stops.

Quarry fetches and builds Calx libraries, which are called stones, at quarry.calxlang.com.

**Plan:** `P0.6` in [Phase 0](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-0-design-on-paper).

**Plan:** `P0.3` in [Phase 0](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-0-design-on-paper).

**Plan:** `P4.1` in [Phase 4](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-4-protocol-and-a-flat-world) Declare a packet's fields once and generate its reader and writer.

Calcite needs files from P4.2 on: `server.properties`, `server-icon.png`, and later worlds, logs and plugins.

Calcite's log lines carry the local time (`[HH:mm:ss]`), and std.time only had a monotonic clock.

`net.close` reset the connection on Windows: the runtime keeps a `WSARecv` pending, and `closesocket` with a receive pending aborts the connection, so a peer that hadn't read yet lost what was sent just before the close.

`calx build x.calx -o build/server/x.exe` failed with `can't write ...: unknown error` when `build/server` didn't exist.

Vanilla names a connection by its address in logs (`/127.0.0.1:50412 lost connection: ...`), and needs it for `log-ips`, IP bans, `prevent-proxy-connections` and the login's throttling.

Found while testing Calcite's login (CAL-37).

A Calx program that recurses too deep dies with no message: 0xC00000FD on Windows, SIGSEGV on Linux.

`Box<T>` owns one value on the heap, so a type can hold itself through it, as the spec has it.

For Calcite's boot cache (CAL boot card): - **A build ID:** a hash of the program's generated C and the runtime, the same for the same program and different when any of it changes, so a program can key caches on its own code.

Calcite's `logs/latest.log` rolls as log4j's `RollingRandomAccessFile` does, which names an archive for the day the file was last written (`File.lastModified`).

Calcite's console colors its lines on a terminal, and writes vanilla's plain lines to a pipe or a file, which hosting panels read (CAL-50).

For Calcite's live status bar ([CAL-55](https://acta.aaenz.no/aaen-studios/calcite#CAL-55)).

Calcite's console bar (CAL-55) needs two things std doesn't have yet.

Calx has no way to read text a line at a time: `std.io` reads bytes, and the guide's first program (CLX-36) needs lines.

Left over from CLX-19 (`P3.12`), which closed with the Phase 3 gate: every shipped feature has its reference page (G3.3), but `docs/guide/` doesn't exist yet.

`xs.sort()` beats Rust 1.91's `sort` on every list measured, and its `sort_unstable` on all but one: 10,000 random `i64` take 0.066 ms against 0.053 ([D96](https://github.com/ellipog/calx/blob/main/docs/reference/lists.md#sorting)).

Left over from CLX-18 (`P3.11`), which closed with the Phase 3 gate.

Found in CLX-35.

Found in CLX-35.

**Plan:** `P5.1` in [Phase 5](https://github.com/ellipog/calcite/blob/main/docs/PLAN.md#phase-5-chunks-storage-regions-and-worldgen) Palette containers for block states and biomes, plus what chunk sections and heightmaps need from the language.

For Calcite's region files ([CAL-61](https://acta.aaenz.no/aaen-studios/calcite#CAL-61)), which vanilla writes in place: a chunk's sectors, then the header that points at them.

Calcite's world folder needs `session.lock` as vanilla's `DirectoryLock` takes it (CAL-61): open the file to write, creating it, write `☃` at its start, sync it, then take an exclusive lock on the whole file without waiting, as Java's `FileChannel.tryLock`.

Vanilla's messages print paths as Java's `Path` does, with the system's separator: `.\world\level.dat` on Windows, `./world/level.dat` on Linux.

Vanilla removes keys from fastutil tables with the iterator in loops that act on each key as they go: `TicketStorage.removeTicketIf` (tickets that run out, telling the chunk trackers about each chunk) and `ChunkMap.processUnloads`.

Found by Calcite's chunk workers (CAL-65): `var data = parsed else { ...