Update to Zig 0.15.0-dev.1160+e43617e68

build.zig

···
     const example_step = b.step("example", "Run example");
     const example = b.addExecutable(.{
         .name = "example",
-        // future versions should use b.path, see zig PR #19597
-        .root_source_file = b.path(
-            b.fmt("examples/{s}.zig", .{@tagName(example_option)}),
-        ),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(
+                b.fmt("examples/{s}.zig", .{@tagName(example_option)}),
+            ),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{
+                .{ .name = "vaxis", .module = vaxis_mod },
+            },
+        }),
     });
-    example.root_module.addImport("vaxis", vaxis_mod);
 
     const example_run = b.addRunArtifact(example);
     example_step.dependOn(&example_run.step);
···
     const tests_step = b.step("test", "Run tests");
 
     const tests = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{
+                .{ .name = "code_point", .module = zg_dep.module("code_point") },
+                .{ .name = "Graphemes", .module = zg_dep.module("Graphemes") },
+                .{ .name = "DisplayWidth", .module = zg_dep.module("DisplayWidth") },
+                .{ .name = "zigimg", .module = zigimg_dep.module("zigimg") },
+            },
+        }),
     });
-    tests.root_module.addImport("code_point", zg_dep.module("code_point"));
-    tests.root_module.addImport("Graphemes", zg_dep.module("Graphemes"));
-    tests.root_module.addImport("DisplayWidth", zg_dep.module("DisplayWidth"));
-    tests.root_module.addImport("zigimg", zigimg_dep.module("zigimg"));
 
     const tests_run = b.addRunArtifact(tests);
     b.installArtifact(tests);
