build(toolchain): bump Zig to dev.2085 — @hasDecl is now pub-only

src/grants.zig

@@ -379,23 +379,23 @@ const FakeProbes = struct {
     requests: [8]Grant = undefined,
     request_count: usize = 0,
 
-    fn micGranted(self: *FakeProbes) bool {
+    pub fn micGranted(self: *FakeProbes) bool {
         return self.mic;
     }
-    fn listenGranted(self: *FakeProbes) bool {
+    pub fn listenGranted(self: *FakeProbes) bool {
         return self.listen;
     }
-    fn tapEnabled(self: *FakeProbes) bool {
+    pub fn tapEnabled(self: *FakeProbes) bool {
         return self.tap;
     }
-    fn postEventGranted(self: *FakeProbes) bool {
+    pub fn postEventGranted(self: *FakeProbes) bool {
         return self.post_event;
     }
-    fn request(self: *FakeProbes, grant: Grant) void {
+    pub fn request(self: *FakeProbes, grant: Grant) void {
         self.requests[self.request_count] = grant;
         self.request_count += 1;
     }
-    fn nowMs(self: *FakeProbes) i64 {
+    pub fn nowMs(self: *FakeProbes) i64 {
         return self.now;
     }
     fn requested(self: *FakeProbes) []const Grant {

src/insertion_runner.zig

@@ -455,11 +455,11 @@ const FakeDeps = struct {
     /// flight and its clipboard restore is still owed.
     quit_during_insert: bool = false,
 
-    fn insertionPlan(self: *FakeDeps) insertmod.Plan {
+    pub fn insertionPlan(self: *FakeDeps) insertmod.Plan {
         return self.plan;
     }
 
-    fn insert(self: *FakeDeps, plan: insertmod.Plan, text: [*:0]const u8) insertmod.InsertError!void {
+    pub fn insert(self: *FakeDeps, plan: insertmod.Plan, text: [*:0]const u8) insertmod.InsertError!void {
         if (self.quit_during_insert) self.quit = true;
         self.calls += 1;
         self.last_plan = plan;
@@ -469,7 +469,7 @@ const FakeDeps = struct {
         return self.result;
     }
 
-    fn complete(self: *FakeDeps, id: coord.UtteranceId, result: coord.InsertResult, focused_app: ?coord.AppIdentity, inserted: []const u8) void {
+    pub fn complete(self: *FakeDeps, id: coord.UtteranceId, result: coord.InsertResult, focused_app: ?coord.AppIdentity, inserted: []const u8) void {
         self.completions += 1;
         self.last_completion_id = id;
         self.last_completion = result;
@@ -478,33 +478,33 @@ const FakeDeps = struct {
         self.last_inserted_len = inserted.len;
     }
 
-    fn focusedApp(self: *FakeDeps) ?coord.AppIdentity {
+    pub fn focusedApp(self: *FakeDeps) ?coord.AppIdentity {
         self.focus_reads += 1;
         return self.focused_app;
     }
 
-    fn finishInsert(self: *FakeDeps) void {
+    pub fn finishInsert(self: *FakeDeps) void {
         self.finishes += 1;
         self.completions_at_finish = self.completions;
     }
 
-    fn copyToClipboard(self: *FakeDeps, text: [*:0]const u8) void {
+    pub fn copyToClipboard(self: *FakeDeps, text: [*:0]const u8) void {
         self.copies += 1;
         self.finishes_at_copy = self.finishes;
         const s = std.mem.span(text);
         @memcpy(self.last_copy[0..s.len], s);
         self.last_copy_len = s.len;
     }
 
-    fn actionRefused(self: *FakeDeps) void {
+    pub fn actionRefused(self: *FakeDeps) void {
         self.refuses += 1;
     }
 
-    fn shouldQuit(self: *FakeDeps) bool {
+    pub fn shouldQuit(self: *FakeDeps) bool {
         return self.quit;
     }
 
-    fn idle(self: *FakeDeps) void {
+    pub fn idle(self: *FakeDeps) void {
         self.idles += 1;
         self.quit = true;
     }

src/local_backend.zig

@@ -548,18 +548,18 @@ const FakeHelper = struct {
     reserve_error: bool = false,
     submit_error: bool = false,
 
-    fn isReady(_: *FakeHelper) bool {
+    pub fn isReady(_: *FakeHelper) bool {
         return true;
     }
-    fn setEvents(_: *FakeHelper, _: HelperEvents) void {}
-    fn reserveUtterance(self: *FakeHelper, id: backend.UtteranceId) !void {
+    pub fn setEvents(_: *FakeHelper, _: HelperEvents) void {}
+    pub fn reserveUtterance(self: *FakeHelper, id: backend.UtteranceId) !void {
         if (self.reserve_error) return error.NotReady;
         if (self.lease_id != null) return error.Busy;
         self.lease_id = id;
         self.reserves += 1;
     }
 
-    fn submit(self: *FakeHelper, id: backend.UtteranceId, language: ipc.Language, prompt: []const u8, pcm: []const u8) !void {
+    pub fn submit(self: *FakeHelper, id: backend.UtteranceId, language: ipc.Language, prompt: []const u8, pcm: []const u8) !void {
         if (self.submit_error) return error.BrokenPipe;
         if (self.lease_id != id) return error.WrongUtterance;
         self.ids[self.submits] = id;
@@ -572,25 +572,25 @@ const FakeHelper = struct {
         self.last_id = id;
         self.language = language;
     }
-    fn cancel(self: *FakeHelper, id: backend.UtteranceId) void {
+    pub fn cancel(self: *FakeHelper, id: backend.UtteranceId) void {
         self.cancels += 1;
         self.last_cancel_id = id;
         if (self.lease_id == id) self.lease_id = null;
     }
-    fn requestCancel(self: *FakeHelper, id: backend.UtteranceId) void {
+    pub fn requestCancel(self: *FakeHelper, id: backend.UtteranceId) void {
         self.cancellation_requests += 1;
         self.last_request_id = id;
     }
-    fn retry(self: *FakeHelper) void {
+    pub fn retry(self: *FakeHelper) void {
         self.retries += 1;
     }
     // The Adapter's segmentation tests never drive backend reselection or teardown, so these
     // two members of the Helper contract are inert here — present so the fake is a complete
     // Helper (asserted below), not a partial one.
-    fn usesModel(_: *FakeHelper, _: []const u8) bool {
+    pub fn usesModel(_: *FakeHelper, _: []const u8) bool {
         return true;
     }
-    fn shutdown(_: *FakeHelper) void {}
+    pub fn shutdown(_: *FakeHelper) void {}
 };
 
 comptime {

src/session.zig

@@ -1440,40 +1440,40 @@ const FakeTransport = struct {
     write_buf: [1 << 14]u8 = undefined,
     write_len: usize = 0,
 
-    const Reader = struct {
+    pub const Reader = struct {
         pub fn join(_: Reader) void {}
     };
 
-    fn init(_: std.Io, _: std.mem.Allocator) FakeTransport {
+    pub fn init(_: std.Io, _: std.mem.Allocator) FakeTransport {
         return .{};
     }
-    fn connect(self: *FakeTransport, _: []const u8) !void {
+    pub fn connect(self: *FakeTransport, _: []const u8) !void {
         self.connected = true;
     }
-    fn startReadLoop(self: *FakeTransport, _: anytype) !Reader {
+    pub fn startReadLoop(self: *FakeTransport, _: anytype) !Reader {
         self.reads_started += 1;
         return .{};
     }
-    fn write(self: *FakeTransport, bytes: []u8) !void {
+    pub fn write(self: *FakeTransport, bytes: []u8) !void {
         self.writes += 1;
         if (self.write_len + bytes.len <= self.write_buf.len) {
             @memcpy(self.write_buf[self.write_len..][0..bytes.len], bytes);
             self.write_len += bytes.len;
         }
     }
-    fn writePing(self: *FakeTransport, _: []u8) !void {
+    pub fn writePing(self: *FakeTransport, _: []u8) !void {
         self.pings += 1;
     }
-    fn writePong(self: *FakeTransport, _: []u8) !void {
+    pub fn writePong(self: *FakeTransport, _: []u8) !void {
         self.pongs += 1;
     }
-    fn writeCloseFrame(self: *FakeTransport, _: []u8) !void {
+    pub fn writeCloseFrame(self: *FakeTransport, _: []u8) !void {
         self.close_frames += 1;
     }
-    fn forceClose(self: *FakeTransport) void {
+    pub fn forceClose(self: *FakeTransport) void {
         self.force_closes += 1;
     }
-    fn deinit(self: *FakeTransport) void {
+    pub fn deinit(self: *FakeTransport) void {
         self.connected = false;
     }
 

src/undo.zig

@@ -375,33 +375,33 @@ const FakeDeps = struct {
     undo_confirms: usize = 0,
     undo_refuses: usize = 0,
 
-    fn enabled(self: *FakeDeps) bool {
+    pub fn enabled(self: *FakeDeps) bool {
         self.enabled_reads += 1;
         return self.on;
     }
-    fn focusedApp(self: *FakeDeps) ?coord.AppIdentity {
+    pub fn focusedApp(self: *FakeDeps) ?coord.AppIdentity {
         self.focus_reads += 1;
         if (self.focus_switch_after) |k| {
             if (self.focus_reads > k) return self.focused_app_later;
         }
         return self.focused_app;
     }
-    fn secureInputActive(self: *FakeDeps) bool {
+    pub fn secureInputActive(self: *FakeDeps) bool {
         self.secure_reads += 1;
         return self.secure_input;
     }
-    fn deleteChars(self: *FakeDeps, n: usize) usize {
+    pub fn deleteChars(self: *FakeDeps, n: usize) usize {
         self.deletes += 1;
         self.last_delete_n = n;
         const available = if (self.delete_posts) |budget| budget -| self.posted_total else n;
         const got = @min(available, n);
         self.posted_total += got;
         return got;
     }
-    fn undoConfirmed(self: *FakeDeps) void {
+    pub fn undoConfirmed(self: *FakeDeps) void {
         self.undo_confirms += 1;
     }
-    fn undoRefused(self: *FakeDeps) void {
+    pub fn undoRefused(self: *FakeDeps) void {
         self.undo_refuses += 1;
     }
 };