fix smol import

Author: nathantippy

Cargo.lock

@@ -37,9 +37,10 @@ default = ["proactor_nuclei", "telemetry_server_builtin", "prometheus_metrics",
 proactor_nuclei = ["nuclei/async-exec", "nuclei/iouring"]
 # Use the tokio async runtime (proactor_? exclusive one or the other)
 proactor_tokio = ["nuclei/tokio", "nuclei/iouring"]
-exec_embassy = ["embassy-executor"]
-#exec_smol = ["smol"]
+
 exec_async_std = ["async-std"]
+exec_embassy = ["embassy-executor"]
+exec_smol = ["smol"]
 
 proactor_windows = ["nuclei/async-exec"]
 
@@ -83,9 +84,9 @@ cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 
 [dependencies]
 nuclei           = { version = "0.4.4", optional = true } # foundational proactive runtime
-embassy-executor = { version = "0.5.0", optional = true }
-async-std        = { version = "1.13.1", attributes="", optional = true}
-#smol             = { version = "2.0.2", option = true}
+embassy-executor = { version = "0.7.0", optional = true }
+async-std        = { version = "1.13.1", optional = true, features = ["attributes"]}
+smol             = { version = "2.0.2", optional = true}
 ringbuf          = "0.4.7"  # foundational bounded message passing
 async-ringbuf    = "0.3.2"  # foundational bounded message passing
 log              = "0.4.25"  # common logging traits

core/Cargo.toml

@@ -11,7 +11,7 @@ pub(crate) mod core_exec {
     use lazy_static::lazy_static;
     use parking_lot::Once;
     use crate::ProactorConfig;
-    use embassy_executor::{Executor, Spawner};
+    use embassy_executor::{Spawner};
 
     /// Spawns a local task intended for lightweight operations.
     ///

core/src/abstract_executor_embassy.rs

@@ -15,25 +15,25 @@ pub(crate) mod core_exec {
     use log::{error, trace, warn};
     use parking_lot::Once;
     use crate::ProactorConfig;
-    use smol::{spawn, Task, unblock, block_on};
+    use smol::{Task, unblock};
     use std::panic::{catch_unwind, AssertUnwindSafe};
 
     /// Spawns a local task intended for lightweight operations.
     ///
     /// Note: In `smol`, tasks are scheduled on the global executor, which may not guarantee
     /// execution on the current thread, unlike `nuclei::spawn_local`.
     pub fn spawn_local<F: Future<Output = T> + 'static, T: 'static>(f: F) -> Task<T> {
-        spawn(f)
+        smol::spawn(f)
     }
 
     /// Spawns a blocking task on a separate thread for CPU-bound or blocking operations.
     pub fn spawn_blocking<F: FnOnce() -> T + Send + 'static, T: Send + 'static>(f: F) -> Task<T> {
-        spawn(unblock(f))
+        smol::spawn(unblock(f))
     }
 
     /// Spawns a task that can run on any thread in the pool for parallel execution.
     pub fn spawn<F: Future<Output = T> + Send + 'static, T: Send + 'static>(future: F) -> Task<T> {
-        spawn(future)
+        smol::spawn(future)
     }
 
     /// Asynchronously spawns additional threads in the executor.
@@ -78,7 +78,8 @@ pub(crate) mod core_exec {
 
     /// Blocks the current thread until the given future completes.
     pub fn block_on<F: Future<Output = T>, T>(future: F) -> T {
-        block_on(future)
+
+        smol::block_on(future)
     }
 }