winloop 0.2.0 → 0.2.1

data/lib/winloop/ops.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Winloop
-  # Upper bound for Backend#op_prepare's `capacity:` — 16 MiB. Fits a DWORD with
-  # huge margin (and is far past ReadDirectoryChangesW's 64 KiB network ceiling).
-  OP_CAPACITY_MAX = 16 * 1024 * 1024
-
-  # The validated, keyword-argument face of the generic-op preparation primitive.
-  # Suite convention: validated kwargs live in Ruby; the C bridge (_op_prepare)
-  # is underscore-private so the checks can't be skipped.
-  class Backend
-    # Allocate one backend-owned op record (state :prepared): a zeroed OVERLAPPED,
-    # a `tag` echoed back in the completion tuple, and an optional embedded data
-    # buffer. Returns [op_id, ov_addr, buf_addr] (all Integers; buf_addr is 0 when
-    # capacity is 0). `handle` must have been passed to #associate on this backend
-    # first — an op on a handle that is not on the port never completes (a silent
-    # hang, not an error), so unknown handles raise Winloop::Error up front.
-    def op_prepare(handle, tag: 0, capacity: 0)
-      raise TypeError, "handle must be an Integer (got #{handle.class})"   unless handle.is_a?(Integer)
-      raise TypeError, "tag must be an Integer (got #{tag.class})"         unless tag.is_a?(Integer)
-      raise TypeError, "capacity must be an Integer (got #{capacity.class})" unless capacity.is_a?(Integer)
-      if handle.zero? || handle == 0xFFFF_FFFF_FFFF_FFFF || !handle.between?(1, 2**64 - 1)
-        raise ArgumentError, "#{handle} is not a usable HANDLE value"
-      end
-      unless tag.between?(0, 2**64 - 1)
-        raise ArgumentError, "tag must be in 0..2**64-1 (got #{tag})"
-      end
-      unless capacity.between?(0, OP_CAPACITY_MAX)
-        raise ArgumentError, "capacity must be in 0..#{OP_CAPACITY_MAX} (got #{capacity})"
-      end
-      _op_prepare(handle, tag, capacity)
-    end
-
-    private :_op_prepare
-  end
-end

data/lib/winloop/scheduler.rb

