v0.8.0-beta.3

Immplement native "vector" function to construct vectors

CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.8.0-beta.3
+
+- Luau vector constructor
+- Luau sandboxing support
+- Luau interrupts (yieldable)
+- More Luau compiler options (mutable globals)
+- Other performance improvements
+
+## v0.8.0-beta.2
+
+- Luau vector datatype support
+- Luau readonly table attribute
+- Other Luau improvements
+
 ## v0.8.0-beta.1
 
 - Roblox Luau support

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.8.0-beta.1" # remember to update html_root_url and mlua_derive
+version = "0.8.0-beta.3" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 edition = "2018"
 repository = "https://github.com/khvzak/mlua"
@@ -57,9 +57,9 @@ erased-serde = { version = "0.3", optional = true }
 [build-dependencies]
 cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
-lua-src = { version = ">= 540.0.0, < 550.0.0", optional = true }
+lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
 luajit-src = { version = ">= 210.3.1, < 220.0.0", optional = true }
-luau0-src = { version = "0.2.0", optional = true }
+luau0-src = { version = "0.2.2", optional = true }
 
 [dev-dependencies]
 rustyline = "9.0"
@@ -70,6 +70,7 @@ hyper = { version = "0.14", features = ["client", "server"] }
 reqwest = { version = "0.11", features = ["json"] }
 tokio = { version = "1.0", features = ["full"] }
 futures-timer = "3.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 maplit = "1.0"
 tempfile = "3"

README.md

@@ -104,7 +104,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.8.0-beta.1", features = ["lua54", "vendored"] }
+mlua = { version = "0.8.0-beta.3", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -139,7 +139,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.8.0-beta.1", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.8.0-beta.3", features = ["lua54", "vendored", "module"] }
 ```
 
 `lib.rs` :

src/chunk.rs

@@ -64,15 +64,19 @@ pub enum ChunkMode {
 }
 
 /// Luau compiler
-#[cfg(feature = "luau")]
-#[derive(Clone, Copy, Debug)]
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug)]
 pub struct Compiler {
     optimization_level: u8,
     debug_level: u8,
     coverage_level: u8,
+    vector_lib: Option<String>,
+    vector_ctor: Option<String>,
+    mutable_globals: Vec<String>,
 }
 
-#[cfg(feature = "luau")]
+#[cfg(any(feature = "luau", doc))]
 impl Default for Compiler {
     fn default() -> Self {
         // Defaults are taken from luacode.h
@@ -80,11 +84,14 @@ impl Default for Compiler {
             optimization_level: 1,
             debug_level: 1,
             coverage_level: 0,
+            vector_lib: None,
+            vector_ctor: None,
+            mutable_globals: Vec::new(),
         }
     }
 }
 
-#[cfg(feature = "luau")]
+#[cfg(any(feature = "luau", doc))]
 impl Compiler {
     /// Creates Luau compiler instance with default options
     pub fn new() -> Self {
@@ -94,11 +101,10 @@ impl Compiler {
     /// Sets Luau compiler optimization level.
     ///
     /// Possible values:
-    /// 0 - no optimization
-    /// 1 - baseline optimization level that doesn't prevent debuggability (default)
-    /// 2 - includes optimizations that harm debuggability such as inlining
-    #[cfg(feature = "luau")]
-    pub fn set_optimization_level(mut self, level: u8) -> Self {
+    /// * 0 - no optimization
+    /// * 1 - baseline optimization level that doesn't prevent debuggability (default)
+    /// * 2 - includes optimizations that harm debuggability such as inlining
+    pub fn set_optimization_level(&mut self, level: u8) -> &mut Self {
         self.optimization_level = level;
         self
     }
@@ -106,11 +112,10 @@ impl Compiler {
     /// Sets Luau compiler debug level.
     ///
     /// Possible values:
-    /// 0 - no debugging support
-    /// 1 - line info & function names only; sufficient for backtraces (default)
-    /// 2 - full debug info with local & upvalue names; necessary for debugger
-    #[cfg(feature = "luau")]
-    pub fn set_debug_level(mut self, level: u8) -> Self {
+    /// * 0 - no debugging support
+    /// * 1 - line info & function names only; sufficient for backtraces (default)
+    /// * 2 - full debug info with local & upvalue names; necessary for debugger
+    pub fn set_debug_level(&mut self, level: u8) -> &mut Self {
         self.debug_level = level;
         self
     }
@@ -118,28 +123,70 @@ impl Compiler {
     /// Sets Luau compiler code coverage level.
     ///
     /// Possible values:
-    /// 0 - no code coverage support (default)
-    /// 1 - statement coverage
-    /// 2 - statement and expression coverage (verbose)
-    #[cfg(feature = "luau")]
-    pub fn set_coverage_level(mut self, level: u8) -> Self {
+    /// * 0 - no code coverage support (default)
+    /// * 1 - statement coverage
+    /// * 2 - statement and expression coverage (verbose)
+    pub fn set_coverage_level(&mut self, level: u8) -> &mut Self {
         self.coverage_level = level;
         self
     }
 
+    #[doc(hidden)]
+    pub fn set_vector_lib(&mut self, lib: Option<String>) -> &mut Self {
+        self.vector_lib = lib;
+        self
+    }
+
+    #[doc(hidden)]
+    pub fn set_vector_ctor(&mut self, ctor: Option<String>) -> &mut Self {
+        self.vector_ctor = ctor;
+        self
+    }
+
+    /// Sets a list of globals that are mutable.
+    ///
+    /// It disables the import optimization for fields accessed through these.
+    pub fn set_mutable_globals(&mut self, globals: Vec<String>) -> &mut Self {
+        self.mutable_globals = globals;
+        self
+    }
+
     /// Compiles the `source` into bytecode.
     pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
         use std::os::raw::c_int;
         use std::ptr;
 
+        let vector_lib = self.vector_lib.clone();
+        let vector_lib = vector_lib.and_then(|lib| CString::new(lib).ok());
+        let vector_lib = vector_lib.as_ref();
+        let vector_ctor = self.vector_ctor.clone();
+        let vector_ctor = vector_ctor.and_then(|ctor| CString::new(ctor).ok());
+        let vector_ctor = vector_ctor.as_ref();
+
+        let mutable_globals = self
+            .mutable_globals
+            .iter()
+            .map(|name| CString::new(name.clone()).ok())
+            .collect::<Option<Vec<_>>>()
+            .unwrap_or_default();
+        let mut mutable_globals = mutable_globals
+            .iter()
+            .map(|s| s.as_ptr())
+            .collect::<Vec<_>>();
+        let mut mutable_globals_ptr = ptr::null_mut();
+        if mutable_globals.len() > 0 {
+            mutable_globals.push(ptr::null());
+            mutable_globals_ptr = mutable_globals.as_mut_ptr();
+        }
+
         unsafe {
             let options = ffi::lua_CompileOptions {
                 optimizationLevel: self.optimization_level as c_int,
                 debugLevel: self.debug_level as c_int,
                 coverageLevel: self.coverage_level as c_int,
-                vectorLib: ptr::null(),
-                vectorCtor: ptr::null(),
-                mutableGlobals: ptr::null_mut(),
+                vectorLib: vector_lib.map_or(ptr::null(), |s| s.as_ptr()),
+                vectorCtor: vector_ctor.map_or(ptr::null(), |s| s.as_ptr()),
+                mutableGlobals: mutable_globals_ptr,
             };
             ffi::luau_compile(source.as_ref(), options)
         }
@@ -148,7 +195,7 @@ impl Compiler {
 
 impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Sets the name of this chunk, which results in more informative error traces.
-    pub fn set_name<S: AsRef<[u8]> + ?Sized>(mut self, name: &S) -> Result<Chunk<'lua, 'a>> {
+    pub fn set_name<S: AsRef<[u8]> + ?Sized>(mut self, name: &S) -> Result<Self> {
         let name =
             CString::new(name.as_ref().to_vec()).map_err(|e| Error::ToLuaConversionError {
                 from: "&str",
@@ -170,7 +217,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// All global variables (including the standard library!) are looked up in `_ENV`, so it may be
     /// necessary to populate the environment in order for scripts using custom environments to be
     /// useful.
-    pub fn set_environment<V: ToLua<'lua>>(mut self, env: V) -> Result<Chunk<'lua, 'a>> {
+    pub fn set_environment<V: ToLua<'lua>>(mut self, env: V) -> Result<Self> {
         // Prefer to propagate errors here and wrap to `Ok`
         self.env = Ok(Some(env.to_lua(self.lua)?));
         Ok(self)
@@ -180,7 +227,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// Be aware, Lua does not check the consistency of the code inside binary chunks.
     /// Running maliciously crafted bytecode can crash the interpreter.
-    pub fn set_mode(mut self, mode: ChunkMode) -> Chunk<'lua, 'a> {
+    pub fn set_mode(mut self, mode: ChunkMode) -> Self {
         self.mode = Some(mode);
         self
     }
@@ -189,8 +236,9 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// See [`Compiler::set_optimization_level`] for details.
     ///
-    /// Requires `feature = "luau`
-    #[cfg(feature = "luau")]
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_optimization_level(mut self, level: u8) -> Self {
         self.compiler
             .get_or_insert_with(Default::default)
@@ -203,7 +251,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// See [`Compiler::set_debug_level`] for details.
     ///
     /// Requires `feature = "luau`
-    #[cfg(feature = "luau")]
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_debug_level(mut self, level: u8) -> Self {
         self.compiler
             .get_or_insert_with(Default::default)
@@ -215,8 +264,9 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// See [`Compiler::set_coverage_level`] for details.
     ///
-    /// Requires `feature = "luau`
-    #[cfg(feature = "luau")]
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_coverage_level(mut self, level: u8) -> Self {
         self.compiler
             .get_or_insert_with(Default::default)
@@ -224,6 +274,40 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         self
     }
 
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    pub fn set_vector_lib(mut self, lib: Option<String>) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_vector_lib(lib);
+        self
+    }
+
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    pub fn set_vector_ctor(mut self, ctor: Option<String>) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_vector_ctor(ctor);
+        self
+    }
+
+    /// Sets a list of globals that are mutable for Luau compiler.
+    ///
+    /// See [`Compiler::set_mutable_globals`] for details.
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_mutable_globals(mut self, globals: Vec<String>) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_mutable_globals(globals);
+        self
+    }
+
     /// Compiles the chunk and changes mode to binary.
     ///
     /// It does nothing if the chunk is already binary.
