rsloop 0.1.23__tar.gz → 0.1.25__tar.gz

{rsloop-0.1.23 → rsloop-0.1.25}/Cargo.lock

@@ -234,9 +234,9 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "bytes"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae3f5d315924270530207e2a68396c3cc547f6dca3fbdca317cfb1a51edb593"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "cc"
@@ -476,18 +476,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-queue"
-version = "0.3.12"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+checksum = "803d13fb3b09d88be9f4dbc29062c66b19bf7170867ceb746d2a8689bf6c7a26"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "dunce"
@@ -581,9 +581,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+checksum = "262590f4fe6afeb0bc83be1daa64e52657fe185690a958af7f3ad0e92085c5ae"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -591,15 +591,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
 
 [[package]]
 name = "futures-io"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+checksum = "4577ecaa3c4f96589d473f679a71b596316f6641bc350038b962a5daf0085d7a"
 
 [[package]]
 name = "futures-lite"
@@ -616,9 +616,9 @@ dependencies = [
 
 [[package]]
 name = "futures-macro"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+checksum = "2d6d3cde68c518367be28956066ddfef33813991b77a55005a69dae04bf3b10b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -627,21 +627,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+checksum = "e34418ac499d6305c2fb5ad0ed2f6ac998c5f8ca209b4510f7f94242c647e307"
 
 [[package]]
 name = "futures-task"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
 
 [[package]]
 name = "futures-util"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -842,15 +842,15 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.8.2"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "mio"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda"
+checksum = "30d65c71f1ce40ab09135ce117d742b9f8a19ff91a41a8b57ed50bc2de59c427"
 dependencies = [
  "libc",
  "log",
@@ -1116,7 +1116,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.23"
+version = "0.1.25"
 dependencies = [
  "async-std",
  "compio",
@@ -1384,9 +1384,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.118"
+version = "2.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1431,9 +1431,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.52.3"
+version = "1.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+checksum = "d988bcd52dbe076d3d46903332f58c912b87a2c49b1428419a5845154762ffee"
 dependencies = [
  "bytes",
  "pin-project-lite",
@@ -1541,9 +1541,9 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibeio"
-version = "0.2.13"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfd556b0b3efd91cb88566b6aa6d0ceef475b37443b6d898e170ce9da73a2f67"
+checksum = "63b968e30d91bc5c14d23f9af184f26ea7f0d886ab309d11b37148b244d7dfa4"
 dependencies = [
  "crossbeam-queue",
  "futures-util",

{rsloop-0.1.23 → rsloop-0.1.25}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsloop"
-version = "0.1.23"
+version = "0.1.25"
 edition = "2024"
 description = "An event loop for asyncio written in Rust"
 license = "Apache-2.0"
@@ -35,7 +35,7 @@ tracy-client = { version = "0.18", default-features = false, features = ["enable
 
 [target.'cfg(windows)'.dependencies]
 tokio = { version = "1", default-features = false, features = ["io-util"] }
-vibeio = { version = "0.2.13", default-features = false }
+vibeio = { version = "0.2.15", default-features = false }
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Networking_WinSock", "Win32_System_Pipes", "Win32_System_Threading"] }
 
 [build-dependencies]

{rsloop-0.1.23 → rsloop-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.23
+Version: 0.1.25
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -379,26 +379,26 @@ uv run --with maturin maturin develop --release
 uv run --with uvloop python benchmarks/compare_event_loops.py
 ```
 
-An example output from that script on Linux with CPython 3.14.0:
+An example output from that script on macOS (arm64) with CPython 3.14:
 
 ```
 callbacks (200,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-rsloop         0.041608     0.040585      4,806,807        1.00x
-uvloop         0.087539     0.086690      2,284,707        2.10x
-asyncio        0.229563     0.221348        871,222        5.52x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.033083     0.032710      6,045,401     67.5 MiB        1.00x
+uvloop         0.040958     0.040721      4,883,026     72.8 MiB        1.24x
+asyncio        0.082233     0.082093      2,432,114     65.3 MiB        2.49x
 
 tasks (50,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-uvloop         0.084425     0.083497        592,239        1.00x
-rsloop         0.091845     0.090982        544,397        1.09x
-asyncio        0.138782     0.137716        360,276        1.64x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.063593     0.063286        786,247     37.6 MiB        1.00x
+uvloop         0.069614     0.069420        718,251     38.4 MiB        1.09x
+asyncio        0.108114     0.107502        462,473     36.1 MiB        1.70x
 
 tcp_streams (5,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-rsloop         0.119483     0.118451         41,847        1.00x
-uvloop         0.119582     0.116446         41,812        1.00x
-asyncio        0.138408     0.134438         36,125        1.16x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.090940     0.083355         54,981     32.2 MiB        1.00x
+uvloop         0.133182     0.127404         37,543     31.5 MiB        1.46x
+asyncio        0.302337     0.299813         16,538     29.6 MiB        3.32x
 ```
 
 See [`benchmarks/README.md`](./benchmarks/README.md) for workload details and

{rsloop-0.1.23 → rsloop-0.1.25}/README.md

@@ -347,26 +347,26 @@ uv run --with maturin maturin develop --release
 uv run --with uvloop python benchmarks/compare_event_loops.py
 ```
 
-An example output from that script on Linux with CPython 3.14.0:
+An example output from that script on macOS (arm64) with CPython 3.14:
 
 ```
 callbacks (200,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-rsloop         0.041608     0.040585      4,806,807        1.00x
-uvloop         0.087539     0.086690      2,284,707        2.10x
-asyncio        0.229563     0.221348        871,222        5.52x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.033083     0.032710      6,045,401     67.5 MiB        1.00x
+uvloop         0.040958     0.040721      4,883,026     72.8 MiB        1.24x
+asyncio        0.082233     0.082093      2,432,114     65.3 MiB        2.49x
 
 tasks (50,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-uvloop         0.084425     0.083497        592,239        1.00x
-rsloop         0.091845     0.090982        544,397        1.09x
-asyncio        0.138782     0.137716        360,276        1.64x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.063593     0.063286        786,247     37.6 MiB        1.00x
+uvloop         0.069614     0.069420        718,251     38.4 MiB        1.09x
+asyncio        0.108114     0.107502        462,473     36.1 MiB        1.70x
 
 tcp_streams (5,000 ops)
-loop           median_s       best_s      ops_per_s   vs_fastest
-rsloop         0.119483     0.118451         41,847        1.00x
-uvloop         0.119582     0.116446         41,812        1.00x
-asyncio        0.138408     0.134438         36,125        1.16x
+loop           median_s       best_s      ops_per_s     peak_rss   vs_fastest
+rsloop         0.090940     0.083355         54,981     32.2 MiB        1.00x
+uvloop         0.133182     0.127404         37,543     31.5 MiB        1.46x
+asyncio        0.302337     0.299813         16,538     29.6 MiB        3.32x
 ```
 
 See [`benchmarks/README.md`](./benchmarks/README.md) for workload details and

{rsloop-0.1.23 → rsloop-0.1.25}/benchmarks/README.md

@@ -57,7 +57,7 @@ The runner executes each loop/workload in a fresh subprocess and reports:
 
 Current workloads:
 
-- `callbacks`: chained `call_soon()` dispatch
+- `callbacks`: pre-scheduled batch of `call_soon()` callbacks (schedule + dispatch cost)
 - `tasks`: many tiny `asyncio.sleep(0)` tasks
 - `tcp_streams`: local `asyncio.start_server()` / `asyncio.open_connection()` echo round trips
 

{rsloop-0.1.23 → rsloop-0.1.25}/benchmarks/compare_event_loops.py

@@ -294,6 +294,10 @@ def run_with_loop(loop_name: str, coro: asyncio.coroutines) -> ChildResult:
 
 
 async def bench_callbacks(loop_name: str, iterations: int) -> ChildResult:
+    # Pre-schedule the full batch instead of chaining callbacks: a chain
+    # forces asyncio/uvloop into one event-loop iteration (including a
+    # kernel poll) per callback, which measures selector overhead rather
+    # than call_soon dispatch cost.
     loop = asyncio.get_running_loop()
     done = loop.create_future()
     remaining = iterations
@@ -303,11 +307,10 @@ async def bench_callbacks(loop_name: str, iterations: int) -> ChildResult:
         remaining -= 1
         if remaining == 0:
             done.set_result(None)
-            return
-        loop.call_soon(callback)
 
     start = time.perf_counter()
-    loop.call_soon(callback)
+    for _ in range(iterations):
+        loop.call_soon(callback)
     await done
     return ChildResult(
         loop_name,

{rsloop-0.1.23 → rsloop-0.1.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rsloop"
-version = "0.1.23"
+version = "0.1.25"
 description = "An event loop for asyncio written in Rust"
 readme = "README.md"
 license = { file = "LICENSE" }

{rsloop-0.1.23 → rsloop-0.1.25}/src/callbacks.rs

@@ -60,7 +60,6 @@ pub struct ReadyCallback {
     kind: CallbackKind,
     callback: Py<PyAny>,
     args: CallbackArgs,
-    args_tuple: Py<PyTuple>,
     context: Py<PyAny>,
     context_needs_run: bool,
     cancelled: AtomicBool,
@@ -94,7 +93,6 @@ impl ReadyCallback {
             kind,
             callback,
             args,
-            args_tuple,
             context,
             context_needs_run,
             cancelled: AtomicBool::new(false),
@@ -159,10 +157,6 @@ impl ReadyCallback {
         }
     }
 
-    pub fn clone_args_tuple(&self, py: Python<'_>) -> Py<PyTuple> {
-        self.args_tuple.clone_ref(py)
-    }
-
     #[inline]
     pub fn cancelled(&self) -> bool {
         self.cancelled.load(Ordering::Relaxed)
@@ -174,42 +168,42 @@ impl ReadyCallback {
     }
 }
 
-#[pyclass(name = "Handle", module = "rsloop._loop", weakref, freelist = 4096)]
+// The handle owns its callback inline (instead of a separate
+// `Arc<ReadyCallback>` allocation) and the ready queue holds `Py<PyHandle>`
+// clones: one allocation per call_soon instead of two. `frozen` lets the
+// event loop read the callback through `Py::get` without borrow checking.
+#[pyclass(name = "Handle", module = "rsloop._loop", weakref, frozen)]
 pub struct PyHandle {
-    callback_id: CallbackId,
-    callback: Weak<ReadyCallback>,
-    cancelled: AtomicBool,
+    callback: ReadyCallback,
 }
 
 impl PyHandle {
     #[inline]
-    pub fn new(callback_id: CallbackId, callback: &Arc<ReadyCallback>) -> Self {
-        Self {
-            callback_id,
-            callback: Arc::downgrade(callback),
-            cancelled: AtomicBool::new(false),
-        }
+    pub fn new(callback: ReadyCallback) -> Self {
+        Self { callback }
+    }
+
+    #[inline]
+    pub fn ready(&self) -> &ReadyCallback {
+        &self.callback
     }
 }
 
 #[pymethods]
 impl PyHandle {
     fn cancel(&self) -> PyResult<()> {
-        self.cancelled.store(true, Ordering::Relaxed);
-        if let Some(callback) = self.callback.upgrade() {
-            callback.cancel();
-        }
+        self.callback.cancel();
         Ok(())
     }
 
     fn cancelled(&self) -> bool {
-        self.cancelled.load(Ordering::Relaxed)
+        self.callback.cancelled()
     }
 
     fn __repr__(&self) -> String {
         format!(
             "<Handle id={} cancelled={}>",
-            self.callback_id,
+            self.callback.id(),
             self.cancelled()
         )
     }

{rsloop-0.1.23 → rsloop-0.1.25}/src/fast_streams.rs

@@ -5,10 +5,19 @@ use pyo3_async_runtimes::TaskLocals;
 
 use crate::python_api::PyLoop;
 use crate::python_names;
-use crate::stream_transport::task_locals_for_loop;
+use crate::stream_transport::{PyStreamTransport, task_locals_for_loop};
 
 const DEFAULT_STREAM_LIMIT: usize = 65_536;
 
+/// Create a future on `loop_obj`, skipping the Python-level method dispatch
+/// when the loop is a native rsloop instance running on this thread.
+fn loop_create_future(py: Python<'_>, loop_obj: &Py<PyAny>) -> PyResult<Py<PyAny>> {
+    if let Some(future) = crate::python_api::try_fast_create_future(py, loop_obj)? {
+        return Ok(future);
+    }
+    python_names::call_method0(py, loop_obj.bind(py), python_names::create_future(py))
+}
+
 struct ReadBuffer {
     bytes: Vec<u8>,
     start: usize,
@@ -167,7 +176,7 @@ impl PyFastStreamReader {
 
     #[inline]
     fn create_future(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
-        python_names::call_method0(py, self.loop_obj.bind(py), python_names::create_future(py))
+        loop_create_future(py, &self.loop_obj)
     }
 
     fn ready_result_future(&self, py: Python<'_>, value: Py<PyAny>) -> PyResult<Py<PyAny>> {
@@ -235,7 +244,15 @@ impl PyFastStreamReader {
     }
 
     fn maybe_pause_transport(&mut self, py: Python<'_>) -> PyResult<()> {
-        if !self.transport.bind(py).is_none() && !self.paused && self.buffer.len() > 2 * self.limit
+        // Never pause while a coroutine is waiting for data: a pending
+        // readexactly()/read() waiter may need more than 2 * limit bytes to
+        // complete, and pausing would starve it forever. This mirrors
+        // asyncio.StreamReader._wait_for_data, which resumes the transport
+        // while a reader is waiting.
+        if self.waiter.is_none()
+            && !self.transport.bind(py).is_none()
+            && !self.paused
+            && self.buffer.len() > 2 * self.limit
         {
             match python_names::call_method0(
                 py,
@@ -541,10 +558,8 @@ impl PyFastStreamProtocol {
         reader: Py<PyFastStreamReader>,
         client_connected_cb: Py<PyAny>,
     ) -> PyResult<Self> {
-        let closed =
-            python_names::call_method0(py, loop_obj.bind(py), python_names::create_future(py))?;
-        let ready_none =
-            python_names::call_method0(py, loop_obj.bind(py), python_names::create_future(py))?;
+        let closed = loop_create_future(py, &loop_obj)?;
+        let ready_none = loop_create_future(py, &loop_obj)?;
         python_names::call_method1(
             py,
             ready_none.bind(py),
@@ -578,11 +593,7 @@ impl PyFastStreamProtocol {
     }
 
     fn ready_exception_future(&self, py: Python<'_>, exc: Py<PyAny>) -> PyResult<Py<PyAny>> {
-        let future = python_names::call_method0(
-            py,
-            self.loop_obj.bind(py),
-            python_names::create_future(py),
-        )?;
+        let future = loop_create_future(py, &self.loop_obj)?;
         python_names::call_method1(
             py,
             future.bind(py),
@@ -593,11 +604,7 @@ impl PyFastStreamProtocol {
     }
 
     fn push_drain_waiter(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
-        let future = python_names::call_method0(
-            py,
-            self.loop_obj.bind(py),
-            python_names::create_future(py),
-        )?;
+        let future = loop_create_future(py, &self.loop_obj)?;
         self.drain_waiters.push(future.clone_ref(py));
         Ok(future)
     }
@@ -832,6 +839,11 @@ impl PyFastStreamWriter {
     }
 
     fn write(&self, py: Python<'_>, data: &Bound<'_, PyAny>) -> PyResult<()> {
+        // Native transports take the direct Rust path; only foreign
+        // transports go through Python method dispatch.
+        if let Ok(transport) = self.transport.bind(py).cast_exact::<PyStreamTransport>() {
+            return transport.borrow().write_data(py, data);
+        }
         self.transport.call_method1(py, "write", (data,))?;
         Ok(())
     }
@@ -1003,9 +1015,10 @@ fn native_stream_loop(
     }
     if let Some(kwargs) = kwargs
         && let Some(ssl) = kwargs.get_item("ssl")?
-            && !ssl.is_none() {
-                return Ok(None);
-            }
+        && !ssl.is_none()
+    {
+        return Ok(None);
+    }
     Ok(Some(loop_obj))
 }
 

{rsloop-0.1.23 → rsloop-0.1.25}/src/fd_ops.rs

@@ -85,7 +85,17 @@ pub fn poll_fd(fd: RawFd, read: bool, write: bool, timeout_ms: i32) -> io::Resul
     }
 
     let revents = pollfd.revents as i32;
-    let error_bits = (libc::POLLERR | libc::POLLHUP | libc::POLLNVAL) as i32;
+    // POLLNVAL means the descriptor is not open (e.g. the socket was closed
+    // out from under the watcher). Reporting it as "ready" would make
+    // watchers fire forever on a dead fd, so surface it as an error instead;
+    // a closed fd produces no readiness events on asyncio either.
+    if revents & (libc::POLLNVAL as i32) != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "file descriptor is not open",
+        ));
+    }
+    let error_bits = (libc::POLLERR | libc::POLLHUP) as i32;
     Ok((
         read && (revents & ((libc::POLLIN as i32) | error_bits)) != 0,
         write && (revents & ((libc::POLLOUT as i32) | error_bits)) != 0,

{rsloop-0.1.23 → rsloop-0.1.25}/src/loop_core/commands.rs

@@ -3,9 +3,8 @@ use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 use pyo3::prelude::*;
-use pyo3::types::PyTuple;
 
-use crate::callbacks::ReadyCallback;
+use crate::callbacks::{PyHandle, ReadyCallback};
 use crate::fd_ops::RawFd;
 use crate::process_transport::ProcessTransportCore;
 use crate::stream_transport::{
@@ -14,6 +13,7 @@ use crate::stream_transport::{
 
 pub enum ReadyItem {
     Callback(Arc<ReadyCallback>),
+    HandleCallback(Py<PyHandle>),
     FutureSetResult {
         future: Py<PyAny>,
         value: Py<PyAny>,
@@ -33,6 +33,7 @@ pub enum ReadyItem {
 
 pub enum LoopCommand {
     ScheduleReady(Arc<ReadyCallback>),
+    ScheduleReadyHandle(Py<PyHandle>),
     ScheduleTimer {
         callback: Arc<ReadyCallback>,
         when: Instant,
@@ -50,6 +51,7 @@ pub enum LoopRunCommand {
     EnterRun {
         pending_ready: Arc<Mutex<VecDeque<ReadyItem>>>,
         wake_tx: std::sync::mpsc::Sender<()>,
+        wake_pending: Arc<std::sync::atomic::AtomicBool>,
     },
     FinishRun {
         done_tx: std::sync::mpsc::Sender<()>,
@@ -63,20 +65,18 @@ pub enum LoopSignalCommand {
 }
 
 pub enum LoopIoCommand {
+    // Fd watches hold one persistent ReadyCallback per registration, shared
+    // with LoopState's keepalive map. Every readiness event schedules the
+    // same callback, so remove_reader()/remove_writer() can cancel pending
+    // fires exactly like asyncio's Handle.cancel() on its reader handle.
     StartReader {
         fd: RawFd,
-        callback: Py<PyAny>,
-        args: Py<PyTuple>,
-        context: Py<PyAny>,
-        context_needs_run: bool,
+        callback: Arc<ReadyCallback>,
     },
     StopReader(RawFd),
     StartWriter {
         fd: RawFd,
-        callback: Py<PyAny>,
-        args: Py<PyTuple>,
-        context: Py<PyAny>,
-        context_needs_run: bool,
+        callback: Arc<ReadyCallback>,
     },
     StopWriter(RawFd),
     StartSocketReader {