rsloop 0.1.44__tar.gz → 0.1.45__tar.gz

{rsloop-0.1.44 → rsloop-0.1.45}/.github/workflows/wheels.yml

@@ -62,7 +62,8 @@ jobs:
       - name: Set up Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.95.0
+          toolchain: stable
+          components: llvm-tools-preview
 
       - name: Cache Cargo registry and target
         uses: Swatinem/rust-cache@v2
@@ -72,7 +73,7 @@ jobs:
         shell: bash
         env:
           RSLOOP_PYTHON_VERSIONS: ${{ matrix.python_versions }}
-        run: scripts/build-wheels.sh --out dist --target "${{ matrix.rust_target }}"
+        run: scripts/build-pgo-wheels.sh --out dist --target "${{ matrix.rust_target }}"
 
       - name: Upload wheel artifacts
         uses: actions/upload-artifact@v4
@@ -102,7 +103,7 @@ jobs:
       - name: Set up Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.95.0
+          toolchain: stable
 
       - name: Cache Cargo registry and target
         uses: Swatinem/rust-cache@v2

{rsloop-0.1.44 → rsloop-0.1.45}/Cargo.lock

@@ -922,14 +922,19 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.44"
+version = "0.1.45"
 dependencies = [
  "async-io",
  "async-std",
  "crossbeam-channel",
+ "crossbeam-queue",
  "futures",
+ "futures-util",
+ "io-uring",
  "libc",
  "memchr",
+ "mio",
+ "oneshot",
  "profiling",
  "proptest",
  "pyo3",
@@ -939,10 +944,10 @@ dependencies = [
  "rustls-native-certs",
  "rustls-pemfile",
  "signal-hook",
+ "slab",
  "socket2",
  "tokio",
  "tracy-client",
- "vibeio",
  "windows-sys 0.61.2",
 ]
 
@@ -1259,21 +1264,6 @@ version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ba6f5989077681266825251a52748b8c1d8a4ad098cc37e440103d0ea717fc0"
 
-[[package]]
-name = "vibeio"
-version = "0.2.15"
-dependencies = [
- "crossbeam-queue",
- "futures-util",
- "io-uring",
- "libc",
- "mio",
- "oneshot",
- "slab",
- "tokio",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"

{rsloop-0.1.44 → rsloop-0.1.45}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsloop"
-version = "0.1.44"
+version = "0.1.45"
 edition = "2024"
 description = "An event loop for asyncio written in Rust"
 license = "Apache-2.0"
@@ -21,9 +21,13 @@ profiler = ["dep:tracy-client", "profiling/profile-with-tracy"]
 async-io = "2"
 async-std = "1"
 crossbeam-channel = "0.5"
+crossbeam-queue = "0.3"
 futures = { version = "0.3", default-features = false, features = ["std"] }
+futures-util = "0.3"
 libc = "0.2"
 memchr = "2"
+mio = "1"
+oneshot = { version = "0.2", features = ["async", "std"] }
 profiling = "1"
 pyo3 = { version = "0.29.2" }
 pyo3-async-runtimes = { version = "0.29", features = ["async-std-runtime"] }
@@ -31,13 +35,18 @@ rustls = "0.23"
 rustls-native-certs = "0.8"
 rustls-pemfile = "2"
 signal-hook = "0.4"
+slab = "0.4"
 socket2 = "0.6"
 tokio = { version = "1", default-features = false, features = ["io-util"] }
 tracy-client = { version = "0.18", default-features = false, features = ["enable", "only-localhost", "sampling"], optional = true }
-vibeio = { version = "0.2.15", path = "vendor/vibeio", default-features = false, features = ["time"] }
+[target.'cfg(target_os = "linux")'.dependencies]
+io-uring = "0.6"
+
+[target.'cfg(unix)'.dependencies]
+mio = { version = "1", features = ["os-poll", "os-ext"] }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Networking_WinSock", "Win32_System_IO", "Win32_System_Pipes", "Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Wdk_Foundation", "Wdk_Storage_FileSystem", "Wdk_System_IO", "Win32_Foundation", "Win32_Networking_WinSock", "Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_IO", "Win32_System_Pipes", "Win32_System_Threading"] }
 
 [build-dependencies]
 pyo3-build-config = "0.29.2"
@@ -83,7 +92,7 @@ borrow_as_ptr = "allow"
 ref_as_ptr = "allow"
 
 [lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ["cfg(kani)"] }
+unexpected_cfgs = { level = "warn", check-cfg = ["cfg(kani)", "cfg(musl_v1_2_3)", "cfg(syscall_accept4)", "cfg(syscall_pipe2)", "cfg(feature, values(\"blocking-default\", \"fs\", \"pipe\", \"process\", \"signal\", \"splice\", \"stdio\"))"] }
 
 [package.metadata.kani.flags]
 # Force every proof that reaches a loop to state and review its own bound.

{rsloop-0.1.44 → rsloop-0.1.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.44
+Version: 0.1.45
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -379,6 +379,27 @@ Build release wheels into `dist/wheels`:
 scripts/build-wheels.sh
 ```
 
+Build the published-wheel configuration with profile-guided optimization:
+
+```bash
+rustup component add llvm-tools-preview
+scripts/build-pgo-wheels.sh
+```
+
+For each requested Python ABI, the PGO wrapper creates an instrumented wheel,
+trains it on sustained HTTP, TLS, WebSocket, mixed-stream, bulk-transfer,
+idle-connection, callback, task, and TCP workloads, merges the resulting LLVM
+profiles, and builds that ABI's final wheel with its matching profile. Per-ABI
+training avoids discarding counters when PyO3's generated control flow differs
+between Python versions or free-threaded builds. The target must be native
+because the instrumented extension runs during training.
+
+Set `RSLOOP_PGO_SCENARIOS` to override the comma-separated network scenarios.
+Tagged and manually dispatched wheel workflows use PGO on every supported
+platform except Windows ARM64. Rust profile-generation binaries currently
+crash on that target ([rust-lang/rust#156675](https://github.com/rust-lang/rust/issues/156675)),
+so it temporarily falls back to the normal fat-LTO release build.
+
 [`scripts/build-wheels.sh`](./scripts/build-wheels.sh) currently defaults to
 CPython `3.10 3.11 3.12 3.13 3.14`, and
 uses `uv python install` / `uv python find` to locate interpreters.

{rsloop-0.1.44 → rsloop-0.1.45}/README.md

@@ -347,6 +347,27 @@ Build release wheels into `dist/wheels`:
 scripts/build-wheels.sh
 ```
 
+Build the published-wheel configuration with profile-guided optimization:
+
+```bash
+rustup component add llvm-tools-preview
+scripts/build-pgo-wheels.sh
+```
+
+For each requested Python ABI, the PGO wrapper creates an instrumented wheel,
+trains it on sustained HTTP, TLS, WebSocket, mixed-stream, bulk-transfer,
+idle-connection, callback, task, and TCP workloads, merges the resulting LLVM
+profiles, and builds that ABI's final wheel with its matching profile. Per-ABI
+training avoids discarding counters when PyO3's generated control flow differs
+between Python versions or free-threaded builds. The target must be native
+because the instrumented extension runs during training.
+
+Set `RSLOOP_PGO_SCENARIOS` to override the comma-separated network scenarios.
+Tagged and manually dispatched wheel workflows use PGO on every supported
+platform except Windows ARM64. Rust profile-generation binaries currently
+crash on that target ([rust-lang/rust#156675](https://github.com/rust-lang/rust/issues/156675)),
+so it temporarily falls back to the normal fat-LTO release build.
+
 [`scripts/build-wheels.sh`](./scripts/build-wheels.sh) currently defaults to
 CPython `3.10 3.11 3.12 3.13 3.14`, and
 uses `uv python install` / `uv python find` to locate interpreters.

{rsloop-0.1.44/vendor/vibeio → rsloop-0.1.45}/build.rs

@@ -1,4 +1,7 @@
 fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+    pyo3_build_config::add_extension_module_link_args();
+
     let musl = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default() == "musl";
     let musl_v1_2_3 = std::env::var("RUST_LIBC_UNSTABLE_MUSL_V1_2_3").is_ok();
     println!("cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_MUSL_V1_2_3");

{rsloop-0.1.44 → rsloop-0.1.45}/pyproject.toml

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

rsloop-0.1.45/scripts/build-pgo-wheels.sh

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "${ROOT_DIR}/scripts/python-versions.sh"
+
+DEFAULT_PGO_SCENARIOS="http_keepalive,tls_http,websocket_messages,websocket_tls,mixed_streams,bulk_transfer,idle_connections"
+BUILD_WHEEL_ARGS=("$@")
+RUST_TARGET="${RSLOOP_RUST_TARGET:-}"
+INSTALL_PYTHONS=1
+MATURIN_ARGS=()
+
+usage() {
+  cat <<'EOF'
+Build PGO-optimized release wheels for rsloop.
+
+Usage:
+  scripts/build-pgo-wheels.sh [build-wheels options] [-- maturin args...]
+
+This wrapper accepts the same options as scripts/build-wheels.sh. For each
+requested Python ABI, it builds an instrumented native wheel, trains it with
+representative traffic, merges the LLVM profiles, and builds that ABI's final
+wheel with its matching profile.
+
+Environment:
+  RSLOOP_PGO_SCENARIOS    Comma-separated workload-matrix training scenarios
+
+PGO requires a native target and the Rust llvm-tools-preview component.
+EOF
+}
+
+host_rust_target() {
+  rustc -vV | sed -n 's/^host: //p'
+}
+
+native_path() {
+  case "${OSTYPE:-}" in
+    msys*|cygwin*) cygpath -m "$1" ;;
+    *) printf '%s\n' "$1" ;;
+  esac
+}
+
+shell_path() {
+  case "${OSTYPE:-}" in
+    msys*|cygwin*) cygpath -u "$1" ;;
+    *) printf '%s\n' "$1" ;;
+  esac
+}
+
+while (($#)); do
+  case "$1" in
+    -o|--out)
+      (($# >= 2)) || { echo "missing value for $1" >&2; exit 1; }
+      shift 2
+      ;;
+    -t|--target)
+      (($# >= 2)) || { echo "missing value for $1" >&2; exit 1; }
+      RUST_TARGET="$2"
+      shift 2
+      ;;
+    --skip-python-install)
+      INSTALL_PYTHONS=0
+      shift
+      ;;
+    -h|--help)
+      usage
+      printf '\nUnderlying wheel-builder options:\n\n'
+      "${ROOT_DIR}/scripts/build-wheels.sh" --help
+      exit 0
+      ;;
+    --)
+      shift
+      MATURIN_ARGS=("$@")
+      break
+      ;;
+    *)
+      echo "unknown argument: $1" >&2
+      usage >&2
+      exit 1
+      ;;
+  esac
+done
+
+cd "$ROOT_DIR"
+HOST_RUST_TARGET="$(host_rust_target)"
+if [[ -n "$RUST_TARGET" && "$RUST_TARGET" != "$HOST_RUST_TARGET" ]]; then
+  echo "PGO requires a native target because the instrumented wheel must run during training" >&2
+  echo "host target: ${HOST_RUST_TARGET}; requested target: ${RUST_TARGET}" >&2
+  exit 1
+fi
+if [[ "$RUST_TARGET" == *-apple-darwin ]]; then
+  export MACOSX_DEPLOYMENT_TARGET="${MACOSX_DEPLOYMENT_TARGET:-13.0}"
+fi
+if [[ "$RUST_TARGET" == "aarch64-pc-windows-msvc" ]]; then
+  # rustc profile-generate binaries currently crash on native Windows ARM64:
+  # https://github.com/rust-lang/rust/issues/156675
+  echo "PGO is unavailable on Windows ARM64; building a normal fat-LTO release wheel"
+  export RUSTFLAGS="${RUSTFLAGS:-} -Clink-arg=/arm64hazardfree"
+  exec "${ROOT_DIR}/scripts/build-wheels.sh" "${BUILD_WHEEL_ARGS[@]}"
+fi
+
+RSLOOP_PYTHON_VERSIONS_OVERRIDE="${RSLOOP_PYTHON_VERSIONS:-}"
+rsloop_load_python_versions "$RUST_TARGET"
+PYTHON_VERSIONS=("${RSLOOP_PYTHON_VERSIONS[@]}")
+PGO_SCENARIOS="${RSLOOP_PGO_SCENARIOS:-$DEFAULT_PGO_SCENARIOS}"
+
+rust_sysroot="$(shell_path "$(rustc --print sysroot)")"
+llvm_profdata="${rust_sysroot}/lib/rustlib/${HOST_RUST_TARGET}/bin/llvm-profdata"
+if [[ "${OSTYPE:-}" == msys* || "${OSTYPE:-}" == cygwin* ]]; then
+  llvm_profdata+=".exe"
+fi
+if [[ ! -x "$llvm_profdata" ]]; then
+  echo "llvm-profdata was not found at ${llvm_profdata}" >&2
+  echo "install it with: rustup component add llvm-tools-preview" >&2
+  exit 1
+fi
+
+PGO_WORK_DIR="$(mktemp -d "${TMPDIR:-/tmp}/rsloop-wheel-pgo.XXXXXX")"
+cleanup() {
+  if [[ -n "${PGO_WORK_DIR:-}" && -d "$PGO_WORK_DIR" ]]; then
+    rm -rf -- "$PGO_WORK_DIR"
+  fi
+}
+trap cleanup EXIT
+
+PROFILE_DIR="${PGO_WORK_DIR}/profiles"
+TARGET_GENERATE="$(native_path "${PGO_WORK_DIR}/target-generate")"
+TARGET_USE="$(native_path "${PGO_WORK_DIR}/target-use")"
+MERGED_PROFILE="${PGO_WORK_DIR}/merged.profdata"
+mkdir -p "$PROFILE_DIR"
+BASE_RUSTFLAGS="${RUSTFLAGS:-}"
+GENERATE_RUSTFLAGS="${BASE_RUSTFLAGS} -Cprofile-generate=$(native_path "$PROFILE_DIR")"
+USE_RUSTFLAGS="${BASE_RUSTFLAGS} -Cprofile-use=$(native_path "$MERGED_PROFILE") -Cllvm-args=-pgo-warn-missing-function"
+
+for version in "${PYTHON_VERSIONS[@]}"; do
+  python_request="$version"
+  if [[ -n "$RUST_TARGET" ]]; then
+    python_request="$(rsloop_target_python_request "$version" "$RUST_TARGET")"
+  fi
+  if (( INSTALL_PYTHONS )); then
+    uv python install "$python_request"
+  fi
+
+  version_key="${version//[^a-zA-Z0-9]/_}"
+  version_dir="${PGO_WORK_DIR}/${version_key}"
+  wheel_dir="${version_dir}/instrumented-wheel"
+  tls_dir="${version_dir}/tls"
+  training_venv="${version_dir}/venv"
+  mkdir -p "$wheel_dir"
+  find "$PROFILE_DIR" -maxdepth 1 -type f -name '*.profraw' -delete
+
+  instrumented_build=(uv run --no-project --python "$python_request" --with maturin maturin build --release --interpreter "$(uv python find "$python_request")" --out "$wheel_dir")
+  if [[ -n "$RUST_TARGET" ]]; then
+    instrumented_build+=(--target "$RUST_TARGET")
+  fi
+  if ((${#MATURIN_ARGS[@]})); then
+    instrumented_build+=("${MATURIN_ARGS[@]}")
+  fi
+  echo "Building instrumented PGO training wheel for Python ${version}"
+  CARGO_TARGET_DIR="$TARGET_GENERATE" RUSTFLAGS="$GENERATE_RUSTFLAGS" "${instrumented_build[@]}"
+
+  shopt -s nullglob
+  instrumented_wheels=("$wheel_dir"/*.whl)
+  shopt -u nullglob
+  if ((${#instrumented_wheels[@]} != 1)); then
+    echo "expected one instrumented training wheel, found ${#instrumented_wheels[@]}" >&2
+    exit 1
+  fi
+
+  uv venv --no-project --python "$python_request" "$training_venv"
+  if [[ -x "$training_venv/Scripts/python.exe" ]]; then
+    training_python="$training_venv/Scripts/python.exe"
+  else
+    training_python="$training_venv/bin/python"
+  fi
+  uv pip install --python "$training_python" "${instrumented_wheels[0]}"
+  "$training_python" scripts/generate_test_tls_certs.py "$tls_dir"
+
+  echo "Training Python ${version} PGO with sustained representative network traffic"
+  "$training_python" benches/workload_matrix.py --loops rsloop --scenarios "$PGO_SCENARIOS" --sustained --tls-dir "$tls_dir"
+  echo "Training Python ${version} PGO with callbacks, tasks, and TCP streams"
+  "$training_python" benches/compare_event_loops.py --loops rsloop
+
+  shopt -s nullglob
+  raw_profiles=("$PROFILE_DIR"/*.profraw)
+  shopt -u nullglob
+  if ((${#raw_profiles[@]} == 0)); then
+    echo "PGO training produced no .profraw files for Python ${version}" >&2
+    exit 1
+  fi
+
+  echo "Merging ${#raw_profiles[@]} LLVM profile shards for Python ${version}"
+  "$llvm_profdata" merge -o "$MERGED_PROFILE" "${raw_profiles[@]}"
+  echo "Building final Python ${version} wheel with its matching PGO profile"
+  RSLOOP_PYTHON_VERSIONS="$version" \
+    CARGO_TARGET_DIR="$TARGET_USE" \
+    RUSTFLAGS="$USE_RUSTFLAGS" \
+    "${ROOT_DIR}/scripts/build-wheels.sh" "${BUILD_WHEEL_ARGS[@]}"
+  rm -rf -- "$version_dir"
+done

{rsloop-0.1.44 → rsloop-0.1.45}/src/engine/dispatcher.rs

@@ -36,7 +36,7 @@ fn timer_wait_needs_replacement<T: PartialEq>(current: Option<&T>, deadline: &T)
 struct RuntimeDispatcher {
     core: Arc<LoopCore>,
     command_rx: Receiver<LoopCommand>,
-    timer_wait: Option<(Instant, vibeio::time::Sleep)>,
+    timer_wait: Option<(Instant, crate::vibeio::time::Sleep)>,
     ready_batch: VecDeque<ReadyItem>,
     timers: BinaryHeap<TimerEntry>,
     next_timer_id: u64,
@@ -68,7 +68,7 @@ enum WatchTask {
         stop: Arc<AtomicBool>,
         join: thread::JoinHandle<()>,
     },
-    Vibeio(vibeio::JoinHandle<()>),
+    Vibeio(crate::vibeio::JoinHandle<()>),
 }
 
 impl WatchTask {
@@ -118,7 +118,7 @@ pub fn run_runtime_thread(core: Arc<LoopCore>, command_rx: Receiver<LoopCommand>
     if tracy_client::Client::is_running() {
         tracy_client::set_thread_name!("rsloop-runtime");
     }
-    let runtime = vibeio::RuntimeBuilder::new()
+    let runtime = crate::vibeio::RuntimeBuilder::new()
         .rsloop_profile()
         .enable_timer(true)
         .build()
@@ -188,7 +188,8 @@ impl Future for RuntimeDispatcher {
                 &deadline,
             );
             if replace_timer {
-                self.timer_wait = Some((deadline, vibeio::time::Sleep::sleep_until(deadline)));
+                self.timer_wait =
+                    Some((deadline, crate::vibeio::time::Sleep::sleep_until(deadline)));
             }
             let (_, sleep) = self.timer_wait.as_mut().expect("timer wait missing");
             if Pin::new(sleep).poll(cx).is_ready() {
@@ -447,13 +448,13 @@ impl RuntimeDispatcher {
 
                 let task = match reader {
                     crate::transport::stream::ReaderTarget::Tcp(stream) => {
-                        WatchTask::Vibeio(vibeio::spawn(
+                        WatchTask::Vibeio(crate::vibeio::spawn(
                             crate::transport::stream::run_tcp_socket_reader_task(core, stream),
                         ))
                     }
                     #[cfg(unix)]
                     crate::transport::stream::ReaderTarget::Unix(stream) => {
-                        WatchTask::Vibeio(vibeio::spawn(
+                        WatchTask::Vibeio(crate::vibeio::spawn(
                             crate::transport::stream::run_unix_socket_reader_task(core, stream),
                         ))
                     }
@@ -481,7 +482,7 @@ impl RuntimeDispatcher {
                     cancel_watch_task(task);
                 }
 
-                let task = WatchTask::Vibeio(vibeio::spawn(
+                let task = WatchTask::Vibeio(crate::vibeio::spawn(
                     crate::transport::stream::run_server_accept_task(server, listener),
                 ));
 
@@ -499,7 +500,7 @@ impl RuntimeDispatcher {
                 // vibeio JoinHandle has no Drop, so dropping it detaches (does
                 // not cancel) the running task.
                 let core = Arc::clone(&self.core);
-                std::mem::drop(vibeio::spawn(
+                std::mem::drop(crate::vibeio::spawn(
                     crate::transport::stream::run_connect_watch_task(core, fd, future),
                 ));
             }

{rsloop-0.1.44 → rsloop-0.1.45}/src/engine/loop_core.rs

@@ -41,7 +41,7 @@ thread_local! {
     /// are still alive). If a loop is never closed, its runtime is leaked at
     /// thread exit rather than dropped — dropping during TLS destruction trips
     /// an AccessError panic inside vibeio's `Runtime::drop`.
-    static LOOP_RUNTIMES: RefCell<HashMap<usize, std::mem::ManuallyDrop<vibeio::Runtime>>> =
+    static LOOP_RUNTIMES: RefCell<HashMap<usize, std::mem::ManuallyDrop<crate::vibeio::Runtime>>> =
         RefCell::new(HashMap::new());
 
     /// Handles for cancellable I/O tasks (accept loops, socket readers) spawned
@@ -50,7 +50,7 @@ thread_local! {
     /// here) never conflicts with the park holding an immutable `LOOP_RUNTIMES`
     /// borrow across `block_on`. `JoinHandle` is `!Send`, so this must live in
     /// TLS on the loop thread.
-    static IO_TASKS: RefCell<HashMap<usize, HashMap<RawFd, vibeio::JoinHandle<()>>>> =
+    static IO_TASKS: RefCell<HashMap<usize, HashMap<RawFd, crate::vibeio::JoinHandle<()>>>> =
         RefCell::new(HashMap::new());
 }
 
@@ -90,14 +90,14 @@ impl LoopWake {
 /// GIL and drains.
 struct WaitForWake {
     wake: Arc<LoopWake>,
-    sleep: Pin<Box<vibeio::time::Sleep>>,
+    sleep: Pin<Box<crate::vibeio::time::Sleep>>,
 }
 
 impl WaitForWake {
     fn new(wake: Arc<LoopWake>, timeout: Duration) -> Self {
         Self {
             wake,
-            sleep: Box::pin(vibeio::time::Sleep::new(timeout)),
+            sleep: Box::pin(crate::vibeio::time::Sleep::new(timeout)),
         }
     }
 }
@@ -500,7 +500,7 @@ impl LoopCore {
                 .entry(loop_runtime_key)
                 .or_insert_with(|| {
                     std::mem::ManuallyDrop::new(
-                        vibeio::RuntimeBuilder::new()
+                        crate::vibeio::RuntimeBuilder::new()
                             .rsloop_profile()
                             .enable_timer(true)
                             .build()
@@ -1425,7 +1425,7 @@ mod wake_tests {
 
     #[test]
     fn wait_for_wake_completes_when_its_timer_expires() {
-        let runtime = vibeio::RuntimeBuilder::new()
+        let runtime = crate::vibeio::RuntimeBuilder::new()
             .enable_timer(true)
             .build()
             .expect("timer-enabled runtime");

{rsloop-0.1.44 → rsloop-0.1.45}/src/lib.rs

@@ -28,6 +28,8 @@ pub mod rust_async;
 mod transport;
 #[cfg(kani)]
 mod verification;
+#[path = "vibeio/lib.rs"]
+pub(crate) mod vibeio;
 
 pub(crate) use platform::fd as fd_ops;
 #[cfg(windows)]

{rsloop-0.1.44 → rsloop-0.1.45}/src/platform/fd/mod.rs

@@ -121,7 +121,7 @@ pub async fn wait_readable(fd: RawFd) -> PyResult<()> {
             let (tx, rx) = futures::channel::oneshot::channel();
             let task = crate::windows_vibeio::spawn(move || async move {
                 let result = async {
-                    let stream = vibeio::net::PollTcpStream::from_std(stream)?;
+                    let stream = crate::vibeio::net::PollTcpStream::from_std(stream)?;
                     let mut buf = [0_u8; 1];
                     stream.peek(&mut buf).await.map(|_| ())
                 }

{rsloop-0.1.44 → rsloop-0.1.45}/src/platform/windows_vibeio.rs

@@ -109,8 +109,11 @@ fn spawn_service_thread(
 #[cfg(windows)]
 fn build_service_runtime(
     ready_tx: &std::sync::mpsc::SyncSender<Result<(), String>>,
-) -> Result<vibeio::Runtime, ()> {
-    match vibeio::RuntimeBuilder::new().rsloop_profile().build() {
+) -> Result<crate::vibeio::Runtime, ()> {
+    match crate::vibeio::RuntimeBuilder::new()
+        .rsloop_profile()
+        .build()
+    {
         Ok(runtime) => Ok(runtime),
         Err(err) => {
             let _ = ready_tx.send(Err(err.to_string()));
@@ -124,7 +127,7 @@ async fn run_service_commands(
     mut rx: mpsc::UnboundedReceiver<Command>,
     thread_tx: mpsc::UnboundedSender<Command>,
 ) {
-    let mut tasks: HashMap<u64, vibeio::JoinHandle<()>> = HashMap::new();
+    let mut tasks: HashMap<u64, crate::vibeio::JoinHandle<()>> = HashMap::new();
 
     while let Some(command) = rx.next().await {
         handle_service_command(command, &thread_tx, &mut tasks);
@@ -139,12 +142,12 @@ async fn run_service_commands(
 fn handle_service_command(
     command: Command,
     thread_tx: &mpsc::UnboundedSender<Command>,
-    tasks: &mut HashMap<u64, vibeio::JoinHandle<()>>,
+    tasks: &mut HashMap<u64, crate::vibeio::JoinHandle<()>>,
 ) {
     match command {
         Command::Spawn { id, factory } => {
             let finished_tx = thread_tx.clone();
-            let handle = vibeio::spawn(async move {
+            let handle = crate::vibeio::spawn(async move {
                 factory().await;
                 let _ = finished_tx.unbounded_send(Command::Finished { id });
             });

{rsloop-0.1.44 → rsloop-0.1.45}/src/transport/stream/accept.rs

@@ -26,11 +26,11 @@ use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 
+use crate::vibeio::net::TcpListener as VibeTcpListener;
+#[cfg(unix)]
+use crate::vibeio::net::UnixListener as VibeUnixListener;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
-use vibeio::net::TcpListener as VibeTcpListener;
-#[cfg(unix)]
-use vibeio::net::UnixListener as VibeUnixListener;
 
 use super::io_targets::StreamKind;
 #[cfg(windows)]
@@ -296,7 +296,7 @@ pub(super) async fn run_tcp_accept_task(server: Arc<ServerCore>, listener: StdTc
 }
 
 #[cfg(windows)]
-pub(super) struct WindowsAcceptPool(Vec<vibeio::JoinHandle<()>>);
+pub(super) struct WindowsAcceptPool(Vec<crate::vibeio::JoinHandle<()>>);
 
 #[cfg(windows)]
 impl Drop for WindowsAcceptPool {
@@ -322,7 +322,7 @@ pub(super) async fn run_windows_tcp_accept_pool(server: Arc<ServerCore>, listene
     };
     let lanes = (0..lane_count)
         .map(|_| {
-            vibeio::spawn(run_windows_tcp_accept_lane(
+            crate::vibeio::spawn(run_windows_tcp_accept_lane(
                 Arc::clone(&server),
                 Rc::clone(&listener),
             ))

{rsloop-0.1.44 → rsloop-0.1.45}/src/transport/stream/connect.rs

@@ -6,8 +6,8 @@ use std::os::fd::FromRawFd;
 use std::os::raw::c_int;
 use std::sync::Arc;
 
+use crate::vibeio::net::PollTcpStream as VibePollTcpStream;
 use pyo3::prelude::*;
-use vibeio::net::PollTcpStream as VibePollTcpStream;
 
 use crate::engine::{LoopCommand, LoopCore};
 use crate::fd_ops;
@@ -23,7 +23,7 @@ pub(crate) async fn run_connect_watch_task(
     fd: fd_ops::RawFd,
     future: Py<PyAny>,
 ) {
-    use vibeio::io::AsyncWritePoll;
+    use crate::vibeio::io::AsyncWritePoll;
 
     let wait_errno = 'wait: {
         let Ok(raw) = c_int::try_from(fd) else {