@@ -233,7 +317,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         if self.detect_mode() == ChunkMode::Text {
             let data = self
                 .compiler
-                .unwrap_or_default()
+                .get_or_insert_with(Default::default)
                 .compile(self.source.as_ref());
             self.mode = Some(ChunkMode::Binary);
             self.source = Cow::Owned(data);
@@ -372,7 +456,11 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         let source = self.expression_source();
         // We don't need to compile source if no compiler options set
         #[cfg(feature = "luau")]
-        let source = self.compiler.map(|c| c.compile(&source)).unwrap_or(source);
+        let source = self
+            .compiler
+            .as_ref()
+            .map(|c| c.compile(&source))
+            .unwrap_or(source);
 
         self.lua
             .load_chunk(&source, self.name.as_ref(), self.env()?, None)

src/conversion.rs

@@ -464,21 +464,33 @@ impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
 where
     T: FromLua<'lua>,
 {
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
-            vec.try_into()
-                .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
-                    from: "Table",
-                    to: "Array",
-                    message: Some(format!("expected table of length {}, got {}", N, vec.len())),
-                })
-        } else {
-            Err(Error::FromLuaConversionError {
+    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+        match value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) if N == 3 => Ok(mlua_expect!(
+                vec![
+                    T::from_lua(Value::Number(x as _), _lua)?,
+                    T::from_lua(Value::Number(y as _), _lua)?,
+                    T::from_lua(Value::Number(z as _), _lua)?,
+                ]
+                .try_into()
+                .map_err(|_| ()),
+                "cannot convert vector to array"
+            )),
+            Value::Table(table) => {
+                let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
+                vec.try_into()
+                    .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
+                        from: "Table",
+                        to: "Array",
+                        message: Some(format!("expected table of length {}, got {}", N, vec.len())),
+                    })
+            }
+            _ => Err(Error::FromLuaConversionError {
                 from: value.type_name(),
                 to: "Array",
                 message: Some("expected table".to_string()),
-            })
+            }),
         }
     }
 }
@@ -490,16 +502,8 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.sequence_values().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "Box<[T]>",
-                message: Some("expected table".to_string()),
-            })
-        }
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+        Ok(Vec::<T>::from_lua(value, lua)?.into_boxed_slice())
     }
 }
 
@@ -510,15 +514,20 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.sequence_values().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
+    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+        match value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => Ok(vec![
+                T::from_lua(Value::Number(x as _), _lua)?,
+                T::from_lua(Value::Number(y as _), _lua)?,
+                T::from_lua(Value::Number(z as _), _lua)?,
+            ]),
+            Value::Table(table) => table.sequence_values().collect(),
+            _ => Err(Error::FromLuaConversionError {
                 from: value.type_name(),
                 to: "Vec",
                 message: Some("expected table".to_string()),
-            })
+            }),
         }
     }
 }

src/error.rs

@@ -37,7 +37,8 @@ pub enum Error {
     /// Lua garbage collector error, aka `LUA_ERRGCMM`.
     ///
     /// The Lua VM returns this error when there is an error running a `__gc` metamethod.
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
+    #[cfg(any(feature = "lua53", feature = "lua52", doc))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua53", feature = "lua52"))))]
     GarbageCollectorError(StdString),
     /// Potentially unsafe action in safe mode.
     SafetyError(StdString),

src/ffi/luau/lauxlib.rs

@@ -72,6 +72,11 @@ extern "C" {
     // TODO: luaL_findtable
 
     pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
+
+    // sandbox libraries and globals
+    #[link_name = "luaL_sandbox"]
+    pub fn luaL_sandbox_(L: *mut lua_State);
+    pub fn luaL_sandboxthread(L: *mut lua_State);
 }
 
 //
@@ -123,6 +128,29 @@ pub unsafe fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int) {
     lua::lua_unref(L, r#ref)
 }
 
+pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
+    use super::lua::*;
+
+    // set all libraries to read-only
+    lua_pushnil(L);
+    while lua_next(L, LUA_GLOBALSINDEX) != 0 {
+        if lua_istable(L, -1) != 0 {
+            lua_setreadonly(L, -1, enabled);
+        }
+        lua_pop(L, 1);
+    }
+
+    // set all builtin metatables to read-only
+    lua_pushliteral(L, "");
+    lua_getmetatable(L, -1);
+    lua_setreadonly(L, -1, enabled);
+    lua_pop(L, 2);
+
+    // set globals to readonly and activate safeenv since the env is immutable
+    lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
+    lua_setsafeenv(L, LUA_GLOBALSINDEX, enabled);
+}
+
 //
 // TODO: Generic Buffer Manipulation
 //

src/ffi/luau/lualib.rs

@@ -26,8 +26,4 @@ extern "C" {
 
     // open all builtin libraries
     pub fn luaL_openlibs(L: *mut lua_State);
-
-    // sandbox libraries and globals
-    pub fn luaL_sandbox(L: *mut lua_State);
-    pub fn luaL_sandboxthread(L: *mut lua_State);
 }

src/function.rs

