refactor: migrate entire codebase to Zig 0.16.0 I/O API

Upgrade zvm to compile against Zig 0.16.0, which introduces a
fundamental I/O revolution — every filesystem and network operation
now requires an explicit io: std.Io parameter threaded through
the call chain.

Key API migrations in this commit:
- main() signature: pub fn main() void → pub fn main(init: std.process.Init) !void
  using init.gpa, init.io, init.environ_map, init.minimal.args
- File/Dir operations: std.fs.cwd() → std.Io.Dir.cwd() with io param
- File close: file.close() → file.close(io)
- Dir close: dir.close() → dir.close(io)
- Dir iteration: iter.next() → iter.next(io)
- Dir rename: dir.rename(old, new) → dir.rename(old, dir, new, io)
- Symlink: std.posix.symlink() → std.Io.Dir.symLinkAbsolute(io, ...)
- File reading: reader.allocRemaining() → reader.interface.allocRemaining()
- Subprocess: std.process.Child.run() → std.process.run(alloc, io, opts)
- Spawn: std.process.Child.init/spawn/wait → std.process.spawn/wait
- Timestamps: std.time.timestamp() → Io.Clock.Timestamp.now(io, .real)
- Latency: std.time.Instant → Io.Timestamp.now(io, .awake) + durationTo()
- Zip extract: std.zip.extract(cwd, io, reader, opts) → extract(cwd, reader, opts)
- Term fields: .Exited/.Signal → .exited/.signal (lowercase)
- CLI args: argsWithAllocator → Args.Iterator.initAllocator
- Env vars: getEnvVarOwned → environ_map.get()
- Build: build_options.minimum_zig_version bumped to 0.14.0

Architecture: io and environ_map stored in ZVM struct to minimize
signature changes across command handlers — all commands access
zvm.io and zvm.environ_map as needed.

Verified: binary compiles and passes basic smoke tests (help, version, ls)

Author: lispking

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Setup Zig
         uses: mlugg/setup-zig@v2
         with:
-          version: '0.15.2'
+          version: '0.16.0'
 
       - name: Build
         run: zig build -Doptimize=ReleaseSafe -Dtarget=aarch64-linux-gnu
@@ -39,7 +39,7 @@ jobs:
       - name: Setup Zig
         uses: mlugg/setup-zig@v2
         with:
-          version: '0.15.2'
+          version: '0.16.0'
 
       - name: Check formatting
         run: zig fmt --check src/

.github/workflows/release.yml

@@ -48,7 +48,7 @@ jobs:
       - name: Setup Zig
         uses: mlugg/setup-zig@v2
         with:
-          version: '0.15.2'
+          version: '0.16.0'
 
       - name: Build
         run: |

README.md

