rsloop 0.1.45__tar.gz → 0.1.46__tar.gz

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

@@ -197,15 +197,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
 
 [[package]]
 name = "blocking"
@@ -522,11 +516,12 @@ checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "io-uring"
-version = "0.6.4"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "595a0399f411a508feb2ec1e970a4a30c249351e30208960d58298de8660b0e5"
+checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
+ "cfg-if",
  "libc",
 ]
 
@@ -568,9 +563,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.186"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "linux-raw-sys"
@@ -730,33 +725,13 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "profiling"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
-dependencies = [
- "profiling-procmacros",
- "tracy-client",
-]
-
-[[package]]
-name = "profiling-procmacros"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb"
-dependencies = [
- "quote",
- "syn",
-]
-
 [[package]]
 name = "proptest"
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
 dependencies = [
- "bitflags 2.13.0",
+ "bitflags",
  "num-traits",
  "rand",
  "rand_chacha",
@@ -922,7 +897,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "async-io",
  "async-std",
@@ -935,7 +910,6 @@ dependencies = [
  "memchr",
  "mio",
  "oneshot",
- "profiling",
  "proptest",
  "pyo3",
  "pyo3-async-runtimes",
@@ -957,7 +931,7 @@ version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags 2.13.0",
+ "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -1048,7 +1022,7 @@ version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "bitflags 2.13.0",
+ "bitflags",
  "core-foundation",
  "core-foundation-sys",
  "libc",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rsloop"
-version = "0.1.45"
+version = "0.1.46"
 edition = "2024"
 description = "An event loop for asyncio written in Rust"
 license = "Apache-2.0"
@@ -15,7 +15,7 @@ crate-type = ["cdylib", "rlib"]
 
 [features]
 default = []
-profiler = ["dep:tracy-client", "profiling/profile-with-tracy"]
+profiler = ["dep:tracy-client"]
 
 [dependencies]
 async-io = "2"
@@ -28,7 +28,6 @@ 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"] }
 rustls = "0.23"
@@ -40,7 +39,7 @@ 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 }
 [target.'cfg(target_os = "linux")'.dependencies]
-io-uring = "0.6"
+io-uring = "0.7"
 
 [target.'cfg(unix)'.dependencies]
 mio = { version = "1", features = ["os-poll", "os-ext"] }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.45
+Version: 0.1.46
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

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

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

{rsloop-0.1.45 → rsloop-0.1.46}/src/bindings/loop_api/connections.rs

@@ -37,7 +37,7 @@ pub(super) fn create_connection<'py>(
     py: Python<'py>,
     params: CreateConnectionParams,
 ) -> PyResult<Bound<'py, PyAny>> {
-    profiling::scope!("PyLoop::create_connection");
+    crate::profile_scope!("PyLoop::create_connection");
     let CreateConnectionParams {
         protocol_factory,
         host,
@@ -146,7 +146,7 @@ pub(super) fn create_connection_transport(
     sock: Py<PyAny>,
     tls: TlsParams,
 ) -> PyResult<Py<PyAny>> {
-    profiling::scope!("PyLoop::_create_connection_transport");
+    crate::profile_scope!("PyLoop::_create_connection_transport");
     tls.validate()?;
 
     let env = LoopSpawnEnv::capture(py, &slf)?;
@@ -214,7 +214,7 @@ pub(super) fn connect_accepted_socket<'py>(
     sock: Py<PyAny>,
     tls: TlsParams,
 ) -> PyResult<Bound<'py, PyAny>> {
-    profiling::scope!("PyLoop::connect_accepted_socket");
+    crate::profile_scope!("PyLoop::connect_accepted_socket");
     tls.validate()?;
 
     let locals = PyLoop::task_locals(py, &slf)?;
@@ -250,7 +250,7 @@ pub(super) fn start_tls<'py>(
     tls: TlsParams,
     server_side: bool,
 ) -> PyResult<Bound<'py, PyAny>> {
-    profiling::scope!("PyLoop::start_tls");
+    crate::profile_scope!("PyLoop::start_tls");
     let locals = PyLoop::task_locals(py, &slf)?;
     let locals_for_barrier = locals.clone();
     let transport: Py<PyStreamTransport> = transport.extract(py)?;

{rsloop-0.1.45 → rsloop-0.1.46}/src/bindings/loop_api/methods.rs

@@ -137,13 +137,13 @@ impl PyLoop {
         self.core.set_debug(enabled);
     }
 
-    #[profiling::function]
     fn run_forever(slf: Py<Self>, py: Python<'_>) -> PyResult<()> {
+        crate::profile_function!();
         lifecycle::run_forever(slf, py)
     }
 
