build: finish Zig 0.18 standard-library migration

Home is preparing to move from the Pantry-pinned Zig 0.17 dev toolchain to 0.18/master. A source and compile audit against 0.18.0-dev.146 found three distinct classes that must be handled independently rather than by blanket rewrites.

Confirmed work:

• Remove only the obsolete error handling around std.crypto.dh.X25519.recoverPublicKey; retain X25519.scalarmult error propagation because it rejects attacker-controlled identity/small-order public inputs. Ed25519 deterministic generation and the visible AEAD/KDF checks remain fallible.
• Complete the std.Io migration. The tree already has broad std.Io adoption, but packages/io/src/async_io.zig still calls one-argument Threaded.init and the removed std.fs.cwd() surface. Many other legacy filesystem call sites require separate measured slices.
• Rename bare old optimize tags such as .ReleaseFast to lowercase tags where the contextual type is std.lang.Optimize. Qualified deprecated aliases still compile through 0.18, so this is mechanical rather than semantic.

Coverage findings:

• zig build --help, home-tool, and home-tsc build successfully with 0.18.0-dev.146.
• Direct compilation of the real packages/io and packages/build sources exposes failures that the top-level filtered tests do not compile.
• Main compiler/runtime production and test modules both link libc; no libltvpn-style test-only libc mismatch was found.
• Current Pantry, CI, and release workflows still pin 0.17.0-dev.2163, so green CI does not yet establish 0.18 compatibility.

Acceptance:

• Migrate in small independently verified slices that compile under both the current pinned compiler and the selected 0.18 baseline while dual support is required.
• Add real coverage for migrated package sources rather than placeholder tests.
• Preserve all meaningful cryptographic validation paths.
• Add an actual 0.18 CI lane before changing the project-wide pin, then move Pantry/release CI and documented commands together.

Related: #66, #855.