@@ -214,6 +214,7 @@ impl<'lua> Function<'lua> {
     /// If `strip` is true, the binary representation may not include all debug information
     /// about the function, to save space.
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
         use std::os::raw::c_void;
         use std::slice;

src/hook.rs

@@ -48,6 +48,7 @@ impl<'lua> Debug<'lua> {
     ///
     /// [Lua 5.1]: https://www.lua.org/manual/5.1/manual.html#pdf-LUA_HOOKTAILRET
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn event(&self) -> DebugEvent {
         unsafe {
             match (*self.ar.get()).event {
@@ -131,6 +132,7 @@ impl<'lua> Debug<'lua> {
     /// Corresponds to the `t` what mask. Returns true if the hook is in a function tail call, false
     /// otherwise.
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn is_tail_call(&self) -> bool {
         unsafe {
             mlua_assert!(
@@ -241,6 +243,7 @@ pub struct DebugStack {
 
 /// Determines when a hook function will be called by Lua.
 #[cfg(not(feature = "luau"))]
+#[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
 #[derive(Clone, Copy, Debug, Default)]
 pub struct HookTriggers {
     /// Before a function call.

src/lib.rs

@@ -72,7 +72,7 @@
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.8.0-beta.1")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.8.0-beta.3")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]
@@ -88,6 +88,8 @@ mod ffi;
 mod function;
 mod hook;
 mod lua;
+#[cfg(feature = "luau")]
+mod luau;
 mod multi;
 mod scope;
 mod stdlib;
@@ -124,8 +126,9 @@ pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti
 #[cfg(not(feature = "luau"))]
 pub use crate::hook::HookTriggers;
 
-#[cfg(feature = "luau")]
-pub use crate::chunk::Compiler;
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub use crate::{chunk::Compiler, types::VmState};
 
 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;

src/lua.rs

@@ -47,6 +47,9 @@ use {
 #[cfg(not(feature = "luau"))]
 use crate::{hook::HookTriggers, types::HookCallback};
 
+#[cfg(feature = "luau")]
+use crate::types::{InterruptCallback, VmState};
+
 #[cfg(feature = "async")]
 use {
     crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},
@@ -108,6 +111,11 @@ struct ExtraData {
     hook_callback: Option<HookCallback>,
     #[cfg(feature = "lua54")]
     warn_callback: Option<WarnCallback>,
+    #[cfg(feature = "luau")]
+    interrupt_callback: Option<InterruptCallback>,
+
+    #[cfg(feature = "luau")]
+    sandboxed: bool,
 }
 
 #[cfg_attr(any(feature = "lua51", feature = "luajit"), allow(dead_code))]
@@ -152,8 +160,8 @@ pub struct LuaOptions {
 
     /// Max size of thread (coroutine) object cache used to execute asynchronous functions.
     ///
-    /// It works only on Lua 5.4 or LuaJIT (vendored) with [`lua_resetthread`] function,
-    /// and allows to reuse old coroutines with reset state.
+    /// It works on Lua 5.4, LuaJIT (vendored) and Luau, where [`lua_resetthread`] function
+    /// is available and allows to reuse old coroutines with reset state.
     ///
     /// Default: **0** (disabled)
     ///
@@ -204,8 +212,8 @@ impl LuaOptions {
 pub(crate) static ASYNC_POLL_PENDING: u8 = 0;
 pub(crate) static EXTRA_REGISTRY_KEY: u8 = 0;
 
-const WRAPPED_FAILURES_CACHE_SIZE: usize = 16;
-const MULTIVALUE_CACHE_SIZE: usize = 16;
+const WRAPPED_FAILURES_CACHE_SIZE: usize = 32;
+const MULTIVALUE_CACHE_SIZE: usize = 32;
 
 /// Requires `feature = "send"`
 #[cfg(feature = "send")]
@@ -232,6 +240,13 @@ impl Drop for Lua {
                     ffi::lua_replace(extra.ref_thread, extra.ref_waker_idx);
                     extra.ref_free.push(extra.ref_waker_idx);
                 }
+                #[cfg(feature = "luau")]
+                {
+                    let callbacks = ffi::lua_callbacks(self.state);
+                    let extra_ptr = (*callbacks).userdata as *mut Arc<UnsafeCell<ExtraData>>;
+                    drop(Box::from_raw(extra_ptr));
+                    (*callbacks).userdata = ptr::null_mut();
+                }
                 mlua_debug_assert!(
                     ffi::lua_gettop(extra.ref_thread) == extra.ref_stack_top
                         && extra.ref_stack_top as usize == extra.ref_free.len(),
@@ -408,11 +423,6 @@ impl Lua {
         #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
         let state = ffi::luaL_newstate();
 
-        // #[cfg(feature = "luau")]
-        // {
-        //     ffi::luaL_sandbox(state);
-        // }
-
         ffi::luaL_requiref(state, cstr!("_G"), ffi::luaopen_base, 1);
         ffi::lua_pop(state, 1);
 
@@ -553,6 +563,10 @@ impl Lua {
             hook_callback: None,
             #[cfg(feature = "lua54")]
             warn_callback: None,
+            #[cfg(feature = "luau")]
+            interrupt_callback: None,
+            #[cfg(feature = "luau")]
+            sandboxed: false,
         }));
 
         mlua_expect!(
@@ -581,6 +595,14 @@ impl Lua {
         );
         assert_stack(main_state, ffi::LUA_MINSTACK);
 
+        // Set Luau callbacks userdata to extra data
+        // We can use global callbacks userdata since we don't allow C modules in Luau
+        #[cfg(feature = "luau")]
+        {
+            let extra_raw = Box::into_raw(Box::new(Arc::clone(&extra)));
+            (*ffi::lua_callbacks(main_state)).userdata = extra_raw as *mut c_void;
+        }
+
         Lua {
             state,
             main_state: maybe_main_state,
@@ -701,32 +723,6 @@ impl Lua {
         Ok(())
     }
 
-    /// Consumes and leaks `Lua` object, returning a static reference `&'static Lua`.
-    ///
-    /// This function is useful when the `Lua` object is supposed to live for the remainder
-    /// of the program's life.
-    /// In particular in asynchronous context this will allow to spawn Lua tasks to execute
-    /// in background.
-    ///
-    /// Dropping the returned reference will cause a memory leak. If this is not acceptable,
-    /// the reference should first be wrapped with the [`Lua::from_static`] function producing a `Lua`.
-    /// This `Lua` object can then be dropped which will properly release the allocated memory.
-    ///
-    /// [`Lua::from_static`]: #method.from_static
-    #[doc(hidden)]
-    pub fn into_static(self) -> &'static Self {
-        Box::leak(Box::new(self))
-    }
-
-    /// Constructs a `Lua` from a static reference to it.
-    ///
-    /// # Safety
-    /// This function is unsafe because improper use may lead to memory problems or undefined behavior.
-    #[doc(hidden)]
-    pub unsafe fn from_static(lua: &'static Lua) -> Self {
-        *Box::from_raw(lua as *const Lua as *mut Lua)
-    }
-
     // Executes module entrypoint function, which returns only one Value.
     // The returned value then pushed onto the stack.
     #[doc(hidden)]
@@ -781,6 +777,60 @@ impl Lua {
         self.entrypoint(move |lua, _: ()| func(lua))
     }
 
+    /// Enables (or disables) sandbox mode on this Lua instance.
+    ///
+    /// This method, in particular:
+    /// - Set all libraries to read-only
+    /// - Set all builtin metatables to read-only
+    /// - Set globals to read-only (and activates safeenv)
+    /// - Setup local environment table that performs writes locally and proxies reads
+    ///   to the global environment.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result};
+    /// # fn main() -> Result<()> {
+    /// let lua = Lua::new();
+    ///
+    /// lua.sandbox(true)?;
+    /// lua.load("var = 123").exec()?;
+    /// assert_eq!(lua.globals().get::<_, u32>("var")?, 123);
+    ///
+    /// // Restore the global environment (clear changes made in sandbox)
+    /// lua.sandbox(false)?;
+    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    pub fn sandbox(&self, enabled: bool) -> Result<()> {
+        unsafe {
+            let extra = &mut *self.extra.get();
+            if extra.sandboxed != enabled {
+                let state = self.main_state.ok_or(Error::MainThreadNotAvailable)?;
+                check_stack(state, 3)?;
+                protect_lua!(state, 0, 0, |state| {
+                    if enabled {
+                        ffi::luaL_sandbox(state, 1);
+                        ffi::luaL_sandboxthread(state);
+                    } else {
+                        // Restore original `LUA_GLOBALSINDEX`
+                        self.ref_thread_exec(|ref_thread| {
+                            ffi::lua_xpush(ref_thread, state, ffi::LUA_GLOBALSINDEX);
+                            ffi::lua_replace(state, ffi::LUA_GLOBALSINDEX);
+                        });
+                        ffi::luaL_sandbox(state, 0);
+                    }
+                })?;
+                extra.sandboxed = enabled;
+            }
+            Ok(())
+        }
+    }
+
     /// Sets a 'hook' function that will periodically be called as Lua code executes.
     ///
     /// When exactly the hook function is called depends on the contents of the `triggers`
@@ -815,9 +865,10 @@ impl Lua {
     /// [`HookTriggers`]: crate::HookTriggers
     /// [`HookTriggers.every_nth_instruction`]: crate::HookTriggers::every_nth_instruction
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
     where
-        F: 'static + MaybeSend + FnMut(&Lua, Debug) -> Result<()>,
+        F: 'static + MaybeSend + Fn(&Lua, Debug) -> Result<()>,
     {
         unsafe extern "C" fn hook_proc(state: *mut ffi::lua_State, ar: *mut ffi::lua_Debug) {
             let lua = match Lua::make_from_ptr(state) {
@@ -829,30 +880,26 @@ impl Lua {
                 let debug = Debug::new(&lua, ar);
                 let hook_cb = (*lua.extra.get()).hook_callback.clone();
                 let hook_cb = mlua_expect!(hook_cb, "no hook callback set in hook_proc");
-
-                #[allow(clippy::match_wild_err_arm)]
-                match hook_cb.try_lock() {
-                    Ok(mut cb) => cb(&lua, debug),
-                    Err(_) => {
-                        mlua_panic!("Lua should not allow hooks to be called within another hook")
-                    }
-                }?;
-
-                Ok(())
+                if Arc::strong_count(&hook_cb) > 2 {
+                    return Ok(()); // Don't allow recursion
+                }
+                hook_cb(&lua, debug)
             })
         }
 
         let state = self.main_state.ok_or(Error::MainThreadNotAvailable)?;
         unsafe {
-            (*self.extra.get()).hook_callback = Some(Arc::new(Mutex::new(callback)));
+            (*self.extra.get()).hook_callback = Some(Arc::new(callback));
             ffi::lua_sethook(state, Some(hook_proc), triggers.mask(), triggers.count());
         }
         Ok(())
     }
 
-    /// Remove any hook previously set by `set_hook`. This function has no effect if a hook was not
-    /// previously set.
+    /// Removes any hook previously set by `set_hook`.
+    ///
+    /// This function has no effect if a hook was not previously set.
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn remove_hook(&self) {
         // If main_state is not available, then sethook wasn't called.
         let state = match self.main_state {
@@ -865,6 +912,102 @@ impl Lua {
         }
     }
 
+    /// Sets an 'interrupt' function that will periodically be called by Luau VM.
+    ///
+    /// Any Luau code is guaranteed to call this handler "eventually"
+    /// (in practice this can happen at any function call or at any loop iteration).
+    ///
+    /// The provided interrupt function can error, and this error will be propagated through
+    /// the Luau code that was executing at the time the interrupt was triggered.
+    /// Also this can be used to implement continuous execution limits by instructing Luau VM to yield
+    /// by returning [`VmState::Yield`].
+    ///
+    /// This is similar to [`Lua::set_hook`] but in more simplified form.
+    ///
+    /// # Example
+    ///
+    /// Periodically yield Luau VM to suspend execution.
+    ///
+    /// ```
+    /// # use std::sync::{Arc, atomic::{AtomicU64, Ordering}};
+    /// # use mlua::{Lua, Result, ThreadStatus, VmState};
+    /// # fn main() -> Result<()> {
+    /// let lua = Lua::new();
+    /// let count = Arc::new(AtomicU64::new(0));
+    /// lua.set_interrupt(move |_lua| {
+    ///     if count.fetch_add(1, Ordering::Relaxed) % 2 == 0 {
+    ///         return Ok(VmState::Yield);
+    ///     }
+    ///     Ok(VmState::Continue)
+    /// });
+    ///
+    /// let co = lua.create_thread(
+    ///     lua.load(r#"
+    ///         local b = 0
+    ///         for _, x in ipairs({1, 2, 3}) do b += x end
+    ///     "#)
+    ///     .into_function()?,
+    /// )?;
+    /// while co.status() == ThreadStatus::Resumable {
+    ///     co.resume(())?;
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_interrupt<F>(&self, callback: F)
+    where
+        F: 'static + MaybeSend + Fn(&Lua) -> Result<VmState>,
+    {
+        unsafe extern "C" fn interrupt_proc(state: *mut ffi::lua_State, gc: c_int) {
+            if gc != -1 {
+                // We don't support GC interrupts since they cannot survive Lua exceptions
+                return;
+            }
+            // TODO: think about not using drop types here
+            let lua = match Lua::make_from_ptr(state) {
+                Some(lua) => lua,
+                None => return,
+            };
+            let extra = lua.extra.get();
+            let result = callback_error_ext(state, extra, move |_| {
+                let interrupt_cb = (*extra).interrupt_callback.clone();
+                let interrupt_cb =
+                    mlua_expect!(interrupt_cb, "no interrupt callback set in interrupt_proc");
+                if Arc::strong_count(&interrupt_cb) > 2 {
+                    return Ok(VmState::Continue); // Don't allow recursion
+                }
+                interrupt_cb(&lua)
+            });
+            match result {
+                VmState::Continue => {}
+                VmState::Yield => {
+                    ffi::lua_yield(state, 0);
+                }
+            }
+        }
+
+        let state = mlua_expect!(self.main_state, "Luau should always has main state");
+        unsafe {
+            (*self.extra.get()).interrupt_callback = Some(Arc::new(callback));
+            (*ffi::lua_callbacks(state)).interrupt = Some(interrupt_proc);
+        }
+    }
+
+    /// Removes any 'interrupt' previously set by `set_interrupt`.
+    ///
+    /// This function has no effect if an 'interrupt' was not previously set.
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn remove_interrupt(&self) {
+        let state = mlua_expect!(self.main_state, "Luau should always has main state");
+        unsafe {
+            (*self.extra.get()).interrupt_callback = None;
+            (*ffi::lua_callbacks(state)).interrupt = None;
+        }
+    }
+
     /// Sets the warning function to be used by Lua to emit warnings.
     ///
     /// Requires `feature = "lua54"`
@@ -987,7 +1130,7 @@ impl Lua {
 
     /// Returns true if the garbage collector is currently running automatically.
     ///
-    /// Requires `feature = "lua54/lua53/lua52"`
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
     #[cfg(any(
         feature = "lua54",
         feature = "lua53",
@@ -1051,6 +1194,7 @@ impl Lua {
     ///
     /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn gc_set_pause(&self, pause: c_int) -> c_int {
         let state = self.main_state.unwrap_or(self.state);
         unsafe { ffi::lua_gc(state, ffi::LUA_GCSETPAUSE, pause) }
@@ -1074,6 +1218,7 @@ impl Lua {
     ///
     /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5.1
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn gc_inc(&self, pause: c_int, step_multiplier: c_int, step_size: c_int) -> GCMode {
         let state = self.main_state.unwrap_or(self.state);
 
@@ -1451,7 +1596,11 @@ impl Lua {
         &'lua self,
         func: Function<'lua>,
     ) -> Result<Thread<'lua>> {
-        #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+        #[cfg(any(
+            feature = "lua54",
+            all(feature = "luajit", feature = "vendored"),
+            feature = "luau",
+        ))]
         unsafe {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 1)?;
@@ -1461,6 +1610,14 @@ impl Lua {
                 let thread_state = ffi::lua_tothread(extra.ref_thread, index);
                 self.push_ref(&func.0);
                 ffi::lua_xmove(self.state, thread_state, 1);
+
+                #[cfg(feature = "luau")]
+                {
+                    // Inherit `LUA_GLOBALSINDEX` from the caller
+                    ffi::lua_xpush(self.state, thread_state, ffi::LUA_GLOBALSINDEX);
+                    ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
+                }
+
                 return Ok(Thread(LuaRef { lua: self, index }));
             }
         };
@@ -1469,7 +1626,11 @@ impl Lua {
 
     /// Resets thread (coroutine) and returns to the cache for later use.
     #[cfg(feature = "async")]
-    #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+    #[cfg(any(
+        feature = "lua54",
+        all(feature = "luajit", feature = "vendored"),
+        feature = "luau",
+    ))]
     pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) {
         let extra = &mut *self.extra.get();
         let thread_state = ffi::lua_tothread(extra.ref_thread, thread.0.index);
@@ -1972,6 +2133,11 @@ impl Lua {
                 ffi::lua_pushnumber(self.state, n);
             }
 
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => {
+                ffi::lua_pushvector(self.state, x, y, z);
+            }
+
             Value::String(s) => {
                 self.push_ref(&s.0);
             }
@@ -2033,6 +2199,15 @@ impl Lua {
                 }
             }
 
+            #[cfg(feature = "luau")]
+            ffi::LUA_TVECTOR => {
+                let v = ffi::lua_tovector(state, -1);
+                mlua_debug_assert!(!v.is_null(), "vector is null");
+                let vec = Value::Vector(*v, *v.add(1), *v.add(2));
+                ffi::lua_pop(state, 1);
+                vec
+            }
+
             ffi::LUA_TSTRING => Value::String(String(self.pop_ref())),
 
             ffi::LUA_TTABLE => Value::Table(Table(self.pop_ref())),
@@ -2081,8 +2256,13 @@ impl Lua {
             "Lua instance passed Value created from a different main Lua state"
         );
         let extra = &*self.extra.get();
-        ffi::lua_pushvalue(extra.ref_thread, lref.index);
-        ffi::lua_xmove(extra.ref_thread, self.state, 1);
+        #[cfg(not(feature = "luau"))]
+        {
+            ffi::lua_pushvalue(extra.ref_thread, lref.index);
+            ffi::lua_xmove(extra.ref_thread, self.state, 1);
+        }
+        #[cfg(feature = "luau")]
+        ffi::lua_xpush(extra.ref_thread, self.state, lref.index);
     }
 
     // Pops the topmost element of the stack and stores a reference to it. This pins the object,
@@ -2601,105 +2781,11 @@ impl Lua {
         Ok(())
     }
 
-    #[cfg(feature = "luau")]
-    unsafe fn prepare_luau_state(&self) -> Result<()> {
-        use std::ffi::CStr;
-
-        // Since Luau has some missing standard function, we re-implement them here
-
-        unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
-            let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
-            let option = CStr::from_ptr(option);
-            match option.to_str() {
-                Ok("collect") => {
-                    ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
-                    0
-                }
-                Ok("count") => {
-                    let n = ffi::lua_gc(state, ffi::LUA_GCCOUNT, 0);
-                    ffi::lua_pushnumber(state, n as ffi::lua_Number);
-                    1
-                }
-                // TODO: More variants
-                _ => ffi::luaL_error(
-                    state,
-                    cstr!("collectgarbage must be called with 'count' or 'collect'"),
-                ),
-            }
-        }
-
-        fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
-            let name = name.ok_or_else(|| Error::RuntimeError("name is nil".into()))?;
-
-            // Find module in the cache
-            let loaded = unsafe {
-                let _sg = StackGuard::new(lua.state);
-                check_stack(lua.state, 2)?;
-                protect_lua!(lua.state, 0, 1, fn(state) {
-                    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED"));
-                })?;
-                Table(lua.pop_ref())
-            };
-            if let Some(v) = loaded.raw_get(name.clone())? {
-                return Ok(v);
-            }
-
-            // Load file from filesystem
-            let mut search_path = std::env::var("LUAU_PATH").unwrap_or_default();
-            if search_path.is_empty() {
-                search_path = "?.luau;?.lua".into();
-            }
-
-            let mut source = None;
-            for path in search_path.split(';') {
-                if let Ok(buf) = std::fs::read(path.replacen('?', &name, 1)) {
-                    source = Some(buf);
-                    break;
-                }
-            }
-            let source =
-                source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{}'", name)))?;
-
-            let value = lua
-                .load(&source)
-                .set_name(&format!("={}", name))?
-                .set_mode(ChunkMode::Text)
-                .call::<_, Value>(())?;
-
-            // Save in the cache
-            loaded.raw_set(
-                name,
-                match value.clone() {
-                    Value::Nil => Value::Boolean(true),
-                    v => v,
-                },
-            )?;
-
-            Ok(value)
-        }
-
-        let globals = self.globals();
-        globals.raw_set(
-            "collectgarbage",
-            self.create_c_function(lua_collectgarbage)?,
-        )?;
-        globals.raw_set("require", self.create_function(lua_require)?)?;
-
-        Ok(())
-    }
-
     pub(crate) unsafe fn make_from_ptr(state: *mut ffi::lua_State) -> Option<Self> {
         let _sg = StackGuard::new(state);
         assert_stack(state, 1);
 
-        let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
-        if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, extra_key) != ffi::LUA_TUSERDATA {
-            return None;
-        }
-        let extra_ptr = ffi::lua_touserdata(state, -1) as *mut Arc<UnsafeCell<ExtraData>>;
-        let extra = Arc::clone(&*extra_ptr);
-        ffi::lua_pop(state, 1);
-
+        let extra = extra_data(state)?;
         let safe = (*extra.get()).safe;
         Some(Lua {
             state,
@@ -2731,6 +2817,27 @@ impl Lua {
     }
 }
 
+#[cfg(feature = "luau")]
+unsafe fn extra_data(state: *mut ffi::lua_State) -> Option<Arc<UnsafeCell<ExtraData>>> {
+    let extra_ptr = (*ffi::lua_callbacks(state)).userdata as *mut Arc<UnsafeCell<ExtraData>>;
+    if extra_ptr.is_null() {
+        return None;
+    }
+    Some(Arc::clone(&*extra_ptr))
+}
+
+#[cfg(not(feature = "luau"))]
+unsafe fn extra_data(state: *mut ffi::lua_State) -> Option<Arc<UnsafeCell<ExtraData>>> {
+    let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+    if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, extra_key) != ffi::LUA_TUSERDATA {
+        return None;
+    }
+    let extra_ptr = ffi::lua_touserdata(state, -1) as *mut Arc<UnsafeCell<ExtraData>>;
+    let extra = Arc::clone(&*extra_ptr);
+    ffi::lua_pop(state, 1);
+    Some(extra)
+}
+
 // Creates required entries in the metatable cache (see `util::METATABLE_CACHE`)
 pub(crate) fn init_metatable_cache(cache: &mut FxHashMap<TypeId, u8>) {
     cache.insert(TypeId::of::<Arc<UnsafeCell<ExtraData>>>(), 0);

src/luau.rs

@@ -0,0 +1,106 @@
+use std::ffi::CStr;
+use std::os::raw::{c_float, c_int};
+
+use crate::chunk::ChunkMode;
+use crate::error::{Error, Result};
+use crate::ffi;
+use crate::lua::Lua;
+use crate::table::Table;
+use crate::util::{check_stack, StackGuard};
+use crate::value::Value;
+
+// Since Luau has some missing standard function, we re-implement them here
+
+impl Lua {
+    pub(crate) unsafe fn prepare_luau_state(&self) -> Result<()> {
+        let globals = self.globals();
+
+        globals.raw_set(
+            "collectgarbage",
+            self.create_c_function(lua_collectgarbage)?,
+        )?;
+        globals.raw_set("require", self.create_function(lua_require)?)?;
+        globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
+
+        Ok(())
+    }
+}
+
+unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
+    let option = CStr::from_ptr(option);
+    match option.to_str() {
+        Ok("collect") => {
+            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
+            0
+        }
+        Ok("count") => {
+            let n = ffi::lua_gc(state, ffi::LUA_GCCOUNT, 0);
+            ffi::lua_pushnumber(state, n as ffi::lua_Number);
+            1
+        }
+        // TODO: More variants
+        _ => ffi::luaL_error(
+            state,
+            cstr!("collectgarbage must be called with 'count' or 'collect'"),
+        ),
+    }
+}
+
+fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
+    let name = name.ok_or_else(|| Error::RuntimeError("name is nil".into()))?;
+
+    // Find module in the cache
+    let loaded = unsafe {
+        let _sg = StackGuard::new(lua.state);
+        check_stack(lua.state, 2)?;
+        protect_lua!(lua.state, 0, 1, fn(state) {
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED"));
+        })?;
+        Table(lua.pop_ref())
+    };
+    if let Some(v) = loaded.raw_get(name.clone())? {
+        return Ok(v);
+    }
+
+    // Load file from filesystem
+    let mut search_path = std::env::var("LUAU_PATH").unwrap_or_default();
+    if search_path.is_empty() {
+        search_path = "?.luau;?.lua".into();
+    }
+
+    let mut source = None;
+    for path in search_path.split(';') {
+        if let Ok(buf) = std::fs::read(path.replacen('?', &name, 1)) {
+            source = Some(buf);
+            break;
+        }
+    }
+    let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{}'", name)))?;
+
+    let value = lua
+        .load(&source)
+        .set_name(&format!("={}", name))?
+        .set_mode(ChunkMode::Text)
+        .call::<_, Value>(())?;
+
+    // Save in the cache
+    loaded.raw_set(
+        name,
+        match value.clone() {
+            Value::Nil => Value::Boolean(true),
+            v => v,
+        },
+    )?;
+
+    Ok(value)
+}
+
+// Luau vector datatype constructor
+unsafe extern "C" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
+    let x = ffi::luaL_checknumber(state, 1) as c_float;
+    let y = ffi::luaL_checknumber(state, 2) as c_float;
+    let z = ffi::luaL_checknumber(state, 3) as c_float;
+    ffi::lua_pushvector(state, x, y, z);
+    1
+}

src/prelude.rs

@@ -15,6 +15,14 @@ pub use crate::{
     Value as LuaValue,
 };
 
+#[cfg(not(feature = "luau"))]
+#[doc(no_inline)]
+pub use crate::HookTriggers as LuaHookTriggers;
+
+#[cfg(feature = "luau")]
+#[doc(no_inline)]
+pub use crate::VmState as LuaVmState;
+
 #[cfg(feature = "async")]
 #[doc(no_inline)]
 pub use crate::AsyncThread as LuaAsyncThread;

src/serde/de.rs

@@ -123,6 +123,8 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             }
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => visitor.visit_f64(n.into()),
+            #[cfg(feature = "luau")]
+            Value::Vector(_, _, _) => self.deserialize_seq(visitor),
             Value::String(s) => match s.to_str() {
                 Ok(s) => visitor.visit_str(s),
                 Err(_) => visitor.visit_bytes(s.as_bytes()),
@@ -214,6 +216,16 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
         V: de::Visitor<'de>,
     {
         match self.value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => {
+                let mut deserializer = VecDeserializer {
+                    vec: [x, y, z],
+                    next: 0,
+                    options: self.options,
+                    visited: self.visited,
+                };
+                visitor.visit_seq(&mut deserializer)
+            }
             Value::Table(t) => {
                 let _guard = RecursionGuard::new(&t, &self.visited);
 
@@ -352,6 +364,39 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
     }
 }
 
+#[cfg(feature = "luau")]
+struct VecDeserializer {
+    vec: [f32; 3],
+    next: usize,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
+
+#[cfg(feature = "luau")]
+impl<'de> de::SeqAccess<'de> for VecDeserializer {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.vec.get(self.next) {
+            Some(&n) => {
+                self.next += 1;
+                let visited = Rc::clone(&self.visited);
+                let deserializer =
+                    Deserializer::from_parts(Value::Number(n as _), self.options, visited);
+                seed.deserialize(deserializer).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(3)
+    }
+}
+
 struct MapDeserializer<'lua> {
     pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
     value: Option<Value<'lua>>,

src/serde/mod.rs

@@ -14,6 +14,7 @@ use crate::util::{assert_stack, check_stack, StackGuard};
 use crate::value::Value;
 
 /// Trait for serializing/deserializing Lua values using Serde.
+#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub trait LuaSerdeExt<'lua> {
     /// A special value (lightuserdata) to encode/decode optional (none) values.
     ///

src/stdlib.rs

@@ -8,7 +8,7 @@ pub struct StdLib(u32);
 impl StdLib {
     /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
     ///
-    /// Requires `feature = "lua54/lua53/lua52"`
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
     #[cfg(any(
         feature = "lua54",
         feature = "lua53",
@@ -20,6 +20,7 @@ impl StdLib {
     pub const TABLE: StdLib = StdLib(1 << 1);
     /// [`io`](https://www.lua.org/manual/5.4/manual.html#6.8) library
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const IO: StdLib = StdLib(1 << 2);
     /// [`os`](https://www.lua.org/manual/5.4/manual.html#6.9) library
     pub const OS: StdLib = StdLib(1 << 3);
@@ -27,18 +28,19 @@ impl StdLib {
     pub const STRING: StdLib = StdLib(1 << 4);
     /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
     ///
-    /// Requires `feature = "lua54/lua53"`
+    /// Requires `feature = "lua54/lua53/luau"`
     #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
     pub const UTF8: StdLib = StdLib(1 << 5);
     /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
     ///
-    /// Requires `feature = "lua52/luajit"`
+    /// Requires `feature = "lua52/luajit/luau"`
     #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
     pub const BIT: StdLib = StdLib(1 << 6);
     /// [`math`](https://www.lua.org/manual/5.4/manual.html#6.7) library
     pub const MATH: StdLib = StdLib(1 << 7);
     /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
     #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const PACKAGE: StdLib = StdLib(1 << 8);
     /// [`jit`](http://luajit.org/ext_jit.html) library
     ///

src/table.rs

@@ -348,6 +348,34 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Sets `readonly` attribute on the table.
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_readonly(&self, enabled: bool) {
+        let lua = self.0.lua;
+        unsafe {
+            lua.ref_thread_exec(|refthr| {
+                ffi::lua_setreadonly(refthr, self.0.index, enabled as _);
+                if !enabled {
+                    // Reset "safeenv" flag
+                    ffi::lua_setsafeenv(refthr, self.0.index, 0);
+                }
+            });
+        }
+    }
+
+    /// Returns `readonly` attribute of the table.
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn is_readonly(&self) -> bool {
+        let lua = self.0.lua;
+        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_getreadonly(refthr, self.0.index) != 0) }
+    }
+
     /// Consume this table and return an iterator over the pairs of the table.
     ///
     /// This works like the Lua `pairs` function, but does not invoke the `__pairs` metamethod.

src/thread.rs

@@ -7,7 +7,11 @@ use crate::types::LuaRef;
 use crate::util::{check_stack, error_traceback, pop_error, StackGuard};
 use crate::value::{FromLuaMulti, ToLuaMulti};
 
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 use crate::function::Function;
 
 #[cfg(feature = "async")]
@@ -173,16 +177,20 @@ impl<'lua> Thread<'lua> {
     /// Returns a error in case of either the original error that stopped the thread or errors
     /// in closing methods.
     ///
-    /// In [LuaJIT]: resets to the initial state of a newly created Lua thread.
+    /// In [LuaJIT] and Luau: resets to the initial state of a newly created Lua thread.
     /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
     ///
     /// Sets a Lua function for the thread afterwards.
     ///
-    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"`
+    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"` OR `feature = "luau"`
     ///
     /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_resetthread
     /// [LuaJIT]: https://github.com/openresty/luajit2#lua_resetthread
-    #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+    #[cfg(any(
+        feature = "lua54",
+        all(feature = "luajit", feature = "vendored"),
+        feature = "luau",
+    ))]
     pub fn reset(&self, func: Function<'lua>) -> Result<()> {
         let lua = self.0.lua;
         unsafe {
@@ -206,6 +214,13 @@ impl<'lua> Thread<'lua> {
             lua.push_ref(&func.0);
             ffi::lua_xmove(lua.state, thread_state, 1);
 
+            #[cfg(feature = "luau")]
+            {
+                // Inherit `LUA_GLOBALSINDEX` from the caller
+                ffi::lua_xpush(lua.state, thread_state, ffi::LUA_GLOBALSINDEX);
+                ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
+            }
+
             Ok(())
         }
     }
@@ -270,6 +285,57 @@ impl<'lua> Thread<'lua> {
             recycle: false,
         }
     }
+
+    /// Enables sandbox mode on this thread.
+    ///
+    /// Under the hood replaces the global environment table with a new table,
+    /// that performs writes locally and proxies reads to caller's global environment.
+    ///
+    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox()`].
+    ///
+    /// Please note that Luau links environment table with chunk when loading it into Lua state.
+    /// Therefore you need to load chunks into a thread to link with the thread environment.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(feature = "luau")]
+    /// # fn main() -> mlua::Result<()> {
+    /// use mlua::Lua;
+    /// let lua = Lua::new();
+    /// let thread = lua.create_thread(lua.create_function(|lua2, ()| {
+    ///     lua2.load("var = 123").exec()?;
+    ///     assert_eq!(lua2.globals().get::<_, u32>("var")?, 123);
+    ///     Ok(())
+    /// })?)?;
+    /// thread.sandbox()?;
+    /// thread.resume(())?;
+    ///
+    /// // The global environment should be unchanged
+    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// # Ok(())
+    /// # }
+    ///
+    /// # #[cfg(not(feature = "luau"))]
+    /// fn main() {}
+    /// ```
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    pub fn sandbox(&self) -> Result<()> {
+        let lua = self.0.lua;
+        unsafe {
+            let thread = lua.ref_thread_exec(|t| ffi::lua_tothread(t, self.0.index));
+            check_stack(thread, 1)?;
+            check_stack(lua.state, 3)?;
+            // Inherit `LUA_GLOBALSINDEX` from the caller
+            ffi::lua_xpush(lua.state, thread, ffi::LUA_GLOBALSINDEX);
+            ffi::lua_replace(thread, ffi::LUA_GLOBALSINDEX);
+            protect_lua!(lua.state, 0, 0, |_| ffi::luaL_sandboxthread(thread))
+        }
+    }
 }
 
 impl<'lua> PartialEq for Thread<'lua> {
@@ -287,7 +353,11 @@ impl<'lua, R> AsyncThread<'lua, R> {
 }
 
 #[cfg(feature = "async")]
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 impl<'lua, R> Drop for AsyncThread<'lua, R> {
     fn drop(&mut self) {
         if self.recycle {

src/types.rs

@@ -49,11 +49,26 @@ pub(crate) struct AsyncPollUpvalue<'lua> {
     pub(crate) lua: Lua,
     pub(crate) fut: LocalBoxFuture<'lua, Result<MultiValue<'lua>>>,
 }
+
+/// Type to set next Luau VM action after executing interrupt function.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub enum VmState {
+    Continue,
+    Yield,
+}
+
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()> + Send>>;
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
 
 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+
+#[cfg(all(feature = "luau", feature = "send"))]
+pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState> + Send>;
+
+#[cfg(all(feature = "luau", not(feature = "send")))]
+pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState>>;
 
 #[cfg(all(feature = "send", feature = "lua54"))]
 pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;

src/userdata.rs

@@ -865,7 +865,6 @@ impl<'lua> AnyUserData<'lua> {
     ///
     /// [`get_user_value`]: #method.get_user_value
     /// [`set_nth_user_value`]: #method.set_nth_user_value
-    // #[cfg(not(feature = "luau"))]
     #[inline]
     pub fn set_user_value<V: ToLua<'lua>>(&self, v: V) -> Result<()> {
         self.set_nth_user_value(1, v)
@@ -877,7 +876,6 @@ impl<'lua> AnyUserData<'lua> {
     ///
     /// [`set_user_value`]: #method.set_user_value
     /// [`get_nth_user_value`]: #method.get_nth_user_value
-    // #[cfg(not(feature = "luau"))]
     #[inline]
     pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
         self.get_nth_user_value(1)
@@ -893,7 +891,6 @@ impl<'lua> AnyUserData<'lua> {
     /// For other Lua versions this functionality is provided using a wrapping table.
     ///
     /// [`get_nth_user_value`]: #method.get_nth_user_value
-    // #[cfg(not(feature = "luau"))]
     pub fn set_nth_user_value<V: ToLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
         if n < 1 || n > u16::MAX as usize {
             return Err(Error::RuntimeError(
@@ -948,7 +945,6 @@ impl<'lua> AnyUserData<'lua> {
     /// For other Lua versions this functionality is provided using a wrapping table.
     ///
     /// [`set_nth_user_value`]: #method.set_nth_user_value
-    // #[cfg(not(feature = "luau"))]
     pub fn get_nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
         if n < 1 || n > u16::MAX as usize {
             return Err(Error::RuntimeError(
@@ -990,7 +986,6 @@ impl<'lua> AnyUserData<'lua> {
     /// The value can be retrieved with [`get_named_user_value`].
     ///
     /// [`get_named_user_value`]: #method.get_named_user_value
-    // #[cfg(not(feature = "luau"))]
     pub fn set_named_user_value<S, V>(&self, name: &S, v: V) -> Result<()>
     where
         S: AsRef<[u8]> + ?Sized,
@@ -1030,7 +1025,6 @@ impl<'lua> AnyUserData<'lua> {
     /// Returns an associated value by name set by [`set_named_user_value`].
     ///
     /// [`set_named_user_value`]: #method.set_named_user_value
-    // #[cfg(not(feature = "luau"))]
     pub fn get_named_user_value<S, V>(&self, name: &S) -> Result<V>
     where
         S: AsRef<[u8]> + ?Sized,

src/util.rs

@@ -965,6 +965,13 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
                 i.to_string()
             }
         }
+        #[cfg(feature = "luau")]
+        ffi::LUA_TVECTOR => {
+            let v = ffi::lua_tovector(state, index);
+            mlua_debug_assert!(!v.is_null(), "vector is null");
+            let (x, y, z) = (*v, *v.add(1), *v.add(2));
+            format!("vector({},{},{})", x, y, z)
+        }
         ffi::LUA_TSTRING => {
             let mut size = 0;
             // This will not trigger a 'm' error, because the reference is guaranteed to be of

src/value.rs

@@ -34,6 +34,10 @@ pub enum Value<'lua> {
     Integer(Integer),
     /// A floating point number.
     Number(Number),
+    /// A Luau vector.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    Vector(f32, f32, f32),
     /// An interned string, managed by Lua.
     ///
     /// Unlike Rust strings, Lua strings may not be valid UTF-8.
@@ -61,6 +65,8 @@ impl<'lua> Value<'lua> {
             Value::LightUserData(_) => "lightuserdata",
             Value::Integer(_) => "integer",
             Value::Number(_) => "number",
+            #[cfg(feature = "luau")]
+            Value::Vector(_, _, _) => "vector",
             Value::String(_) => "string",
             Value::Table(_) => "table",
             Value::Function(_) => "function",
@@ -99,6 +105,8 @@ impl<'lua> PartialEq for Value<'lua> {
             (Value::Integer(a), Value::Number(b)) => *a as Number == *b,
             (Value::Number(a), Value::Integer(b)) => *a == *b as Number,
             (Value::Number(a), Value::Number(b)) => *a == *b,
+            #[cfg(feature = "luau")]
+            (Value::Vector(x1, y1, z1), Value::Vector(x2, y2, z2)) => (x1, y1, z1) == (x2, y2, z2),
             (Value::String(a), Value::String(b)) => a == b,
             (Value::Table(a), Value::Table(b)) => a == b,
             (Value::Function(a), Value::Function(b)) => a == b,
@@ -130,6 +138,8 @@ impl<'lua> Serialize for Value<'lua> {
                 .serialize_i64((*i).try_into().expect("cannot convert lua_Integer to i64")),
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => serializer.serialize_f64(*n),
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => (x, y, z).serialize(serializer),
             Value::String(s) => s.serialize(serializer),
             Value::Table(t) => t.serialize(serializer),
             Value::UserData(ud) => ud.serialize(serializer),

tests/hooks.rs

@@ -3,6 +3,7 @@
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::str;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use mlua::{DebugEvent, Error, HookTriggers, Lua, Result, Value};
@@ -128,18 +129,17 @@ fn test_error_within_hook() -> Result<()> {
 #[test]
 fn test_limit_execution_instructions() -> Result<()> {
     let lua = Lua::new();
-    let mut max_instructions = 10000;
 
-    #[cfg(feature = "luajit")]
     // For LuaJIT disable JIT, as compiled code does not trigger hooks
+    #[cfg(feature = "luajit")]
     lua.load("jit.off()").exec()?;
 
+    let max_instructions = AtomicI64::new(10000);
     lua.set_hook(
         HookTriggers::every_nth_instruction(30),
         move |_lua, debug| {
             assert_eq!(debug.event(), DebugEvent::Count);
-            max_instructions -= 30;
-            if max_instructions < 0 {
+            if max_instructions.fetch_sub(30, Ordering::Relaxed) <= 30 {
                 Err(Error::RuntimeError("time's up".to_string()))
             } else {
                 Ok(())

tests/luau.rs

@@ -2,8 +2,10 @@
 
 use std::env;
 use std::fs;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 
-use mlua::{Lua, Result};
+use mlua::{Error, Lua, Result, Table, ThreadStatus, Value, VmState};
 
 #[test]
 fn test_require() -> Result<()> {
@@ -29,3 +31,184 @@ fn test_require() -> Result<()> {
     )
     .exec()
 }
+
+#[test]
+fn test_vectors() -> Result<()> {
+    let lua = Lua::new();
+
+    let v: [f32; 3] = lua.load("vector(1, 2, 3) + vector(3, 2, 1)").eval()?;
+    assert_eq!(v, [4.0, 4.0, 4.0]);
+
+    // Test vector methods
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+    "#,
+    )
+    .exec()?;
+
+    // Test vector methods (fastcall)
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+    "#,
+    )
+    .set_vector_ctor(Some("vector".to_string()))
+    .exec()?;
+
+    Ok(())
+}
+
+#[test]
+fn test_readonly_table() -> Result<()> {
+    let lua = Lua::new();
+
+    let t = lua.create_table()?;
+    assert!(!t.is_readonly());
+    t.set_readonly(true);
+    assert!(t.is_readonly());
+
+    match t.set("key", "value") {
+        Err(Error::RuntimeError(err)) if err.contains("Attempt to modify a readonly table") => {}
+        r => panic!(
+            "expected RuntimeError(...) with a specific message, got {:?}",
+            r
+        ),
+    };
+
+    Ok(())
+}
+
+#[test]
+fn test_sandbox() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.sandbox(true)?;
+
+    lua.load("global = 123").exec()?;
+    let n: i32 = lua.load("return global").eval()?;
+    assert_eq!(n, 123);
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(123));
+
+    // Threads should inherit "main" globals
+    let f = lua.create_function(|lua, ()| lua.globals().get::<_, i32>("global"))?;
+    let co = lua.create_thread(f.clone())?;
+    assert_eq!(co.resume::<_, Option<i32>>(())?, Some(123));
+
+    // Sandboxed threads should also inherit "main" globals
+    let co = lua.create_thread(f)?;
+    co.sandbox()?;
+    assert_eq!(co.resume::<_, Option<i32>>(())?, Some(123));
+
+    lua.sandbox(false)?;
+
+    // Previously set variable `global` should be cleared now
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, None);
+
+    // Readonly flags should be cleared as well
+    let table = lua.globals().get::<_, Table>("table")?;
+    table.set("test", "test")?;
+
+    Ok(())
+}
+
+#[test]
+fn test_sandbox_threads() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua.create_function(|lua, v: Value| lua.globals().set("global", v))?;
+
+    let co = lua.create_thread(f.clone())?;
+    co.resume(321)?;
+    // The main state should see the `global` variable (as the thread is not sandboxed)
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(321));
+
+    let co = lua.create_thread(f.clone())?;
+    co.sandbox()?;
+    co.resume(123)?;
+    // The main state should see the previous `global` value (as the thread is sandboxed)
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(321));
+
+    // Try to reset the (sandboxed) thread
+    co.reset(f)?;
+    co.resume(111)?;
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(111));
+
+    Ok(())
+}
+
+#[test]
+fn test_interrupts() -> Result<()> {
+    let lua = Lua::new();
+
+    let interrupts_count = Arc::new(AtomicU64::new(0));
+    let interrupts_count2 = interrupts_count.clone();
+
+    lua.set_interrupt(move |_lua| {
+        interrupts_count2.fetch_add(1, Ordering::Relaxed);
+        Ok(VmState::Continue)
+    });
+    let f = lua
+        .load(
+            r#"
+        local x = 2 + 3
+        local y = x * 63
+        local z = string.len(x..", "..y)
+    "#,
+        )
+        .into_function()?;
+    f.call(())?;
+
+    assert!(interrupts_count.load(Ordering::Relaxed) > 0);
+
+    //
+    // Test yields from interrupt
+    //
+    let yield_count = Arc::new(AtomicU64::new(0));
+    let yield_count2 = yield_count.clone();
+    lua.set_interrupt(move |_lua| {
+        if yield_count2.fetch_add(1, Ordering::Relaxed) == 1 {
+            return Ok(VmState::Yield);
+        }
+        Ok(VmState::Continue)
+    });
+    let co = lua.create_thread(
+        lua.load(
+            r#"
+            local a = {1, 2, 3}
+            local b = 0
+            for _, x in ipairs(a) do b += x end
+            return b
+        "#,
+        )
+        .into_function()?,
+    )?;
+    co.resume(())?;
+    assert_eq!(co.status(), ThreadStatus::Resumable);
+    let result: i32 = co.resume(())?;
+    assert_eq!(result, 6);
+    assert_eq!(yield_count.load(Ordering::Relaxed), 7);
+    assert_eq!(co.status(), ThreadStatus::Unresumable);
+
+    //
+    // Test errors in interrupts
+    //
+    lua.set_interrupt(|_| Err(Error::RuntimeError("error from interrupt".into())));
+    match f.call::<_, ()>(()) {
+        Err(Error::CallbackError { cause, .. }) => match *cause {
+            Error::RuntimeError(ref m) if m == "error from interrupt" => {}
+            ref e => panic!("expected RuntimeError with a specific message, got {:?}", e),
+        },
+        r => panic!("expected CallbackError, got {:?}", r),
+    }
+
+    lua.remove_interrupt();
+
+    Ok(())
+}

tests/serde.rs

@@ -144,6 +144,29 @@ fn test_serialize_failure() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+#[cfg(feature = "luau")]
+#[test]
+fn test_serialize_vector() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set(
+        "vector",
+        lua.create_function(|_, (x, y, z)| Ok(Value::Vector(x, y, z)))?,
+    )?;
+
+    let val = lua.load("{_vector = vector(1, 2, 3)}").eval::<Value>()?;
+    let json = serde_json::json!({
+        "_vector": [1.0, 2.0, 3.0],
+    });
+    assert_eq!(serde_json::to_value(&val)?, json);
+
+    let expected_json = lua.from_value::<serde_json::Value>(val)?;
+    assert_eq!(expected_json, json);
+
+    Ok(())
+}
+
 #[test]
 fn test_to_value_struct() -> LuaResult<()> {
     let lua = Lua::new();

tests/thread.rs

@@ -94,7 +94,11 @@ fn test_thread() -> Result<()> {
 }
 
 #[test]
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 fn test_thread_reset() -> Result<()> {
     use mlua::{AnyUserData, UserData};
     use std::sync::Arc;
@@ -121,14 +125,14 @@ fn test_thread_reset() -> Result<()> {
         assert_eq!(Arc::strong_count(&arc), 1);
     }
 
-    // Check for errors (Lua 5.4 only)
+    // Check for errors
+    let func: Function = lua.load(r#"function(ud) error("test error") end"#).eval()?;
+    let thread = lua.create_thread(func.clone())?;
+    let _ = thread.resume::<_, AnyUserData>(MyUserData(arc.clone()));
+    assert_eq!(thread.status(), ThreadStatus::Error);
+    assert_eq!(Arc::strong_count(&arc), 2);
     #[cfg(feature = "lua54")]
     {
-        let func: Function = lua.load(r#"function(ud) error("test error") end"#).eval()?;
-        let thread = lua.create_thread(func.clone())?;
-        let _ = thread.resume::<_, AnyUserData>(MyUserData(arc.clone()));
-        assert_eq!(thread.status(), ThreadStatus::Error);
-        assert_eq!(Arc::strong_count(&arc), 2);
         assert!(thread.reset(func.clone()).is_err());
         // Reset behavior has changed in Lua v5.4.4
         // It's became possible to force reset thread by popping error object
@@ -140,6 +144,11 @@ fn test_thread_reset() -> Result<()> {
         // assert!(thread.reset(func.clone()).is_ok());
         // assert_eq!(thread.status(), ThreadStatus::Resumable);
     }
+    #[cfg(any(feature = "lua54", feature = "luau"))]
+    {
+        assert!(thread.reset(func.clone()).is_ok());
+        assert_eq!(thread.status(), ThreadStatus::Resumable);
+    }
 
     Ok(())
 }