fix: Prevent panicking in VirtualTaskManagerExt::spawn_and_block_on

lib/cli/src/commands/run/mod.rs

@@ -217,7 +217,7 @@ impl Run {
                     .spawn_and_block_on(async move {
                         BinaryPackage::from_registry(&specifier, inner_runtime.as_ref()).await
                     })
-                    .with_context(|| format!("Unable to load \"{name}\""))?
+                    .with_context(|| format!("Unable to load \"{name}\""))??
             };
             dependencies.push(pkg);
         }
@@ -574,7 +574,7 @@ impl PackageSource {
                 let inner_rt = rt.clone();
                 let pkg = rt.task_manager().spawn_and_block_on(async move {
                     BinaryPackage::from_registry(&inner_pck, inner_rt.as_ref()).await
-                })?;
+                })??;
                 Ok(ExecutableTarget::Package(pkg))
             }
         }
@@ -667,7 +667,7 @@ impl ExecutableTarget {
         let inner_runtime = runtime.clone();
         let pkg = runtime.task_manager().spawn_and_block_on(async move {
             BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
-        })?;
+        })??;
 
         Ok(ExecutableTarget::Package(pkg))
     }
@@ -718,7 +718,7 @@ impl ExecutableTarget {
                 let inner_runtime = runtime.clone();
                 let pkg = runtime.task_manager().spawn_and_block_on(async move {
                     BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
-                })?;
+                })??;
                 Ok(ExecutableTarget::Package(pkg))
             }
         }

lib/cli/src/commands/run/wasi.rs

@@ -237,7 +237,7 @@ impl Wasi {
                     .spawn_and_block_on(async move {
                         BinaryPackage::from_registry(&specifier, &*inner_rt).await
                     })
-                    .with_context(|| format!("Unable to load \"{name}\""))?
+                    .with_context(|| format!("Unable to load \"{name}\""))??
             };
             uses.push(pkg);
         }

lib/wasix/src/runners/wasi.rs

@@ -377,7 +377,7 @@ impl crate::runners::Runner for WasiRunner {
                     .context("Unable to wait for the process to exit")
             }
             .in_current_span(),
-        )?;
+        )??;
 
         if exit_code.raw() == 0 {
             Ok(())

lib/wasix/src/runners/wcgi/runner.rs

@@ -150,7 +150,7 @@ impl WcgiRunner {
                     })
                     .await
             })
-            .context("Unable to start the server")?;
+            .context("Unable to start the server")??;
 
         Ok(())
     }

lib/wasix/src/runtime/task_manager/mod.rs

@@ -402,7 +402,10 @@ impl dyn VirtualTaskManager {
 pub trait VirtualTaskManagerExt {
     /// Runs the work in the background via the task managers shared background
     /// threads while blocking the current execution until it finishs
-    fn spawn_and_block_on<A>(&self, task: impl Future<Output = A> + Send + 'static) -> A
+    fn spawn_and_block_on<A>(
+        &self,
+        task: impl Future<Output = A> + Send + 'static,
+    ) -> Result<A, anyhow::Error>
     where
         A: Send + 'static;
 
@@ -422,17 +425,21 @@ where
 {
     /// Runs the work in the background via the task managers shared background
     /// threads while blocking the current execution until it finishs
-    fn spawn_and_block_on<A>(&self, task: impl Future<Output = A> + Send + 'static) -> A
+    fn spawn_and_block_on<A>(
+        &self,
+        task: impl Future<Output = A> + Send + 'static,
+    ) -> Result<A, anyhow::Error>
     where
         A: Send + 'static,
     {
-        let (work_tx, mut work_rx) = ::tokio::sync::mpsc::unbounded_channel();
+        let (tx, rx) = ::tokio::sync::oneshot::channel();
         let work = Box::pin(async move {
             let ret = task.await;
-            work_tx.send(ret).ok();
+            tx.send(ret).ok();
         });
         self.task_shared(Box::new(move || work)).unwrap();
-        InlineWaker::block_on(work_rx.recv()).unwrap()
+        rx.blocking_recv()
+            .map_err(|_| anyhow::anyhow!("task execution failed - result channel dropped"))
     }
 
     fn spawn_await<O, F>(