feat(Runtime): make Runtime::run return lua return values

`Runtime::run` now returns a tuple of both the `ExitCode` (denoting whether the lua thread generally succeeded or not) and also the values returned by it.

src/cli/run.rs

@@ -7,9 +7,8 @@ use tokio::{
     io::{stdin, AsyncReadExt as _},
 };
 
-use lune::Runtime;
-
 use super::utils::files::{discover_script_path_including_lune_dirs, strip_shebang};
+use lune::Runtime;
 
 /// Run a script
 #[derive(Debug, Clone, Parser)]
@@ -41,8 +40,8 @@ impl RunCommand {
         };
 
         // Create a new lune object with all globals & run the script
-        let result = Runtime::new()
+        let mut runtime = Runtime::new().with_args(self.script_args);
-            .with_args(self.script_args)
+        let result = runtime
             .run(&script_display_name, strip_shebang(script_contents))
             .await;
         Ok(match result {
@@ -50,7 +49,7 @@ impl RunCommand {
                 eprintln!("{err}");
                 ExitCode::FAILURE
             }
-            Ok(code) => code,
+            Ok((code, _)) => code,
         })
     }
 }

src/lune/mod.rs

@@ -7,7 +7,7 @@ use std::{
     },
 };
 
-use mlua::Lua;
+use mlua::{Lua, Value};
 use mlua_luau_scheduler::Scheduler;
 
 mod builtins;
@@ -64,7 +64,7 @@ impl Runtime {
         &mut self,
         script_name: impl AsRef<str>,
         script_contents: impl AsRef<[u8]>,
-    ) -> Result<ExitCode, RuntimeError> {
+    ) -> Result<(ExitCode, Vec<Value>), RuntimeError> {
         // Create a new scheduler for this run
         let sched = Scheduler::new(&self.lua);
 
@@ -83,16 +83,23 @@ impl Runtime {
             .set_name(script_name.as_ref());
 
         // Run it on our scheduler until it and any other spawned threads complete
-        sched.push_thread_back(main, ())?;
+        let main_thread_id = sched.push_thread_back(main, ())?;
         sched.run().await;
 
-        // Return the exit code - default to FAILURE if we got any errors
+        let thread_res = sched
-        Ok(sched.get_exit_code().unwrap_or({
+            .get_thread_result(main_thread_id)
-            if got_any_error.load(Ordering::SeqCst) {
+            .unwrap()
-                ExitCode::FAILURE
+            .unwrap()
-            } else {
+            .into_vec();
-                ExitCode::SUCCESS
+        Ok((
-            }
+            sched.get_exit_code().unwrap_or({
-        }))
+                if got_any_error.load(Ordering::SeqCst) {
+                    ExitCode::FAILURE
+                } else {
+                    ExitCode::SUCCESS
+                }
+            }),
+            thread_res,
+        ))
     }
 }

src/standalone/mod.rs

@@ -29,16 +29,14 @@ pub async fn run(patched_bin: impl AsRef<[u8]>) -> Result<ExitCode> {
     let args = env::args().skip(1).collect::<Vec<_>>();
     let meta = Metadata::from_bytes(patched_bin).expect("must be a standalone binary");
 
-    let result = Runtime::new()
+    let mut runtime = Runtime::new().with_args(args);
-        .with_args(args)
+    let result = runtime.run("STANDALONE", meta.bytecode).await;
-        .run("STANDALONE", meta.bytecode)
-        .await;
 
     Ok(match result {
         Err(err) => {
             eprintln!("{err}");
             ExitCode::FAILURE
         }
-        Ok(code) => code,
+        Ok((code, _)) => code,
     })
 }

src/tests.rs

@@ -31,7 +31,7 @@ macro_rules! create_tests {
 				.trim_end_matches(".luau")
 				.trim_end_matches(".lua")
 				.to_string();
-            let exit_code = lune.run(&script_name, &script).await?;
+            let (exit_code, _) = lune.run(&script_name, &script).await?;
             Ok(exit_code)
         }
     )* }