First migration slice landed directly on main as bcec002 (fix(io): migrate package filesystem operations (#884)).\n\nExactly three files changed. packages/io now uses the explicit std.Io filesystem surface, passes Threaded.init options, maps initWithThreads to the supported async limit, and exercises both embedded unit behavior and the public package module through its real standalone build graph. The obsolete Build.pathFromRoot test setup was also replaced rather than bypassed.\n\nPost-rebase verification:\n- Pantry Zig 0.17.0-dev.2163: 5/5 build steps, public tests 2/2, peak 334 MB.\n- Zig 0.18.0-dev.146: 5/5 build steps, public tests 2/2, peak 351 MB.\n- Direct embedded tests: 3/3 on each compiler.\n\nThe X25519 signature correction, optimize-tag cleanup, broader legacy std.fs inventory, and actual 0.18 CI lane remain open as separate slices. No cryptographic validation was removed in this commit.

Landed c142ab9989685eb3dd5bbb6991a57339e570df13 (fix(runtime): bridge X25519 recovery signatures (#884)) on origin/main.

This is a narrow semantic bridge rather than a blanket catch removal:

• Zig 0.17's fallible X25519.recoverPublicKey path is retained.
• Zig 0.18's direct [32]u8 return is accepted.
• X25519.scalarmult remains fallible; the attacker-controlled identity/small-order rejection was not weakened.
• Added a fixed RFC/Node vector unit test and wired it into the main test graph as crypto_compat.

Verification on the committed tree:

• pinned Zig 0.17: zig build test -Dfilter=crypto_compat -j1 passed (guard peak 279 MB)
• Zig 0.18.0-dev.146: same target passed (guard peak 362 MB)
• pinned Zig 0.17: zig build home-tool -j1 passed
• Zig 0.18.0-dev.146: zig build home-tool -j1 passed (guard peak 1,947 MB)
• both changed Zig files plus build.zig pass zig fmt --check under both compilers

The existing X25519 corpus invocation was blocked by the cached Home binary's jsc-disabled configuration, so it is explicitly not counted as a runtime pass.

Landed c451ed8525d62a7c2833c4af5ef9ac39da5c88f5 (fix(build): restore LTO compiler compatibility (#884)) on origin/main after rebasing over the latest FileHandle evidence commit.

What changed:

• OptimizeMode dispatch now uses qualified std.builtin.OptimizeMode.Debug/ReleaseSafe/ReleaseFast/ReleaseSmall lookups. This is a rename-only compatibility bridge: the aliases exist in the pinned 0.17 compiler and Zig 0.18, while tests exercise the canonical .debug/.safe/.fast/.small values.
• Migrated the LTO module from stale managed-ArrayList construction/calls to the current allocator-explicit API.
• Repaired stale IR-global and ThinLTO summary field construction.
• ThinLTO now frees owned function/import/export metadata and has OOM cleanup for partially built summaries.
• Wired packages/build/src/lto.zig into the top-level test graph as zig build test -Dfilter=lto; the previous -Dfilter=build run only compiled build_cli_options and did not cover this package.
• Updated the LTO documentation to name the real dual-version test target.

Verification:

• direct LTO suite: 6/6 under pinned Zig 0.17 (168 MB peak)
• direct LTO suite: 6/6 under Zig 0.18.0-dev.146 (162 MB peak)
• top-level -Dfilter=lto -j1: passed under pinned Zig 0.17 (324 MB peak)
• top-level -Dfilter=lto -j1: passed under Zig 0.18.0-dev.146 (369 MB peak)
• both top-level targets passed again after the rebase
• zig fmt --check passes under both compilers; git diff --check passes

Zig 0.18 migration checkpoint landed on main as 61b5cba (ci: gate Zig master compatibility).

Configuration findings and changes:

• Added a dedicated zig-master.yml lane using setup-zig's documented master selector. It runs on changes, daily schedule, and manual dispatch.
• The master lane currently gates the qualified compatibility seams: X25519 recovery, OptimizeMode/LTO, and packages/io std.Io migration.
• Release tests now run with -Doptimize=ReleaseFast, matching the optimization mode of the binaries packaged by release.yml. Previously the release job built ReleaseFast and then tested Debug.
• Stable CI and release builds remain on the Pantry-pinned 0.17 compiler; master churn is isolated to the compatibility lane.

Semantic audit:

• X25519.recoverPublicKey changed from an error union to a direct [32]u8 result; Home's compatibility helper accepts both signatures.
• X25519.scalarmult remains fallible. Home keeps both catches/try sites because they reject attacker-controlled identity/small-order public inputs.
• Ed25519 KeyPair.generateDeterministic is still fallible in 0.18.0-dev.146, so its catches remain.
• AEAD decrypt, PBKDF2, and scrypt error handling remains security-meaningful and was not removed.
• OptimizeMode is a rename-only compatibility concern; qualified legacy aliases are used where dual-version support is required.
• The broad std.Io migration is still separate scope. Existing unported std.fs filesystem call sites are not being mechanically rewritten until their exact 0.18 signatures and behavior are exercised.

Validation:

• Pickier passed on all three changed workflow files.
• Pinned Zig ReleaseFast crypto_compat: 1/1 passed, peak 229 MB.
• packages/io exact workflow command: 2/2 passed on Zig 0.17 and 0.18.0-dev.146, peaks 310 MB and 318 MB.
• No full master or full ReleaseFast suite claim is made locally; the new CI lanes are the persistent evidence.

Landed ec5e07048 (fix(ffi): propagate libc through public modules (#884)) directly on main.

This corrects the earlier audit statement that no test-only libc mismatch existed. The main compiler/runtime roots were consistent, but the standalone FFI package was not: both build graphs attached libc to test/example roots while the reusable ffi module omitted it. Consumers therefore did not inherit the module's actual C-library requirement.

The five-file slice:

• makes both public FFI modules own link_libc and removes root-level test/example compensation;
• removes the standalone header generator's unnecessary dependency on the entire basics package and migrates it to the current allocator-explicit ArrayList API and lowercase @typeInfo tags;
• restores the documented ffi.c_char/c_int/c_long/c_float/c_double public aliases;
• fixes CAllocator.resize, which previously called potentially-moving libc realloc and discarded the returned pointer; shrinking now retains the allocation and growth uses the allocator's safe alloc/copy/free fallback;
• adds a compile-only FFI test step so cross-target linkage is verified without pretending the host can execute the target binary.

Verification, one guarded process at a time under 3,840 MB:

• top-level FFI: 6/6 on pinned Zig 0.17 and Zig 0.18.0-dev.146;
• standalone FFI: 38/38 Debug and 38/38 ReleaseFast on both compilers;
• real math consumer: builds and runs successfully on both compilers;
• x86_64-linux compile-only test binary: succeeds in Debug and ReleaseFast on both compilers;
• all five Zig files pass zig fmt --check under both compilers; git diff --check passes.

The Linux checks prove compilation/linkage only; they are not represented as Linux runtime execution. Broader Zig 0.18 standard-library migration remains open.

Landed and pushed c6e950e04 (fix(session): migrate runtime services to std.Io (#884)) directly to origin/main.

This five-file slice migrates packages/session from removed process-global services to the shared std.Io surface:

• wall time now uses std.Io.Clock.real.now(io).toSeconds();
• cryptographic IDs, CSRF tokens, GC sampling, and cookie nonces use fallible std.Io.randomSecure and propagate failures;
• the file driver uses std.Io.Dir/std.Io.File operations and explicit io arguments;
• the ChaCha20-Poly1305 namespace rename is applied (aead.chacha20_poly1305 -> aead.chacha_poly);
• package test discovery now executes the file, memory, and cookie driver tests instead of only compiling them;
• file tests use an isolated temporary directory and perform a real write/read/destroy round trip;
• authenticated-cookie tests now prove modified ciphertext is rejected, while fixing plaintext cleanup on that successful-null path.

Verification (guarded, one process at a time, 3,840 MB ceiling):

• Zig 0.18.0-dev.146 Debug: 6/6
• pinned Zig 0.17.0-dev.2163 Debug: 6/6
• Zig 0.18.0-dev.146 ReleaseFast: 6/6
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 6/6
• x86_64-linux compile-only: success on both compilers
• formatting: success on both compilers

Classification: the ChaCha path is a pure namespace rename; the clock/random/filesystem work is the semantic std.Io migration. Secure randomness remains fallible and no error check was stripped.

Landed and pushed 5bb45b03f (fix(syslog): migrate secure runtime services to std.Io (#884)) directly to origin/main.

This four-file slice migrates syslog wall-clock and cryptographic randomness to std.Io, making AuthKey.generate, EncryptionKey.generate, and nonce generation explicitly fallible so secure-random failures are propagated rather than erased. It also ports associated-data construction from removed std.io.fixedBufferStream to std.Io.Writer.fixed.

The previous top-level syslog gate reported 2/2 because imported auth/encryption tests were not discovered. The root now activates them, raising real coverage to 9/9.

Guarded verification under the 3,840 MB ceiling:

• Zig 0.18.0-dev.146 Debug: 9/9
• pinned Zig 0.17.0-dev.2163 Debug: 9/9
• Zig 0.18.0-dev.146 ReleaseFast: 9/9
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 9/9
• x86_64-linux compile-only: success on both compilers

Classification: fixedBufferStream -> std.Io.Writer.fixed is an API migration; global clock/random removal is semantic because the caller must now supply an I/O implementation and secure randomness can fail. No security-relevant error was dropped.

Landed and pushed 7c11db726 (fix(syslog): complete std.Io concurrency migration (#884)) directly to origin/main.

This five-file follow-up completes the syslog package migration:

• rate-limit wall clocks use the shared std.Io.Clock provider;
• remote connection/retry delays use fallible std.Io.sleep and propagate cancellation through existing error-returning APIs;
• removed std.Thread.Mutex fields are now std.Io.Mutex;
• APIs that were intentionally infallible retain that contract with lockUncancelable, rather than catching and discarding cancellation errors;
• ConnectionStatus now has an explicit u8 representation required by std.atomic.Value;
• access/rate-limit/remote tests are activated at the root.

Activating the full suite exposed a contradictory ACL fixture: the user role is configured for .notice and higher priority but the test expected .info to pass. The fixture now tests .notice as allowed and adds an explicit .info rejection assertion, strengthening rather than weakening coverage.

Guarded verification:

• Zig 0.18.0-dev.146 Debug: 18/18
• pinned Zig 0.17.0-dev.2163 Debug: 18/18
• Zig 0.18.0-dev.146 ReleaseFast: 18/18
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 18/18
• x86_64-linux compile-only: success on both compilers

Together with 5bb45b03f, the syslog root now runs all 18 package tests instead of the prior misleading 2/2.

Landed and pushed 05cc320a8 (fix(coredump): migrate secure runtime services to std.Io (#884)) directly to origin/main after rebasing over the concurrent TS checker commit.

This four-file coredump slice migrates metadata/key expiration wall time and all key/ID/nonce generation to the shared std.Io provider. Every secure-random operation remains fallible and uses existing error-returning call paths; no cryptographic failure is caught or dropped. The coredump root now activates key-management and encryption tests, increasing actual coverage from 2/2 to 10/10.

Guarded verification before rebase:

• Zig 0.18.0-dev.146 Debug: 10/10
• pinned Zig 0.17.0-dev.2163 Debug: 10/10
• Zig 0.18.0-dev.146 ReleaseFast: 10/10
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 10/10
• x86_64-linux compile-only: success on both

After the non-overlapping rebase, both Zig 0.18 and pinned-Zig debug gates passed again (cached build graph).

Landed and pushed a7bbbbe6e (fix(auth): migrate cryptographic services to std.Io (#884)) directly to origin/main.

The standalone auth build was a confirmed Zig 0.18 failure: remember-token and password-salt generation referenced removed std.crypto.random. This four-file slice:

• routes remember tokens and Argon2 salts through fallible std.Io.randomSecure;
• migrates JWT wall time to std.Io.Clock.real;
• updates Argon2 KDF calls to the allocator + mode + std.Io signature for both hashing and verification;
• activates JWT, guard, and hash tests at the auth root.

No cryptographic error was dropped: token/salt failures propagate through existing error-returning APIs; hashing maps KDF failures to HashingFailed; verification remains a boolean and maps KDF failure to false as before.

Guarded verification:

• Zig 0.18.0-dev.146 Debug: 12/12
• pinned Zig 0.17.0-dev.2163 Debug: 12/12
• Zig 0.18.0-dev.146 ReleaseFast: 12/12
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 12/12
• x86_64-linux compile-only: success on both compilers

Landed and pushed 9a9865b0a (fix(coredump): migrate persisted files to std.Io (#884)) directly to origin/main.

This exact five-file slice completes coredump persisted-file migration:

• key save/load, encrypted-dump save/load, metadata extraction, directory scanning, integrity checks, and size queries now use std.Io.Dir/std.Io.File;
• private key/dump creation preserves 0600 permissions where the target permission type supports POSIX modes;
• integer fields remain explicitly little-endian;
• untrusted dump loading uses bounded exact positional reads rather than buffering the whole file, validates declared length against file size, and checked-casts u64 sizes;
• root discovery now executes decrypt, format, and capture tests;
• real temporary-file tests cover key save/load, encrypted save/load/decrypt/metadata extraction, directory filtering, magic verification, and size reporting.

Guarded verification:

• Zig 0.18.0-dev.146 Debug: 21/21
• pinned Zig 0.17.0-dev.2163 Debug: 21/21
• Zig 0.18.0-dev.146 ReleaseFast: 21/21
• pinned Zig 0.17.0-dev.2163 ReleaseFast: 21/21
• x86_64-linux compile-only: success on both compilers
• peak observed guarded tree footprint: below 300 MB

Pushed e94a935 (fix(modsign): migrate key generation to std.Io (#884)) directly to origin/main.

This is a semantic Zig 0.18 migration, not a rename:

• replaced the removed global std.crypto.random.bytes service with explicit std.Io.randomSecure;
• preserved the new failure path with try (no security check was removed);
• exposed the key tests through the package root, increasing this target from 2 to 6 discovered tests.

Verification (one guarded process at a time, 3,840 MB ceiling):

• Zig 0.18.0-dev.146: Debug 6/6, ReleaseFast 6/6;
• pinned Zig 0.17.0-dev.2163: Debug 6/6, ReleaseFast 6/6;
• aarch64-linux compile-only passes on both toolchains.

Peak guarded tree footprint was 279 MB. The next modsign slice is the shipped key/module persistence path, whose old std.fs calls still need explicit std.Io migration and real file round-trip coverage.

Pushed 6c97291 (fix(modsign): migrate persistence to std.Io (#884)) directly to origin/main.

This five-file slice completed modsign's shipped file-I/O migration and exposed semantic bugs that the previous two-test root never instantiated:

• private/public PEM and signed-module I/O now use explicit std.Io;
• private keys are created with private file permissions;
• public PEM payloads are now actually Base64-decoded (the old loader stored encoded bytes as the key);
• key fingerprints now depend on key material rather than an unsaved description, so persisted public keys can match signatures;
• algorithm recovery is explicit from the persisted key size instead of silently forcing RSA-2048;
• signing and verification now HMAC the same 32-byte digest (the old signer used the whole 64-byte backing buffer);
• the old verification test's valid-or-invalid escape hatch was replaced with an exact valid assertion;
• forged appended-signature lengths are rejected before subtraction, avoiding an underflow;
• the owned extracted signature is mutable so its allocation can be released.

The package root now discovers 18 tests (previously 2 before these modsign slices). Verification:

• Zig 0.18.0-dev.146: Debug 18/18, ReleaseFast 18/18;
• pinned Zig 0.17.0-dev.2163: Debug 18/18, ReleaseFast 18/18;
• aarch64-linux compile-only passes on both.

No crypto error union was stripped. All new secure-random and I/O failures remain propagated. Peak guarded tree footprint was 289 MB.

Pushed 38dd474 (fix(tpm): migrate secure services to std.Io (#884)) directly to origin/main.

The old TPM root reported 2/2 green because it did not import any submodule tests. The package root now discovers 14 tests and exposed both Zig 0.18 migration failures and semantic defects:

• attestation time now uses explicit std.Io clock access;
• challenge and simulated-key entropy now use std.Io.randomSecure;
• AttestationChallenge.init is intentionally fallible and callers propagate secure-random failure;
• allocated key material is released if entropy acquisition fails;
• unmanaged PCR lists now receive their allocator during deinit;
• authorization sealing now removes the old policy stream before applying the new policy stream. Previously, correct credentials decrypted to garbage even though the hidden test expected the original secret.

Verification:

• Zig 0.18.0-dev.146: Debug 14/14, ReleaseFast 14/14;
• pinned Zig 0.17.0-dev.2163: Debug 14/14, ReleaseFast 14/14;
• aarch64-linux compile-only passes on both.

No fallible crypto check was removed. Peak guarded tree footprint was 288 MB.

Pushed 4d9dca2 (fix(websocket): migrate secure handshakes to std.Io (#884)) directly to origin/main.

The standalone package previously reported 1/1 while hiding server, broadcaster, handshake, and mask-generation paths. It now discovers 7 tests and:

• uses std.Io.randomSecure for the client handshake nonce and every RFC 6455 client mask;
• makes mask generation fallible and propagates entropy failures through send/ping/pong/close;
• validates the server's Sec-WebSocket-Accept proof instead of accepting any 101 response;
• validates the client key's fixed 24-byte Base64 width before hashing/copying, eliminating an attacker-controlled fixed-buffer overflow;
• parses HTTP field names case-insensitively;
• emits CRLF-correct handshake responses;
• ports hidden JSON serialization paths from removed std.io.fixedBufferStream to std.Io.Writer.fixed;
• includes the RFC 6455 published accept-key vector.

Verification:

• Zig 0.18.0-dev.146: Debug 7/7, ReleaseFast 7/7;
• pinned Zig 0.17.0-dev.2163: Debug 7/7, ReleaseFast 7/7;
• aarch64-linux compile-only passes on both.

No entropy error was swallowed or converted to predictable fallback data. Peak guarded tree footprint was 278 MB.

Pushed add029156 (fix(ipv6): migrate protocol services to std.Io (#884)) directly to origin/main.

This is a semantic migration, not a blanket rename:

• route/NDP clocks now use std.Io.Clock.real;
• routing and neighbor caches use std.Io.Mutex.lockUncancelable, preserving their existing non-fallible APIs;
• DHCPv6 transaction IDs now come from fallible secure entropy instead of a millisecond-seeded PRNG, and entropy failure propagates through solicit/request/renew/release;
• Zig 0.18 array-repetition parser breakages in the IPv6/ICMPv6 tests were replaced with typed @splat equivalents.

Verification on the expanded 29-test suite:

• Zig 0.17.0-dev.2163 Debug: 29/29
• Zig 0.17.0-dev.2163 ReleaseFast: 29/29
• Zig 0.18.0-dev.146 Debug: 29/29
• Zig 0.18.0-dev.146 ReleaseFast: 29/29
• x86_64-linux-gnu compile-only: passed on both compilers

The shipped/test module configuration is the same ipv6_pkg; no libc-only test masking was found.

Pushed 5b36cd07f (fix(build): finish Zig 0.18 compatibility batch (#884)) directly to origin/main.

Breakdown:

• Rename-only: Home-owned optimization mirrors now use debug/safe/fast/small; the JSON example uses qualified std.builtin.OptimizeMode.{Debug,ReleaseSafe,ReleaseFast} aliases, which compile on both the pinned compiler and 0.18-dev.146. A 9th build test verifies all four old qualified aliases map to the lowercase modes.
• API migration: kernel builder ArrayLists now pass allocators explicitly; byte generation uses std.Io.Writer.Allocating.
• Semantic fixes exposed by the migration: Multiboot2 checksum is now explicit wrapping u32 arithmetic; compiler/linker flag arrays now return uniformly owned strings and clean partial allocations, fixing the previous invalid free of string literals.
• Coverage: the IPv6 root now imports all four protocol modules, increasing the ordinary package suite from 5 to 29 tests.

Verification:

• kernel builder: 4/4 Debug and ReleaseFast on Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146
• build tests: 9/9 Debug and ReleaseFast on both compilers
• JSON example: AST-check passes on both compilers
• kernel builder x86_64-linux-gnu ReleaseFast compile-only: passes on both compilers
• IPv6 expanded suite was already verified 29/29 Debug/ReleaseFast on both plus Linux compile-only

No real error union was removed in this batch.

Pushed two verified variadic Zig 0.18 migration commits directly to origin/main:

• bee7cb8 — fix(variadic): migrate formatting to std.Io (#884), exactly five files.
• 1b32f76 — fix(variadic): repair std.Io examples (#884), exactly four files.

The first slice replaces removed struct .fields reflection with field_names/field_types, moves fixed and allocating output to std.Io.Writer, makes LoggerConfig borrow a live *std.Io.Writer, migrates timestamps to std.Io.Clock.real and global locking to std.Io.Mutex.lockUncancelable, and updates syscall argument reflection. This is an API/semantic migration: writer state must remain shared rather than copied, clock access is explicit, and the logger's infallible global API retains its contract.

The second slice fixes the shipped examples and docs. Printf return values are consumed, the logger example now owns a real stdout writer instead of silently dropping every log, all mixed examples use one output stream for deterministic ordering, and integer syscall addresses use hexadecimal formatting rather than the pointer formatter.

Verification under the 3,840 MB guard, one process at a time:

• Zig 0.18.0-dev.146 Debug: 25/25 tests.
• pinned Zig 0.17.0-dev.2163 Debug: 25/25 tests.
• Zig 0.18 ReleaseFast: 25/25 tests.
• pinned Zig ReleaseFast: 25/25 tests.
• aarch64-linux-gnu ReleaseFast compile-only: passes on both compilers.
• shipped ReleaseFast package/examples build: 7/7 on both compilers.
• printf, logger, and syscall examples execute successfully; the corrected traces emit 0x1000 and 0x2000 exactly.

The only targeted formatter findings are pre-existing semantic rewrites from @intFromEnum to @backingInt in logger/syscall sources; they were not mixed into these commits. Broader std.Io migration remains open.

Pushed cfb9625cb (fix(cloud): migrate request signing to std.Io (#884)) directly to main.

This five-file slice fixes the cloud package's real Zig 0.17/0.18 breakage:

• injects std.Io into SQS/SES/SNS clients and obtains AWS signing timestamps through std.Io.Clock.real
• migrates request/signature assembly from removed ArrayList.writer helpers to std.Io.Writer.Allocating
• replaces removed fmtSliceHexLower use with native {x} formatting
• removes leaked lowercase header allocations during SigV4 canonicalization
• migrates packages/cloud/build.zig to the current Build API and expands zig build test to instantiate SQS, SES, and SNS rather than testing only the lazily compiled root

Verification (all guarded and serialized):

• direct SQS/SES/SNS tests: Debug + ReleaseFast on pinned Zig 0.17.0-dev.2163 and master Zig 0.18.0-dev.146
• shipped static-library build + expanded package test step: Debug + ReleaseFast on both Zig versions
• shipped aarch64-linux-gnu ReleaseFast cross-build on both versions
• focused zig fmt --check on all five files with both compilers

The expanded package test step peaked at about 1.1 GB, below the 3,840 MB ceiling.

Pushed ae2ef57dd (fix(cloud): migrate S3 and test every service (#884)) directly to main.

This three-file follow-up completes the cloud runtime-service Zig migration slice:

• S3 now receives std.Io explicitly and obtains copy timestamps from std.Io.Clock.real
• S3 presigned URL assembly uses std.Io.Writer.Allocating
• S3 ETag formatting uses native {x} byte formatting instead of removed fmtSliceHexLower
• the public cloud root references SQS, SES, SNS, DynamoDB, and S3 declarations, so their tests are no longer skipped by lazy compilation
• the package test graph now uses one public-root artifact rather than duplicating multiple service executables

Verification (guarded and serialized):

• package test: 18/18 in Debug and ReleaseFast on pinned Zig 0.17.0-dev.2163 and master Zig 0.18.0-dev.146
• shipped ReleaseFast static-library build on both versions
• shipped aarch64-linux-gnu ReleaseFast cross-build on both versions
• focused zig fmt --check on all three files with both compilers

The single-artifact test graph peaked around 323 MB, down from roughly 1.1 GB for the duplicated graph.

Pushed 9dc2333e0 (fix(modsign): migrate lazy formatting paths (#884)) directly to main, rebased on the latest upstream TypeScript commits.

The existing modsign suite was 18/18 on both Zig versions but did not instantiate two public methods. This three-file slice closes that reachability gap:

• signatureSummary now uses std.Io.Writer.Allocating instead of the removed ArrayList.writer path
• PublicKey.keyIdHex now uses native {x} byte formatting instead of removed fmtSliceHexLower
• tests execute both public methods and verify exact lowercase output
• the package-root declaration test now explicitly references every public submodule

Verification (guarded and serialized):

• top-level -Dfilter=modsign: 19/19 in Debug and ReleaseFast on pinned Zig 0.17.0-dev.2163 and master Zig 0.18.0-dev.146
• aarch64-linux-gnu ReleaseFast compile-only on both compilers
• post-rebase rerun of all four top-level compiler/mode combinations

Focused formatter inspection found only two pre-existing semantic builtin rewrites outside this slice (@enumFromInt to @fromBackingInt), so they were not mixed into this commit.

Database 0.18 compatibility slice landed directly on main as 4127e828c (fix(database): migrate hidden auth and migration paths (#884)).

What this found:

• API migration: the migrations module still used allocator-bound ArrayList, ArrayList.writer(), and std.time.timestamp(). It now uses caller-supplied allocator operations, std.Io.Writer.Allocating, and an explicit std.Io clock.
• Previously uncompiled code: the standalone database test build did not import src/migrations.zig, so 18 green tests never instantiated these paths. The test root now imports the migrations module, and zig build check provides a compile-only cross-target step using the same database module and SQLite linkage as the tests.
• Semantic bug: PostgreSQL MD5 auth allocated 35 bytes for "md5" + 32 hex digits + NUL, which requires 36. The old code overwrote the final digest digit with NUL. The response is now complete and checked against an independently computed vector.
• Lifetime fixes: every migrations query result is finalized; rollback and getApplied copy SQLite row text before stepping/finalizing; allocated VARCHAR(n) type strings are released.

Verification (all under the 3,840 MB guard, one process at a time):

• macOS Debug tests: 20/20 on pinned Zig 0.17 and Zig 0.18.0-dev.146
• macOS ReleaseFast tests: 20/20 on both compilers
• aarch64-linux-gnu ReleaseFast compile-only check: green on both compilers
• peak observed guarded footprint: 874 MB

Formatting note: both compilers accept all changed code. migrations.zig is formatter-clean. postgresql.zig retains three pre-existing @enumFromInt spellings because these dev formatters semantically rewrite them to @fromBackingInt; that unrelated churn was deliberately excluded.

Validation std.Io slice landed directly on main as 2eb8d04d4 (fix(validation): inject clocks and run real tests (#884)).

• ValidationContext now receives std.Io explicitly and obtains start/phase timestamps from std.Io.Clock.real.
• This is an API/semantic migration, not a rename: timeout decisions now use a caller-selected clock and can be exercised without ambient legacy time calls.
• The old package test root contained zero tests and excluded messages.zig and rules.zig. The package now runs a real external API suite plus all 11 existing message/rule tests: 15 tests total.
• A compile-only check step covers cross-target configuration.

Verification under the 3,840 MB guard:

• Debug: 15/15 on pinned Zig 0.17 and Zig 0.18.0-dev.146
• ReleaseFast: 15/15 on both compilers
• aarch64-linux-gnu ReleaseFast compile-only: green on both compilers
• focused format checks: clean on both compilers
• peak guarded footprint: 675 MB

No cryptographic error handling changed in this slice. The separate compression build/test and std.Io migration discovered during this audit is tracked in #887.

Current-tree follow-up audit against Zig 0.18.0-dev.146+35accc06e (HEAD 2eb8d04d4):

Crypto error unions

• There are no Home call sites for X25519.KeyPair.generateDeterministic.
• The one X25519 public-key recovery caller goes through crypto_compat.recoverX25519PublicKey, which accepts the fallible pinned-0.17 signature and the direct 0.18 return.
• The runtime's X25519.scalarmult catch remains in place. Both toolchains still declare IdentityElementError![32]u8, so removing it would discard rejection of attacker-controlled identity/small-order public keys.
• The two remaining generateDeterministic catches are Ed25519, whose 0.18 signature is still IdentityElementError!KeyPair.
• Visible AEAD decrypt, PBKDF2, and scrypt handling also remains fallible. No blanket catch removal is valid.

The exact crypto_compat top-level gate passes on both pinned Zig 0.17 and Zig 0.18.0-dev.146.

OptimizeMode

This is rename-only in the audited call sites. Home-owned modes use lowercase tags; the remaining old names are qualified std.builtin.OptimizeMode.{Debug,ReleaseSafe,ReleaseFast,ReleaseSmall} aliases. The 9-test build compatibility suite and 6-test LTO suite pass on both toolchains; the exact Zig-master -Dfilter=lto gate also passes.

std.Io scope

The migration is already active in the pinned 0.17 fork, not newly introduced by 0.18. A static inventory still finds 48 non-upstream Zig files referencing removed lowercase std.io. Most are dormant/lazy examples or APIs and therefore do not invalidate the successful ordinary shipped build. They need separate source-owning package slices rather than a mechanical repository-wide rewrite. The migrated packages/io build passes its exact 5/5 Zig-master gate. Compression's known subset remains tracked in #887.

Shipped versus test configuration

• Ordinary Zig 0.18 zig build -Denable_jsc=false -j1 succeeds under the 3,840 MB supervisor (2,910 MB peak).
• Emitted production and test commands both include -lc; there is no top-level libltvpn-style test-only libc masking.
• Release CI builds and tests with the same -Doptimize=ReleaseFast setting.
• A separate real configuration defect exists in the convenience release-fast step: its command line sets only -Mroot to -Ofast; imported modules remain -Odebug unless the caller also supplies -Doptimize=fast. The trace includes -lc, so this is optimization propagation, not libc. The guarded link was stopped at 3,873 MB against the 3,840 MB ceiling, so no completed-build claim is made for that convenience target.

The full Zig 0.18 test graph is not green, but focused pinned-Zig reproductions show the observed compile failures are pre-existing graph/reachability defects rather than 0.18-only changes: missing no-JSC HTTPServerAgent stubs, dormant runtime CSS/Cow test errors, and the top-level database test root omitting its new migrations module import. The aggregate run was stopped after those classifications and unrelated behavioral failures; no full-suite pass is claimed.

Pushed eaf77c012 (fix(runtime): restore no-JSC substrate tests (#884)) directly to main.

This five-file slice fixes failures exposed while auditing the Zig 0.18 test graph:

• construct the CSS diagnostic union values instead of accidentally formatting their tag enums;
• build valid empty StyleRule fixtures for nesting tests;
• make the test Cow vtable methods satisfy the public declaration contract;
• add the missing no-JSC HTTP server inspector stubs with the generated bridge signatures.

Verification:

• zig fmt --check passes with pinned Zig 0.17 and Zig 0.18.0-dev.146;
• git diff --check passes;
• focused Cow/ptr tests pass under both compiler versions;
• the no-JSC runtime aggregate now compiles past all original errors. Its complete link/test run remains above the enforced 3,840 MB process-tree ceiling (the guard stopped it at 3,915/4,138 MB), so I did not weaken or raise the safety limit and am not claiming a full aggregate pass.

The Zig 0.18 crypto/OptimizeMode/build-parity audit remains documented in the preceding update. In particular, the live X25519 scalarmult attacker-input error check remains intact.

Pushed two verified serialization migration commits directly to origin/main:

• 3f53e381e — fix(serialization): migrate codecs to std.Io (#884) (exactly five files).
• fa1cdf7f9 — test(serialization): exercise the shipped module graph (#884) (exactly three files).

What broke on Zig 0.18.0-dev.146:

• MessagePack and Protobuf still used removed std.io.fixedBufferStream, old reader methods, allocator-bound ArrayList, and ArrayList.writer().
• CBOR and Avro still used allocator-bound ArrayList output/storage APIs.
• Recursive generic encode/decode paths needed explicit error sets; otherwise master reports dependency loops while inferring errors.
• Avro relied on two structurally identical anonymous structs being interchangeable; the union payload now has one named type.
• Cap'n Proto had stricter unused-variable/immutability diagnostics.
• The package test step referenced five source files that do not exist, so it never exercised a real shipped/test configuration.

Semantic hardening included with the API migration:

• MessagePack partial array/map decoding now destroys already-owned values on malformed input; duplicate map keys release the replaced key/value.
• Protobuf rejects field zero/out-of-range field numbers, wire tags 6/7, truncated tags, and overlong 64-bit varints instead of trapping, truncating, or accepting a partial message.
• The package now installs and tests the same serialization module object, and a public-import suite verifies the exported API. The compile-only check step includes the shipped static library.

Guarded verification, serialized under the 3,840 MB ceiling:

• direct public-root suite: 23/23 in Debug and ReleaseFast on pinned Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146;
• repaired package graph: 25/25 native tests in Debug/ReleaseFast on both compilers;
• shipped aarch64-linux-gnu ReleaseFast compile-only check passes on both compilers;
• peak observed guarded footprint: 591 MB.

The three files touched in the build-parity commit pass focused formatting checks on both compilers. Three codec files retain pre-existing formatter-only semantic builtin rewrites (@intFromEnum/@enumFromInt); those unrelated rewrites were deliberately not mixed into the migration.

No cryptographic error handling changed in this slice. The earlier X25519 audit still stands: recoverPublicKey is bridged across the removed error union, while scalarmult remains fallible and its attacker-input identity check must remain.

Pushed fc2937a65 (fix(diagnostics): inject terminal services via std.Io (#884)) directly to origin/main as an exact three-file slice.

The maintained diagnostics target previously did not import colorizer.zig, leaving three removed APIs invisible: std.process.getEnvVarOwned, std.io.getStdErr, and std.io.fixedBufferStream. Direct Zig 0.18 compilation reproduced the failure.

The colorizer now:

• receives a borrowed std.process.Environ.Map instead of allocating ambient environment values;
• receives std.Io for stderr TTY detection and propagates cancellation rather than silently treating it as a non-TTY;
• uses std.Io.Writer.fixed for ANSI sequence construction;
• is exported by the public diagnostics root and covered through deterministic public tests for exact ANSI output, TERM, NO_COLOR, and LANG behavior.

Guarded verification under the unchanged 3,840 MB ceiling:

• exact diagnostics/AST/lexer graph: 13/13 Debug and ReleaseFast on pinned Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146;
• direct colorizer suite: 2/2 Debug/ReleaseFast on both compilers;
• aarch64-linux-gnu ReleaseFast compile-only: passes on both compilers;
• focused formatting and diff checks: clean;
• peak focused footprint: 268 MB.

The broad top-level filtered graph was stopped by the guard at 4,304 MB and receives no passing claim. No limit was raised and no identical retry was run; the exact module graph above uses the same real diagnostics, AST, and lexer sources without unrelated build-graph construction.

fb20db9ac advances the Zig 0.18 migration through the standalone realtime package.

The semantic migration is intentionally explicit:

• RealtimeConfig now owns the caller-provided std.Io.
• realtime timestamps use std.Io.Clock.real.now(io).
• all three drivers use std.Io.Mutex with the same injected I/O implementation.
• tests use std.testing.io and compile through the exact installed module graph.

This avoids a process-global compatibility shim and keeps blocking/cancellation services visible at the API boundary. Both Zig 0.17 and 0.18 pass Debug and ReleaseFast shipped builds/tests, plus x86_64-linux-gnu ReleaseFast compile-only checks.

Redis std.Io migration landed on main in a742b69f6.

This is a semantic migration, not a rename: RedisConfig now carries the injected std.Io; DNS/IP connection, stream operations, close, and pool locking all use that backend. The public-import test materializes Redis and RedisPool, while the package check step compiles the same module used by the shipped static library.

The batch passes Debug and ReleaseFast tests on Zig 0.17.0-dev.2163 and 0.18.0-dev.146, plus x86_64-linux-gnu ReleaseFast compile checks on both.

Cache package std.Io migration landed on main in 60c673b02.

This is the expensive semantic migration class: CacheConfig carries the I/O backend, and clocks, filesystem operations, Redis DNS/TCP streams, closes, and driver mutexes all consume it. No global compatibility backend or test-only workaround was introduced.

The shipped static library and both test suites now share/materialize the exact same public module. Debug checks, ReleaseFast tests, and Linux release compile checks pass on Zig 0.17.0-dev.2163 and 0.18.0-dev.146.

Mail package Zig-master migration landed in e7cadfd7f.

MemoryTransport now receives std.Io, uses std.Io.Mutex for its actual synchronization, and takes timestamps from the injected real clock. The old unused std.net and POSIX clock dependencies are gone. Shipped and tested module graphs are now identical.

Verified on Zig 0.17.0-dev.2163 and 0.18.0-dev.146, including ReleaseFast tests and Linux release compilation.

Rate-limit package Zig-master migration landed in 2d2abd417.

This removes the package's POSIX clock and std.Thread.Mutex dependencies in favor of explicit std.Io injection through token buckets and both stores. A public-import test now materializes the same module used by the installed static library.

Verified on Zig 0.17.0-dev.2163 and 0.18.0-dev.146, including ReleaseFast tests and Linux release compilation.

Logging package Zig-master migration landed in 5e058526c.

This removes legacy std.io, std.fs writer calls, POSIX time, and std.Thread.Mutex usage from the package. Handlers now retain an injected std.Io and std.Io.File, create buffered writers per operation, flush explicitly, and use std.Io.Mutex; child/global logger APIs propagate the same backend.

Verified on Zig 0.17.0-dev.2163 and 0.18.0-dev.146, including ReleaseFast tests and Linux release compilation.

Database std.Io migration landed on main in 26baac70d.

Covered four independently stale network clients (mysql.zig, postgres.zig, postgresql.zig, redis.zig) and their pool synchronization, DNS/IP connection paths, stream lifetime, wire reads/writes, allocator-explicit lists, and declaration-level compile coverage. All four compile on both the pinned Zig 0.17 build and Zig 0.18.0-dev.146; the package passes Debug/ReleaseFast natively and ReleaseFast for x86_64-linux-gnu on both.

Classification: this is a semantic API change, not a rename. No fallible protocol or attacker-controlled input validation was removed; malformed PostgreSQL lengths/rows and malformed RESP lengths/terminators remain error paths.

Pushed 6aac8dd77 to finish the database package's hidden Zig 0.18 graph.

Beyond the four network clients in 26baac70d, this commit migrates both ORM modules from removed writer/collection/reflection APIs and changes the package build so check covers the installed static library and every public module using the same SQLite/libc root. Concrete ORM and typed-ORM tests prevent these declarations from going lazy again.

Debug, ReleaseFast, and x86_64-linux-gnu ReleaseFast all pass on both Zig 0.17.0-dev.2163+89ff10d56 and 0.18.0-dev.146+35accc06e under the 3,840 MB guard.

Zig 0.18 audit progress in 59dea25b6:

• Added shipped/test graph parity for validation, queue, and scheduler.
• Confirmed all three packages compile and test on Zig 0.17.0-dev.2163 and 0.18.0-dev.146 in Debug and ReleaseFast.
• Confirmed their shipped graphs cross-compile for x86_64-linux-gnu ReleaseFast on both compilers.
• The cross-build found a semantic configuration defect, not a rename: queue uses libc close but its module did not declare libc. Native tests concealed it. The shared shipped/test module now carries the dependency.
• Scheduler's standalone build was also missing its actual threading dependency; tests and shipped library now share the same complete graph.

Crypto audit remains conservative: the two Home catches around X25519.scalarmult are retained because that API is still fallible and the peer key is attacker-controlled. Home already calls X25519.recoverPublicKey without try/catch, and has no X25519 generateDeterministic callsite.

Zig 0.18 migration progress in 565c1fbfa:

• auth, config, and i18n now compile installed libraries and tests from one shared module graph.
• i18n's removed allocator-owning ArrayList.init usage was migrated to the explicit allocator API used by both supported Zig versions.
• The stronger test graph exposed escaped substituted-string allocations; generated translations are now owned by Translator and released by deinit.
• Dual-Zig Debug/ReleaseFast host tests and Linux ReleaseFast cross-checks all pass.

This is a semantic ownership/API migration, not a compatibility alias change.

Dual-Zig package-graph progress in 84ae6fd71:

• inline, intrinsics, and volatile now compile their shipped static libraries and tests from one shared module each.
• Debug/ReleaseFast host tests and Linux ReleaseFast cross-checks pass on both Zig 0.17 and 0.18-dev.
• The intrinsics cross-target check exercises its target-specific source through the shipped graph, rather than only a duplicate test root.

No compatibility alias or test weakening was introduced.

Zig 0.18 migration progress in 634c94c31:

• middleware, notifications, and routing now share one module graph between shipped libraries and tests.
• Notifications timestamp acquisition moved from removed std.posix.clock_gettime to std.Io.Clock.real.
• A previously uncompiled multipart fixture now uses cross-version typed @splat rather than invalid string repetition.
• Both Zig versions pass Debug/ReleaseFast host tests and Linux ReleaseFast shipped-graph checks.

This is a real I/O-capability API migration plus build-graph parity, not a renamed enum alias or suppressed test.

Dual-Zig package-graph progress in ad3503b2a:

• session, storage, and templates now compile shipped static libraries and tests from one module graph each.
• Debug/ReleaseFast host tests and Linux ReleaseFast cross-checks pass on Zig 0.17 and current 0.18-dev.
• No compatibility aliases, alternate test roots, or weakened assertions were added.

Eight standalone tested packages still lack shipped-artifact checks.

Dual-Zig package-graph progress in ac5ba9a82:

• compression, I/O, and platform now compile installed static libraries and their tests from the intended module graphs;
• the I/O shipped artifact includes its real collections dependency;
• Debug/ReleaseFast host tests and Linux ReleaseFast cross-checks pass on Zig 0.17 and current 0.18-dev.

Five standalone tested packages still lack shipped-artifact checks.

Dual-Zig package-graph progress in 4793b595b:

• app, HTTP client, and WebSocket now compile installed static libraries and tests from one shared module each;
• Debug/ReleaseFast host tests and Linux ReleaseFast checks pass on Zig 0.17 and current 0.18-dev;
• no test-only alternate implementation or compatibility workaround was introduced.

Only the dependency-rich media and video standalone graphs remain in this audit.

Fresh Zig 0.18.0-dev.146 audit revalidation (2026-10-14):

• X25519.recoverPublicKey is the only reachable X25519 direct-return signature change found. The compatibility bridge in packages/runtime/src/jsc/crypto_compat.zig still compiles and passes under pinned Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146.
• Both first-party X25519.scalarmult call sites retain try/catch. This remains security-significant because attacker-controlled identity/small-order public inputs are rejected through the error union.
• The two generateDeterministic catches in packages/runtime/src/jsc/node_modules.zig are Ed25519, not X25519. Ed25519 remains fallible in 0.18.0-dev.146, so removing those catches would be incorrect.
• No first-party X25519 KeyPair.generateDeterministic call site exists.
• Qualified std.builtin.OptimizeMode.Debug/ReleaseSafe/ReleaseFast/ReleaseSmall aliases remain the dual-version bridge. The focused 9-test build suite passes under both compilers; no bare optimize-mode legacy literals were found.
• The top-level Zig 0.18 build graph evaluates successfully, and zig build test -j1 -Dfilter=crypto-compat passes under 0.18 (guard peak 1,106 MB).
• std.Io is already a broad semantic migration in Home (1,670 first-party references across 388 files). A lexical audit still finds 41 first-party files containing lowercase std.io references; these include a mixture of reachable old APIs, compatibility comments/shims, tests, examples, and dormant package code. They need shipped-graph triage, not a mechanical rename.

No crypto validation was removed in this revalidation.

Zig 0.18 migration progress: 5bf57649a is now on origin/main and the repaired accessibility, CEA-608, CEA-708, GIF, and H.264 source files compile/test identically under the pinned Zig 0.17 compiler and Zig 0.18.0-dev.146.

Focused evidence:

• accessibility/captions: 13/13 on each compiler;
• GIF LZW roundtrip: 1/1 on each compiler;
• H.264 analysis declarations: compile cleanly on each compiler.

This batch distinguishes API migration from semantic repair: allocator-explicit ArrayList calls and the reserved align identifier are 0.18 compatibility changes; caption dispatch/UTF-8 handling, GIF LZW decoding, and allocator-failure ownership are runtime correctness fixes exposed while making the code compile.

Another dual-toolchain migration batch is on origin/main: d0adb9776.

This removes current-Zig blockers in five audio files: the removed ** array-repeat syntax is replaced by typed @splat, shadowing and non-mutated bindings are corrected, and removed std.math.max usage is replaced with @max. Focused audio tests pass 5/5 under both the pinned Zig 0.17 compiler and Zig 0.18.0-dev.146. The full video graph reports the same remaining 33/34 unrelated diagnostics under both toolchains.

Pushed Zig migration batch 2ddb9ff8d to origin/main. Five analysis/decoder files now use typed @splat instead of the removed ** array-repeat form and current allocator-explicit ArrayList calls. The migration also exposed and fixed unsafe PSNR/SSIM slicing by validating the complete YUV420 frame size before indexing.

All 12 focused analysis tests pass on pinned Zig 0.17 and Zig 0.18.0-dev.146. The full video graph now has 28/29 later diagnostics, identical across toolchains apart from the integration test root's extra diagnostic.

Zig migration batch 476a876b6 is now on origin/main. Vorbis, H.264, and VP9 no longer use the removed array-repeat operator; typed @splat preserves the exact fixed-size initialization semantics across pinned Zig 0.17 and Zig 0.18.0-dev.146. Dual-toolchain package diagnostics now stand at 23/24, all outside this five-file batch.

Dual-toolchain migration batch 005147fc5 is on origin/main. Five metadata/streaming modules now use current fixed-array and allocator APIs and clear both pinned Zig 0.17 and Zig 0.18.0-dev.146. Focused coverage is 21/21, and full video diagnostics are down to 18/19. The batch also fixes real RTSP wire-case behavior and SDP ownership uncovered after compilation advanced.

Zig 0.18 migration progress: 1ec0f51c6 is pushed to origin/main with exactly five files.

The batch replaces allocator-capturing ArrayList usage with allocator-explicit operations, replaces removed array repetition syntax with @splat, corrects an @abs(i64) result to u64, and repairs lazy public MP4 paths that only became semantically analyzed once tests exercised them.

Both pinned Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146 pass the same focused 23-test root. This is a compatible migration, not a version gate or test workaround.

Zig 0.18 migration progress: d7a389227 is pushed to origin/main.

Four more video files now use allocator-explicit ArrayList initialization, mutation, writers, ownership transfer, and teardown. The shipped packages/video static library compiles under both pinned Zig 0.17.0-dev.2163 and Zig 0.18.0-dev.146; remaining failures are isolated to test-only source paths and test-framework call sites.