···
     const docs_step = b.step("docs", "Build the vaxis library docs");
     const docs_obj = b.addObject(.{
         .name = "vaxis",
-        .root_source_file = root_source_file,
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = root_source_file,
+            .target = target,
+            .optimize = optimize,
+        }),
     });
     const docs = docs_obj.getEmittedDocs();
     docs_step.dependOn(&b.addInstallDirectory(.{

build.zig.zon

···
     .minimum_zig_version = "0.14.0",
     .dependencies = .{
         .zigimg = .{
-            .url = "git+https://github.com/zigimg/zigimg#74caab5edd7c5f1d2f7d87e5717435ce0f0affa1",
-            .hash = "zigimg-0.1.0-8_eo2nWlEgCddu8EGLOM_RkYshx3sC8tWv-yYA4-htS6",
+            // TODO .url = "git+https://github.com/zigimg/zigimg",
+            .url = "git+https://github.com/ivanstepanovftw/zigimg#aa4c31db872612c39edbb79f753b3cd9a79fe726",
+            .hash = "zigimg-0.1.0-8_eo2mWmEgBoqdr0sH9O5GTqDHthkoEPM5_tipcBRreL",
         },
         .zg = .{
-            .url = "git+https://codeberg.org/atman/zg#0b05141b033043c5f7bcd72048a48eef6531ea6c",
-            .hash = "zg-0.14.0-oGqU3KEFswIffnDu8eAE2XlhzwcfgjwtM6akIc5L7cEV",
+            // TODO .url = "git+https://codeberg.org/atman/zg",
+            .url = "git+https://codeberg.org/ivanstepanovftw/zg#4fe689e56ce2ed5a8f59308b471bccd7da89fac9",
+            .hash = "zg-0.14.1-oGqU3J4_tAKBfyes3AWleKDjo-IcYvnEwaB8qxOqFMwM",
         },
     },
     .paths = .{

examples/vaxis.zig

···
         // try vx.render(bw.writer().any());
         // try bw.flush();
         try vx.render(tty.anyWriter());
-        std.time.sleep(16 * std.time.ns_per_ms);
+        std.Thread.sleep(16 * std.time.ns_per_ms);
         switch (dir) {
             .up => {
                 pct += 1;

examples/vt.zig

···
 
     var redraw: bool = false;
     while (true) {
-        std.time.sleep(8 * std.time.ns_per_ms);
+        std.Thread.sleep(8 * std.time.ns_per_ms);
         // try vt events first
         while (vt.tryEvent()) |event| {
             redraw = true;

src/Parser.zig

···
 
             // Check if we have a multi-codepoint grapheme
             var code = cp.code;
-            var g_state: Graphemes.State = .{};
+            var g_state: Graphemes.IterState = .{};
             var prev_cp = code;
             while (iter.next()) |next_cp| {
                 if (Graphemes.graphemeBreak(prev_cp, next_cp.code, data, &g_state)) {

src/queue.zig

···
     // still full and the push in the other thread is still blocked
     // waiting for space.
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s);
+    std.Thread.sleep(std.time.ns_per_s);
     // Finally, let that other thread go.
     try std.testing.expectEqual(1, q.pop());
 
···
         try Thread.yield();
     // But we want to ensure that there's a second push waiting, so
     // here's another sleep.
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
 
     // Another spurious wake...
     q.not_full.signal();
···
     // And another chance for the other thread to see that it's
     // spurious and go back to sleep.
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
 
     // Pop that thing and we're done.
     try std.testing.expectEqual(2, q.pop());
···
 fn sleepyPush(q: *Queue(u8, 1)) !void {
     // Try to ensure the other thread has already started trying to pop.
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
 
     // Spurious wake
     q.not_full.signal();
     q.not_empty.signal();
 
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
 
     // Stick something in the queue so it can be popped.
     q.push(1);
···
         try Thread.yield();
     // Give the other thread time to block again.
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
 
     // Spurious wake
     q.not_full.signal();
···
     const t1 = try Thread.spawn(cfg, readerThread, .{&queue});
     const t2 = try Thread.spawn(cfg, readerThread, .{&queue});
     try Thread.yield();
-    std.time.sleep(std.time.ns_per_s / 2);
+    std.Thread.sleep(std.time.ns_per_s / 2);
     queue.push(1);
     queue.push(1);
     t1.join();

src/tty.zig

···
             .handler = .{ .handler = PosixTty.handleWinch },
             .mask = switch (builtin.os.tag) {
                 .macos => 0,
-                else => posix.empty_sigset,
+                else => posix.sigemptyset(),
             },
             .flags = 0,
         };
···
             .handler = .{ .handler = posix.SIG.DFL },
             .mask = switch (builtin.os.tag) {
                 .macos => 0,
-                else => posix.empty_sigset,
+                else => posix.sigemptyset(),
             },
             .flags = 0,
         };
···
         handler_idx += 1;
     }
 
-    fn handleWinch(_: c_int) callconv(.C) void {
+    fn handleWinch(_: c_int) callconv(.c) void {
         handler_mutex.lock();
         defer handler_mutex.unlock();
         var i: usize = 0;

src/vxfw/App.zig

···
             next_frame_ms = now_ms + tick_ms;
         } else {
             // Sleep until the deadline
-            std.time.sleep((next_frame_ms - now_ms) * std.time.ns_per_ms);
+            std.Thread.sleep((next_frame_ms - now_ms) * std.time.ns_per_ms);
             next_frame_ms += tick_ms;
         }
 

src/vxfw/vxfw.zig

···
             file.name[0..idx]
         else
             continue;
-        const data = try cwd.readFileAllocOptions(std.testing.allocator, file.name, 10_000_000, null, @alignOf(u8), 0x00);
+        const data = try cwd.readFileAllocOptions(std.testing.allocator, file.name, 10_000_000, null, .of(u8), 0x00);
         defer std.testing.allocator.free(data);
         var ast = try std.zig.Ast.parse(std.testing.allocator, data, .zig);
         defer ast.deinit(std.testing.allocator);
···
         var has_doctest: bool = false;
         var has_refAllDecls: bool = false;
         for (ast.rootDecls()) |root_decl| {
-            const decl = ast.nodes.get(root_decl);
+            const decl = ast.nodes.get(@intFromEnum(root_decl));
             switch (decl.tag) {
                 .test_decl => {
-                    const test_name = ast.tokenSlice(decl.data.lhs);
+                    const test_name = ast.tokenSlice(decl.main_token + 1);
                     if (std.mem.eql(u8, "\"refAllDecls\"", test_name))
                         has_refAllDecls = true
                     else if (std.mem.eql(u8, container_name, test_name))

src/widgets/terminal/Command.zig

···
             .handler = .{ .handler = handleSigChild },
             .mask = switch (builtin.os.tag) {
                 .macos => 0,
-                .linux => posix.empty_sigset,
+                .linux => posix.sigemptyset(),
                 else => @compileError("os not supported"),
             },
             .flags = 0,