fix: revert condvar wakeup, keep 1ms polling for mesh scheduler

Author: HTRMC

src/client/world/MeshSchedulerThread.zig

@@ -52,9 +52,7 @@ pub const MeshSchedulerThread = struct {
 
     // Unbounded inbox (main thread produces via queueMesh, scheduler thread drains)
     // Mutex-protected — push is O(1) amortized, never fails (C2ME-style)
-    // Condvar wakeup eliminates 1ms polling sleep (C2ME uses semaphores)
     inbox_mutex: Io.Mutex = Io.Mutex.init,
-    inbox_cond: Io.Condition = Io.Condition.init,
     inbox: std.ArrayListUnmanaged(MeshRequest) = .{},
 
     // Direct pool submission (thread-safe via mutex)
@@ -113,7 +111,6 @@ pub const MeshSchedulerThread = struct {
 
         logger.info("MeshSchedulerThread shutting down...", .{});
         self.running.store(false, .release);
-        self.inbox_cond.signal(self.io); // Wake thread so it sees running=false
 
         if (self.thread) |thread| {
             thread.join();
@@ -125,18 +122,14 @@ pub const MeshSchedulerThread = struct {
 
     /// Queue a mesh request from the main thread (unbounded, never fails).
     /// C2ME-style: push always succeeds, no retry mechanism needed.
-    /// Signals condvar to wake scheduler thread immediately (no polling delay).
     pub fn queueMesh(self: *Self, req: MeshRequest) void {
         self.inbox_mutex.lockUncancelable(self.io);
+        defer self.inbox_mutex.unlock(self.io);
         self.inbox.append(self.allocator, req) catch {
             logger.warn("Failed to queue mesh request for ({},{},{}): OOM", .{
                 req.pos.x, req.pos.z, req.pos.section_y,
             });
-            self.inbox_mutex.unlock(self.io);
-            return;
         };
-        self.inbox_mutex.unlock(self.io);
-        self.inbox_cond.signal(self.io);
     }
 
     fn threadLoop(self: *Self) void {
@@ -153,13 +146,12 @@ pub const MeshSchedulerThread = struct {
             // 2. Process pending_mesh_queue (FIFO, no per-tick cap — not on render thread)
             const submitted = self.processPendingQueue();
 
-            // Wait for work when idle (C2ME-style: condvar wakeup, no polling)
+            // Sleep when idle (1ms polling)
             if (drained == 0 and submitted == 0) {
-                self.inbox_mutex.lockUncancelable(self.io);
-                if (self.inbox.items.len == 0 and self.running.load(.acquire)) {
-                    self.inbox_cond.waitUncancelable(self.io, &self.inbox_mutex);
-                }
-                self.inbox_mutex.unlock(self.io);
+                Io.Clock.Duration.sleep(.{
+                    .clock = .awake,
+                    .raw = .fromNanoseconds(1_000_000), // 1ms
+                }, self.io) catch {};
             }
         }