-    #[profiling::function]
     fn run_until_complete(slf: Py<Self>, py: Python<'_>, future: Py<PyAny>) -> PyResult<Py<PyAny>> {
+        crate::profile_function!();
         lifecycle::run_until_complete(slf, py, future)
     }
 

{rsloop-0.1.45 → rsloop-0.1.46}/src/bindings/loop_api/servers.rs

@@ -42,7 +42,7 @@ pub(super) fn create_server<'py>(
     py: Python<'py>,
     params: CreateServerParams,
 ) -> PyResult<Bound<'py, PyAny>> {
-    profiling::scope!("PyLoop::create_server");
+    crate::profile_scope!("PyLoop::create_server");
     let CreateServerParams {
         protocol_factory,
         host,

{rsloop-0.1.45 → rsloop-0.1.46}/src/engine/callbacks.rs

@@ -129,7 +129,7 @@ impl ReadyCallback {
     /// A nested-context error falls back to direct invocation because that means
     /// the desired context is already active on this thread.
     pub fn invoke(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
-        profiling::scope!("ReadyCallback::invoke");
+        crate::profile_scope!("ReadyCallback::invoke");
         if !self.context_needs_run {
             return self.invoke_direct(py);
         }
@@ -152,7 +152,7 @@ impl ReadyCallback {
     }
 
     fn invoke_direct(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
-        profiling::scope!("ReadyCallback::invoke_direct");
+        crate::profile_scope!("ReadyCallback::invoke_direct");
         match &self.args {
             CallbackArgs::None => call_callback_noargs(py, &self.callback),
             CallbackArgs::One(arg) => call_callback_onearg(py, &self.callback, arg),

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

@@ -113,7 +113,7 @@ fn cancel_watch_task(task: WatchTask) {
 }
 
 pub fn run_runtime_thread(core: Arc<LoopCore>, command_rx: Receiver<LoopCommand>) {
-    profiling::scope!("runtime.run_thread");
+    crate::profile_scope!("runtime.run_thread");
     #[cfg(feature = "profiler")]
     if tracy_client::Client::is_running() {
         tracy_client::set_thread_name!("rsloop-runtime");
@@ -148,7 +148,7 @@ impl Future for RuntimeDispatcher {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        profiling::scope!("runtime.dispatcher.poll");
+        crate::profile_scope!("runtime.dispatcher.poll");
         // Register before inspecting the command channel so a concurrent send
         // either wakes this poll or remains visible when the channel is
         // drained.  The retained waker is intentional: consuming it while the
@@ -222,7 +222,7 @@ impl RuntimeDispatcher {
     }
 
     fn collect_expired_timers(&mut self) {
-        profiling::scope!("runtime.collect_expired_timers");
+        crate::profile_scope!("runtime.collect_expired_timers");
         if self.active_run.is_none() {
             return;
         }
@@ -239,49 +239,49 @@ impl RuntimeDispatcher {
     }
 
     fn handle_command(&mut self, command: LoopCommand) -> bool {
-        profiling::scope!("runtime.handle_command");
+        crate::profile_scope!("runtime.handle_command");
         match command {
             LoopCommand::ScheduleReady(callback) => {
-                profiling::scope!("runtime.cmd.schedule_ready");
+                crate::profile_scope!("runtime.cmd.schedule_ready");
                 self.ready_batch.push_back(ReadyItem::Callback(callback));
             }
             LoopCommand::ScheduleReadyHandle(handle) => {
-                profiling::scope!("runtime.cmd.schedule_ready_handle");
+                crate::profile_scope!("runtime.cmd.schedule_ready_handle");
                 self.ready_batch
                     .push_back(ReadyItem::HandleCallback(handle));
             }
             LoopCommand::Future(LoopFutureCommand::SetResult { future, value }) => {
-                profiling::scope!("runtime.cmd.future_set_result");
+                crate::profile_scope!("runtime.cmd.future_set_result");
                 self.ready_batch
                     .push_back(ReadyItem::FutureSetResult { future, value });
             }
             LoopCommand::Future(LoopFutureCommand::SetException { future, value }) => {
-                profiling::scope!("runtime.cmd.future_set_exception");
+                crate::profile_scope!("runtime.cmd.future_set_exception");
                 self.ready_batch
                     .push_back(ReadyItem::FutureSetException { future, value });
             }
             LoopCommand::Transport(LoopTransportCommand::StreamRead(core)) => {
-                profiling::scope!("runtime.cmd.stream_transport_read");
+                crate::profile_scope!("runtime.cmd.stream_transport_read");
                 self.ready_batch
                     .push_back(ReadyItem::StreamTransportRead(core));
             }
             LoopCommand::Transport(LoopTransportCommand::StreamWrite(core)) => {
-                profiling::scope!("runtime.cmd.stream_transport_write");
+                crate::profile_scope!("runtime.cmd.stream_transport_write");
                 self.ready_batch
                     .push_back(ReadyItem::StreamTransportWrite(core));
             }
             LoopCommand::Transport(LoopTransportCommand::Process(core)) => {
-                profiling::scope!("runtime.cmd.process_transport");
+                crate::profile_scope!("runtime.cmd.process_transport");
                 self.ready_batch
                     .push_back(ReadyItem::ProcessTransport(core));
             }
             LoopCommand::Transport(LoopTransportCommand::ServerAccepted { server, stream }) => {
-                profiling::scope!("runtime.cmd.server_accepted");
+                crate::profile_scope!("runtime.cmd.server_accepted");
                 self.ready_batch
                     .push_back(ReadyItem::ServerAccepted { server, stream });
             }
             LoopCommand::ScheduleTimer { callback, when } => {
-                profiling::scope!("runtime.cmd.schedule_timer");
+                crate::profile_scope!("runtime.cmd.schedule_timer");
                 let seq = self.next_timer_id;
                 self.next_timer_id += 1;
                 self.timers.push(TimerEntry {
@@ -291,12 +291,12 @@ impl RuntimeDispatcher {
                 });
             }
             LoopCommand::Run(LoopRunCommand::EnterRun { pending_ready }) => {
-                profiling::scope!("runtime.cmd.enter_run");
+                crate::profile_scope!("runtime.cmd.enter_run");
                 self.active_run = Some(ActiveRun { pending_ready });
                 self.dispatch_ready_batch();
             }
             LoopCommand::Run(LoopRunCommand::FinishRun { done_tx }) => {
-                profiling::scope!("runtime.cmd.finish_run");
+                crate::profile_scope!("runtime.cmd.finish_run");
                 self.finish_run();
                 let _ = done_tx.send(());
             }
@@ -495,7 +495,7 @@ impl RuntimeDispatcher {
             }
             #[cfg(unix)]
             LoopCommand::Io(LoopIoCommand::WatchConnect { fd, future }) => {
-                profiling::scope!("runtime.cmd.watch_connect");
+                crate::profile_scope!("runtime.cmd.watch_connect");
                 // Detached: the task self-reports via ConnectCompleted, and a
                 // vibeio JoinHandle has no Drop, so dropping it detaches (does
                 // not cancel) the running task.
@@ -510,7 +510,7 @@ impl RuntimeDispatcher {
                 fd,
                 wait_errno,
             } => {
-                profiling::scope!("runtime.cmd.connect_completed");
+                crate::profile_scope!("runtime.cmd.connect_completed");
                 self.ready_batch.push_back(ReadyItem::ConnectCompleted {
                     future,
                     fd,
@@ -518,11 +518,11 @@ impl RuntimeDispatcher {
                 });
             }
             LoopCommand::RequestStop => {
-                profiling::scope!("runtime.cmd.request_stop");
+                crate::profile_scope!("runtime.cmd.request_stop");
                 self.ready_batch.push_back(ReadyItem::Stop);
             }
             LoopCommand::Close => {
-                profiling::scope!("runtime.cmd.close");
+                crate::profile_scope!("runtime.cmd.close");
                 self.finish_run();
                 self.cleanup_watchers();
                 self.shutting_down = true;
@@ -534,7 +534,7 @@ impl RuntimeDispatcher {
     }
 
     fn dispatch_ready_batch(&mut self) {
-        profiling::scope!("runtime.dispatch_ready_batch");
+        crate::profile_scope!("runtime.dispatch_ready_batch");
         let Some(active_run) = self.active_run.as_ref() else {
             return;
         };
@@ -555,7 +555,7 @@ impl RuntimeDispatcher {
     }
 
     fn finish_run(&mut self) {
-        profiling::scope!("runtime.finish_run");
+        crate::profile_scope!("runtime.finish_run");
         let Some(active_run) = self.active_run.take() else {
             return;
         };
@@ -572,7 +572,7 @@ impl RuntimeDispatcher {
     }
 
     fn cleanup_watchers(&mut self) {
-        profiling::scope!("runtime.cleanup_watchers");
+        crate::profile_scope!("runtime.cleanup_watchers");
         #[cfg(unix)]
         for (_, watcher) in self.signal_tasks.drain() {
             watcher.handle.close();

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

@@ -315,7 +315,7 @@ impl LoopCore {
     /// avoid a channel round trip. `LoopCoreError::ChannelClosed` means the
     /// dispatcher has already terminated.
     pub fn send_command(&self, command: LoopCommand) -> Result<(), LoopCoreError> {
-        profiling::scope!("LoopCore::send_command");
+        crate::profile_scope!("LoopCore::send_command");
         let command = match self.try_handle_local_command(command) {
             Ok(()) => return Ok(()),
             Err(command) => command,
@@ -395,7 +395,7 @@ impl LoopCore {
         args: Py<PyTuple>,
         context: Option<Py<PyAny>>,
     ) -> PyResult<Py<super::callbacks::PyHandle>> {
-        profiling::scope!("LoopCore::schedule_callback");
+        crate::profile_scope!("LoopCore::schedule_callback");
         let (captured, context_needs_run) = capture_context(py, context)?;
         let ready = ReadyCallback::new(
             py,
@@ -427,7 +427,7 @@ impl LoopCore {
         args: Py<PyTuple>,
         context: Option<Py<PyAny>>,
     ) -> PyResult<(Arc<ReadyCallback>, f64)> {
-        profiling::scope!("LoopCore::schedule_timer");
+        crate::profile_scope!("LoopCore::schedule_timer");
         let (captured, context_needs_run) = capture_context(py, context)?;
         let ready = Arc::new(ReadyCallback::new(
             py,
@@ -456,8 +456,8 @@ impl LoopCore {
     /// to Python again before invoking user code.
     ///
     /// Returns an error if the loop is closed or already running.
-    #[profiling::function]
     pub fn run_forever(self: &Arc<Self>, py: Python<'_>, loop_obj: Py<PyAny>) -> PyResult<()> {
+        crate::profile_function!();
         {
             let mut state = self.state.lock().expect("poisoned loop state");
             if state.closed {
@@ -579,11 +579,11 @@ impl LoopCore {
                     .expect("ready batch was checked as non-empty");
                 match item {
                     ReadyItem::Stop => {
-                        profiling::scope!("ready.stop");
+                        crate::profile_scope!("ready.stop");
                         self.state.lock().expect("poisoned loop state").stopping = true;
                     }
                     ReadyItem::Callback(callback) => {
-                        profiling::scope!("ready.callback");
+                        crate::profile_scope!("ready.callback");
                         let should_rearm = matches!(
                             callback.kind(),
                             CallbackKind::Reader(_) | CallbackKind::Writer(_)
@@ -599,7 +599,7 @@ impl LoopCore {
                         }
                     }
                     ReadyItem::HandleCallback(handle) => {
-                        profiling::scope!("ready.handle_callback");
+                        crate::profile_scope!("ready.handle_callback");
                         if let Some(err) =
                             self.execute_ready(py, Some(&loop_obj), handle.get().ready())?
                         {
@@ -608,7 +608,7 @@ impl LoopCore {
                         }
                     }
                     ReadyItem::FutureSetResult { future, value } => {
-                        profiling::scope!("ready.future_set_result");
+                        crate::profile_scope!("ready.future_set_result");
                         let future = future.bind(py);
                         if !crate::python_names::call_method0(
                             py,
@@ -627,7 +627,7 @@ impl LoopCore {
                         }
                     }
                     ReadyItem::FutureSetException { future, value } => {
-                        profiling::scope!("ready.future_set_exception");
+                        crate::profile_scope!("ready.future_set_exception");
                         let future = future.bind(py);
                         if !crate::python_names::call_method0(
                             py,
@@ -646,19 +646,19 @@ impl LoopCore {
                         }
                     }
                     ReadyItem::StreamTransportRead(core) => {
-                        profiling::scope!("ready.stream_transport_read");
+                        crate::profile_scope!("ready.stream_transport_read");
                         core.drain_pending_read_events_with_py(py)?;
                     }
                     ReadyItem::StreamTransportWrite(core) => {
-                        profiling::scope!("ready.stream_transport_write");
+                        crate::profile_scope!("ready.stream_transport_write");
                         core.flush_pending_direct_write();
                     }
                     ReadyItem::ProcessTransport(core) => {
-                        profiling::scope!("ready.process_transport");
+                        crate::profile_scope!("ready.process_transport");
                         core.drain_pending_events_with_py(py)?;
                     }
                     ReadyItem::ServerAccepted { server, stream } => {
-                        profiling::scope!("ready.server_accepted");
+                        crate::profile_scope!("ready.server_accepted");
                         if let Err(err) = crate::transport::stream::spawn_accepted_transport_with_py(
                             py, &server, stream,
                         ) {
@@ -671,7 +671,7 @@ impl LoopCore {
                         fd,
                         wait_errno,
                     } => {
-                        profiling::scope!("ready.connect_completed");
+                        crate::profile_scope!("ready.connect_completed");
                         self.resolve_connect_completed(py, future, fd, wait_errno)?;
                     }
                 }
@@ -825,7 +825,7 @@ impl LoopCore {
     /// Already-ready callbacks are still processed according to asyncio's
     /// stop semantics before `run_forever` returns.
     pub fn schedule_stop(&self) -> Result<(), LoopCoreError> {
-        profiling::scope!("LoopCore::schedule_stop");
+        crate::profile_scope!("LoopCore::schedule_stop");
         self.send_command(LoopCommand::RequestStop)
     }
 
@@ -835,7 +835,7 @@ impl LoopCore {
     /// `LoopCoreError::Running`. Tracked I/O tasks are cancelled before the
     /// on-thread runtime is dropped.
     pub fn close(&self) -> Result<(), LoopCoreError> {
-        profiling::scope!("LoopCore::close");
+        crate::profile_scope!("LoopCore::close");
         {
             let mut state = self.state.lock().expect("poisoned loop state");
             if state.running {
@@ -946,7 +946,7 @@ impl LoopCore {
         loop_obj: Option<&Py<PyAny>>,
         ready: &ReadyCallback,
     ) -> PyResult<Option<PyErr>> {
-        profiling::scope!("LoopCore::execute_ready");
+        crate::profile_scope!("LoopCore::execute_ready");
         if ready.cancelled() {
             return Ok(None);
         }
@@ -1440,4 +1440,42 @@ mod wake_tests {
         assert!(!wake.ready_pending.load(Ordering::Acquire));
         assert!(started.elapsed() >= Duration::from_millis(1));
     }
+
+    #[test]
+    fn command_channel_accepts_concurrent_producers_and_disconnects_cleanly() {
+        const PRODUCERS: usize = 8;
+        const COMMANDS_PER_PRODUCER: usize = 128;
+
+        let core = LoopCore::new();
+        let producers = (0..PRODUCERS)
+            .map(|_| {
+                let core = Arc::clone(&core);
+                std::thread::spawn(move || {
+                    for _ in 0..COMMANDS_PER_PRODUCER {
+                        core.send_command(LoopCommand::RequestStop)
+                            .expect("dispatcher should accept concurrent commands");
+                    }
+                })
+            })
+            .collect::<Vec<_>>();
+
+        for producer in producers {
+            producer.join().expect("command producer");
+        }
+
+        core.send_command(LoopCommand::Close)
+            .expect("dispatcher close command");
+        core.runtime_thread
+            .lock()
+            .expect("runtime thread mutex")
+            .take()
+            .expect("runtime thread")
+            .join()
+            .expect("runtime thread join");
+
+        assert!(matches!(
+            core.send_command(LoopCommand::RequestStop),
+            Err(LoopCoreError::ChannelClosed)
+        ));
+    }
 }

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

@@ -34,6 +34,7 @@ pub(crate) mod vibeio;
 pub(crate) use platform::fd as fd_ops;
 #[cfg(windows)]
 pub(crate) use platform::windows_vibeio;
+pub(crate) use profiler::{profile_function, profile_scope};
 
 // Compatibility re-exports for the crate's existing Rust API. Internal module
 // registration imports from the owning modules directly, so these can be

{rsloop-0.1.45 → rsloop-0.1.46}/src/profiler.rs

@@ -1,5 +1,27 @@
 //! Optional Tracy profiler lifecycle exposed to Python.
 
+/// Opens a named profiling scope when Tracy support is compiled in.
+///
+/// Default builds intentionally expand this macro to nothing, matching the
+/// previous `profiling` facade without retaining it as a dependency.
+macro_rules! profile_scope {
+    ($name:literal) => {
+        #[cfg(feature = "profiler")]
+        let _rsloop_tracy_span = tracy_client::span!($name, 0);
+    };
+}
+
+/// Opens a scope named after the enclosing function in profiler builds.
+macro_rules! profile_function {
+    () => {
+        #[cfg(feature = "profiler")]
+        let _rsloop_tracy_span = tracy_client::span!();
+    };
+}
+
+pub(crate) use profile_function;
+pub(crate) use profile_scope;
+
 use pyo3::prelude::*;
 
 #[cfg(feature = "profiler")]