winloop 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6920000bbfa8ee7b4ddb3a773e560ec9fd17ebf7912926fd47ea838b9ccf1ceb
-  data.tar.gz: 9c935d93743bf1858e5ab64326dbd3a2b32230a98672f4fbd76417095ceb2e1b
+  metadata.gz: 421971bb70dfb847bc33075448fd61cb6b5821f8c8a4d2db1b9af90f40ecc151
+  data.tar.gz: 93cb1c5234f1c337fb9978725672b8607490bf904302e06e3044b5171882df63
 SHA512:
-  metadata.gz: 3313cb9155d745caa65538b904b8615b6fd3f700c8d9d1d14028e0042fd3de2581acabfd126d783d22989c01d1cee28560f7231209ae6680f94561087e5e30dc
-  data.tar.gz: 6a7dda120d347e68e1dcd433eea90db639a7b9dcbfc15d47220b0503ee0ae8f29fc15b1e4a29cc3b8b79dda096e4ebc3607819e798b8339a9aefb15137f54ec3
+  metadata.gz: c9fc6ac85100e03148872e24cef8beadd10e4989d34f748fb30c94d0b0f08b55a672483eb60f0e5edce7fca605acbfb12053c7bd6d68a7d135f0c8a60ed1eb92
+  data.tar.gz: c8b7b095198daecccc195c3b69eb4c67812f653911a552301bc191e4e010ab57f4f88aaa6ffe7a751af50ce1e13b056779a8a6dc88085566a2fc15aa8de7b199

data/README.md