@@ -70,13 +70,13 @@ export PATH="$HOME/.zvm/bin:$PATH"
 
 ```bash
 # Install a Zig version
-zvm install 0.15.2
+zvm install 0.16.0
 
 # Install latest nightly build
 zvm install master
 
 # Install with ZLS (Zig Language Server)
-zvm install --zls 0.15.2
+zvm install --zls 0.16.0
 
 # Switch to a different version
 zvm use 0.14.0
@@ -221,7 +221,7 @@ eval "$(zvm completion bash)"
 ~/.zvm/
 ├── bin            → symlink/junction to the active version directory
 ├── .active        → marker file tracking the active version name
-├── 0.15.2/        → Zig 0.15.2 installation
+├── 0.16.0/        → Zig 0.16.0 installation
 │   └── zig        → Zig compiler binary
 ├── 0.14.0/        → Zig 0.14.0 installation
 │   └── zig

build.zig

@@ -12,12 +12,11 @@ pub fn build(b: *std.Build) void {
         "version",
         "Semantic version (e.g. 0.2.0). In CI, pass the git tag. Locally defaults to git describe or \"0.0.1\".",
     ) orelse blk: {
-        const tag = std.process.Child.run(.{
-            .allocator = b.allocator,
+        const tag = std.process.run(b.allocator, b.graph.io, .{
             .argv = &.{ "git", "describe", "--tags", "--abbrev=0" },
         }) catch break :blk "0.0.1";
         switch (tag.term) {
-            .Exited => |code| if (code != 0) break :blk "0.0.1",
+            .exited => |code| if (code != 0) break :blk "0.0.1",
             else => break :blk "0.0.1",
         }
         const trimmed = std.mem.trim(u8, tag.stdout, " \n\r");
@@ -26,8 +25,7 @@ pub fn build(b: *std.Build) void {
     };
 
     const git_commit = blk: {
-        const result = std.process.Child.run(.{
-            .allocator = b.allocator,
+        const result = std.process.run(b.allocator, b.graph.io, .{
             .argv = &.{ "git", "rev-parse", "--short", "HEAD" },
         }) catch break :blk "unknown";
         break :blk std.mem.trim(u8, result.stdout, " \n\r");

build.zig.zon

@@ -25,7 +25,7 @@
     .fingerprint = 0xec41f7019ea1800d, // Changing this has security and trust implications.
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = "0.15.1",
+    .minimum_zig_version = "0.16.0",
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.
     // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.

src/archive.zig

@@ -1,59 +1,56 @@
 //! Archive extraction for .tar.xz and .zip files.
-//! Uses the `tar` CLI for .tar.xz (stdlib xz has compile issues in Zig 0.15.2)
+//! Uses the `tar` CLI for .tar.xz (stdlib xz has compile issues in Zig 0.16.0)
 //! and std.zip for .zip archives.
 
 const std = @import("std");
 const builtin = @import("builtin");
 
 /// Extract a .tar.xz archive using the system `tar` command.
-/// This is the primary extraction method on Unix platforms.
-pub fn extractTarXz(allocator: std.mem.Allocator, archive_path: []const u8, output_dir: []const u8) !void {
-    const result = try std.process.Child.run(.{
-        .allocator = allocator,
+pub fn extractTarXz(allocator: std.mem.Allocator, io: std.Io, archive_path: []const u8, output_dir: []const u8) !void {
+    const result = try std.process.run(allocator, io, .{
         .argv = &.{ "tar", "-xf", archive_path, "-C", output_dir },
     });
     defer allocator.free(result.stdout);
     defer allocator.free(result.stderr);
 
-    if (result.term != .Exited or result.term.Exited != 0) {
+    if (result.term != .exited or result.term.exited != 0) {
         return error.ExtractionFailed;
     }
 }
 
 /// Extract a .zip archive using Zig's stdlib zip implementation.
-pub fn extractZip(allocator: std.mem.Allocator, archive_path: []const u8, output_dir: []const u8) !void {
+pub fn extractZip(allocator: std.mem.Allocator, io: std.Io, archive_path: []const u8, output_dir: []const u8) !void {
     _ = output_dir;
-    const file = try std.fs.cwd().openFile(archive_path, .{});
-    defer file.close();
+    const file = try std.Io.Dir.cwd().openFile(io, archive_path, .{});
+    defer file.close(io);
 
     var reader_buf: [8192]u8 = undefined;
-    var reader = file.reader(&reader_buf);
+    var reader = file.reader(io, &reader_buf);
 
     var diagnostics: std.zip.Diagnostics = .{ .allocator = allocator };
     defer diagnostics.deinit();
 
-    try std.zip.extract(std.fs.cwd(), &reader, .{
+    try std.zip.extract(std.Io.Dir.cwd(), &reader, .{
         .diagnostics = &diagnostics,
     });
 }
 
 /// Extract an archive based on its file extension.
 /// Supports: .tar.xz, .zip, .tar
-pub fn extractArchive(allocator: std.mem.Allocator, archive_path: []const u8, output_dir: []const u8) !void {
+pub fn extractArchive(allocator: std.mem.Allocator, io: std.Io, archive_path: []const u8, output_dir: []const u8) !void {
     if (std.mem.endsWith(u8, archive_path, ".tar.xz")) {
-        try extractTarXz(allocator, archive_path, output_dir);
+        try extractTarXz(allocator, io, archive_path, output_dir);
     } else if (std.mem.endsWith(u8, archive_path, ".zip")) {
-        try extractZip(allocator, archive_path, output_dir);
+        try extractZip(allocator, io, archive_path, output_dir);
     } else if (std.mem.endsWith(u8, archive_path, ".tar")) {
         // Plain tar using CLI
-        const result = try std.process.Child.run(.{
-            .allocator = allocator,
+        const result = try std.process.run(allocator, io, .{
             .argv = &.{ "tar", "-xf", archive_path, "-C", output_dir },
         });
         defer allocator.free(result.stdout);
         defer allocator.free(result.stderr);
 
-        if (result.term != .Exited or result.term.Exited != 0) {
+        if (result.term != .exited or result.term.exited != 0) {
             return error.ExtractionFailed;
         }
     } else {

src/clean.zig

@@ -17,16 +17,16 @@ pub fn run(
 
     const extensions = [_][]const u8{ ".zip", ".xz", ".tar", ".tar.xz" };
 
-    var dir = try std.fs.cwd().openDir(zvm.base_dir, .{ .iterate = true });
-    defer dir.close();
+    var dir = try std.Io.Dir.cwd().openDir(zvm.io, zvm.base_dir, .{ .iterate = true });
+    defer dir.close(zvm.io);
 
     var count: usize = 0;
     var iter = dir.iterate();
-    while (try iter.next()) |entry| {
+    while (try iter.next(zvm.io)) |entry| {
         if (entry.kind != .file) continue;
         for (extensions) |ext| {
             if (std.mem.endsWith(u8, entry.name, ext)) {
-                dir.deleteFile(entry.name) catch continue;
+                dir.deleteFile(zvm.io, entry.name) catch continue;
                 count += 1;
                 break;
             }

src/cli.zig

@@ -121,8 +121,8 @@ const command_aliases = std.StaticStringMap(Command).initComptime(.{
     .{ "-v", .version },
 });
 
-pub fn parse(allocator: std.mem.Allocator) !struct { global: GlobalFlags, cmd: ParsedCommand } {
-    var args = try std.process.argsWithAllocator(allocator);
+pub fn parse(allocator: std.mem.Allocator, args_data: std.process.Args) !struct { global: GlobalFlags, cmd: ParsedCommand } {
+    var args = std.process.Args.Iterator.initAllocator(args_data, allocator) catch return error.OutOfMemory;
     defer args.deinit();
 
     // Skip program name

src/crypto.zig

@@ -20,11 +20,13 @@ fn hexEncode(digest: *const [Sha256.digest_length]u8, buf: *[hex_len]u8) []const
 /// Compute SHA256 hash of a file and return as hex-encoded string.
 /// Reads the entire file into memory (up to 500MB).
 /// Caller owns returned memory.
-pub fn computeFileSha256(allocator: std.mem.Allocator, path: []const u8) ![]const u8 {
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
+pub fn computeFileSha256(allocator: std.mem.Allocator, io: std.Io, path: []const u8) ![]const u8 {
+    const file = try std.Io.Dir.cwd().openFile(io, path, .{});
+    defer file.close(io);
 
-    const content = try file.readToEndAlloc(allocator, 500 * 1024 * 1024);
+    var read_buf: [16384]u8 = undefined;
+    var reader = file.reader(io, &read_buf);
+    const content = try reader.interface.allocRemaining(allocator, .limited(500 * 1024 * 1024));
     defer allocator.free(content);
 
     var hasher = Sha256.init(.{});
@@ -40,11 +42,13 @@ pub fn computeFileSha256(allocator: std.mem.Allocator, path: []const u8) ![]cons
 
 /// Verify that a file's SHA256 hash matches the expected hex-encoded checksum.
 /// Returns true if they match, false otherwise.
-pub fn verifyFileSha256(path: []const u8, expected_hex: []const u8) !bool {
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
+pub fn verifyFileSha256(io: std.Io, path: []const u8, expected_hex: []const u8) !bool {
+    const file = try std.Io.Dir.cwd().openFile(io, path, .{});
+    defer file.close(io);
 
-    const content = try file.readToEndAlloc(std.heap.page_allocator, 500 * 1024 * 1024);
+    var read_buf: [16384]u8 = undefined;
+    var reader = file.reader(io, &read_buf);
+    const content = try reader.interface.allocRemaining(std.heap.page_allocator, .limited(500 * 1024 * 1024));
     defer std.heap.page_allocator.free(content);
 
     var hasher = Sha256.init(.{});