@@ -1,656 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-
-module Winloop
-  # A Fiber::Scheduler for MRI on Windows, backed by an I/O Completion Port.
-  #
-  # Strategy (matches libuv/mio/wepoll on Windows):
-  #   * io_wait          -> IOCTL_AFD_POLL submitted as an overlapped op on the IOCP
-  #                         (the only way to get *readiness* onto a completion port).
-  #                         Polls are COALESCED per socket: at most one AFD poll is
-  #                         outstanding per socket, covering the union of every
-  #                         waiter's interest, and its completion fans out to all of
-  #                         them. (The AFD driver completes only ONE pending poll per
-  #                         readiness edge, so independent polls on the same socket
-  #                         would lose wakeups.)
-  #   * io_read/io_write -> recv_nonblock/write_nonblock driven by io_wait
-  #   * kernel_sleep /
-  #     timeout_after    -> a monotonic timer min-heap (the loop's GQCSEx timeout)
-  #   * block / unblock  -> in-process waiter lists; cross-thread unblock wakes the
-  #                         loop with PostQueuedCompletionStatus
-  #   * close            -> drives the run loop until every fiber has finished
-  #
-  # Single thread-of-use: only the owning thread runs the loop and resumes fibers.
-  # #unblock may be called from another thread and only mutates the (locked) ready
-  # queue + posts a wakeup; it never resumes a fiber itself.
-  class Scheduler
-    # One blocking wait. `settled` is the one-shot guard: whoever wakes the fiber
-    # first (I/O completion, timeout, or unblock) sets it; everyone else skips.
-    Waiter = Struct.new(:fiber, :settled)
-
-    # One fiber waiting on a socket for `events` (an io_wait waiter).
-    IoWaiter = Struct.new(:fiber, :events, :settled)
-
-    # The single outstanding AFD poll for one socket, shared by its io waiters.
-    PollEntry = Struct.new(:key, :io, :id, :armed, :waiters)
-
-    # A timer heap node. `value` is what the fiber is resumed with when it fires;
-    # `raise_exc` (for Timeout.timeout) makes it raise into the fiber instead.
-    Timer = Struct.new(:deadline, :waiter, :value, :raise_exc)
-
-    def initialize
-      @backend = Backend.new
-      @ready   = []     # [[fiber, resume_value], ...]   (shared: unblock pushes here)
-      @timers  = MinHeap.new # of Timer, keyed on :deadline
-      @polls   = {}     # socket key (fileno) => PollEntry
-      @ops     = {}     # backend poll id => PollEntry
-      @parked  = {}     # fiber => Waiter   (its CURRENT block/kernel_sleep park)
-      @lock    = Thread::Mutex.new # guards @ready + @parked (the cross-thread path)
-      @loop    = Fiber.current     # the thread's root fiber == the loop
-      @closed  = false
-
-      # ---- generic OVERLAPPED op state (winloop 0.2) ----
-      @thread     = Thread.current # the op API is loop-thread-only (enforced)
-      @op_waiters = {} # op_id => Waiter        (a fiber parked in await_op)
-      @op_orphans = {} # op_id => true          (timed-out/unwound awaits; the late
-                       #                         packet is retired without waking anyone)
-      @op_done    = {} # op_id => [bytes, error] (completed before anyone awaited)
-      @op_shut    = false # true once the loop has fully finished (backend shut down).
-                          # NOT @closed: under Winloop.run, #close IS the event loop,
-                          # so @closed is true while op-protocol fibers still run.
-    end
-
-    def monotonic
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
-    # ---- I/O readiness (accept / connect / IO#wait) -----------------------
-
-    # Wait until `io` is ready for `events`; returns the ready-events bitmask
-    # (0 on timeout). events is an OR of Winloop::READABLE/WRITABLE/PRIORITY.
-    def io_wait(io, events, timeout)
-      key    = io.fileno
-      waiter = IoWaiter.new(Fiber.current, events, false)
-      entry  = (@polls[key] ||= PollEntry.new(key, io, nil, 0, []))
-      entry.waiters << waiter
-      arm_poll(entry)
-      @timers.push(Timer.new(monotonic + timeout, waiter, 0, nil)) if timeout
-      Fiber.yield # resumed with the ready-events mask (or 0 on timeout)
-    ensure
-      # On the normal completion path the loop already removed us from the entry
-      # and re-armed/dropped it. If we are unwinding by any other path (timeout,
-      # or Timeout.timeout raised into us), detach and re-arm/cancel for the rest.
-      waiter.settled = true
-      if entry.waiters.delete(waiter)
-        if entry.waiters.empty?
-          cancel_entry(entry)
-        else
-          arm_poll(entry) # interest shrank; existing poll still covers it (no-op)
-        end
-      end
-    end
-
-    # ---- stream read/write (recv_nonblock + io_wait) ----------------------
-    #
-    # `length` is the MINIMUM bytes to transfer; 0 means "the whole region
-    # [offset, buffer.size)". MUST use recv_nonblock — read_nonblock / sysread /
-    # readpartial re-enter this hook on mswin and recurse forever.
-
-    def io_read(io, buffer, length, offset = 0)
-      return blocking_read(io, buffer, length, offset) unless io.respond_to?(:recv_nonblock)
-      total   = 0
-      minimum = length.zero? ? 1 : length
-      while total < minimum
-        maximum = buffer.size - offset - total
-        break if maximum <= 0
-        result = io.recv_nonblock(maximum, exception: false)
-        case result
-        when :wait_readable then io_wait(io, READABLE, nil)
-        when nil then break # EOF
-        else
-          buffer.set_string(result, offset + total)
-          total += result.bytesize
-        end
-      end
-      total
-    end
-
-    def io_write(io, buffer, length, offset = 0)
-      total   = 0
-      maximum = buffer.size - offset
-      return 0 if maximum <= 0
-      minimum = length.zero? ? maximum : length
-      minimum = maximum if minimum > maximum # never spin writing empty chunks
-      while total < minimum
-        chunk = buffer.get_string(offset + total, maximum - total)
-        break if chunk.empty?
-        result = io.write_nonblock(chunk, exception: false)
-        if result == :wait_writable
-          io_wait(io, WRITABLE, nil)
-        else
-          total += result
-        end
-      end
-      total
-    end
-
-    # ---- timers -----------------------------------------------------------
-
-    def kernel_sleep(duration = nil)
-      fiber  = Fiber.current
-      waiter = Waiter.new(fiber, false)
-      # Park under @parked so a cross-thread #unblock (e.g. ConditionVariable#wait
-      # with a timeout parks HERE, and a racing signal must wake us through the
-      # SAME one-shot guard as the timer — never a second, competing wakeup).
-      @lock.synchronize { @parked[fiber] = waiter }
-      @timers.push(Timer.new(monotonic + duration, waiter, nil, nil)) if duration
-      Fiber.yield
-      duration
-    ensure
-      @lock.synchronize do
-        waiter.settled = true # disarm a not-yet-fired timer on abnormal exit
-        @parked.delete(fiber)
-      end
-    end
-
-    def timeout_after(duration, exception_class, *exception_arguments)
-      waiter = Waiter.new(Fiber.current, false)
-      @timers.push(Timer.new(monotonic + duration, waiter, nil,
-                             [exception_class, exception_arguments]))
-      begin
-        yield duration
-      ensure
-        # disarm if the block finished before the deadline
-        @lock.synchronize { waiter.settled = true }
-      end
-    end
-
-    # ---- block / unblock (Mutex, ConditionVariable, Queue, Thread#join) ----
-
-    def block(blocker, timeout = nil)
-      fiber  = Fiber.current
-      waiter = Waiter.new(fiber, false)
-      @lock.synchronize { @parked[fiber] = waiter }
-      @timers.push(Timer.new(monotonic + timeout, waiter, false, nil)) if timeout
-      Fiber.yield # true (unblocked) or false (timed out)
-    ensure
-      @lock.synchronize do
-        waiter.settled = true
-        @parked.delete(fiber)
-      end
-    end
-
-    # Called from ANY thread: only mutate shared state under the lock and wake
-    # the loop — never resume the fiber here.
-    #
-    # We wake by FIBER identity through its single parked Waiter, ignoring
-    # `blocker`. That is deliberate and important:
-    #   * Thread#join calls block(thread) but MRI calls unblock(<a DIFFERENT
-    #     object>, fiber); keying on the fiber wakes it correctly anyway.
-    #   * A fiber can have more than one live wakeup source (a timeout timer AND
-    #     this unblock — e.g. ConditionVariable#wait(mutex, timeout) racing a
-    #     signal). Routing through the one Waiter's `settled` guard means exactly
-    #     one of them resumes the fiber; the loser is dropped. A raw, unguarded
-    #     "@ready << fiber" would double-resume and cut the fiber's NEXT wait short.
-    def unblock(_blocker, fiber)
-      @lock.synchronize do
-        waiter = @parked[fiber]
-        if waiter
-          wake_locked(waiter, true)
-        elsif @ready.none? { |f, _| f.equal?(fiber) }
-          # Not parked in any wait we track (spurious/late unblock) — last resort,
-          # de-duplicated so it can never double-enqueue.
-          @ready << [fiber, true]
-        end
-      end
-      @backend.wakeup
-    end
-
-    # ---- fiber creation ----------------------------------------------------
-
-    def fiber(&block)
-      fiber = Fiber.new(blocking: false, &block)
-      fiber.resume
-      fiber
-    end
-
-    # ---- optional hooks (offloaded to a thread; the originals re-enter) -----
-
-    # Run a blocking operation on a fresh, scheduler-FREE thread and park the
-    # calling fiber on it cooperatively (Thread#value -> our block hook). The
-    # worker is killed if this fiber unwinds first (Timeout.timeout / Fiber kill)
-    # so it can never outlive us, leak, or race a later operation. We do NOT
-    # join after kill — that would re-enter the scheduler mid-unwind; Thread#kill
-    # interrupts the blocking syscall and the worker terminates on its own.
-    def await_on_thread(&block)
-      worker = Thread.new(&block)
-      worker.report_on_exception = false # expected errors are surfaced via #value
-      begin
-        worker.value
-      ensure
-        if worker.alive?
-          # Unwound first (Timeout/kill): interrupt the worker out of its blocking
-          # syscall and WAIT for it to die before returning, so it can't read (and
-          # discard) bytes that a later operation on the same IO expects. kill
-          # interrupts readpartial immediately, so this join does not block.
-          worker.kill
-          worker.join
-        end
-      end
-    end
-
-    def address_resolve(hostname)
-      await_on_thread do
-        Addrinfo.getaddrinfo(hostname, nil, nil, :STREAM).map(&:ip_address).uniq
-      end
-    rescue SocketError
-      []
-    end
-
-    def process_wait(pid, flags)
-      await_on_thread { Process::Status.wait(pid, flags) }
-    end
-
-    # ---- generic OVERLAPPED completions (the cross-gem op protocol) ---------
-    #
-    # Client gems feature-detect with `Fiber.scheduler.respond_to?(:await_op)`
-    # and talk ONLY to these wrappers (never the Backend — they cannot reach
-    # #wait/#shutdown and corrupt the loop). The contract loop:
-    #
-    #   op_associate(h)                            # once, at handle-open time
-    #   op_id, ov, buf = op_prepare(h, capacity: n)
-    #   ok = <the client's own native submit using ov/buf>
-    #   if ok # native call returned TRUE or GetLastError == ERROR_IO_PENDING
-    #     op_submitted(op_id)
-    #     bytes, error, data = await_op(op_id, timeout: t)  # fiber parks here
-    #   else  # synchronous failure: no packet will ever arrive
-    #     op_abandon(op_id)
-    #   end
-    #
-    # All of these are loop-thread-only and raise once the scheduler has shut down.
-
-    def op_associate(handle)
-      op_guard!
-      @backend.associate(handle)
-    end
-
-    def op_prepare(handle, tag: 0, capacity: 0)
-      op_guard!
-      @backend.op_prepare(handle, tag: tag, capacity: capacity)
-    end
-
-    def op_submitted(op_id)
-      op_guard!
-      @backend.op_submitted(op_id)
-    end
-
-    def op_abandon(op_id)
-      op_guard!
-      @backend.op_abandon(op_id)
-    end
-
-    def op_cancel(op_id)
-      op_guard!
-      @backend.op_cancel(op_id)
-    end
-
-    def op_state(op_id)
-      op_guard!
-      @backend.op_state(op_id)
-    end
-
-    # Park the calling fiber until op_id's completion packet is reaped by the
-    # loop, then return [bytes, error, data] (op_result is pulled HERE, in the
-    # woken fiber, so orphaned completions never allocate Strings). On timeout:
-    # returns nil, auto-cancels and orphans the op. Either way the op is retired:
-    # after await_op returns — value or nil — the op_id must not be used again.
-    #
-    # timeout: nil (wait forever — safe provided the op was submitted on a handle
-    # that is still the associated handle) or a positive Numeric in seconds.
-    # Recommendation: pass a real timeout while first integrating a new native
-    # API; switch to nil once the submit path is proven.
-    def await_op(op_id, timeout: nil)
-      op_guard!
-      validate_op_timeout!(timeout)
-      if @op_done.delete(op_id)              # early completion: no yield
-        return @backend.op_result(op_id)
-      end
-      raise Error, "winloop: op #{op_id} already has a waiter" if @op_waiters.key?(op_id)
-      raise Error, "winloop: op #{op_id} has not been submitted" if @backend.op_state(op_id) == :prepared
-      waiter = Waiter.new(Fiber.current, false)
-      @op_waiters[op_id] = waiter
-      @timers.push(Timer.new(monotonic + timeout, waiter, nil, nil)) if timeout
-      completed = Fiber.yield                # [bytes, error] or nil (timer fired)
-      completed ? @backend.op_result(op_id) : nil
-    ensure
-      # NOTHING in this ensure may raise — it runs during Timeout::Error /
-      # Fiber#raise / Fiber#kill unwinds and must never mask the in-flight
-      # exception (op_cancel's no-raise-on-CancelIoEx contract exists for this).
-      if waiter
-        waiter.settled = true
-        if @op_waiters.delete(op_id)         # loop did NOT deliver: timeout or unwind
-          @op_orphans[op_id] = true
-          begin
-            @backend.op_cancel(op_id)        # late packet -> orphan path retires it
-          rescue Error
-            # backend already shut down mid-unwind: nothing left to cancel
-          end
-        elsif !completed                     # loop DID deliver, but we were unwound
-          # (Fiber#kill, or a sibling raise) before resuming with the value: the
-          # record sits OP_COMPLETED with nobody left to op_result it — free it
-          # now. Guarded: the loop's settled/timer branch may have retired the id.
-          @backend.op_free(op_id) if op_completed_unconsumed?(op_id)
-        end
-      end
-    end
-
-    # ---- lifecycle ---------------------------------------------------------
-
-    # MRI calls this automatically at thread/program exit. It IS the event loop.
-    def close
-      return if @closed
-      @closed = true
-      run
-    ensure
-      @op_shut = true # the op protocol is over; op_* / await_op raise from here on
-      @backend.shutdown
-      # NEVER call Fiber.set_scheduler(nil) here — it raises SystemStackError
-      # during MRI's implicit close at thread exit.
-    end
-
-    def closed? = @closed
-
-    # ---- the run loop ------------------------------------------------------
-
-    def run
-      run_once until done?
-    end
-
-    private
-
-    def done?
-      # Locked so the "are we idle?" decision is atomic against a cross-thread
-      # #unblock that is moving a waiter into @ready right now.
-      @lock.synchronize do
-        drop_settled_timers
-        @ready.empty? && @timers.empty? && @ops.empty? && @parked.empty? &&
-          @op_waiters.empty?
-        # @op_orphans/@op_done deliberately do NOT keep the loop alive —
-        # shutdown's cancel+drain+sweep retires whatever is left.
-      end
-    end
-
-    def run_once
-      # (a) resume everything currently ready (outside the lock — resume runs
-      #     arbitrary Ruby which may re-enter the scheduler). An unhandled error
-      #     in a scheduled child fiber is reported, not fatal to the loop
-      #     (Thread-like); the main block's own errors are handled by Winloop.run.
-      ready = @lock.synchronize { r = @ready; @ready = []; r }
-      ready.each do |fiber, value|
-        next unless fiber.alive?
-        begin
-          fiber.resume(value)
-        rescue StandardError => e
-          report_fiber_error(e)
-        end
-      end
-
-      # (b) fire expired timers (skipping any already settled by another path)
-      drop_settled_timers
-      now = monotonic
-      while (t = @timers.peek) && t.deadline <= now
-        @timers.pop
-        next if t.waiter.settled
-        if t.raise_exc
-          t.waiter.settled = true
-          klass, args = t.raise_exc
-          f = t.waiter.fiber
-          begin
-            f.raise(klass, *args) if f.alive?
-          rescue StandardError => e
-            report_fiber_error(e)
-          end
-        else
-          @lock.synchronize { wake_locked(t.waiter, t.value) }
-        end
-        drop_settled_timers
-      end
-
-      # (c) compute the single-wait timeout. The idle decision is taken under
-      #     the lock so a concurrent #unblock can't slip a ready fiber past us.
-      timeout_ms = nil
-      idle = false
-      @lock.synchronize do
-        drop_settled_timers
-        if !@ready.empty?
-          timeout_ms = 0
-        elsif (t = @timers.peek)
-          ms = ((t.deadline - monotonic) * 1000).ceil
-          timeout_ms = ms < 0 ? 0 : ms
-        elsif @ops.empty? && @parked.empty? && @op_waiters.empty?
-          idle = true # nothing to wait for
-        else
-          timeout_ms = nil # INFINITE — pending I/O, parked fibers or awaited ops
-          # wake us. An awaited op pending => INFINITE is correct for contract-
-          # abiding ops: its completion (or its cancel's completion) wakes the
-          # port — guaranteed because op_prepare verified the handle is on it.
-        end
-      end
-      return if idle
-
-      # (d) one GetQueuedCompletionStatusEx; dispatch per entry on tuple size:
-      #     AFD readiness completions are 2-tuples [id, ready_events]; generic
-      #     op completions (winloop 0.2) are 4-tuples [op_id, bytes, error, tag].
-      @backend.wait(timeout_ms).each do |entry|
-        if entry.size == 4
-          op_id, bytes, error, _tag = entry
-          if (w = @op_waiters.delete(op_id))
-            if w.settled                     # its timer fired this same turn: orphan
-              @backend.op_free(op_id)
-            else
-              w.settled = true
-              @lock.synchronize { @ready << [w.fiber, [bytes, error]] }
-            end
-          elsif @op_orphans.delete(op_id)    # await timed out / unwound earlier
-            @backend.op_free(op_id)
-          else                               # completed before anyone awaited
-            @op_done[op_id] = [bytes, error]
-          end
-        else
-          fan_out_afd(entry[0], entry[1])
-        end
-      end
-    end
-
-    # Fan one AFD readiness completion out to the io waiters whose interest the
-    # ready mask satisfies (the pre-0.2 body of run_once step (d), unchanged).
-    def fan_out_afd(id, ready_events)
-      entry = @ops.delete(id)
-      return unless entry # stale: a superseded/cancelled poll
-      entry.id = nil
-      entry.armed = 0
-      to_wake = []
-      entry.waiters.reject! do |w|
-        if w.settled
-          true
-        elsif (got = w.events & ready_events) != 0
-          w.settled = true
-          to_wake << [w.fiber, got]
-          true
-        else
-          false # this waiter's direction didn't fire; keep it
-        end
-      end
-      @lock.synchronize { @ready.concat(to_wake) } unless to_wake.empty?
-      if entry.waiters.empty?
-        @polls.delete(entry.key)
-      else
-        arm_poll(entry) # re-arm for the still-waiting fibers
-      end
-    end
-
-    # Ensure at most one AFD poll is outstanding for `entry`'s socket, covering
-    # the union of all its waiters' interests. Re-arms only when the union grows.
-    def arm_poll(entry)
-      union = entry.waiters.inject(0) { |m, w| m | w.events }
-      return if union.zero?
-      return if entry.id && (union & ~entry.armed).zero? # current poll covers it
-
-      if entry.id
-        @ops.delete(entry.id)
-        @backend.cancel(entry.id) # its cancelled completion is reaped + ignored later
-        entry.id = nil
-      end
-      begin
-        entry.id = @backend.poll(entry.io, union)
-        entry.armed = union
-        @ops[entry.id] = entry
-      rescue Winloop::Error
-        # Socket vanished/closed mid-wait: wake every waiter so the follow-up
-        # recv/send surfaces the real error instead of hanging here.
-        to_wake = []
-        entry.waiters.each do |w|
-          next if w.settled
-          w.settled = true
-          to_wake << [w.fiber, w.events]
-        end
-        entry.waiters.clear
-        @lock.synchronize { @ready.concat(to_wake) } unless to_wake.empty?
-        @polls.delete(entry.key)
-      end
-    end
-
-    def cancel_entry(entry)
-      if entry.id
-        @ops.delete(entry.id)
-        @backend.cancel(entry.id)
-        entry.id = nil
-      end
-      @polls.delete(entry.key)
-    end
-
-    # Discard settled timers from the heap top so done? and the wait-timeout
-    # computation never block on a timer whose fiber already woke another way.
-    def drop_settled_timers
-      @timers.pop while (t = @timers.peek) && t.waiter.settled
-    end
-
-    # ---- generic-op helpers (winloop 0.2) ----------------------------------
-
-    # The op protocol is loop-thread-only (ops are submitted on the loop thread —
-    # fibers run there anyway; Ruby worker threads must not submit) and over once
-    # the loop has shut down.
-    def op_guard!
-      unless Thread.current == @thread
-        raise Error, "winloop: op API must be called on the scheduler's thread"
-      end
-      raise Error, "winloop: scheduler is closed" if @op_shut
-    end
-
-    def validate_op_timeout!(timeout)
-      return if timeout.nil?
-      return if timeout.is_a?(Numeric) && timeout.positive?
-      raise ArgumentError, "timeout must be nil or a positive Numeric (got #{timeout.inspect})"
-    end
-
-    # true iff the id is still live and in :completed state; false for retired ids
-    # (op_state raises "unknown op id" — swallowed here, never re-raised: this
-    # probe runs inside await_op's must-not-raise ensure).
-    def op_completed_unconsumed?(op_id)
-      @backend.op_state(op_id) == :completed
-    rescue Error
-      false
-    end
-
-    # Enqueue a fiber to resume, honouring the one-shot guard. Caller holds @lock.
-    def wake_locked(waiter, value)
-      return if waiter.settled
-      waiter.settled = true
-      @ready << [waiter.fiber, value]
-    end
-
-    def report_fiber_error(error)
-      return unless Thread.report_on_exception
-      warn "winloop: unhandled exception in scheduled fiber: #{error.class}: #{error.message}"
-      warn(error.backtrace.first(10).map { |l| "\tfrom #{l}" }.join("\n")) if error.backtrace
-    rescue StandardError
-      # never let error reporting itself break the loop
-    end
-
-    # Degraded path for non-socket IO (pipes, the console — no AFD readiness).
-    #
-    # The read runs on a scheduler-free worker thread (see await_on_thread) so
-    # IO#readpartial there is a genuine blocking syscall instead of re-dispatching
-    # back into this io_read hook (which would recurse to a SystemStackError),
-    # while the calling fiber parks cooperatively and the loop keeps serving
-    # others. `want` is clamped to the buffer's free region so set_string can't
-    # overflow. Note: non-socket IO is best-effort — if THIS read is unwound by a
-    # Timeout, bytes the worker had already pulled off the stream are lost (you
-    # can't un-read). Sockets are the first-class path.
-    def blocking_read(io, buffer, length, offset)
-      maximum = buffer.size - offset
-      return 0 if maximum <= 0
-      want = length.zero? ? maximum : [length, maximum].min
-      data =
-        begin
-          await_on_thread { io.readpartial(want) }
-        rescue EOFError, IOError
-          nil
-        end
-      return 0 if data.nil? || data.empty?
-      buffer.set_string(data, offset)
-      data.bytesize
-    end
-  end
-
-  # A tiny binary min-heap keyed on the node's #deadline. Enough for timers.
-  class MinHeap
-    def initialize
-      @a = []
-    end
-
-    def empty? = @a.empty?
-    def size = @a.size
-    def peek = @a[0]
-
-    def push(node)
-      @a << node
-      i = @a.size - 1
-      while i > 0
-        parent = (i - 1) / 2
-        break if @a[parent].deadline <= @a[i].deadline
-        @a[parent], @a[i] = @a[i], @a[parent]
-        i = parent
-      end
-      node
-    end
-
-    def pop
-      return nil if @a.empty?
-      top = @a[0]
-      last = @a.pop
-      unless @a.empty?
-        @a[0] = last
-        sift_down(0)
-      end
-      top
-    end
-
-    private
-
-    def sift_down(i)
-      n = @a.size
-      loop do
-        l = 2 * i + 1
-        r = 2 * i + 2
-        smallest = i
-        smallest = l if l < n && @a[l].deadline < @a[smallest].deadline
-        smallest = r if r < n && @a[r].deadline < @a[smallest].deadline
-        break if smallest == i
-        @a[i], @a[smallest] = @a[smallest], @a[i]
-        i = smallest
-      end
-    end
-  end
-end

data/lib/winloop/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Winloop
-  VERSION = "0.2.0"
-end