@@ -1,278 +1,11 @@
-# winloop
-
-A native **Windows** Fiber Scheduler for MRI Ruby, built on **I/O Completion Ports**.
-
-`winloop` makes ordinary blocking code — socket reads and writes, `sleep`,
-`Timeout.timeout`, `Mutex`, `Queue`, `Thread#join`, DNS lookups — run
-cooperatively on a single thread. Wrap your code in `Winloop.run { ... }`,
-spawn fibers with `Fiber.schedule`, and thousands of connections share one
-thread without you touching a single nonblocking API.
-
-```ruby
-require "winloop"
-require "socket"
-
-Winloop.run do
-  server = TCPServer.new("127.0.0.1", 9292)
-  loop do
-    client = server.accept                 # readiness via AFD poll on the IOCP
-    Fiber.schedule do                       # one lightweight fiber per connection
-      while (line = client.gets)            # recv driven by the completion port
-        client.write(line)                  # send, never blocking the loop
-      end
-      client.close
-    end
-  end
-end
-```
-
-## Why this exists
-
-Ruby's `Fiber::Scheduler` (the engine behind `socketry/async` and friends) is the
-modern way to write concurrent I/O. But on Windows the selectors that back it —
-`socketry/io-event` ships `select`, `epoll`, `kqueue`, and `io_uring` — have **no
-IOCP backend**. The result has long been the weakest async story of any major
-platform: `select()`-bound, capped at 64 handles, and slow.
-
-`winloop` fills that hole the same way libuv, Rust's mio, and wepoll do it:
-
-* The event loop is a real **I/O Completion Port**. One
-  `GetQueuedCompletionStatusEx` call per turn reaps every ready event at once.
-* **Readiness** (accept, connect, `IO#wait_readable`) — which IOCP doesn't natively
-  provide — is obtained by submitting `IOCTL_AFD_POLL` against `\Device\Afd` as an
-  overlapped operation on the port. This is the undocumented mechanism libuv/mio
-  rely on, and it is the only way to get readiness semantics onto a completion port.
-* **Reads and writes** are driven by `recv`/`send` once the port reports readiness.
-* **Timers** (`sleep`, `Timeout.timeout`) use a monotonic min-heap that sets the
-  port's wait timeout — no kernel timer objects, no extra threads.
-* **`Mutex`/`Queue`/`Thread#join`** park the fiber on an in-process waiter list; a
-  wakeup from another OS thread breaks the loop's wait via
-  `PostQueuedCompletionStatus`.
-
-## Requirements
-
-* A **native Windows MSVC build of Ruby** (`x64-mswin64`). winloop compiles a C
-  extension with `cl.exe` and links `ws2_32`. It will refuse to install on any
-  non-`mswin` platform.
-* Ruby >= 3.1 (for a stable `Fiber::Scheduler` and `IO::Buffer`).
-* `\Device\Afd` readiness polling is a Windows NT facility; winloop is **not**
-  expected to work under Wine.
-
-## Installation
-
-```sh
-gem install winloop
-```
-
-Or build from a checkout (it dogfoods the [`vcvars`](https://rubygems.org/gems/vcvars)
-gem so it can find the MSVC toolchain without a Developer Command Prompt):
-
-```sh
-rake compile
-rake test
-```
-
-## What runs cooperatively
-
-Inside `Winloop.run { ... }` (and any `Fiber.schedule` started within it):
-
-| Operation                                  | Hook            | Mechanism                              |
-| ------------------------------------------ | --------------- | -------------------------------------- |
-| `TCPServer#accept`, `IO#wait_readable`     | `io_wait`       | `IOCTL_AFD_POLL` overlapped on the IOCP |
-| `IO#read` / `gets` / `recv` on a socket    | `io_read`       | `recv_nonblock` + `io_wait`             |
-| `IO#write` / `puts` on a socket            | `io_write`      | `write_nonblock` + `io_wait`            |
-| `sleep`                                     | `kernel_sleep`  | monotonic timer heap                   |
-| `Timeout.timeout`                           | `timeout_after` | timer heap + `Fiber#raise`             |
-| `Mutex`, `ConditionVariable`, `Queue`, `Thread#join` | `block`/`unblock` | waiter lists + `PostQueuedCompletionStatus` |
-| `Addrinfo.getaddrinfo`, DNS in `TCPSocket.new` | `address_resolve` | resolved on a worker thread        |
-| `Process.wait`                              | `process_wait`  | reaped on a worker thread              |
-| your own OVERLAPPED ops (any gem)           | `await_op`      | generic completion packets on the same IOCP |
-
-## API
-
-```ruby
-Winloop.run { ... }   # install a scheduler, run the block in a fiber, drive the
-                      # loop until every scheduled fiber finishes; returns the
-                      # block's value (and re-raises anything it raised).
-
-Winloop.supported?    # true when the native IOCP/AFD backend loaded.
-```
-
-For full control you can drive it yourself, exactly like any other
-`Fiber::Scheduler`:
-
-```ruby
-scheduler = Winloop::Scheduler.new
-Fiber.set_scheduler(scheduler)
-Fiber.schedule { ... }
-scheduler.close       # runs the event loop to completion
-```
-
-The generic-op surface (winloop 0.2 — see the next section):
-
-```ruby
-# Scheduler (the cross-gem protocol; loop-thread-only):
-sched.op_associate(handle)                        # => true   (permanent; handle stays yours)
-sched.op_prepare(handle, tag: 0, capacity: 0)     # => [op_id, ov_addr, buf_addr]
-sched.op_submitted(op_id)                         # => true   (native call returned TRUE or ERROR_IO_PENDING)
-sched.op_abandon(op_id)                           # => true   (native call failed synchronously)
-sched.op_cancel(op_id)                            # => true | false (false: already completed, or CancelIoEx failed — warned, never raised)
-sched.op_state(op_id)                             # => :prepared | :submitted | :completed
-sched.await_op(op_id, timeout: nil)               # => [bytes, error, data] | nil (timeout; op auto-cancelled)
-
-# Backend (the power layer; also the standalone-embedding layer):
-backend.associate(handle)                         # => true
-backend.op_prepare(handle, tag: 0, capacity: 0)   # => [op_id, ov_addr, buf_addr]
-backend.op_submitted(op_id)                       # => true
-backend.op_abandon(op_id)                         # => true
-backend.op_cancel(op_id)                          # => true | false
-backend.op_result(op_id)                          # => [bytes, error, data] (frees the record)
-backend.op_free(op_id)                            # => true (retire a completion nobody wants)
-backend.op_state(op_id)                           # => :prepared | :submitted | :completed
-backend.port_handle                               # => Integer (read-only; tests/diagnostics)
-backend.wait(timeout_ms)                          # => [[id, events], ..., [op_id, bytes, error, tag], ...]
-Winloop::EXTERNAL_KEY                             # => 0x45585431 — completion key of all generic ops
-Winloop::OP_CAPACITY_MAX                          # => 16 MiB — op_prepare capacity ceiling
-```
-
-## Bring your own OVERLAPPED (generic completions)
-
-**winloop 0.2 lets any gem associate a Windows handle with the loop's completion
-port, submit its own overlapped operation, and park the calling fiber until the
-completion packet arrives — cancel and synchronous-completion semantics done
-right, with zero change to everything winloop already does.** This is a seam for
-**gem authors** (file watchers, named pipes, mailslots…), not app code.
-
-The contract loop: `op_associate` → `op_prepare` → your native submit →
-`op_submitted` (success **or** `ERROR_IO_PENDING` — both queue a packet) /
-`op_abandon` (synchronous failure — the only no-packet case) → `await_op` →
-`[bytes, error, data]`.
-
-A real overlapped file read driven from plain Ruby via Fiddle (stdlib):
-
-```ruby
-require "winloop"
-require "fiddle/import"
-
-module K32
-  extend Fiddle::Importer
-  dlload "kernel32.dll"
-  extern "void* CreateFileW(void*, unsigned long, unsigned long, void*, unsigned long, unsigned long, void*)"
-  extern "int ReadFile(void*, void*, unsigned long, void*, void*)"
-  extern "int CloseHandle(void*)"
-end
-
-GENERIC_READ         = 0x8000_0000
-FILE_SHARE_READ      = 0x1
-OPEN_EXISTING        = 3
-FILE_FLAG_OVERLAPPED = 0x4000_0000
-ERROR_IO_PENDING     = 997
-
-Winloop.run do
-  sched = Fiber.scheduler                 # a Winloop::Scheduler
-  wpath = (File.expand_path(__FILE__) + "\0").encode("UTF-16LE")
-  h = K32.CreateFileW(wpath, GENERIC_READ, FILE_SHARE_READ, nil,
-                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, nil).to_i
-  sched.op_associate(h)
-  op_id, ov, buf = sched.op_prepare(h, capacity: 4096)
-  ok = K32.ReadFile(h, buf, 4096, nil, ov)
-  if ok != 0 || Fiddle.win32_last_error == ERROR_IO_PENDING
-    sched.op_submitted(op_id)             # success AND pending both queue a packet
-    bytes, error, data = sched.await_op(op_id, timeout: 5)   # fiber parks HERE
-    raise Winloop::Error, "read failed (#{error})" unless error.zero?
-    puts "read #{bytes} bytes: #{data[0, 40].inspect}"
-  else
-    sched.op_abandon(op_id)               # synchronous failure: no packet will come
-    raise Winloop::Error, "ReadFile failed (#{Fiddle.win32_last_error})"
-  end
-  K32.CloseHandle(h)
-end
-```
-
-### Rules (read this twice)
-
-* **Handles stay yours.** winloop owns the op memory (OVERLAPPED + buffer, one
-  backend-owned heap allocation); you open and close your handles — winloop
-  never calls `CloseHandle` on them.
-* **Association is permanent** — one port per handle, no disassociation (Win32
-  rule). After the loop shuts down an associated handle can never join another
-  winloop loop; re-open per `Winloop.run` session.
-* **Associate before prepare.** `op_prepare` rejects handles it has never seen,
-  because an op on a handle that is not on the port never completes: not an
-  error, a **silent hang**. The one case the check cannot catch — closing a
-  handle mid-flight so the OS recycles its value — is on you: cancel → await →
-  only then `CloseHandle`.
-* **Use `await_op` timeouts while first integrating a new native API**; switch
-  to `nil` once the submit path is proven.
-* Never set `FILE_SKIP_COMPLETION_PORT_ON_SUCCESS` on an associated handle (it
-  is irreversible and per-handle): winloop's invariant is exactly one packet per
-  submitted op, always. Don't use `ReadFileEx`/`WriteFileEx` (APC I/O) on
-  associated handles, and don't duplicate/inherit them.
-* **Cancel never frees** — the cancelled op still posts a packet (usually error
-  995), which is reaped normally.
-* **After `await_op` returns — value or `nil` — the op id is dead.** Don't use
-  it again.
-* Loop thread only: ops are submitted on the loop thread (fibers run there
-  anyway); the scheduler wrappers enforce it.
-* **Completion errors are values, not exceptions**: `995` cancelled, `1022`
-  RDCW rescan, `38` EOF, … A zero-byte successful completion is a real signal
-  (RDCW overflow ⇒ rescan), delivered verbatim.
-* No PQCS injection — out of scope in v1. `Backend#port_handle` exists for
-  tests and diagnostics only.
-
-### Standalone (no scheduler)
-
-Client gems never hard-depend on winloop. The protocol is duck-typed on the
-scheduler:
-
-```ruby
-sched = Fiber.scheduler
-if sched&.respond_to?(:await_op)
-  # winloop (or compatible) IOCP path: op_associate / op_prepare / native
-  # submit / op_submitted / await_op — as above.
-else
-  # the client gem's own standalone mechanism, e.g. the winipc pattern:
-  # stack OVERLAPPED + manual-reset hEvent, WaitForSingleObject without the
-  # GVL with ubf = CancelIoEx, GetOverlappedResult; or a gem-owned wait thread
-  # for continuous streams.
-end
-```
-
-winloop ships **no** shared standalone wait thread or service (dependency
-direction, irreversible association, ownership — clients own their threads).
-`Winloop::Backend` itself does work standalone — create, `associate`,
-prepare/submit, `wait`-poll (dispatch on tuple size: AFD 2-tuples vs op
-4-tuples in the same array), `op_result`, `shutdown` — which is how an embedder
-or a test drives it deterministically.
-
-## Scope and limitations (v0.2)
-
-* **Sockets are the focus.** TCP/UDP sockets get the full IOCP/AFD path. Pipes and
-  regular files fall back to a blocking read inside `io_read` (async file I/O on
-  Windows is a separate mechanism, planned for later).
-* **Single thread-of-use.** One thread runs the loop and resumes fibers; other OS
-  threads may safely wake it (e.g. a background `Queue` producer), but the loop
-  itself is not a multi-threaded worker pool.
-* `IOCTL_AFD_POLL` is undocumented; winloop resolves its `ntdll` entry points at
-  runtime and degrades by raising a clear error if `\Device\Afd` is unavailable.
-* **The ops API is for gem authors.** Buffers are backend-owned only (no
-  IO::Buffer/String pinning — copy-out removes the whole lifetime/compaction bug
-  class). Ops still in flight at shutdown are cancelled and drained for a
-  bounded interval; stragglers may be deliberately leaked rather than freed
-  under possible kernel ownership.
-* **x64 only.** arm64-mswin is expected to work (all code is `_WIN64`/
-  `uintptr_t`-clean, no arch-specific anything — AFD + IOCP are
-  production-proven on arm64 via libuv/Node and mio/Rust) but is untested and
-  unsupported until an arm64-mswin Ruby distribution exists.
-
-## How it compares
-
-`winloop` is a drop-in `Fiber::Scheduler`, so it works with anything that targets
-the scheduler interface. It is *not* a reimplementation of `async` — it's the
-missing Windows engine such libraries can run on. The reference scheduler shipped
-with Ruby is intended for testing and is `IO.select`-bound; winloop replaces that
-selector with a true completion port.
-
-## License
-
-MIT. See [LICENSE.txt](LICENSE.txt).
+# winloop (discontinued)
+
+**winloop is no longer maintained.** This final release (0.2.1) contains no
+code: installing it compiles nothing, and `require "winloop"` raises a
+`LoadError` explaining the discontinuation.
+
+Use async / io-event (native Windows IOCP support is in progress upstream) instead.
+
+Earlier releases remain on RubyGems only because RubyGems does not allow
+versions older than 30 days to be yanked. They are unmaintained and not
+recommended.

data/lib/winloop.rb

@@ -1,81 +1,4 @@
-# frozen_string_literal: true
-
-require_relative "winloop/version"
-
-# winloop — a native Windows (IOCP) Fiber Scheduler for MRI Ruby.
-#
-#   require "winloop"
-#
-#   Winloop.run do
-#     server = TCPServer.new("127.0.0.1", 9292)
-#     loop do
-#       client = server.accept          # io_wait via AFD poll
-#       Fiber.schedule do               # one fiber per connection
-#         while (line = client.gets)    # io_read via recv_nonblock + io_wait
-#           client.write(line)
-#         end
-#         client.close
-#       end
-#     end
-#   end
-#
-# All blocking socket I/O, sleeps, timeouts and Mutex/Queue/Thread#join inside
-# the block run cooperatively on a single thread, driven by one I/O Completion
-# Port. See Winloop::Scheduler for the hook implementations.
-module Winloop
-  class Error < StandardError; end unless const_defined?(:Error)
-
-  # Loaded for its side effect of defining Winloop::Backend + the IO event
-  # constants (READABLE/WRITABLE/PRIORITY). mswin-only.
-  begin
-    require "winloop/winloop"
-  rescue LoadError => e
-    raise LoadError, "winloop's native backend failed to load — winloop needs a " \
-                     "Windows MSVC (mswin) Ruby. (#{e.message})"
-  end
-
-  require_relative "winloop/scheduler"
-  require_relative "winloop/ops" # generic-op validation layer (OP_CAPACITY_MAX, op_prepare)
-
-  module_function
-
-  # True if the IOCP/AFD backend is available on this platform.
-  def supported?
-    const_defined?(:Backend)
-  end
-
-  # Install a fresh Winloop::Scheduler on the current thread, run `block` inside
-  # a non-blocking fiber, drive the event loop until every scheduled fiber has
-  # finished, and return the block's value.
-  #
-  # Nesting is not supported; if a scheduler is already installed, the block is
-  # simply scheduled on it.
-  def run
-    raise ArgumentError, "Winloop.run requires a block" unless block_given?
-
-    # Already inside a scheduler (e.g. a nested Winloop.run within a fiber): just
-    # run the block here — blocking operations already cooperate with that loop.
-    return yield if Fiber.scheduler
-
-    scheduler = Scheduler.new
-    Fiber.set_scheduler(scheduler)
-    result = nil
-    error = nil
-    Fiber.schedule do
-      begin
-        result = yield
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        error = e
-      end
-    end
-    scheduler.close # drives the loop to completion
-    raise error if error
-    result
-  ensure
-    # Detach our (now-closed) scheduler so subsequent ordinary I/O on this
-    # thread doesn't hit a closed backend. Safe here: we are on the main fiber
-    # and close has already returned (the reentrant-close trap only bites when
-    # set_scheduler(nil) is called from *inside* #close during finalization).
-    Fiber.set_scheduler(nil) if Fiber.scheduler.equal?(scheduler)
-  end
-end
+# frozen_string_literal: true
+
+raise LoadError, "winloop is discontinued and this release contains no code. Use async / io-event (native Windows IOCP support is in progress upstream) instead." \
+  " Earlier winloop releases are unmaintained and not recommended."

metadata

@@ -1,87 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: winloop
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - ned
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-description: |
-  winloop is a Ruby Fiber::Scheduler built on Win32 I/O Completion Ports. It
-  makes ordinary socket I/O, sleeps, timeouts and Mutex/Queue/Thread#join run
-  cooperatively on a single thread — the async-runtime story that has always
-  been weak on Windows, done the way libuv/mio/wepoll do it: readiness over an
-  IOCP via \Device\Afd polling, with recv/send driven by the completion port.
-  Requires a native Windows MSVC (mswin) build of Ruby.
+dependencies: []
+description: winloop is discontinued. This final release contains no code and exists
+  only so that installing winloop explains the discontinuation instead of building
+  an unmaintained native extension.
 executables: []
-extensions:
-- ext/winloop/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- ext/winloop/extconf.rb
-- ext/winloop/winloop.c
 - lib/winloop.rb
-- lib/winloop/ops.rb
-- lib/winloop/scheduler.rb
-- lib/winloop/version.rb
-homepage: https://github.com/main-path/winloop
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/main-path/winloop
-  source_code_uri: https://github.com/main-path/winloop
-  changelog_uri: https://github.com/main-path/winloop/blob/main/CHANGELOG.md
-  bug_tracker_uri: https://github.com/main-path/winloop/issues
-  allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
+post_install_message: winloop is discontinued and this release contains no code. Use
+  async / io-event (native Windows IOCP support is in progress upstream) instead.
 rdoc_options: []
 require_paths:
 - lib
@@ -89,7 +32,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -98,5 +41,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A native Windows (IOCP) Fiber Scheduler for MRI Ruby.
+summary: Discontinued. Use async / io-event (native Windows IOCP support is in progress
+  upstream) instead.
 test_files: []

data/CHANGELOG.md

@@ -1,88 +0,0 @@
-# Changelog
-
-## 0.2.0
-
-**Bring your own OVERLAPPED** — a generic OVERLAPPED/IOCP completion API, so any
-gem can associate a Windows handle with the loop's completion port, submit its
-own overlapped operation, and park the calling fiber until the completion packet
-arrives. Strictly additive: nothing in the 0.1 API changes signature or behavior,
-and all 34 pre-existing tests pass byte-unmodified.
-
-### Added
-
-* **`Winloop::Backend` op API** (the power layer; also works standalone, with no
-  scheduler): `#associate(handle)`, `#op_prepare(handle, tag:, capacity:)` →
-  `[op_id, ov_addr, buf_addr]` (backend-owned OVERLAPPED + 8-byte-aligned
-  embedded buffer), `#op_submitted`, `#op_abandon` (synchronous-failure path —
-  the only no-packet case), `#op_cancel` (`CancelIoEx`; **never frees** — the
-  cancelled op still posts a packet, which is reaped normally; CancelIoEx
-  failures warn and return `false`, never raise), `#op_result` →
-  `[bytes, error, data]`, `#op_free`, `#op_state`, and `#port_handle`
-  (tests/diagnostics only).
-* **`Winloop::Scheduler` op protocol** (the misuse-resistant cross-gem surface,
-  feature-gated by `Fiber.scheduler.respond_to?(:await_op)`): `op_associate`,
-  `op_prepare`, `op_submitted`, `op_abandon`, `op_cancel`, `op_state`, and
-  `await_op(op_id, timeout: nil)`, which parks the calling fiber until the
-  completion is reaped (returns the `[bytes, error, data]` triple, or `nil` on
-  timeout after auto-cancelling and orphaning the op). Loop-thread-only,
-  enforced.
-* Constants `Winloop::EXTERNAL_KEY` (the completion key carried by all generic
-  ops) and `Winloop::OP_CAPACITY_MAX` (16 MiB embedded-buffer ceiling).
-* **Completion errors are data, not exceptions**: the `error` element carries
-  the Win32 code mapped from the final NTSTATUS via `RtlNtStatusToDosError`
-  (`0` success, `995` cancelled, `1022` RDCW rescan, `38` EOF, …).
-* `op_prepare` rejects handles never passed to `#associate` — an op on a handle
-  that is not on the port never completes (a silent hang, not an error).
-* Defensive reap: unknown EXT packets and duplicate posts for already-completed
-  ops are skipped with a warning, never cast, never re-completed.
-* `ObjectSpace.memsize_of(backend)` now reports live op-buffer bytes.
-* Gemspec metadata tightened to suite grade: `bug_tracker_uri`,
-  `rubygems_mfa_required`.
-
-### Changed
-
-* `Backend#shutdown` (and the GC free hook) now also cancels every in-flight
-  generic op per op (`CancelIoEx(handle, ov)`), drains their packets — including
-  one bounded 100 ms wait taken **only** when generic ops are still in flight —
-  and frees retired records. Ops whose packet never surfaced inside the bounded
-  drain are deliberately leaked (the kernel may still write their
-  OVERLAPPED/IOSB; a use-after-free beats a bounded leak). Existing AFD-only
-  workloads see byte-identical shutdown.
-* `Backend#wait` may now return 4-element arrays `[op_id, bytes, error, tag]`
-  alongside the existing AFD 2-tuples — when, and only when, the new op API is
-  used in the process. Callers dispatch on tuple size; the AFD contract
-  (2-tuples, `[]` on timeout, wakeups skipped) is untouched.
-
-## 0.1.0
-
-Initial release.
-
-* A `Fiber::Scheduler` for MRI on Windows backed by I/O Completion Ports.
-* C backend (`Winloop::Backend`): one IOCP plus a `\Device\Afd` handle, with
-  one-shot readiness polls (`IOCTL_AFD_POLL`) submitted as overlapped operations
-  on the port, reaped in batches via `GetQueuedCompletionStatusEx`. The wait runs
-  without the GVL so background threads can wake the loop with
-  `PostQueuedCompletionStatus`.
-* Scheduler hooks: `io_wait`, `io_read`, `io_write`, `kernel_sleep`,
-  `timeout_after`, `block`/`unblock`, `fiber`, `address_resolve`, `process_wait`,
-  and `close` (which drives the event loop).
-* Monotonic timer min-heap for `sleep` and `Timeout.timeout`.
-* `Winloop.run { ... }` convenience entry point.
-* Verified with TCP echo over many concurrent connections, large multi-chunk
-  transfers, EOF handling, `Timeout` (both firing and not), cross-thread `Queue`,
-  inter-fiber `Mutex` contention, `Thread#join`, DNS resolution, and `IO.popen`.
-
-  Hardened over three rounds of adversarial review (the GVL is released around the
-  completion wait so background threads can wake the loop):
-  * AFD readiness polls are **coalesced per socket** — multiple fibers waiting the
-    same socket for the same event all wake (the AFD driver only completes one poll
-    per readiness edge, so independent polls would lose wakeups).
-  * Cross-thread wakeups are unified through a single per-fiber guard, so a timeout
-    timer racing an `unblock` (e.g. `ConditionVariable#wait(mutex, timeout)` racing a
-    signal, or `Thread#join(timeout)` near its deadline) can never double-resume a
-    fiber and cut its next wait short.
-  * Settled timers are dropped from the heap so an early-resolved wait can't pin the
-    loop asleep until its original (possibly long) timeout.
-  * An unhandled exception in a scheduled fiber is reported, not fatal to the loop.
-  * The non-socket read fallback runs on a worker thread that is killed if its fiber
-    unwinds, so it can't leak or steal data; pipe EOF is silent.

data/ext/winloop/extconf.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-#
-# extconf.rb for the winloop C backend (IOCP + \Device\Afd readiness).
-
-require "mkmf"
-
-unless RbConfig::CONFIG["target_os"] =~ /mswin/
-  abort <<~MSG
-    winloop requires a native Windows MSVC (mswin) Ruby — its event loop is built
-    on Win32 I/O Completion Ports and \\Device\\Afd readiness polling (cl.exe).
-    Your Ruby is "#{RbConfig::CONFIG['arch']}".
-  MSG
-end
-
-# Winsock. (ntdll's Nt*/Rtl* entry points are resolved at runtime via
-# GetProcAddress, so no ntdll import lib is required.) Pure C — no -EHsc.
-$libs = [$libs, "ws2_32.lib"].join(" ")
-
-create_makefile("winloop/winloop")