v0.11.3

Update CHANGELOG
Add new benchmark to measure complex userdata method calls
2026-06-08 16:05:43 +00:00 · 2025-08-29 23:11:21 +01:00 · 2025-08-29 00:18:06 +01:00 · 2025-08-28 23:56:03 +01:00 · 2025-08-28 23:50:18 +01:00 · 2025-08-28 18:41:24 +01:00
57 changed files with 1252 additions and 550 deletions
@@ -1,3 +1,38 @@
+## v0.11.3 (Aug 30, 2025)
+
+- Add `Lua::yield_with` to use as `coroutine.yield` functional replacement in async functions for any Lua
+- Do not try to yield at non-yielable points in Luau interrupt (#632)
+- Add `Buffer::cursor` method (Luau)
+- Add `Lua::create_buffer_with_capacity` method (Luau)
+- Make Lua reference values cheap to clone (only increments ref count)
+- Fix panic on large (>67M entries) table creation
+
+## v0.11.2 (Aug 10, 2025)
+
+- Faster stack push for `Variadic<T>`
+- Fix handling Windows paths with drive letter in Luau require (#623)
+- Make Luau registered aliases ascii case-insensitive (#620)
+- Fix deserializing negative zeros `-0.0` (#618)
+
+## v0.11.1 (Jul 15, 2025)
+
+- Fixed bug exhausting Lua auxiliary stack and leaving it without reserve (#615)
+- `Lua::push_c_function` now correctly handles OOM for Lua 5.1 and Luau
+
+## v0.11.0 (Jul 14, 2025)
+
+Changes since v0.11.0-beta.3
+
+- Allow linking external Lua libraries in a build script (e.g. pluto) using `external` mlua-sys feature flag
+- `Lua::inspect_stack` takes a callback with `&Debug` argument, instead of returning `Debug` directly
+- Added `Debug::function` method to get function running at a given level
+- `Debug::curr_line` is deprecated in favour of `Debug::current_line` that returns `Option<usize>`
+- Added `Lua::set_globals` method to replace global environment
+- `Table::set_metatable` now returns `Result<()>` (this operation can fail in sandboxed Luau mode)
+- `impl ToString` replaced with `Into<StdString>`  in `UserData` registration
+- `Value::as_str` and `Value::as_string_lossy` methods are deprecated (as they are non-idiomatic)
+- Bugfixes and improvements
+
 ## v0.11.0-beta.3 (Jun 23, 2025)

 - Luau in sandboxed mode has reduced options in `collectgarbage` function (to follow the official doc)
@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.11.0-beta.3" # remember to update mlua_derive
+version = "0.11.3" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
 rust-version = "1.79.0"
 edition = "2021"
@@ -49,7 +49,7 @@ userdata-wrappers = ["parking_lot/send_guard"]
 serialize = ["serde"]

 [dependencies]
-mlua_derive = { version = "=0.11.0-beta.2", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.11.0", optional = true, path = "mlua_derive" }
 bstr = { version = "1.0", features = ["std"], default-features = false }
 either = "1.0"
 num-traits = { version = "0.2.14" }
@@ -62,7 +62,7 @@ parking_lot = { version = "0.12", features = ["arc_lock"] }
 anyhow = { version = "1.0", optional = true }
 rustversion = "1.0"

-ffi = { package = "mlua-sys", version = "0.8.0", path = "mlua-sys" }
+ffi = { package = "mlua-sys", version = "0.8.3", path = "mlua-sys" }

 [dev-dependencies]
 trybuild = "1.0"
@@ -78,8 +78,8 @@ tempfile = "3"
 static_assertions = "1.0"

 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-criterion = { version = "0.6", features = ["async_tokio"] }
-rustyline = "16.0"
+criterion = { version = "0.7", features = ["async_tokio"] }
+rustyline = "17.0"
 tokio = { version = "1.0", features = ["full"] }

 [lints.rust]
@@ -17,12 +17,6 @@
 [Benchmarks]: https://github.com/khvzak/script-bench-rs
 [FAQ]: FAQ.md

-# The main branch is the development version of `mlua`. Please see the [v0.10](https://github.com/mlua-rs/mlua/tree/v0.10) branch for the stable versions of `mlua`.
-
-> **Note**
->
-> See v0.10 [release notes](https://github.com/mlua-rs/mlua/blob/main/docs/release_notes/v0.10.md).
-
 `mlua` is a set of bindings to the [Lua](https://www.lua.org) programming language for Rust with a goal to provide a
 _safe_ (as much as possible), high level, easy to use, practical and flexible API.

@@ -100,11 +94,11 @@ cargo run --example async_http_server --features=lua54,async,macros,send
 curl -v http://localhost:3000
 ```

-### Serialization (serde) support
+### Serde support

-With the `serde` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition, `mlua` provides the [`serde::Serialize`] trait implementation for it (including `UserData` support).
+With the `serde` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition, `mlua` provides the [`serde::Serialize`] trait implementation for `mlua::Value` (including `UserData` support).

-[Example](examples/serialize.rs)
+[Example](examples/serde.rs)

 [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
@@ -135,7 +129,7 @@ Add to `Cargo.toml`:

 ``` toml
 [dependencies]
-mlua = { version = "0.10", features = ["lua54", "vendored"] }
+mlua = { version = "0.11", features = ["lua54", "vendored"] }
 ```

 `main.rs`
@@ -170,7 +164,7 @@ Add to `Cargo.toml`:
 crate-type = ["cdylib"]

 [dependencies]
-mlua = { version = "0.10", features = ["lua54", "module"] }
+mlua = { version = "0.11", features = ["lua54", "module"] }
 ```

 `lib.rs`:
@@ -128,6 +128,22 @@ fn table_traversal_sequence(c: &mut Criterion) {
    });
 }

+fn table_ref_clone(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let t = lua.create_table().unwrap();
+
+    c.bench_function("table [ref clone]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                let _t2 = t.clone();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
 fn function_create(c: &mut Criterion) {
    let lua = Lua::new();

@@ -350,6 +366,39 @@ fn userdata_call_method(c: &mut Criterion) {
    });
 }

+// A userdata method call that goes through an implicit `__index` function
+fn userdata_call_method_complex(c: &mut Criterion) {
+    struct UserData(u64);
+    impl LuaUserData for UserData {
+        fn register(registry: &mut LuaUserDataRegistry<Self>) {
+            registry.add_field_method_get("val", |_, this| Ok(this.0));
+            registry.add_method_mut("inc_by", |_, this, by: u64| {
+                this.0 += by;
+                Ok(this.0)
+            });
+        }
+    }
+
+    let lua = Lua::new();
+    let ud = lua.create_userdata(UserData(0)).unwrap();
+    let inc_by = lua
+        .load("function(ud, s) return ud:inc_by(s) end")
+        .eval::<LuaFunction>()
+        .unwrap();
+
+    c.bench_function("userdata [call method complex]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+            },
+            |_| {
+                inc_by.call::<()>((&ud, 1)).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
 fn userdata_async_call_method(c: &mut Criterion) {
    struct UserData(i64);
    impl LuaUserData for UserData {
@@ -399,6 +448,7 @@ criterion_group! {
        table_traversal_pairs,
        table_traversal_for_each,
        table_traversal_sequence,
+        table_ref_clone,

        function_create,
        function_call_sum,
@@ -413,6 +463,7 @@ criterion_group! {
        userdata_create,
        userdata_call_index,
        userdata_call_method,
+        userdata_call_method_complex,
        userdata_async_call_method,
 }

@@ -20,14 +20,16 @@ fn main() {
            match lua.load(&line).eval::<MultiValue>() {
                Ok(values) => {
                    editor.add_history_entry(line).unwrap();
-                    println!(
-                        "{}",
-                        values
-                            .iter()
-                            .map(|value| format!("{:#?}", value))
-                            .collect::<Vec<_>>()
-                            .join("\t")
-                    );
+                    if values.len() > 0 {
+                        println!(
+                            "{}",
+                            values
+                                .iter()
+                                .map(|value| format!("{:#?}", value))
+                                .collect::<Vec<_>>()
+                                .join("\t")
+                        );
+                    }
                    break;
                }
                Err(Error::SyntaxError {
@@ -1,6 +1,6 @@
 [package]
 name = "mlua-sys"
-version = "0.8.1"
+version = "0.8.3"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 rust-version = "1.71"
 edition = "2021"
@@ -30,6 +30,7 @@ luau = ["luau0-src"]
 luau-codegen = ["luau"]
 luau-vector4 = ["luau"]
 vendored = ["lua-src", "luajit-src"]
+external = []
 module = []

 [dependencies]
@@ -40,7 +41,7 @@ cfg-if = "1.0"
 pkg-config = "0.3.17"
 lua-src = { version = ">= 548.1.0, < 548.2.0", optional = true }
 luajit-src = { version = ">= 210.6.0, < 210.7.0", optional = true }
-luau0-src = { version = "0.15.0", optional = true }
+luau0-src = { version = "0.15.6", optional = true }

 [lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }
@@ -14,22 +14,29 @@ fn main() {
    #[cfg(all(feature = "luau", feature = "module", windows))]
    compile_error!("Luau does not support `module` mode on Windows");

-    #[cfg(all(feature = "module", feature = "vendored"))]
-    compile_error!("`vendored` and `module` features are mutually exclusive");
+    #[cfg(any(
+        all(feature = "vendored", any(feature = "external", feature = "module")),
+        all(feature = "external", any(feature = "vendored", feature = "module")),
+        all(feature = "module", any(feature = "vendored", feature = "external"))
+    ))]
+    compile_error!("`vendored`, `external` and `module` features are mutually exclusive");

    println!("cargo:rerun-if-changed=build");

-    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
-    if target_os == "windows" && cfg!(feature = "module") {
-        if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
-            // Don't use raw-dylib linking
-            find::probe_lua();
-            return;
+    // Check if compilation and linking is handled by external crate
+    if cfg!(not(feature = "external")) {
+        let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+        if target_os == "windows" && cfg!(feature = "module") {
+            if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
+                // Don't use raw-dylib linking
+                find::probe_lua();
+                return;
+            }
+
+            println!("cargo:rustc-cfg=raw_dylib");
        }

-        println!("cargo:rustc-cfg=raw_dylib");
+        #[cfg(not(feature = "module"))]
+        find::probe_lua();
    }
-
-    #[cfg(not(feature = "module"))]
-    find::probe_lua();
 }
@@ -186,7 +186,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
    if lua_type(L, idx) == LUA_TNUMBER {
        let n = lua_tonumber(L, idx);
        let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
            return 1;
        }
    }
@@ -51,7 +51,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
    if lua_type(L, idx) == LUA_TNUMBER {
        let n = lua_tonumber(L, idx);
        let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
            return 1;
        }
    }
@@ -120,7 +120,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
    if lua_type(L, idx) == LUA_TNUMBER {
        let n = lua_tonumber(L, idx);
        let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
            return 1;
        }
    }
@@ -235,6 +235,7 @@ unsafe extern "C-unwind" {
    ) -> c_int;
    pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
    pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
+    pub fn lua_cpcall(L: *mut lua_State, f: lua_CFunction, ud: *mut c_void) -> c_int;

    //
    // Coroutine functions
@@ -1,6 +1,6 @@
 [package]
 name = "mlua_derive"
-version = "0.11.0-beta.2"
+version = "0.11.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2021"
 description = "Procedural macros for the mlua crate."
@@ -129,13 +129,13 @@ pub fn chunk(input: TokenStream) -> TokenStream {
            let globals = lua.globals();
            let env = lua.create_table()?;
            let meta = lua.create_table()?;
-            meta.raw_set("__index", globals.clone())?;
-            meta.raw_set("__newindex", globals)?;
+            meta.raw_set("__index", &globals)?;
+            meta.raw_set("__newindex", &globals)?;

            // Add captured variables
            #(#caps)*

-            env.set_metatable(Some(meta));
+            env.set_metatable(Some(meta))?;
            Ok(env)
        };

@@ -1,6 +1,9 @@
+use std::io;
+
 #[cfg(feature = "serde")]
 use serde::ser::{Serialize, Serializer};

+use crate::state::RawLua;
 use crate::types::ValueRef;

 /// A Luau buffer type.
@@ -16,12 +19,14 @@ pub struct Buffer(pub(crate) ValueRef);
 impl Buffer {
    /// Copies the buffer data into a new `Vec<u8>`.
    pub fn to_vec(&self) -> Vec<u8> {
-        unsafe { self.as_slice().to_vec() }
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).to_vec()
    }

    /// Returns the length of the buffer.
    pub fn len(&self) -> usize {
-        unsafe { self.as_slice().len() }
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).len()
    }

    /// Returns `true` if the buffer is empty.
@@ -34,7 +39,8 @@ impl Buffer {
    /// Offset is 0-based.
    #[track_caller]
    pub fn read_bytes<const N: usize>(&self, offset: usize) -> [u8; N] {
-        let data = unsafe { self.as_slice() };
+        let lua = self.0.lua.lock();
+        let data = self.as_slice(&lua);
        let mut bytes = [0u8; N];
        bytes.copy_from_slice(&data[offset..offset + N]);
        bytes
@@ -45,21 +51,36 @@ impl Buffer {
    /// Offset is 0-based.
    #[track_caller]
    pub fn write_bytes(&self, offset: usize, bytes: &[u8]) {
-        let data = unsafe {
-            let (buf, size) = self.as_raw_parts();
-            std::slice::from_raw_parts_mut(buf, size)
-        };
+        let lua = self.0.lua.lock();
+        let data = self.as_slice_mut(&lua);
        data[offset..offset + bytes.len()].copy_from_slice(bytes);
    }

-    pub(crate) unsafe fn as_slice(&self) -> &[u8] {
-        let (buf, size) = self.as_raw_parts();
-        std::slice::from_raw_parts(buf, size)
+    /// Returns an adaptor implementing [`io::Read`], [`io::Write`] and [`io::Seek`] over the
+    /// buffer.
+    ///
+    /// Buffer operations are infallible, none of the read/write functions will return a Err.
+    pub fn cursor(self) -> impl io::Read + io::Write + io::Seek {
+        BufferCursor(self, 0)
+    }
+
+    pub(crate) fn as_slice(&self, lua: &RawLua) -> &[u8] {
+        unsafe {
+            let (buf, size) = self.as_raw_parts(lua);
+            std::slice::from_raw_parts(buf, size)
+        }
+    }
+
+    #[allow(clippy::mut_from_ref)]
+    fn as_slice_mut(&self, lua: &RawLua) -> &mut [u8] {
+        unsafe {
+            let (buf, size) = self.as_raw_parts(lua);
+            std::slice::from_raw_parts_mut(buf, size)
+        }
    }

    #[cfg(feature = "luau")]
-    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
-        let lua = self.0.lua.lock();
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
        let mut size = 0usize;
        let buf = ffi::lua_tobuffer(lua.ref_thread(), self.0.index, &mut size);
        mlua_assert!(!buf.is_null(), "invalid Luau buffer");
@@ -67,15 +88,76 @@ impl Buffer {
    }

    #[cfg(not(feature = "luau"))]
-    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
        unreachable!()
    }
 }

+struct BufferCursor(Buffer, usize);
+
+impl io::Read for BufferCursor {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice(&lua);
+        if self.1 == data.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(data.len() - self.1);
+        buf[..len].copy_from_slice(&data[self.1..self.1 + len]);
+        self.1 += len;
+        Ok(len)
+    }
+}
+
+impl io::Write for BufferCursor {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice_mut(&lua);
+        if self.1 == data.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(data.len() - self.1);
+        data[self.1..self.1 + len].copy_from_slice(&buf[..len]);
+        self.1 += len;
+        Ok(len)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl io::Seek for BufferCursor {
+    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice(&lua);
+        let new_offset = match pos {
+            io::SeekFrom::Start(offset) => offset as i64,
+            io::SeekFrom::End(offset) => data.len() as i64 + offset,
+            io::SeekFrom::Current(offset) => self.1 as i64 + offset,
+        };
+        if new_offset < 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to a negative position",
+            ));
+        }
+        if new_offset as usize > data.len() {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to a position beyond the end of the buffer",
+            ));
+        }
+        self.1 = new_offset as usize;
+        Ok(self.1 as u64)
+    }
+}
+
 #[cfg(feature = "serde")]
 impl Serialize for Buffer {
    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
-        serializer.serialize_bytes(unsafe { self.as_slice() })
+        let lua = self.0.lua.lock();
+        serializer.serialize_bytes(self.as_slice(&lua))
    }
 }

@@ -160,18 +160,39 @@ pub enum CompileConstant {
    Boolean(bool),
    Number(crate::Number),
    Vector(crate::Vector),
-    String(String),
+    String(StdString),
 }

-#[cfg(feature = "luau")]
-impl From<&'static str> for CompileConstant {
-    fn from(s: &'static str) -> Self {
-        CompileConstant::String(s.to_string())
+#[cfg(any(feature = "luau", doc))]
+impl From<bool> for CompileConstant {
+    fn from(b: bool) -> Self {
+        CompileConstant::Boolean(b)
    }
 }

 #[cfg(any(feature = "luau", doc))]
-type LibraryMemberConstantMap = std::sync::Arc<HashMap<(String, String), CompileConstant>>;
+impl From<crate::Number> for CompileConstant {
+    fn from(n: crate::Number) -> Self {
+        CompileConstant::Number(n)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<crate::Vector> for CompileConstant {
+    fn from(v: crate::Vector) -> Self {
+        CompileConstant::Vector(v)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<&str> for CompileConstant {
+    fn from(s: &str) -> Self {
+        CompileConstant::String(s.to_owned())
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+type LibraryMemberConstantMap = HashMap<(StdString, StdString), CompileConstant>;

 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
@@ -182,14 +203,14 @@ pub struct Compiler {
    debug_level: u8,
    type_info_level: u8,
    coverage_level: u8,
-    vector_lib: Option<String>,
-    vector_ctor: Option<String>,
-    vector_type: Option<String>,
-    mutable_globals: Vec<String>,
-    userdata_types: Vec<String>,
-    libraries_with_known_members: Vec<String>,
+    vector_lib: Option<StdString>,
+    vector_ctor: Option<StdString>,
+    vector_type: Option<StdString>,
+    mutable_globals: Vec<StdString>,
+    userdata_types: Vec<StdString>,
+    libraries_with_known_members: Vec<StdString>,
    library_constants: Option<LibraryMemberConstantMap>,
-    disabled_builtins: Vec<String>,
+    disabled_builtins: Vec<StdString>,
 }

 #[cfg(any(feature = "luau", doc))]
@@ -267,70 +288,102 @@ impl Compiler {
        self
    }

+    /// Sets alternative global builtin to construct vectors, in addition to default builtin
+    /// `vector.create`.
+    ///
+    /// To set the library and method name, use the `lib.ctor` format.
    #[doc(hidden)]
    #[must_use]
-    pub fn set_vector_lib(mut self, lib: impl Into<String>) -> Self {
-        self.vector_lib = Some(lib.into());
+    pub fn set_vector_ctor(mut self, ctor: impl Into<StdString>) -> Self {
+        let ctor = ctor.into();
+        let lib_ctor = ctor.split_once('.');
+        self.vector_lib = lib_ctor.as_ref().map(|&(lib, _)| lib.to_owned());
+        self.vector_ctor = (lib_ctor.as_ref())
+            .map(|&(_, ctor)| ctor.to_owned())
+            .or(Some(ctor));
        self
    }

+    /// Sets alternative vector type name for type tables, in addition to default type `vector`.
    #[doc(hidden)]
    #[must_use]
-    pub fn set_vector_ctor(mut self, ctor: impl Into<String>) -> Self {
-        self.vector_ctor = Some(ctor.into());
-        self
-    }
-
-    #[doc(hidden)]
-    #[must_use]
-    pub fn set_vector_type(mut self, r#type: impl Into<String>) -> Self {
+    pub fn set_vector_type(mut self, r#type: impl Into<StdString>) -> Self {
        self.vector_type = Some(r#type.into());
        self
    }

+    /// Adds a mutable global.
+    ///
+    /// It disables the import optimization for fields accessed through it.
+    #[must_use]
+    pub fn add_mutable_global(mut self, global: impl Into<StdString>) -> Self {
+        self.mutable_globals.push(global.into());
+        self
+    }
+
    /// Sets a list of globals that are mutable.
    ///
    /// It disables the import optimization for fields accessed through these.
    #[must_use]
-    pub fn set_mutable_globals<S: Into<String>>(mut self, globals: Vec<S>) -> Self {
+    pub fn set_mutable_globals<S: Into<StdString>>(mut self, globals: impl IntoIterator<Item = S>) -> Self {
        self.mutable_globals = globals.into_iter().map(|s| s.into()).collect();
        self
    }

+    /// Adds a userdata type to the list that will be included in the type information.
+    #[must_use]
+    pub fn add_userdata_type(mut self, r#type: impl Into<StdString>) -> Self {
+        self.userdata_types.push(r#type.into());
+        self
+    }
+
    /// Sets a list of userdata types that will be included in the type information.
    #[must_use]
-    pub fn set_userdata_types<S: Into<String>>(mut self, types: Vec<S>) -> Self {
+    pub fn set_userdata_types<S: Into<StdString>>(mut self, types: impl IntoIterator<Item = S>) -> Self {
        self.userdata_types = types.into_iter().map(|s| s.into()).collect();
        self
    }

-    /// Sets constants for known library members.
+    /// Adds a constant for a known library member.
    ///
    /// The constants are used by the compiler to optimize the generated bytecode.
    /// Optimization level must be at least 2 for this to have any effect.
    ///
-    /// The first element of the tuple is the library name,the second is the member name, and the
-    /// third is the constant value.
+    /// The `name` is a string in the format `lib.member`, where `lib` is the library name
+    /// and `member` is the member (constant) name.
    #[must_use]
-    pub fn set_library_constants<L, M>(mut self, constants: Vec<(L, M, CompileConstant)>) -> Self
-    where
-        L: Into<String>,
-        M: Into<String>,
-    {
-        let map = constants
-            .into_iter()
-            .map(|(lib, member, cons)| ((lib.into(), member.into()), cons))
-            .collect::<HashMap<_, _>>();
-        self.library_constants = Some(std::sync::Arc::new(map));
-        self.libraries_with_known_members = (self.library_constants.clone())
-            .map(|map| map.keys().map(|(lib, _)| lib.clone()).collect())
-            .unwrap_or_default();
+    pub fn add_library_constant(
+        mut self,
+        name: impl AsRef<str>,
+        r#const: impl Into<CompileConstant>,
+    ) -> Self {
+        let Some((lib, member)) = name.as_ref().split_once('.') else {
+            return self;
+        };
+        let (lib, member) = (lib.to_owned(), member.to_owned());
+
+        if !self.libraries_with_known_members.contains(&lib) {
+            self.libraries_with_known_members.push(lib.clone());
+        }
+        self.library_constants
+            .get_or_insert_with(HashMap::new)
+            .insert((lib, member), r#const.into());
+        self
+    }
+
+    /// Adds a builtin that should be disabled.
+    #[must_use]
+    pub fn add_disabled_builtin(mut self, builtin: impl Into<StdString>) -> Self {
+        self.disabled_builtins.push(builtin.into());
        self
    }

    /// Sets a list of builtins that should be disabled.
    #[must_use]
-    pub fn set_disabled_builtins<S: Into<String>>(mut self, builtins: Vec<S>) -> Self {
+    pub fn set_disabled_builtins<S: Into<StdString>>(
+        mut self,
+        builtins: impl IntoIterator<Item = S>,
+    ) -> Self {
        self.disabled_builtins = builtins.into_iter().map(|s| s.into()).collect();
        self
    }
@@ -437,7 +490,7 @@ impl Compiler {
        if bytecode.first() == Some(&0) {
            // The rest of the bytecode is the error message starting with `:`
            // See https://github.com/luau-lang/luau/blob/0.640/Compiler/src/Compiler.cpp#L4336
-            let message = String::from_utf8_lossy(&bytecode[2..]).to_string();
+            let message = StdString::from_utf8_lossy(&bytecode[2..]).into_owned();
            return Err(Error::SyntaxError {
                incomplete_input: message.ends_with("<eof>"),
                message,
@@ -460,7 +513,7 @@ impl Chunk<'_> {
    /// - `@` - file path (when truncation is needed, the end of the file path is kept, as this is
    ///   more useful for identifying the file)
    /// - `=` - custom chunk name (when truncation is needed, the beginning of the name is kept)
-    pub fn set_name(mut self, name: impl Into<String>) -> Self {
+    pub fn set_name(mut self, name: impl Into<StdString>) -> Self {
        self.name = name.into();
        self
    }
@@ -708,7 +761,7 @@ impl Chunk<'_> {
        ChunkMode::Text
    }

-    fn convert_name(name: String) -> Result<CString> {
+    fn convert_name(name: StdString) -> Result<CString> {
        CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
    }

@@ -645,7 +645,7 @@ impl FromLua for BString {
        match value {
            Value::String(s) => Ok((*s.as_bytes()).into()),
            #[cfg(feature = "luau")]
-            Value::Buffer(buf) => unsafe { Ok(buf.as_slice().into()) },
+            Value::Buffer(buf) => Ok(buf.to_vec().into()),
            _ => Ok((*lua
                .coerce_string(value)?
                .ok_or_else(|| Error::FromLuaConversionError {
@@ -1,66 +1,33 @@
 use std::borrow::Cow;
-use std::cell::UnsafeCell;
-use std::ops::Deref;
-#[cfg(not(feature = "luau"))]
-use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::c_int;

-use ffi::lua_Debug;
+use ffi::{lua_Debug, lua_State};

+use crate::function::Function;
 use crate::state::RawLua;
-use crate::types::ReentrantMutexGuard;
-use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
+use crate::util::{assert_stack, linenumber_to_usize, ptr_to_lossy_str, ptr_to_str, StackGuard};

 /// Contains information about currently executing Lua code.
 ///
-/// The `Debug` structure is provided as a parameter to the hook function set with
-/// [`Lua::set_hook`]. You may call the methods on this structure to retrieve information about the
-/// Lua code executing at the time that the hook function was called. Further information can be
-/// found in the Lua [documentation].
+/// You may call the methods on this structure to retrieve information about the Lua code executing
+/// at the specific level. Further information can be found in the Lua [documentation].
 ///
 /// [documentation]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
-/// [`Lua::set_hook`]: crate::Lua::set_hook
 pub struct Debug<'a> {
-    lua: EitherLua<'a>,
-    ar: ActivationRecord,
-    #[cfg(feature = "luau")]
+    state: *mut lua_State,
+    lua: &'a RawLua,
+    #[cfg_attr(not(feature = "luau"), allow(unused))]
    level: c_int,
-}
-
-enum EitherLua<'a> {
-    Owned(ReentrantMutexGuard<'a, RawLua>),
-    #[cfg(not(feature = "luau"))]
-    Borrowed(&'a RawLua),
-}
-
-impl Deref for EitherLua<'_> {
-    type Target = RawLua;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            EitherLua::Owned(guard) => guard,
-            #[cfg(not(feature = "luau"))]
-            EitherLua::Borrowed(lua) => lua,
-        }
-    }
+    ar: *mut lua_Debug,
 }

 impl<'a> Debug<'a> {
-    // We assume the lock is held when this function is called.
-    #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'a RawLua, ar: *mut lua_Debug) -> Self {
+    pub(crate) fn new(lua: &'a RawLua, level: c_int, ar: *mut lua_Debug) -> Self {
        Debug {
-            lua: EitherLua::Borrowed(lua),
-            ar: ActivationRecord::Borrowed(ar),
-        }
-    }
-
-    pub(crate) fn new_owned(guard: ReentrantMutexGuard<'a, RawLua>, _level: c_int, ar: lua_Debug) -> Self {
-        Debug {
-            lua: EitherLua::Owned(guard),
-            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
-            #[cfg(feature = "luau")]
-            level: _level,
+            state: lua.state(),
+            lua,
+            ar,
+            level,
        }
    }

@@ -74,7 +41,7 @@ impl<'a> Debug<'a> {
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn event(&self) -> DebugEvent {
        unsafe {
-            match (*self.ar.get()).event {
+            match (*self.ar).event {
                ffi::LUA_HOOKCALL => DebugEvent::Call,
                ffi::LUA_HOOKRET => DebugEvent::Ret,
                ffi::LUA_HOOKTAILCALL => DebugEvent::TailCall,
@@ -85,24 +52,48 @@ impl<'a> Debug<'a> {
        }
    }

-    /// Corresponds to the `n` what mask.
+    /// Returns the function that is running at the given level.
+    ///
+    /// Corresponds to the `f` "what" mask.
+    pub fn function(&self) -> Function {
+        unsafe {
+            let _sg = StackGuard::new(self.state);
+            assert_stack(self.state, 1);
+
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+
+            ffi::lua_xmove(self.state, self.lua.ref_thread(), 1);
+            Function(self.lua.pop_ref_thread())
+        }
+    }
+
+    /// Corresponds to the `n` "what" mask.
    pub fn names(&self) -> DebugNames<'_> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("n"), self.ar) != 0,
                "lua_getinfo failed with `n`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("n"), self.ar) != 0,
                "lua_getinfo failed with `n`"
            );

            DebugNames {
-                name: ptr_to_lossy_str((*self.ar.get()).name),
+                name: ptr_to_lossy_str((*self.ar).name),
                #[cfg(not(feature = "luau"))]
-                name_what: match ptr_to_str((*self.ar.get()).namewhat) {
+                name_what: match ptr_to_str((*self.ar).namewhat) {
                    Some("") => None,
                    val => val,
                },
@@ -112,118 +103,110 @@ impl<'a> Debug<'a> {
        }
    }

-    /// Corresponds to the `S` what mask.
+    /// Corresponds to the `S` "what" mask.
    pub fn source(&self) -> DebugSource<'_> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("S"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("S"), self.ar) != 0,
                "lua_getinfo failed with `S`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("s"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("s"), self.ar) != 0,
                "lua_getinfo failed with `s`"
            );

            DebugSource {
-                source: ptr_to_lossy_str((*self.ar.get()).source),
+                source: ptr_to_lossy_str((*self.ar).source),
                #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_lossy_str((*self.ar.get()).short_src.as_ptr()),
+                short_src: ptr_to_lossy_str((*self.ar).short_src.as_ptr()),
                #[cfg(feature = "luau")]
-                short_src: ptr_to_lossy_str((*self.ar.get()).short_src),
-                line_defined: linenumber_to_usize((*self.ar.get()).linedefined),
+                short_src: ptr_to_lossy_str((*self.ar).short_src),
+                line_defined: linenumber_to_usize((*self.ar).linedefined),
                #[cfg(not(feature = "luau"))]
-                last_line_defined: linenumber_to_usize((*self.ar.get()).lastlinedefined),
+                last_line_defined: linenumber_to_usize((*self.ar).lastlinedefined),
                #[cfg(feature = "luau")]
                last_line_defined: None,
-                what: ptr_to_str((*self.ar.get()).what).unwrap_or("main"),
+                what: ptr_to_str((*self.ar).what).unwrap_or("main"),
            }
        }
    }

-    /// Corresponds to the `l` what mask. Returns the current line.
+    #[doc(hidden)]
+    #[deprecated(note = "Use `current_line` instead")]
    pub fn curr_line(&self) -> i32 {
+        self.current_line().map(|n| n as i32).unwrap_or(-1)
+    }
+
+    /// Corresponds to the `l` "what" mask. Returns the current line.
+    pub fn current_line(&self) -> Option<usize> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("l"), self.ar) != 0,
                "lua_getinfo failed with `l`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("l"), self.ar) != 0,
                "lua_getinfo failed with `l`"
            );

-            (*self.ar.get()).currentline
+            linenumber_to_usize((*self.ar).currentline)
        }
    }

-    /// 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"))))]
+    /// Corresponds to the `t` "what" mask. Returns true if the hook is in a function tail call,
+    /// false otherwise.
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52")))
+    )]
    pub fn is_tail_call(&self) -> bool {
        unsafe {
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("t"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("t"), self.ar) != 0,
                "lua_getinfo failed with `t`"
            );
-            (*self.ar.get()).currentline != 0
+            (*self.ar).istailcall != 0
        }
    }

-    /// Corresponds to the `u` what mask.
+    /// Corresponds to the `u` "what" mask.
    pub fn stack(&self) -> DebugStack {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("u"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("u"), self.ar) != 0,
                "lua_getinfo failed with `u`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("au"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("au"), self.ar) != 0,
                "lua_getinfo failed with `au`"
            );

            #[cfg(not(feature = "luau"))]
            let stack = DebugStack {
-                num_ups: (*self.ar.get()).nups as _,
+                num_ups: (*self.ar).nups as _,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as _,
+                num_params: (*self.ar).nparams as _,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar.get()).isvararg != 0,
+                is_vararg: (*self.ar).isvararg != 0,
            };
            #[cfg(feature = "luau")]
            let stack = DebugStack {
-                num_ups: (*self.ar.get()).nupvals,
-                num_params: (*self.ar.get()).nparams,
-                is_vararg: (*self.ar.get()).isvararg != 0,
+                num_ups: (*self.ar).nupvals,
+                num_params: (*self.ar).nparams,
+                is_vararg: (*self.ar).isvararg != 0,
            };
            stack
        }
    }
 }

-enum ActivationRecord {
-    #[cfg(not(feature = "luau"))]
-    Borrowed(*mut lua_Debug),
-    Owned(UnsafeCell<lua_Debug>),
-}
-
-impl ActivationRecord {
-    #[inline]
-    fn get(&self) -> *mut lua_Debug {
-        match self {
-            #[cfg(not(feature = "luau"))]
-            ActivationRecord::Borrowed(x) => *x,
-            ActivationRecord::Owned(x) => x.get(),
-        }
-    }
-}
-
 /// Represents a specific event that triggered the hook.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum DebugEvent {
@@ -382,7 +365,7 @@ impl HookTriggers {
 }

 #[cfg(not(feature = "luau"))]
-impl BitOr for HookTriggers {
+impl std::ops::BitOr for HookTriggers {
    type Output = Self;

    fn bitor(mut self, rhs: Self) -> Self::Output {
@@ -397,7 +380,7 @@ impl BitOr for HookTriggers {
 }

 #[cfg(not(feature = "luau"))]
-impl BitOrAssign for HookTriggers {
+impl std::ops::BitOrAssign for HookTriggers {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = *self | rhs;
    }
@@ -434,7 +434,7 @@ impl Function {
    /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn coverage<F>(&self, mut func: F)
+    pub fn coverage<F>(&self, func: F)
    where
        F: FnMut(CoverageInfo),
    {
@@ -454,13 +454,16 @@ impl Function {
            } else {
                None
            };
-            let rust_callback = &mut *(data as *mut F);
-            rust_callback(CoverageInfo {
-                function,
-                line_defined,
-                depth,
-                hits: slice::from_raw_parts(hits, size).to_vec(),
-            });
+            let rust_callback = &*(data as *const RefCell<F>);
+            if let Ok(mut rust_callback) = rust_callback.try_borrow_mut() {
+                // Call the Rust callback with CoverageInfo
+                rust_callback(CoverageInfo {
+                    function,
+                    line_defined,
+                    depth,
+                    hits: slice::from_raw_parts(hits, size).to_vec(),
+                });
+            }
        }

        let lua = self.0.lua.lock();
@@ -470,7 +473,8 @@ impl Function {
            assert_stack(state, 1);

            lua.push_ref(&self.0);
-            let func_ptr = &mut func as *mut F as *mut c_void;
+            let func = RefCell::new(func);
+            let func_ptr = &func as *const RefCell<F> as *mut c_void;
            ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
        }
    }
@@ -653,6 +657,13 @@ impl LuaType for Function {
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncCallFuture<R: FromLuaMulti>(Result<AsyncThread<R>>);

+#[cfg(feature = "async")]
+impl<R: FromLuaMulti> AsyncCallFuture<R> {
+    pub(crate) fn error(err: Error) -> Self {
+        AsyncCallFuture(Err(err))
+    }
+}
+
 #[cfg(feature = "async")]
 impl<R: FromLuaMulti> Future for AsyncCallFuture<R> {
    type Output = Result<R>;
@@ -75,9 +75,9 @@ mod macros;
 mod buffer;
 mod chunk;
 mod conversion;
+mod debug;
 mod error;
 mod function;
-mod hook;
 #[cfg(any(feature = "luau", doc))]
 mod luau;
 mod memory;
@@ -101,9 +101,9 @@ pub use bstr::BString;
 pub use ffi::{self, lua_CFunction, lua_State};

 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
+pub use crate::debug::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
 pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
-pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
 pub use crate::multi::{MultiValue, Variadic};
 pub use crate::scope::Scope;
 pub use crate::state::{GCMode, Lua, LuaOptions, WeakLua};
@@ -124,7 +124,7 @@ pub use crate::userdata::{
 pub use crate::value::{Nil, Value};

 #[cfg(not(feature = "luau"))]
-pub use crate::hook::HookTriggers;
+pub use crate::debug::HookTriggers;

 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
@@ -7,6 +7,7 @@ use crate::error::Result;
 use crate::function::Function;
 use crate::state::{callback_error_ext, ExtraData, Lua};
 use crate::traits::{FromLuaMulti, IntoLua};
+use crate::types::MaybeSend;

 pub use require::{NavigateError, Require, TextRequirer};

@@ -17,7 +18,7 @@ impl Lua {
    /// and load modules.
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn create_require_function<R: Require + 'static>(&self, require: R) -> Result<Function> {
+    pub fn create_require_function<R: Require + MaybeSend + 'static>(&self, require: R) -> Result<Function> {
        require::create_require_function(self, require)
    }

@@ -14,7 +14,7 @@ use crate::state::{callback_error_ext, Lua};
 use crate::table::Table;
 use crate::types::MaybeSend;

-/// An error that can occur during navigation in the Luau `require` system.
+/// An error that can occur during navigation in the Luau `require-by-string` system.
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 #[derive(Debug, Clone)]
@@ -50,10 +50,10 @@ impl From<Error> for NavigateError {
 #[cfg(feature = "luau")]
 type WriteResult = ffi::luarequire_WriteResult;

-/// A trait for handling modules loading and navigation in the Luau `require` system.
+/// A trait for handling modules loading and navigation in the Luau `require-by-string` system.
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub trait Require: MaybeSend {
+pub trait Require {
    /// Returns `true` if "require" is permitted for the given chunk name.
    fn is_require_allowed(&self, chunk_name: &str) -> bool;

@@ -103,23 +103,33 @@ impl fmt::Debug for dyn Require {
    }
 }

-/// The standard implementation of Luau `require` navigation.
-#[doc(hidden)]
+/// The standard implementation of Luau `require-by-string` navigation.
 #[derive(Default, Debug)]
 pub struct TextRequirer {
+    /// An absolute path to the current Luau module (not mapped to a physical file)
    abs_path: PathBuf,
+    /// A relative path to the current Luau module (not mapped to a physical file)
    rel_path: PathBuf,
-    module_path: PathBuf,
+    /// A physical path to the current Luau module, which is a file or a directory with an
+    /// `init.lua(u)` file
+    resolved_path: Option<PathBuf>,
 }

 impl TextRequirer {
+    /// The prefix used for chunk names in the require system.
+    /// Only chunk names starting with this prefix are allowed to be used in `require`.
+    const CHUNK_PREFIX: &str = "@";
+
+    /// The file extensions that are considered valid for Luau modules.
+    const FILE_EXTENSIONS: &[&str] = &["luau", "lua"];
+
    /// Creates a new `TextRequirer` instance.
    pub fn new() -> Self {
        Self::default()
    }

    fn normalize_chunk_name(chunk_name: &str) -> &str {
-        if let Some((path, line)) = chunk_name.split_once(':') {
+        if let Some((path, line)) = chunk_name.rsplit_once(':') {
            if line.parse::<u32>().is_ok() {
                return path;
            }
@@ -156,14 +166,17 @@ impl TextRequirer {
        components.into_iter().collect()
    }

-    fn find_module(path: &Path) -> StdResult<PathBuf, NavigateError> {
+    /// Resolve a Luau module path to a physical file or directory.
+    ///
+    /// Empty directories without init files are considered valid as "intermediate" directories.
+    fn resolve_module(path: &Path) -> StdResult<Option<PathBuf>, NavigateError> {
        let mut found_path = None;

        if path.components().next_back() != Some(Component::Normal("init".as_ref())) {
            let current_ext = (path.extension().and_then(|s| s.to_str()))
                .map(|s| format!("{s}."))
                .unwrap_or_default();
-            for ext in ["luau", "lua"] {
+            for ext in Self::FILE_EXTENSIONS {
                let candidate = path.with_extension(format!("{current_ext}{ext}"));
                if candidate.is_file() && found_path.replace(candidate).is_some() {
                    return Err(NavigateError::Ambiguous);
@@ -171,7 +184,7 @@ impl TextRequirer {
            }
        }
        if path.is_dir() {
-            for component in ["init.luau", "init.lua"] {
+            for component in Self::FILE_EXTENSIONS.iter().map(|ext| format!("init.{ext}")) {
                let candidate = path.join(component);
                if candidate.is_file() && found_path.replace(candidate).is_some() {
                    return Err(NavigateError::Ambiguous);
@@ -179,21 +192,22 @@ impl TextRequirer {
            }

            if found_path.is_none() {
-                found_path = Some(PathBuf::new());
+                // Directories without init files are considered valid "intermediate" path
+                return Ok(None);
            }
        }

-        found_path.ok_or(NavigateError::NotFound)
+        Ok(Some(found_path.ok_or(NavigateError::NotFound)?))
    }
 }

 impl Require for TextRequirer {
    fn is_require_allowed(&self, chunk_name: &str) -> bool {
-        chunk_name.starts_with('@')
+        chunk_name.starts_with(Self::CHUNK_PREFIX)
    }

    fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
-        if !chunk_name.starts_with('@') {
+        if !chunk_name.starts_with(Self::CHUNK_PREFIX) {
            return Err(NavigateError::NotFound);
        }
        let chunk_name = Self::normalize_chunk_name(&chunk_name[1..]);
@@ -205,24 +219,24 @@ impl Require for TextRequirer {
            let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
            self.abs_path = Self::normalize_path(&cwd.join(chunk_filename));
            self.rel_path = ([Component::CurDir, Component::Normal(chunk_filename)].into_iter()).collect();
-            self.module_path = PathBuf::new();
+            self.resolved_path = None;

            return Ok(());
        }

        if chunk_path.is_absolute() {
-            let module_path = Self::find_module(&chunk_path)?;
+            let resolved_path = Self::resolve_module(&chunk_path)?;
            self.abs_path = chunk_path.clone();
            self.rel_path = chunk_path;
-            self.module_path = module_path;
+            self.resolved_path = resolved_path;
        } else {
            // Relative path
            let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
            let abs_path = Self::normalize_path(&cwd.join(&chunk_path));
-            let module_path = Self::find_module(&abs_path)?;
+            let resolved_path = Self::resolve_module(&abs_path)?;
            self.abs_path = abs_path;
            self.rel_path = chunk_path;
-            self.module_path = module_path;
+            self.resolved_path = resolved_path;
        }

        Ok(())
@@ -230,11 +244,11 @@ impl Require for TextRequirer {

    fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
        let path = Self::normalize_path(path.as_ref());
-        let module_path = Self::find_module(&path)?;
+        let resolved_path = Self::resolve_module(&path)?;

        self.abs_path = path.clone();
        self.rel_path = path;
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;

        Ok(())
    }
@@ -242,15 +256,18 @@ impl Require for TextRequirer {
    fn to_parent(&mut self) -> StdResult<(), NavigateError> {
        let mut abs_path = self.abs_path.clone();
        if !abs_path.pop() {
+            // It's important to return `NotFound` if we reached the root, as it's a "recoverable" error if we
+            // cannot go beyond the root directory.
+            // Luau "require-by-string` has a special logic to search for config file to resolve aliases.
            return Err(NavigateError::NotFound);
        }
        let mut rel_parent = self.rel_path.clone();
        rel_parent.pop();
-        let module_path = Self::find_module(&abs_path)?;
+        let resolved_path = Self::resolve_module(&abs_path)?;

        self.abs_path = abs_path;
        self.rel_path = Self::normalize_path(&rel_parent);
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;

        Ok(())
    }
@@ -258,21 +275,23 @@ impl Require for TextRequirer {
    fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError> {
        let abs_path = self.abs_path.join(name);
        let rel_path = self.rel_path.join(name);
-        let module_path = Self::find_module(&abs_path)?;
+        let resolved_path = Self::resolve_module(&abs_path)?;

        self.abs_path = abs_path;
        self.rel_path = rel_path;
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;

        Ok(())
    }

    fn has_module(&self) -> bool {
-        self.module_path.is_file()
+        (self.resolved_path.as_deref())
+            .map(Path::is_file)
+            .unwrap_or(false)
    }

    fn cache_key(&self) -> String {
-        self.module_path.display().to_string()
+        self.resolved_path.as_deref().unwrap().display().to_string()
    }

    fn has_config(&self) -> bool {
@@ -285,7 +304,9 @@ impl Require for TextRequirer {

    fn loader(&self, lua: &Lua) -> Result<Function> {
        let name = format!("@{}", self.rel_path.display());
-        lua.load(&*self.module_path).set_name(name).into_function()
+        lua.load(self.resolved_path.as_deref().unwrap())
+            .set_name(name)
+            .into_function()
    }
 }

@@ -496,7 +517,10 @@ unsafe fn write_to_buffer(
 }

 #[cfg(feature = "luau")]
-pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> Result<Function> {
+pub(super) fn create_require_function<R: Require + MaybeSend + 'static>(
+    lua: &Lua,
+    require: R,
+) -> Result<Function> {
    unsafe extern "C-unwind" fn find_current_file(state: *mut ffi::lua_State) -> c_int {
        let mut ar: ffi::lua_Debug = mem::zeroed();
        for level in 2.. {
@@ -543,10 +567,26 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
        1
    }

-    let (error, r#type) = unsafe {
-        lua.exec_raw::<(Function, Function)>((), move |state| {
+    unsafe extern "C-unwind" fn to_lowercase(state: *mut ffi::lua_State) -> c_int {
+        let s = ffi::luaL_checkstring(state, 1);
+        let s = CStr::from_ptr(s);
+        if !s.to_bytes().iter().any(|&c| c.is_ascii_uppercase()) {
+            // If the string does not contain any uppercase ASCII letters, return it as is
+            return 1;
+        }
+        callback_error_ext(state, ptr::null_mut(), true, |extra, _| {
+            let s = (s.to_bytes().iter())
+                .map(|&c| c.to_ascii_lowercase())
+                .collect::<bstr::BString>();
+            (*extra).raw_lua().push(s).map(|_| 1)
+        })
+    }
+
+    let (error, r#type, to_lowercase) = unsafe {
+        lua.exec_raw::<(Function, Function, Function)>((), move |state| {
            ffi::lua_pushcfunctiond(state, error, cstr!("error"));
            ffi::lua_pushcfunctiond(state, r#type, cstr!("type"));
+            ffi::lua_pushcfunctiond(state, to_lowercase, cstr!("to_lowercase"));
        })
    }?;

@@ -559,6 +599,7 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
    env.raw_set("LOADER_CACHE", loader_cache)?;
    env.raw_set("error", error)?;
    env.raw_set("type", r#type)?;
+    env.raw_set("to_lowercase", to_lowercase)?;

    lua.load(
        r#"
@@ -568,7 +609,7 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
        end

        -- Check if the module (path) is explicitly registered
-        local maybe_result = REGISTERED_MODULES[path]
+        local maybe_result = REGISTERED_MODULES[to_lowercase(path)]
        if maybe_result ~= nil then
            return maybe_result
        end
@@ -297,6 +297,15 @@ impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
        MultiValue::from_lua_iter(lua, self)
    }
+
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        let nresults = self.len() as i32;
+        check_stack(lua.state(), nresults + 1)?;
+        for value in self.0 {
+            value.push_into_stack(lua)?;
+        }
+        Ok(nresults)
+    }
 }

 impl<T: FromLua> FromLuaMulti for Variadic<T> {
@@ -25,7 +25,8 @@ pub use crate::HookTriggers as LuaHookTriggers;
 #[doc(no_inline)]
 pub use crate::{
    CompileConstant as LuaCompileConstant, CoverageInfo as LuaCoverageInfo,
-    NavigateError as LuaNavigateError, Require as LuaRequire, Vector as LuaVector,
+    NavigateError as LuaNavigateError, Require as LuaRequire, TextRequirer as LuaTextRequirer,
+    Vector as LuaVector,
 };

 #[cfg(feature = "async")]
@@ -165,7 +165,10 @@ impl<'de> serde::Deserializer<'de> for Deserializer {
                serde_userdata(ud, |value| value.deserialize_any(visitor))
            }
            #[cfg(feature = "luau")]
-            Value::Buffer(buf) => visitor.visit_bytes(unsafe { buf.as_slice() }),
+            Value::Buffer(buf) => {
+                let lua = buf.0.lua.lock();
+                visitor.visit_bytes(buf.as_slice(&lua))
+            }
            Value::Function(_)
            | Value::Thread(_)
            | Value::UserData(_)
@@ -256,7 +256,7 @@ impl<'a> ser::Serializer for Serializer<'a> {
    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let table = self.lua.create_table_with_capacity(len.unwrap_or(0), 0)?;
        if self.options.set_array_metatable {
-            table.set_metatable(Some(self.lua.array_metatable()));
+            table.set_metatable(Some(self.lua.array_metatable()))?;
        }
        Ok(SerializeSeq::new(self.lua, table, self.options))
    }
@@ -529,8 +529,8 @@ impl ser::SerializeStruct for SerializeStruct<'_> {
    fn end(self) -> Result<Value> {
        match self.inner {
            Some(table @ Value::Table(_)) => Ok(table),
-            Some(value) if self.options.detect_serde_json_arbitrary_precision => {
-                let number_s = value.as_str().expect("not an arbitrary precision number");
+            Some(value @ Value::String(_)) if self.options.detect_serde_json_arbitrary_precision => {
+                let number_s = value.to_string()?;
                if number_s.contains(['.', 'e', 'E']) {
                    if let Ok(number) = number_s.parse().map(Value::Number) {
                        return Ok(number);
@@ -8,9 +8,9 @@ use std::result::Result as StdResult;
 use std::{fmt, mem, ptr};

 use crate::chunk::{AsChunk, Chunk};
+use crate::debug::Debug;
 use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::hook::Debug;
 use crate::memory::MemoryState;
 use crate::multi::MultiValue;
 use crate::scope::Scope;
@@ -28,7 +28,7 @@ use crate::util::{assert_stack, check_stack, protect_lua_closure, push_string, r
 use crate::value::{Nil, Value};

 #[cfg(not(feature = "luau"))]
-use crate::{hook::HookTriggers, types::HookKind};
+use crate::{debug::HookTriggers, types::HookKind};

 #[cfg(any(feature = "luau", doc))]
 use crate::{buffer::Buffer, chunk::Compiler};
@@ -37,6 +37,7 @@ use crate::{buffer::Buffer, chunk::Compiler};
 use {
    crate::types::LightUserData,
    std::future::{self, Future},
+    std::task::Poll,
 };

 #[cfg(feature = "serde")]
@@ -358,6 +359,8 @@ impl Lua {
        if cfg!(feature = "luau") && !modname.starts_with('@') {
            return Err(Error::runtime("module name must begin with '@'"));
        }
+        #[cfg(feature = "luau")]
+        let modname = modname.to_ascii_lowercase();
        unsafe {
            self.exec_raw::<()>(value, |state| {
                ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, LOADED_MODULES_KEY);
@@ -544,7 +547,7 @@ impl Lua {
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn set_global_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
    where
-        F: Fn(&Lua, Debug) -> Result<VmState> + MaybeSend + 'static,
+        F: Fn(&Lua, &Debug) -> Result<VmState> + MaybeSend + 'static,
    {
        let lua = self.lock();
        unsafe {
@@ -577,7 +580,7 @@ impl Lua {
    /// # fn main() -> Result<()> {
    /// let lua = Lua::new();
    /// lua.set_hook(HookTriggers::EVERY_LINE, |_lua, debug| {
-    ///     println!("line {}", debug.curr_line());
+    ///     println!("line {:?}", debug.current_line());
    ///     Ok(VmState::Continue)
    /// });
    ///
@@ -594,7 +597,7 @@ impl Lua {
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
    where
-        F: Fn(&Lua, Debug) -> Result<VmState> + MaybeSend + 'static,
+        F: Fn(&Lua, &Debug) -> Result<VmState> + MaybeSend + 'static,
    {
        let lua = self.lock();
        unsafe { lua.set_thread_hook(lua.state(), HookKind::Thread(triggers, XRc::new(callback))) }
@@ -629,13 +632,13 @@ impl Lua {
    ///
    /// Any Luau code is guaranteed to call this handler "eventually"
    /// (in practice this can happen at any function call or at any loop iteration).
+    /// This is similar to `Lua::set_hook` but in more simplified form.
    ///
    /// 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.
+    /// yield by returning [`VmState::Yield`]. The yield will happen only at yieldable points
+    /// of execution (not across metamethod/C-call boundaries).
    ///
    /// # Example
    ///
@@ -693,7 +696,10 @@ impl Lua {
            match result {
                VmState::Continue => {}
                VmState::Yield => {
-                    ffi::lua_yield(state, 0);
+                    // We can yield only at yieldable points, otherwise ignore and continue
+                    if ffi::lua_isyieldable(state) != 0 {
+                        ffi::lua_yield(state, 0);
+                    }
                }
            }
        }
@@ -869,18 +875,16 @@ impl Lua {
        }
    }

-    /// Gets information about the interpreter runtime stack.
+    /// Gets information about the interpreter runtime stack at a given level.
    ///
-    /// This function returns [`Debug`] structure that can be used to get information about the
-    /// function executing at a given level. Level `0` is the current running function, whereas
-    /// level `n+1` is the function that has called level `n` (except for tail calls, which do
-    /// not count in the stack).
-    ///
-    /// [`Debug`]: crate::hook::Debug
-    pub fn inspect_stack(&self, level: usize) -> Option<Debug<'_>> {
+    /// This function calls callback `f`, passing the [`Debug`] structure that can be used to get
+    /// information about the function executing at a given level.
+    /// Level `0` is the current running function, whereas level `n+1` is the function that has
+    /// called level `n` (except for tail calls, which do not count in the stack).
+    pub fn inspect_stack<R>(&self, level: usize, f: impl FnOnce(&Debug) -> R) -> Option<R> {
        let lua = self.lock();
        unsafe {
-            let mut ar: ffi::lua_Debug = mem::zeroed();
+            let mut ar = mem::zeroed::<ffi::lua_Debug>();
            let level = level as c_int;
            #[cfg(not(feature = "luau"))]
            if ffi::lua_getstack(lua.state(), level, &mut ar) == 0 {
@@ -890,7 +894,8 @@ impl Lua {
            if ffi::lua_getinfo(lua.state(), level, cstr!(""), &mut ar) == 0 {
                return None;
            }
-            Some(Debug::new_owned(lua, level, ar))
+
+            Some(f(&Debug::new(&lua, level, &mut ar)))
        }
    }

@@ -1149,7 +1154,7 @@ impl Lua {
        }
    }

-    /// Create and return an interned Lua string.
+    /// Creates and returns an interned Lua string.
    ///
    /// Lua strings can be arbitrary `[u8]` data including embedded nulls, so in addition to `&str`
    /// and `&String`, you can also pass plain `&[u8]` here.
@@ -1158,27 +1163,32 @@ impl Lua {
        unsafe { self.lock().create_string(s) }
    }

-    /// Create and return a Luau [buffer] object from a byte slice of data.
+    /// Creates and returns a Luau [buffer] object from a byte slice of data.
    ///
    /// [buffer]: https://luau.org/library#buffer-library
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn create_buffer(&self, buf: impl AsRef<[u8]>) -> Result<Buffer> {
+    pub fn create_buffer(&self, data: impl AsRef<[u8]>) -> Result<Buffer> {
        let lua = self.lock();
-        let state = lua.state();
+        let data = data.as_ref();
        unsafe {
-            if lua.unlikely_memory_error() {
-                crate::util::push_buffer(state, buf.as_ref(), false)?;
-                return Ok(Buffer(lua.pop_ref()));
-            }
-
-            let _sg = StackGuard::new(state);
-            check_stack(state, 3)?;
-            crate::util::push_buffer(state, buf.as_ref(), true)?;
-            Ok(Buffer(lua.pop_ref()))
+            let (ptr, buffer) = lua.create_buffer_with_capacity(data.len())?;
+            ptr.copy_from_nonoverlapping(data.as_ptr(), data.len());
+            Ok(buffer)
        }
    }

+    /// Creates and returns a Luau [buffer] object with the specified size.
+    ///
+    /// Size limit is 1GB. All bytes will be initialized to zero.
+    ///
+    /// [buffer]: https://luau.org/library#buffer-library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn create_buffer_with_capacity(&self, size: usize) -> Result<Buffer> {
+        unsafe { Ok(self.lock().create_buffer_with_capacity(size)?.1) }
+    }
+
    /// Creates and returns a new empty table.
    #[inline]
    pub fn create_table(&self) -> Result<Table> {
@@ -1287,8 +1297,24 @@ impl Lua {
    /// This function is unsafe because provides a way to execute unsafe C function.
    pub unsafe fn create_c_function(&self, func: ffi::lua_CFunction) -> Result<Function> {
        let lua = self.lock();
-        ffi::lua_pushcfunction(lua.ref_thread(), func);
-        Ok(Function(lua.pop_ref_thread()))
+        if cfg!(any(feature = "lua54", feature = "lua53", feature = "lua52")) {
+            ffi::lua_pushcfunction(lua.ref_thread(), func);
+            return Ok(Function(lua.pop_ref_thread()));
+        }
+
+        // Lua <5.2 requires memory allocation to push a C function
+        let state = lua.state();
+        {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 3)?;
+
+            if lua.unlikely_memory_error() {
+                ffi::lua_pushcfunction(state, func);
+            } else {
+                protect_lua!(state, 0, 1, |state| ffi::lua_pushcfunction(state, func))?;
+            }
+            Ok(Function(lua.pop_ref()))
+        }
    }

    /// Wraps a Rust async function or closure, creating a callable Lua function handle to it.
@@ -1417,7 +1443,7 @@ impl Lua {
        let lua = self.lock();
        unsafe {
            // Deregister the type if it already registered
-            if let Some(&table_id) = (*lua.extra.get()).registered_userdata_t.get(&type_id) {
+            if let Some(table_id) = (*lua.extra.get()).registered_userdata_t.remove(&type_id) {
                ffi::luaL_unref(lua.state(), ffi::LUA_REGISTRYINDEX, table_id);
            }

@@ -1551,6 +1577,39 @@ impl Lua {
        }
    }

+    /// Sets the global environment.
+    ///
+    /// This will replace the current global environment with the provided `globals` table.
+    ///
+    /// For Lua 5.2+ the globals table is stored in the registry and shared between all threads.
+    /// For Lua 5.1 and Luau the globals table is stored in each thread.
+    ///
+    /// Please note that any existing Lua functions have cached global environment and will not
+    /// see the changes made by this method.
+    /// To update the environment for existing Lua functions, use [`Function::set_environment`].
+    pub fn set_globals(&self, globals: Table) -> Result<()> {
+        let lua = self.lock();
+        let state = lua.state();
+        unsafe {
+            #[cfg(feature = "luau")]
+            if (*lua.extra.get()).sandboxed {
+                return Err(Error::runtime("cannot change globals in a sandboxed Lua state"));
+            }
+
+            let _sg = StackGuard::new(state);
+            check_stack(state, 1)?;
+
+            lua.push_ref(&globals.0);
+
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            ffi::lua_rawseti(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_RIDX_GLOBALS);
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_replace(state, ffi::LUA_GLOBALSINDEX);
+        }
+
+        Ok(())
+    }
+
    /// Returns a handle to the active `Thread`.
    ///
    /// For calls to `Lua` this will be the main Lua thread, for parameters given to a callback,
@@ -2021,6 +2080,101 @@ impl Lua {
        LightUserData(&ASYNC_POLL_TERMINATE as *const u8 as *mut std::os::raw::c_void)
    }

+    #[cfg(feature = "async")]
+    #[inline(always)]
+    pub(crate) fn poll_yield() -> LightUserData {
+        static ASYNC_POLL_YIELD: u8 = 0;
+        LightUserData(&ASYNC_POLL_YIELD as *const u8 as *mut std::os::raw::c_void)
+    }
+
+    /// Suspends the current async function, returning the provided arguments to caller.
+    ///
+    /// This function is similar to [`coroutine.yield`] but allow yeilding Rust functions
+    /// and passing values to the caller.
+    /// Please note that you cannot cross [`Thread`] boundaries (e.g. calling `yield_with` on one
+    /// thread and resuming on another).
+    ///
+    /// # Examples
+    ///
+    /// Async iterator:
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result};
+    ///
+    /// async fn generator(lua: Lua, _: ()) -> Result<()> {
+    ///     for i in 0..10 {
+    ///         lua.yield_with::<()>(i).await?;
+    ///     }
+    ///     Ok(())
+    /// }
+    ///
+    /// fn main() -> Result<()> {
+    ///     let lua = Lua::new();
+    ///     lua.globals().set("generator", lua.create_async_function(generator)?)?;
+    ///
+    ///     lua.load(r#"
+    ///        local n = 0
+    ///        for i in coroutine.wrap(generator) do
+    ///            n = n + i
+    ///        end
+    ///        assert(n == 45)
+    ///     "#)
+    ///     .exec()
+    /// }
+    /// ```
+    ///
+    /// Exchange values on yield:
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result, Value};
+    ///
+    /// async fn pingpong(lua: Lua, mut val: i32) -> Result<()> {
+    ///     loop {
+    ///         val = lua.yield_with::<i32>(val).await? + 1;
+    ///     }
+    ///     Ok(())
+    /// }
+    ///
+    /// # fn main() -> Result<()> {
+    /// let lua = Lua::new();
+    ///
+    /// let co = lua.create_thread(lua.create_async_function(pingpong)?)?;
+    /// assert_eq!(co.resume::<i32>(1)?, 1);
+    /// assert_eq!(co.resume::<i32>(2)?, 3);
+    /// assert_eq!(co.resume::<i32>(3)?, 4);
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`coroutine.yield`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.yield
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub async fn yield_with<R: FromLuaMulti>(&self, args: impl IntoLuaMulti) -> Result<R> {
+        let mut args = Some(args.into_lua_multi(self)?);
+        future::poll_fn(move |_cx| match args.take() {
+            Some(args) => unsafe {
+                let lua = self.lock();
+                lua.push(Self::poll_yield())?; // yield marker
+                if args.len() <= 1 {
+                    lua.push(args.front())?;
+                } else {
+                    lua.push(lua.create_sequence_from(&args)?)?;
+                }
+                lua.push(args.len())?;
+                Poll::Pending
+            },
+            None => unsafe {
+                let lua = self.lock();
+                let state = lua.state();
+                let _sg = StackGuard::with_top(state, 0);
+                let nvals = ffi::lua_gettop(state);
+                Poll::Ready(R::from_stack_multi(nvals, &lua))
+            },
+        })
+        .await
+    }
+
    /// Returns a weak reference to the Lua instance.
    ///
    /// This is useful for creating a reference to the Lua instance that does not prevent it from
@@ -2030,7 +2184,6 @@ impl Lua {
        WeakLua(XRc::downgrade(&self.raw))
    }

-    // Luau version located in `luau/mod.rs`
    #[cfg(not(feature = "luau"))]
    fn disable_c_modules(&self) -> Result<()> {
        let package: Table = self.globals().get("package")?;
@@ -2053,7 +2206,9 @@ impl Lua {

        // The third and fourth searchers looks for a loader as a C library
        searchers.raw_set(3, loader)?;
-        searchers.raw_remove(4)?;
+        if searchers.raw_len() >= 4 {
+            searchers.raw_remove(4)?;
+        }

        Ok(())
    }
@@ -64,7 +64,7 @@ pub(crate) struct ExtraData {
    pub(super) wrapped_failure_top: usize,
    // Pool of `Thread`s (coroutines) for async execution
    #[cfg(feature = "async")]
-    pub(super) thread_pool: Vec<c_int>,
+    pub(super) thread_pool: Vec<crate::types::ValueRefIndex>,

    // Address of `WrappedFailure` metatable
    pub(super) wrapped_failure_mt_ptr: *const c_void,
@@ -76,7 +76,7 @@ pub(crate) struct ExtraData {
    #[cfg(not(feature = "luau"))]
    pub(super) hook_callback: Option<crate::types::HookCallback>,
    #[cfg(not(feature = "luau"))]
-    pub(super) hook_triggers: crate::hook::HookTriggers,
+    pub(super) hook_triggers: crate::debug::HookTriggers,
    #[cfg(feature = "lua54")]
    pub(super) warn_callback: Option<crate::types::WarnCallback>,
    #[cfg(feature = "luau")]
@@ -270,7 +270,7 @@ impl ExtraData {
        // Try to grow max stack size
        if self.ref_stack_top >= self.ref_stack_size {
            let mut inc = self.ref_stack_size; // Try to double stack size
-            while inc > 0 && ffi::lua_checkstack(self.ref_thread, inc) == 0 {
+            while inc > 0 && ffi::lua_checkstack(self.ref_thread, inc + REF_STACK_RESERVE) == 0 {
                inc /= 2;
            }
            if inc == 0 {
@@ -38,7 +38,7 @@ use super::{Lua, LuaOptions, WeakLua};

 #[cfg(not(feature = "luau"))]
 use crate::{
-    hook::Debug,
+    debug::Debug,
    types::{HookCallback, HookKind, VmState},
 };

@@ -296,7 +296,7 @@ impl RawLua {
        if is_safe {
            let curr_libs = (*self.extra.get()).libs;
            if (curr_libs ^ (curr_libs | libs)).contains(StdLib::PACKAGE) {
-                mlua_expect!(self.lua().disable_c_modules(), "Error during disabling C modules");
+                mlua_expect!(self.lua().disable_c_modules(), "Error disabling C modules");
            }
        }
        #[cfg(feature = "luau")]
@@ -435,8 +435,8 @@ impl RawLua {
                match (*extra).hook_callback.clone() {
                    Some(hook_callback) => {
                        let rawlua = (*extra).raw_lua();
-                        let debug = Debug::new(rawlua, ar);
-                        hook_callback((*extra).lua(), debug)
+                        let debug = Debug::new(rawlua, 0, ar);
+                        hook_callback((*extra).lua(), &debug)
                    }
                    None => {
                        ffi::lua_sethook(state, None, 0, 0);
@@ -465,9 +465,9 @@ impl RawLua {

            let status = callback_error_ext(state, ptr::null_mut(), false, |extra, _| {
                let rawlua = (*extra).raw_lua();
-                let debug = Debug::new(rawlua, ar);
+                let debug = Debug::new(rawlua, 0, ar);
                let hook_callback = (*hook_callback_ptr).clone();
-                hook_callback((*extra).lua(), debug)
+                hook_callback((*extra).lua(), &debug)
            });
            process_status(state, (*ar).event, status)
        }
@@ -523,6 +523,20 @@ impl RawLua {
        Ok(String(self.pop_ref()))
    }

+    #[cfg(feature = "luau")]
+    pub(crate) unsafe fn create_buffer_with_capacity(&self, size: usize) -> Result<(*mut u8, crate::Buffer)> {
+        let state = self.state();
+        if self.unlikely_memory_error() {
+            let ptr = crate::util::push_buffer(state, size, false)?;
+            return Ok((ptr, crate::Buffer(self.pop_ref())));
+        }
+
+        let _sg = StackGuard::new(state);
+        check_stack(state, 3)?;
+        let ptr = crate::util::push_buffer(state, size, true)?;
+        Ok((ptr, crate::Buffer(self.pop_ref())))
+    }
+
    /// See [`Lua::create_table_with_capacity`]
    pub(crate) unsafe fn create_table_with_capacity(&self, narr: usize, nrec: usize) -> Result<Table> {
        let state = self.state();
@@ -624,7 +638,7 @@ impl RawLua {
    #[cfg(feature = "async")]
    pub(crate) unsafe fn create_recycled_thread(&self, func: &Function) -> Result<Thread> {
        if let Some(index) = (*self.extra.get()).thread_pool.pop() {
-            let thread_state = ffi::lua_tothread(self.ref_thread(), index);
+            let thread_state = ffi::lua_tothread(self.ref_thread(), *index.0);
            ffi::lua_xpush(self.ref_thread(), thread_state, func.0.index);

            #[cfg(feature = "luau")]
@@ -645,8 +659,9 @@ impl RawLua {
    pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) {
        let extra = &mut *self.extra.get();
        if extra.thread_pool.len() < extra.thread_pool.capacity() {
-            extra.thread_pool.push(thread.0.index);
-            thread.0.drop = false; // Prevent thread from being garbage collected
+            if let Some(index) = thread.0.index_count.take() {
+                extra.thread_pool.push(index);
+            }
        }
    }

@@ -728,7 +743,7 @@ impl RawLua {

                let n = ffi::lua_tonumber(state, idx);
                match num_traits::cast(n) {
-                    Some(i) if (n - (i as Number)).abs() < Number::EPSILON => Value::Integer(i),
+                    Some(i) if n.to_bits() == (i as Number).to_bits() => Value::Integer(i),
                    _ => Value::Number(n),
                }
            }
@@ -827,13 +842,6 @@ impl RawLua {
        ValueRef::new(self, index)
    }

-    #[inline]
-    pub(crate) unsafe fn clone_ref(&self, vref: &ValueRef) -> ValueRef {
-        ffi::lua_pushvalue(self.ref_thread(), vref.index);
-        let index = (*self.extra.get()).ref_stack_pop();
-        ValueRef::new(self, index)
-    }
-
    pub(crate) unsafe fn drop_ref(&self, vref: &ValueRef) {
        let ref_thread = self.ref_thread();
        mlua_debug_assert!(
@@ -1270,6 +1278,13 @@ impl RawLua {
                let mut ctx = Context::from_waker(rawlua.waker());
                match fut.as_mut().map(|fut| fut.as_mut().poll(&mut ctx)) {
                    Some(Poll::Pending) => {
+                        let fut_nvals = ffi::lua_gettop(state);
+                        if fut_nvals >= 3 && ffi::lua_tolightuserdata(state, -3) == Lua::poll_yield().0 {
+                            // We have some values to yield
+                            ffi::lua_pushnil(state);
+                            ffi::lua_replace(state, -4);
+                            return Ok(3);
+                        }
                        ffi::lua_pushnil(state);
                        ffi::lua_pushlightuserdata(state, Lua::poll_pending().0);
                        Ok(2)
@@ -1340,6 +1355,7 @@ impl RawLua {
            local poll = get_poll(...)
            local nres, res, res2 = poll()
            while true do
+                -- Poll::Ready branch, `nres` is the number of results
                if nres ~= nil then
                    if nres == 0 then
                        return
@@ -1355,10 +1371,20 @@ impl RawLua {
                        return unpack(res, nres)
                    end
                end
-                -- `res` is a "pending" value
-                -- `yield` can return a signal to drop the future that we should propagate
-                -- to the poller
-                nres, res, res2 = poll(yield(res))
+
+                -- Poll::Pending branch
+                if res2 == nil then
+                    -- `res` is a "pending" value
+                    -- `yield` can return a signal to drop the future that we should propagate
+                    -- to the poller
+                    nres, res, res2 = poll(yield(res))
+                elseif res2 == 0 then
+                    nres, res, res2 = poll(yield())
+                elseif res2 == 1 then
+                    nres, res, res2 = poll(yield(res))
+                else
+                    nres, res, res2 = poll(yield(unpack(res, res2)))
+                end
            end
            "#,
        )
@@ -1370,14 +1396,14 @@ impl RawLua {

    #[cfg(feature = "async")]
    #[inline]
-    pub(crate) unsafe fn waker(&self) -> &Waker {
-        (*self.extra.get()).waker.as_ref()
+    pub(crate) fn waker(&self) -> &Waker {
+        unsafe { (*self.extra.get()).waker.as_ref() }
    }

    #[cfg(feature = "async")]
    #[inline]
-    pub(crate) unsafe fn set_waker(&self, waker: NonNull<Waker>) -> NonNull<Waker> {
-        mem::replace(&mut (*self.extra.get()).waker, waker)
+    pub(crate) fn set_waker(&self, waker: NonNull<Waker>) -> NonNull<Waker> {
+        unsafe { mem::replace(&mut (*self.extra.get()).waker, waker) }
    }
 }

@@ -86,7 +86,7 @@ impl String {

    /// Get the bytes that make up this string.
    ///
-    /// The returned slice will not contain the terminating nul byte, but will contain any nul
+    /// The returned slice will not contain the terminating null byte, but will contain any null
    /// bytes embedded into the Lua string.
    ///
    /// # Examples
@@ -106,15 +106,15 @@ impl String {
        BorrowedBytes::from(self)
    }

-    /// Get the bytes that make up this string, including the trailing nul byte.
+    /// Get the bytes that make up this string, including the trailing null byte.
    pub fn as_bytes_with_nul(&self) -> BorrowedBytes<'_> {
        let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(self);
-        // Include the trailing nul byte (it's always present but excluded by default)
+        // Include the trailing null byte (it's always present but excluded by default)
        let buf = unsafe { slice::from_raw_parts((*buf).as_ptr(), (*buf).len() + 1) };
        BorrowedBytes { buf, borrow, _lua }
    }

-    // Does not return the terminating nul byte
+    // Does not return the terminating null byte
    unsafe fn to_slice(&self) -> (&[u8], Lua) {
        let lua = self.0.lua.upgrade();
        let slice = {
@@ -13,7 +13,7 @@ use crate::util::{assert_stack, check_stack, get_metatable_ptr, StackGuard};
 use crate::value::{Nil, Value};

 #[cfg(feature = "async")]
-use futures_util::future::{self, Either, Future};
+use crate::function::AsyncCallFuture;

 #[cfg(feature = "serde")]
 use {
@@ -211,7 +211,7 @@ impl Table {
    ///
    /// let always_equals_mt = lua.create_table()?;
    /// always_equals_mt.set("__eq", lua.create_function(|_, (_t1, _t2): (Table, Table)| Ok(true))?)?;
-    /// table2.set_metatable(Some(always_equals_mt));
+    /// table2.set_metatable(Some(always_equals_mt))?;
    ///
    /// assert!(table1.equals(&table1.clone())?);
    /// assert!(table1.equals(&table2)?);
@@ -487,16 +487,12 @@ impl Table {
    /// [`getmetatable`]: https://www.lua.org/manual/5.4/manual.html#pdf-getmetatable
    pub fn metatable(&self) -> Option<Table> {
        let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
        unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-
-            lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(state, -1) == 0 {
+            if ffi::lua_getmetatable(ref_thread, self.0.index) == 0 {
                None
            } else {
-                Some(Table(lua.pop_ref()))
+                Some(Table(lua.pop_ref_thread()))
            }
        }
    }
@@ -505,27 +501,23 @@ impl Table {
    ///
    /// If `metatable` is `None`, the metatable is removed (if no metatable is set, this does
    /// nothing).
-    pub fn set_metatable(&self, metatable: Option<Table>) {
-        // Workaround to throw readonly error without returning Result
+    pub fn set_metatable(&self, metatable: Option<Table>) -> Result<()> {
        #[cfg(feature = "luau")]
        if self.is_readonly() {
-            panic!("attempt to modify a readonly table");
+            return Err(Error::runtime("attempt to modify a readonly table"));
        }

        let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
        unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-
-            lua.push_ref(&self.0);
-            if let Some(metatable) = metatable {
-                lua.push_ref(&metatable.0);
+            if let Some(metatable) = &metatable {
+                ffi::lua_pushvalue(ref_thread, metatable.0.index);
            } else {
-                ffi::lua_pushnil(state);
+                ffi::lua_pushnil(ref_thread);
            }
-            ffi::lua_setmetatable(state, -2);
+            ffi::lua_setmetatable(ref_thread, self.0.index);
        }
+        Ok(())
    }

    /// Returns true if the table has metatable attached.
@@ -892,16 +884,16 @@ impl ObjectLike for Table {
        R: FromLuaMulti,
    {
        // Convert table to a function and call via pcall that respects the `__call` metamethod.
-        Function(self.0.copy()).call(args)
+        Function(self.0.clone()).call(args)
    }

    #[cfg(feature = "async")]
    #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
-        Function(self.0.copy()).call_async(args)
+        Function(self.0.clone()).call_async(args)
    }

    #[inline]
@@ -913,7 +905,7 @@ impl ObjectLike for Table {
    }

    #[cfg(feature = "async")]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
@@ -933,23 +925,23 @@ impl ObjectLike for Table {

    #[cfg(feature = "async")]
    #[inline]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
        match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
            Ok(val) => {
                let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
            }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
        }
    }

    #[inline]
    fn to_string(&self) -> Result<StdString> {
-        Value::Table(Table(self.0.copy())).to_string()
+        Value::Table(Table(self.0.clone())).to_string()
    }
 }

@@ -10,7 +10,7 @@ use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};

 #[cfg(not(feature = "luau"))]
 use crate::{
-    hook::{Debug, HookTriggers},
+    debug::{Debug, HookTriggers},
    types::HookKind,
 };

@@ -86,13 +86,15 @@ unsafe impl Sync for Thread {}
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncThread<R> {
    thread: Thread,
-    ret: PhantomData<R>,
+    ret: PhantomData<fn() -> R>,
    recycle: bool,
 }

 impl Thread {
+    /// Returns reference to the Lua state that this thread is associated with.
+    #[doc(hidden)]
    #[inline(always)]
-    fn state(&self) -> *mut ffi::lua_State {
+    pub fn state(&self) -> *mut ffi::lua_State {
        self.1
    }

@@ -154,7 +156,6 @@ impl Thread {
        let thread_state = self.state();
        unsafe {
            let _sg = StackGuard::new(state);
-            let _thread_sg = StackGuard::with_top(thread_state, 0);

            let nargs = args.push_into_stack_multi(&lua)?;
            if nargs > 0 {
@@ -163,6 +164,7 @@ impl Thread {
                pushed_nargs += nargs;
            }

+            let _thread_sg = StackGuard::with_top(thread_state, 0);
            let (_, nresults) = self.resume_inner(&lua, pushed_nargs)?;
            check_stack(state, nresults + 1)?;
            ffi::lua_xmove(thread_state, state, nresults);
@@ -190,12 +192,12 @@ impl Thread {
        let thread_state = self.state();
        unsafe {
            let _sg = StackGuard::new(state);
-            let _thread_sg = StackGuard::with_top(thread_state, 0);

            check_stack(state, 1)?;
            error.push_into_stack(&lua)?;
            ffi::lua_xmove(state, thread_state, 1);

+            let _thread_sg = StackGuard::with_top(thread_state, 0);
            let (_, nresults) = self.resume_inner(&lua, ffi::LUA_RESUMEERROR)?;
            check_stack(state, nresults + 1)?;
            ffi::lua_xmove(thread_state, state, nresults);
@@ -269,7 +271,7 @@ impl Thread {
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
    where
-        F: Fn(&crate::Lua, Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
+        F: Fn(&crate::Lua, &Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
    {
        let lua = self.0.lua.lock();
        unsafe {
@@ -602,7 +604,7 @@ impl<R: FromLuaMulti> Future for AsyncThread<R> {

            if status.is_yielded() {
                if !(nresults == 1 && is_poll_pending(thread_state)) {
-                    // Ignore value returned via yield()
+                    // Ignore values returned via yield()
                    cx.waker().wake_by_ref();
                }
                return Poll::Pending;
@@ -633,7 +635,7 @@ struct WakerGuard<'lua, 'a> {
 impl<'lua, 'a> WakerGuard<'lua, 'a> {
    #[inline]
    pub fn new(lua: &'lua RawLua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
-        let prev = unsafe { lua.set_waker(NonNull::from(waker)) };
+        let prev = lua.set_waker(NonNull::from(waker));
        Ok(WakerGuard {
            lua,
            prev,
@@ -645,7 +647,7 @@ impl<'lua, 'a> WakerGuard<'lua, 'a> {
 #[cfg(feature = "async")]
 impl Drop for WakerGuard<'_, '_> {
    fn drop(&mut self) {
-        unsafe { self.lua.set_waker(self.prev) };
+        self.lua.set_waker(self.prev);
    }
 }

@@ -11,7 +11,7 @@ use crate::util::{check_stack, short_type_name};
 use crate::value::Value;

 #[cfg(feature = "async")]
-use std::future::Future;
+use {crate::function::AsyncCallFuture, std::future::Future};

 /// Trait for types convertible to [`Value`].
 pub trait IntoLua: Sized {
@@ -162,7 +162,7 @@ pub trait ObjectLike: Sealed {
    /// arguments.
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti;

@@ -178,7 +178,7 @@ pub trait ObjectLike: Sealed {
    /// This might invoke the `__index` metamethod.
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti;

@@ -196,7 +196,7 @@ pub trait ObjectLike: Sealed {
    /// This might invoke the `__index` metamethod.
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti;

@@ -1,9 +1,9 @@
 use std::cell::UnsafeCell;
 use std::os::raw::{c_int, c_void};

-use crate::error::Result;
 #[cfg(not(feature = "luau"))]
-use crate::hook::{Debug, HookTriggers};
+use crate::debug::{Debug, HookTriggers};
+use crate::error::Result;
 use crate::state::{ExtraData, Lua, RawLua};

 // Re-export mutex wrappers
@@ -20,6 +20,9 @@ pub use either::Either;
 pub use registry_key::RegistryKey;
 pub(crate) use value_ref::ValueRef;

+#[cfg(feature = "async")]
+pub(crate) use value_ref::ValueRefIndex;
+
 /// Type of Lua integer numbers.
 pub type Integer = ffi::lua_Integer;
 /// Type of Lua floating point numbers.
@@ -79,10 +82,10 @@ pub(crate) enum HookKind {
 }

 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = XRc<dyn Fn(&Lua, Debug) -> Result<VmState> + Send>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState> + Send>;

 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = XRc<dyn Fn(&Lua, Debug) -> Result<VmState>>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState>>;

 #[cfg(all(feature = "send", feature = "luau"))]
 pub(crate) type InterruptCallback = XRc<dyn Fn(&Lua) -> Result<VmState> + Send>;
@@ -1,22 +1,39 @@
 use std::fmt;
 use std::os::raw::{c_int, c_void};

+use super::XRc;
 use crate::state::{RawLua, WeakLua};

 /// A reference to a Lua (complex) value stored in the Lua auxiliary thread.
+#[derive(Clone)]
 pub struct ValueRef {
    pub(crate) lua: WeakLua,
+    // Keep index separate to avoid additional indirection when accessing it.
    pub(crate) index: c_int,
-    pub(crate) drop: bool,
+    // If `index_count` is `None`, the value does not need to be destroyed.
+    pub(crate) index_count: Option<ValueRefIndex>,
+}
+
+/// A reference to a Lua value index in the auxiliary thread.
+/// It's cheap to clone and can be used to track the number of references to a value.
+#[derive(Clone)]
+pub(crate) struct ValueRefIndex(pub(crate) XRc<c_int>);
+
+impl From<c_int> for ValueRefIndex {
+    #[inline]
+    fn from(index: c_int) -> Self {
+        ValueRefIndex(XRc::new(index))
+    }
 }

 impl ValueRef {
    #[inline]
-    pub(crate) fn new(lua: &RawLua, index: c_int) -> Self {
+    pub(crate) fn new(lua: &RawLua, index: impl Into<ValueRefIndex>) -> Self {
+        let index = index.into();
        ValueRef {
            lua: lua.weak().clone(),
-            index,
-            drop: true,
+            index: *index.0,
+            index_count: Some(index),
        }
    }

@@ -25,16 +42,6 @@ impl ValueRef {
        let lua = self.lua.lock();
        unsafe { ffi::lua_topointer(lua.ref_thread(), self.index) }
    }
-
-    /// Returns a copy of the value, which is valid as long as the original value is held.
-    #[inline]
-    pub(crate) fn copy(&self) -> Self {
-        ValueRef {
-            lua: self.lua.clone(),
-            index: self.index,
-            drop: false,
-        }
-    }
 }

 impl fmt::Debug for ValueRef {
@@ -43,17 +50,15 @@ impl fmt::Debug for ValueRef {
    }
 }

-impl Clone for ValueRef {
-    fn clone(&self) -> Self {
-        unsafe { self.lua.lock().clone_ref(self) }
-    }
-}
-
 impl Drop for ValueRef {
    fn drop(&mut self) {
-        if self.drop {
-            if let Some(lua) = self.lua.try_lock() {
-                unsafe { lua.drop_ref(self) };
+        if let Some(ValueRefIndex(index)) = self.index_count.take() {
+            // It's guaranteed that the inner value returns exactly once.
+            // This means in particular that the value is not dropped.
+            if XRc::into_inner(index).is_some() {
+                if let Some(lua) = self.lua.try_lock() {
+                    unsafe { lua.drop_ref(self) };
+                }
            }
        }
    }
@@ -240,6 +240,13 @@ impl AsRef<str> for MetaMethod {
    }
 }

+impl From<MetaMethod> for StdString {
+    #[inline]
+    fn from(method: MetaMethod) -> Self {
+        method.name().to_owned()
+    }
+}
+
 /// Method registry for [`UserData`] implementors.
 pub trait UserDataMethods<T> {
    /// Add a regular method which accepts a `&T` as the first parameter.
@@ -249,7 +256,7 @@ pub trait UserDataMethods<T> {
    ///
    /// If `add_meta_method` is used to set the `__index` metamethod, the `__index` metamethod will
    /// be used as a fall-back if no regular method is found.
-    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -260,7 +267,7 @@ pub trait UserDataMethods<T> {
    /// Refer to [`add_method`] for more information about the implementation.
    ///
    /// [`add_method`]: UserDataMethods::add_method
-    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -273,7 +280,7 @@ pub trait UserDataMethods<T> {
    /// [`add_method`]: UserDataMethods::add_method
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -288,7 +295,7 @@ pub trait UserDataMethods<T> {
    /// [`add_method`]: UserDataMethods::add_method
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -301,7 +308,7 @@ pub trait UserDataMethods<T> {
    /// The first argument will be a [`AnyUserData`] of type `T` if the method is called with Lua
    /// method syntax: `my_userdata:my_method(arg1, arg2)`, or it is passed in as the first
    /// argument: `my_userdata.my_method(my_userdata, arg1, arg2)`.
-    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -312,7 +319,7 @@ pub trait UserDataMethods<T> {
    /// This is a version of [`add_function`] that accepts a `FnMut` argument.
    ///
    /// [`add_function`]: UserDataMethods::add_function
-    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -326,7 +333,7 @@ pub trait UserDataMethods<T> {
    /// [`add_function`]: UserDataMethods::add_function
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -341,7 +348,7 @@ pub trait UserDataMethods<T> {
    /// side has a metatable. To prevent this, use [`add_meta_function`].
    ///
    /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -355,7 +362,7 @@ pub trait UserDataMethods<T> {
    /// side has a metatable. To prevent this, use [`add_meta_function`].
    ///
    /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -371,7 +378,7 @@ pub trait UserDataMethods<T> {
        docsrs,
        doc(cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau")))))
    )]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -387,7 +394,7 @@ pub trait UserDataMethods<T> {
    /// [`add_meta_method_mut`]: UserDataMethods::add_meta_method_mut
    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -400,7 +407,7 @@ pub trait UserDataMethods<T> {
    /// Metamethods for binary operators can be triggered if either the left or right argument to
    /// the binary operator has a metatable, so the first argument here is not necessarily a
    /// userdata of type `T`.
-    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -411,7 +418,7 @@ pub trait UserDataMethods<T> {
    /// This is a version of [`add_meta_function`] that accepts a `FnMut` argument.
    ///
    /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -427,7 +434,7 @@ pub trait UserDataMethods<T> {
        docsrs,
        doc(cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau")))))
    )]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -446,7 +453,7 @@ pub trait UserDataFields<T> {
    ///
    /// If `add_meta_method` is used to set the `__index` metamethod, it will
    /// be used as a fall-back if no regular field or method are found.
-    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_field<V>(&mut self, name: impl Into<StdString>, value: V)
    where
        V: IntoLua + 'static;

@@ -457,7 +464,7 @@ pub trait UserDataFields<T> {
    ///
    /// If `add_meta_method` is used to set the `__index` metamethod, the `__index` metamethod will
    /// be used as a fall-back if no regular field or method are found.
-    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_get<M, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
        R: IntoLua;
@@ -470,21 +477,21 @@ pub trait UserDataFields<T> {
    ///
    /// If `add_meta_method` is used to set the `__newindex` metamethod, the `__newindex` metamethod
    /// will be used as a fall-back if no regular field is found.
-    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
        A: FromLua;

    /// Add a regular field getter as a function which accepts a generic [`AnyUserData`] of type `T`
    /// argument.
-    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
        R: IntoLua;

    /// Add a regular field setter as a function which accepts a generic [`AnyUserData`] of type `T`
    /// first argument.
-    fn add_field_function_set<F, A>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
        A: FromLua;
@@ -497,7 +504,7 @@ pub trait UserDataFields<T> {
    ///
    /// `mlua` will trigger an error on an attempt to define a protected metamethod,
    /// like `__gc` or `__metatable`.
-    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_meta_field<V>(&mut self, name: impl Into<StdString>, value: V)
    where
        V: IntoLua + 'static;

@@ -509,7 +516,7 @@ pub trait UserDataFields<T> {
    ///
    /// `mlua` will trigger an error on an attempt to define a protected metamethod,
    /// like `__gc` or `__metatable`.
-    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl Into<StdString>, f: F)
    where
        F: FnOnce(&Lua) -> Result<R> + 'static,
        R: IntoLua;
@@ -881,16 +888,17 @@ impl AnyUserData {
        self.raw_metatable().map(UserDataMetatable)
    }

+    /// Returns a raw metatable of this [`AnyUserData`].
    fn raw_metatable(&self) -> Result<Table> {
        let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
        unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 3)?;
+            // Check that userdata is registered and not destructed
+            // All registered userdata types have a non-empty metatable
+            let _type_id = lua.get_userdata_ref_type_id(&self.0)?;

-            lua.push_userdata_ref(&self.0)?;
-            ffi::lua_getmetatable(state, -1); // Checked that non-empty on the previous call
-            Ok(Table(lua.pop_ref()))
+            ffi::lua_getmetatable(ref_thread, self.0.index);
+            Ok(Table(lua.pop_ref_thread()))
        }
    }

@@ -8,21 +8,21 @@ use crate::value::Value;
 use crate::Function;

 #[cfg(feature = "async")]
-use futures_util::future::{self, Either, Future};
+use crate::function::AsyncCallFuture;

 impl ObjectLike for AnyUserData {
    #[inline]
    fn get<V: FromLua>(&self, key: impl IntoLua) -> Result<V> {
        // `lua_gettable` method used under the hood can work with any Lua value
        // that has `__index` metamethod
-        Table(self.0.copy()).get_protected(key)
+        Table(self.0.clone()).get_protected(key)
    }

    #[inline]
    fn set(&self, key: impl IntoLua, value: impl IntoLua) -> Result<()> {
        // `lua_settable` method used under the hood can work with any Lua value
        // that has `__newindex` metamethod
-        Table(self.0.copy()).set_protected(key, value)
+        Table(self.0.clone()).set_protected(key, value)
    }

    #[inline]
@@ -30,16 +30,16 @@ impl ObjectLike for AnyUserData {
    where
        R: FromLuaMulti,
    {
-        Function(self.0.copy()).call(args)
+        Function(self.0.clone()).call(args)
    }

    #[cfg(feature = "async")]
    #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
-        Function(self.0.copy()).call_async(args)
+        Function(self.0.clone()).call_async(args)
    }

    #[inline]
@@ -51,7 +51,7 @@ impl ObjectLike for AnyUserData {
    }

    #[cfg(feature = "async")]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
@@ -72,22 +72,22 @@ impl ObjectLike for AnyUserData {
    }

    #[cfg(feature = "async")]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
        match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
            Ok(val) => {
                let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
            }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
        }
    }

    #[inline]
    fn to_string(&self) -> Result<StdString> {
-        Value::UserData(AnyUserData(self.0.copy())).to_string()
+        Value::UserData(AnyUserData(self.0.clone())).to_string()
    }
 }
@@ -63,7 +63,7 @@ impl<T> TryFrom<UserDataVariant<T>> for UserDataRef<T> {

    #[inline]
    fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
-        let guard = if !cfg!(feature = "send") || is_sync::<T>() {
+        let guard = if cfg!(not(feature = "send")) || is_sync::<T>() {
            variant.raw_lock().try_lock_shared_guarded()
        } else {
            variant.raw_lock().try_lock_exclusive_guarded()
@@ -365,101 +365,101 @@ fn get_function_name<T>(name: &str) -> StdString {
 }

 impl<T> UserDataFields<T> for UserDataRegistry<T> {
-    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_field<V>(&mut self, name: impl Into<StdString>, value: V)
    where
        V: IntoLua + 'static,
    {
-        let name = name.to_string();
+        let name = name.into();
        self.raw.fields.push((name, value.into_lua(self.lua.lua())));
    }

-    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_get<M, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
        R: IntoLua,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method(&name, move |lua, data, ()| method(lua, data));
        self.raw.field_getters.push((name, callback));
    }

-    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
        A: FromLua,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method_mut(&name, method);
        self.raw.field_setters.push((name, callback));
    }

-    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
        R: IntoLua,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function(&name, function);
        self.raw.field_getters.push((name, callback));
    }

-    fn add_field_function_set<F, A>(&mut self, name: impl ToString, mut function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl Into<StdString>, mut function: F)
    where
        F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
        A: FromLua,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function_mut(&name, move |lua, (data, val)| function(lua, data, val));
        self.raw.field_setters.push((name, callback));
    }

-    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_meta_field<V>(&mut self, name: impl Into<StdString>, value: V)
    where
        V: IntoLua + 'static,
    {
        let lua = self.lua.lua();
-        let name = name.to_string();
+        let name = name.into();
        let field = Self::check_meta_field(lua, &name, value).and_then(|v| v.into_lua(lua));
        self.raw.meta_fields.push((name, field));
    }

-    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl Into<StdString>, f: F)
    where
        F: FnOnce(&Lua) -> Result<R> + 'static,
        R: IntoLua,
    {
        let lua = self.lua.lua();
-        let name = name.to_string();
+        let name = name.into();
        let field = f(lua).and_then(|v| Self::check_meta_field(lua, &name, v).and_then(|v| v.into_lua(lua)));
        self.raw.meta_fields.push((name, field));
    }
 }

 impl<T> UserDataMethods<T> for UserDataRegistry<T> {
-    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method(&name, method);
        self.raw.methods.push((name, callback));
    }

-    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method_mut(&name, method);
        self.raw.methods.push((name, callback));
    }

    #[cfg(feature = "async")]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -467,13 +467,13 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
        MR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_method(&name, method);
        self.raw.async_methods.push((name, callback));
    }

    #[cfg(feature = "async")]
-    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -481,70 +481,70 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
        MR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_method_mut(&name, method);
        self.raw.async_methods.push((name, callback));
    }

-    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function(&name, function);
        self.raw.methods.push((name, callback));
    }

-    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function_mut(&name, function);
        self.raw.methods.push((name, callback));
    }

    #[cfg(feature = "async")]
-    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
        FR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_function(&name, function);
        self.raw.async_methods.push((name, callback));
    }

-    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method(&name, method);
        self.raw.meta_methods.push((name, callback));
    }

-    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_method_mut(&name, method);
        self.raw.meta_methods.push((name, callback));
    }

    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -552,13 +552,13 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
        MR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_method(&name, method);
        self.raw.async_meta_methods.push((name, callback));
    }

    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -566,42 +566,42 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
        MR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_method_mut(&name, method);
        self.raw.async_meta_methods.push((name, callback));
    }

-    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function(&name, function);
        self.raw.meta_methods.push((name, callback));
    }

-    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_function_mut(&name, function);
        self.raw.meta_methods.push((name, callback));
    }

    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
        FR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti,
    {
-        let name = name.to_string();
+        let name = name.into();
        let callback = self.box_async_function(&name, function);
        self.raw.async_meta_methods.push((name, callback));
    }
@@ -88,7 +88,7 @@ impl Drop for StackGuard {
 #[inline(always)]
 pub(crate) unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -> Result<()> {
    // Always use protected mode if the string is too long
-    if protect || s.len() > (1 << 30) {
+    if protect || s.len() >= const { 1 << 30 } {
        protect_lua!(state, 0, 1, |state| {
            ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
        })
@@ -101,15 +101,13 @@ pub(crate) unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect:
 // Uses 3 stack spaces (when protect), does not call checkstack.
 #[cfg(feature = "luau")]
 #[inline(always)]
-pub(crate) unsafe fn push_buffer(state: *mut ffi::lua_State, b: &[u8], protect: bool) -> Result<()> {
-    let data = if protect {
-        protect_lua!(state, 0, 1, |state| ffi::lua_newbuffer(state, b.len()))?
+pub(crate) unsafe fn push_buffer(state: *mut ffi::lua_State, size: usize, protect: bool) -> Result<*mut u8> {
+    let data = if protect || size > const { 1024 * 1024 * 1024 } {
+        protect_lua!(state, 0, 1, |state| ffi::lua_newbuffer(state, size))?
    } else {
-        ffi::lua_newbuffer(state, b.len())
+        ffi::lua_newbuffer(state, size)
    };
-    let buf = slice::from_raw_parts_mut(data as *mut u8, b.len());
-    buf.copy_from_slice(b);
-    Ok(())
+    Ok(data as *mut u8)
 }

 // Uses 3 stack spaces, does not call checkstack.
@@ -122,7 +120,7 @@ pub(crate) unsafe fn push_table(
 ) -> Result<()> {
    let narr: c_int = narr.try_into().unwrap_or(c_int::MAX);
    let nrec: c_int = nrec.try_into().unwrap_or(c_int::MAX);
-    if protect {
+    if protect || narr >= const { 1 << 26 } || nrec >= const { 1 << 26 } {
        protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
    } else {
        ffi::lua_createtable(state, narr, nrec);
@@ -1,6 +1,6 @@
-//! Mostly copied from [bevy_utils]
+//! Inspired by bevy's [disqualified]
 //!
-//! [bevy_utils]: https://github.com/bevyengine/bevy/blob/main/crates/bevy_utils/src/short_names.rs
+//! [disqualified]: https://github.com/bevyengine/disqualified/blob/main/src/short_name.rs

 use std::any::type_name;

@@ -23,8 +23,7 @@ pub(crate) fn short_type_name<T: ?Sized>() -> String {
    while index < end_of_string {
        let rest_of_string = full_name.get(index..end_of_string).unwrap_or_default();

-        // Collapse everything up to the next special character,
-        // then skip over it
+        // Collapse everything up to the next special character, then skip over it
        if let Some(special_character_index) =
            rest_of_string.find(|c: char| [' ', '<', '>', '(', ')', '[', ']', ',', ';'].contains(&c))
        {
@@ -32,11 +31,16 @@ pub(crate) fn short_type_name<T: ?Sized>() -> String {
            parsed_name += collapse_type_name(segment_to_collapse);
            // Insert the special character
            let special_character = &rest_of_string[special_character_index..=special_character_index];
-            parsed_name.push_str(special_character);
+            parsed_name += special_character;
+
+            // Remove lifetimes like <'_> or <'_, '_, ...>
+            if parsed_name.ends_with("<'_>") || parsed_name.ends_with("<'_, ") {
+                _ = parsed_name.split_off(parsed_name.len() - 4);
+            }

            match special_character {
                ">" | ")" | "]" if rest_of_string[special_character_index + 1..].starts_with("::") => {
-                    parsed_name.push_str("::");
+                    parsed_name += "::";
                    // Move the index past the "::"
                    index += special_character_index + 3;
                }
@@ -53,14 +57,18 @@ pub(crate) fn short_type_name<T: ?Sized>() -> String {
 }

 #[inline(always)]
-fn collapse_type_name(string: &str) -> &str {
-    string.rsplit("::").next().unwrap()
+fn collapse_type_name(segment: &str) -> &str {
+    segment.rsplit("::").next().unwrap()
 }

 #[cfg(test)]
 mod tests {
    use super::short_type_name;
    use std::collections::HashMap;
+    use std::marker::PhantomData;
+
+    struct MyData<'a, 'b>(PhantomData<&'a &'b ()>);
+    struct MyDataT<'a, T>(PhantomData<&'a T>);

    #[test]
    fn tests() {
@@ -73,5 +81,7 @@ mod tests {
            "HashMap<String, Option<[i32; 3]>>"
        );
        assert_eq!(short_type_name::<dyn Fn(i32) -> i32>(), "dyn Fn(i32) -> i32");
+        assert_eq!(short_type_name::<MyDataT<&str>>(), "MyDataT<&str>");
+        assert_eq!(short_type_name::<(&MyData, [MyData])>(), "(MyData, [MyData])");
    }
 }
@@ -356,6 +356,10 @@ impl Value {
    ///
    /// If the value is a Lua [`String`], try to convert it to [`BorrowedStr`] or return `None`
    /// otherwise.
+    #[deprecated(
+        since = "0.11.0",
+        note = "This method does not follow Rust naming convention. Use `as_string().and_then(|s| s.to_str().ok())` instead."
+    )]
    #[inline]
    pub fn as_str(&self) -> Option<BorrowedStr<'_>> {
        self.as_string().and_then(|s| s.to_str().ok())
@@ -364,6 +368,10 @@ impl Value {
    /// Cast the value to [`StdString`].
    ///
    /// If the value is a Lua [`String`], converts it to [`StdString`] or returns `None` otherwise.
+    #[deprecated(
+        since = "0.11.0",
+        note = "This method does not follow Rust naming convention. Use `as_string().map(|s| s.to_string_lossy())` instead."
+    )]
    #[inline]
    pub fn as_string_lossy(&self) -> Option<StdString> {
        self.as_string().map(|s| s.to_string_lossy())
@@ -8,7 +8,7 @@ use futures_util::stream::TryStreamExt;
 use tokio::sync::Mutex;

 use mlua::{
-    Error, Function, Lua, LuaOptions, MultiValue, ObjectLike, Result, StdLib, Table, UserData,
+    Error, Function, Lua, LuaOptions, MultiValue, ObjectLike, Result, StdLib, Table, ThreadStatus, UserData,
    UserDataMethods, UserDataRef, Value,
 };

@@ -386,7 +386,7 @@ async fn test_async_table_object_like() -> Result<()> {
            table.get::<i64>("val")
        })?,
    )?;
-    table.set_metatable(Some(metatable));
+    table.set_metatable(Some(metatable))?;
    assert_eq!(table.call_async::<i64>(()).await.unwrap(), 15);

    match table.call_async_method::<()>("non_existent", ()).await {
@@ -667,3 +667,35 @@ async fn test_async_hook() -> Result<()> {

    Ok(())
 }
+
+#[test]
+fn test_async_yield_with() -> Result<()> {
+    let lua = Lua::new();
+
+    let func = lua.create_async_function(|lua, (mut a, mut b): (i32, i32)| async move {
+        let zero = lua.yield_with::<MultiValue>(()).await?;
+        assert!(zero.is_empty());
+        let one = lua.yield_with::<MultiValue>(a + b).await?;
+        assert_eq!(one.len(), 1);
+
+        for _ in 0..3 {
+            (a, b) = lua.yield_with((a + b, a * b)).await?;
+        }
+        Ok((0, 0))
+    })?;
+
+    let thread = lua.create_thread(func)?;
+
+    let zero = thread.resume::<MultiValue>((2, 3))?; // function arguments
+    assert!(zero.is_empty());
+    let one = thread.resume::<i32>(())?; // value of "zero" is passed here
+    assert_eq!(one, 5);
+
+    assert_eq!(thread.resume::<(i32, i32)>(1)?, (5, 6)); // value of "one" is passed here
+    assert_eq!(thread.resume::<(i32, i32)>((10, 11))?, (21, 110));
+    assert_eq!(thread.resume::<(i32, i32)>((11, 12))?, (23, 132));
+    assert_eq!(thread.resume::<(i32, i32)>((12, 13))?, (0, 0));
+    assert_eq!(thread.status(), ThreadStatus::Finished);
+
+    Ok(())
+}
@@ -1,5 +1,7 @@
 #![cfg(feature = "luau")]

+use std::io::{Read, Seek, SeekFrom, Write};
+
 use mlua::{Lua, Result, Value};

 #[test]
@@ -41,7 +43,7 @@ fn test_buffer() -> Result<()> {
 }

 #[test]
-#[should_panic(expected = "range end index 14 out of range for slice of length 13")]
+#[should_panic(expected = "out of range for slice of length 13")]
 fn test_buffer_out_of_bounds_read() {
    let lua = Lua::new();
    let buf = lua.create_buffer(b"hello, world!").unwrap();
@@ -49,9 +51,73 @@ fn test_buffer_out_of_bounds_read() {
 }

 #[test]
-#[should_panic(expected = "range end index 16 out of range for slice of length 13")]
+#[should_panic(expected = "out of range for slice of length 13")]
 fn test_buffer_out_of_bounds_write() {
    let lua = Lua::new();
    let buf = lua.create_buffer(b"hello, world!").unwrap();
    buf.write_bytes(14, b"!!");
 }
+
+#[test]
+fn create_large_buffer() {
+    let lua = Lua::new();
+    let err = lua.create_buffer_with_capacity(1_073_741_824 + 1).unwrap_err(); // 1GB
+    assert!(err.to_string().contains("memory allocation error"));
+
+    // Normal buffer is okay
+    let buf = lua.create_buffer_with_capacity(1024 * 1024).unwrap();
+    assert_eq!(buf.len(), 1024 * 1024);
+}
+
+#[test]
+fn test_buffer_cursor() -> Result<()> {
+    let lua = Lua::new();
+    let mut cursor = lua.create_buffer(b"hello, world")?.cursor();
+
+    let mut data = Vec::new();
+    cursor.read_to_end(&mut data)?;
+    assert_eq!(data, b"hello, world");
+
+    // No more data to read
+    let mut one = [0u8; 1];
+    assert_eq!(cursor.read(&mut one)?, 0);
+
+    // Seek to start
+    cursor.seek(SeekFrom::Start(0))?;
+    cursor.read_exact(&mut one)?;
+    assert_eq!(one, [b'h']);
+
+    // Seek to end -5
+    cursor.seek(SeekFrom::End(-5))?;
+    let mut five = [0u8; 5];
+    cursor.read_exact(&mut five)?;
+    assert_eq!(&five, b"world");
+
+    // Seek to current -1
+    cursor.seek(SeekFrom::Current(-1))?;
+    cursor.read_exact(&mut one)?;
+    assert_eq!(one, [b'd']);
+
+    // Invalid seek
+    assert!(cursor.seek(SeekFrom::Current(-100)).is_err());
+    assert!(cursor.seek(SeekFrom::End(1)).is_err());
+
+    // Write data
+    let buf = lua.create_buffer_with_capacity(100)?;
+    cursor = buf.clone().cursor();
+
+    cursor.write_all(b"hello, ...")?;
+    cursor.seek(SeekFrom::Current(-3))?;
+    cursor.write_all(b"Rust!")?;
+
+    assert_eq!(&buf.read_bytes::<12>(0), b"hello, Rust!");
+
+    // Writing beyond the end of the buffer does nothing
+    cursor.seek(SeekFrom::End(0))?;
+    assert_eq!(cursor.write(b".")?, 0);
+
+    // Flush is no-op
+    cursor.flush()?;
+
+    Ok(())
+}
@@ -119,12 +119,11 @@ fn test_compiler() -> Result<()> {
        .set_debug_level(2)
        .set_type_info_level(1)
        .set_coverage_level(2)
-        .set_vector_lib("vector")
-        .set_vector_ctor("new")
+        .set_vector_ctor("vector.new")
        .set_vector_type("vector")
-        .set_mutable_globals(vec!["mutable_global"])
-        .set_userdata_types(vec!["MyUserdata"])
-        .set_disabled_builtins(vec!["tostring"]);
+        .set_mutable_globals(["mutable_global"])
+        .set_userdata_types(["MyUserdata"])
+        .set_disabled_builtins(["tostring"]);

    assert!(compiler.compile("return tostring(vector.new(1, 2, 3))").is_ok());

@@ -142,16 +141,14 @@ fn test_compiler() -> Result<()> {
 #[cfg(feature = "luau")]
 #[test]
 fn test_compiler_library_constants() {
-    use mlua::{CompileConstant, Compiler, Vector};
+    use mlua::{Compiler, Vector};

    let compiler = Compiler::new()
        .set_optimization_level(2)
-        .set_library_constants(vec![
-            ("mylib", "const_bool", CompileConstant::Boolean(true)),
-            ("mylib", "const_num", CompileConstant::Number(123.0)),
-            ("mylib", "const_vec", CompileConstant::Vector(Vector::zero())),
-            ("mylib", "const_str", "value1".into()),
-        ]);
+        .add_library_constant("mylib.const_bool", true)
+        .add_library_constant("mylib.const_num", 123.0)
+        .add_library_constant("mylib.const_vec", Vector::zero())
+        .add_library_constant("mylib.const_str", "value1");

    let lua = Lua::new();
    lua.set_compiler(compiler);
@@ -267,7 +267,7 @@ fn test_registry_value_into_lua() -> Result<()> {
    let r = lua.create_registry_value(&s)?;
    let value1 = lua.pack(&r)?;
    let value2 = lua.pack(r)?;
-    assert_eq!(value1.as_str().as_deref(), Some("hello, world"));
+    assert_eq!(value1.to_string()?, "hello, world");
    assert_eq!(value1.to_pointer(), value2.to_pointer());

    // Push into stack
@@ -560,11 +560,11 @@ fn test_osstring_into_from_lua() -> Result<()> {

    let v = lua.pack(s.as_os_str())?;
    assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), "hello, world");
+    assert_eq!(v.as_string().unwrap(), "hello, world");

    let v = lua.pack(s)?;
    assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), "hello, world");
+    assert_eq!(v.as_string().unwrap(), "hello, world");

    let s = lua.create_string("hello, world")?;
    let bstr = lua.unpack::<OsString>(Value::String(s))?;
@@ -588,11 +588,11 @@ fn test_pathbuf_into_from_lua() -> Result<()> {

    let v = lua.pack(pb.as_path())?;
    assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), pb_str);
+    assert_eq!(v.to_string().unwrap(), pb_str);

    let v = lua.pack(pb.clone())?;
    assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), pb_str);
+    assert_eq!(v.to_string().unwrap(), pb_str);

    let s = lua.create_string(pb_str)?;
    let bstr = lua.unpack::<PathBuf>(Value::String(s))?;
@@ -724,7 +724,7 @@ fn test_char_into_lua() -> Result<()> {

    let v = '🦀';
    let v2 = v.into_lua(&lua)?;
-    assert_eq!(Some(v.to_string()), v2.as_string_lossy());
+    assert_eq!(*v2.as_string().unwrap(), v.to_string());

    Ok(())
 }
@@ -24,7 +24,7 @@ fn test_line_counts() -> Result<()> {
    let lua = Lua::new();
    lua.set_hook(HookTriggers::EVERY_LINE, move |_lua, debug| {
        assert_eq!(debug.event(), DebugEvent::Line);
-        hook_output.lock().unwrap().push(debug.curr_line());
+        hook_output.lock().unwrap().push(debug.current_line().unwrap());
        Ok(VmState::Continue)
    })?;
    lua.load(
@@ -240,7 +240,7 @@ fn test_hook_threads() -> Result<()> {
    let hook_output = output.clone();
    co.set_hook(HookTriggers::EVERY_LINE, move |_lua, debug| {
        assert_eq!(debug.event(), DebugEvent::Line);
-        hook_output.lock().unwrap().push(debug.curr_line());
+        hook_output.lock().unwrap().push(debug.current_line().unwrap());
        Ok(VmState::Continue)
    })?;

@@ -3,7 +3,6 @@
 use std::cell::Cell;
 use std::fmt::Debug;
 use std::os::raw::c_void;
-use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU64, Ordering};
 use std::sync::Arc;

@@ -120,11 +119,13 @@ fn test_vector_metatable() -> Result<()> {
    "#,
        )
        .eval::<Table>()?;
-    vector_mt.set_metatable(Some(vector_mt.clone()));
+    vector_mt.set_metatable(Some(vector_mt.clone()))?;
    lua.set_type_metatable::<Vector>(Some(vector_mt.clone()));
    lua.globals().set("Vector3", vector_mt)?;

-    let compiler = Compiler::new().set_vector_lib("Vector3").set_vector_ctor("new");
+    let compiler = Compiler::new()
+        .set_vector_ctor("Vector3.new")
+        .set_vector_type("Vector3");

    // Test vector methods (fastcall)
    lua.load(
@@ -167,9 +168,9 @@ fn test_readonly_table() -> Result<()> {
    check_readonly_error(t.raw_pop::<Value>());

    // Special case
-    match catch_unwind(AssertUnwindSafe(|| t.set_metatable(None))) {
-        Ok(_) => panic!("expected panic, got nothing"),
-        Err(_) => {}
+    match t.set_metatable(None) {
+        Err(Error::RuntimeError(e)) if e.contains("attempt to modify a readonly table") => {}
+        r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
    }

    Ok(())
@@ -329,6 +330,15 @@ fn test_interrupts() -> Result<()> {
    assert_eq!(yield_count.load(Ordering::Relaxed), 7);
    assert_eq!(co.status(), ThreadStatus::Finished);

+    // Test no yielding at non-yieldable points
+    yield_count.store(0, Ordering::Relaxed);
+    let co = lua.create_thread(lua.create_function(|lua, arg: Value| {
+        (lua.load("return (function(x) return x end)(...)")).call::<Value>(arg)
+    })?)?;
+    let res = co.resume::<String>("abc")?;
+    assert_eq!(res, "abc".to_string());
+    assert_eq!(yield_count.load(Ordering::Relaxed), 3);
+
    //
    // Test errors in interrupts
    //
@@ -179,6 +179,11 @@ fn test_require_with_config() {
    let res = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer").unwrap();
    assert_eq!("result from dependency", get_str(&res, 1));

+    // RequirePathWithAlias (case-insensitive)
+    let res2 = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer_uc").unwrap();
+    assert_eq!("result from dependency", get_str(&res2, 1));
+    assert_eq!(res.to_pointer(), res2.to_pointer());
+
    // RequirePathWithParentAlias
    let res = run_require(&lua, "./tests/luau/require/with_config/src/parent_alias_requirer").unwrap();
    assert_eq!("result from other_dependency", get_str(&res, 1));
@@ -0,0 +1 @@
+return require("@DeP")
@@ -43,12 +43,12 @@ fn test_result_conversions() -> Result<()> {
    let multi_err1 = err1.into_lua_multi(&lua)?;
    assert_eq!(multi_err1.len(), 2);
    assert_eq!(multi_err1[0], Value::Nil);
-    assert_eq!(multi_err1[1].as_str().unwrap(), "failure1");
+    assert_eq!(multi_err1[1].as_string().unwrap(), "failure1");

    let ok2 = Ok::<_, Error>("!");
    let multi_ok2 = ok2.into_lua_multi(&lua)?;
    assert_eq!(multi_ok2.len(), 1);
-    assert_eq!(multi_ok2[0].as_str().unwrap(), "!");
+    assert_eq!(multi_ok2[0].as_string().unwrap(), "!");
    let err2 = Err::<String, _>("failure2".into_lua_err());
    let multi_err2 = err2.into_lua_multi(&lua)?;
    assert_eq!(multi_err2.len(), 2);
@@ -382,7 +382,8 @@ fn test_scope_userdata_ref() -> Result<()> {
        modify_userdata(&lua, &ud)?;

        // We can only borrow userdata scoped
-        assert!((matches!(ud.borrow::<MyUserData>(), Err(Error::UserDataTypeMismatch))));
+        #[rustfmt::skip]
+        assert!(matches!(ud.borrow::<MyUserData>(), Err(Error::UserDataTypeMismatch)));
        ud.borrow_scoped::<MyUserData, ()>(|ud_inst| {
            assert_eq!(ud_inst.0.get(), 2);
        })?;
@@ -419,7 +420,8 @@ fn test_scope_userdata_ref_mut() -> Result<()> {
        let ud = scope.create_userdata_ref_mut(&mut data)?;
        modify_userdata(&lua, &ud)?;

-        assert!((matches!(ud.borrow_mut::<MyUserData>(), Err(Error::UserDataTypeMismatch))));
+        #[rustfmt::skip]
+        assert!(matches!(ud.borrow_mut::<MyUserData>(), Err(Error::UserDataTypeMismatch)));
        ud.borrow_mut_scoped::<MyUserData, ()>(|ud_inst| {
            ud_inst.0 += 10;
        })?;
@@ -25,7 +25,7 @@ fn test_serialize() -> Result<(), Box<dyn StdError>> {
    globals.set("null", lua.null())?;

    let empty_array = lua.create_table()?;
-    empty_array.set_metatable(Some(lua.array_metatable()));
+    empty_array.set_metatable(Some(lua.array_metatable()))?;
    globals.set("empty_array", empty_array)?;

    let val = lua
@@ -173,7 +173,7 @@ fn test_serialize_sorted() -> LuaResult<()> {
    globals.set("null", lua.null())?;

    let empty_array = lua.create_table()?;
-    empty_array.set_metatable(Some(lua.array_metatable()));
+    empty_array.set_metatable(Some(lua.array_metatable()))?;
    globals.set("empty_array", empty_array)?;

    let value = lua
@@ -61,6 +61,15 @@ fn test_table() -> Result<()> {
    Ok(())
 }

+#[test]
+#[cfg(target_os = "linux")] // Linux allow overcommiting the memory (relevant for CI)
+fn test_table_with_large_capacity() {
+    let lua = Lua::new();
+
+    let t = lua.create_table_with_capacity(1 << 26, 1 << 26);
+    assert!(t.is_ok());
+}
+
 #[test]
 fn test_table_push_pop() -> Result<()> {
    let lua = Lua::new();
@@ -298,10 +307,10 @@ fn test_metatable() -> Result<()> {
    let table = lua.create_table()?;
    let metatable = lua.create_table()?;
    metatable.set("__index", lua.create_function(|_, ()| Ok("index_value"))?)?;
-    table.set_metatable(Some(metatable));
+    table.set_metatable(Some(metatable))?;
    assert_eq!(table.get::<String>("any_key")?, "index_value");
    assert_eq!(table.raw_get::<Value>("any_key")?, Value::Nil);
-    table.set_metatable(None);
+    table.set_metatable(None)?;
    assert_eq!(table.get::<Value>("any_key")?, Value::Nil);

    Ok(())
@@ -147,6 +147,31 @@ fn test_eval() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_replace_globals() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.create_table()?;
+    globals.set("foo", "bar")?;
+
+    lua.set_globals(globals.clone())?;
+    let val = lua.load("return foo").eval::<StdString>()?;
+    assert_eq!(val, "bar");
+
+    // Updating globals in sandboxed Lua state is not allowed
+    #[cfg(feature = "luau")]
+    {
+        lua.sandbox(true)?;
+        match lua.set_globals(globals) {
+            Err(Error::RuntimeError(msg))
+                if msg.contains("cannot change globals in a sandboxed Lua state") => {}
+            r => panic!("expected RuntimeError(...) with a specific error message, got {r:?}"),
+        }
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_load_mode() -> Result<()> {
    let lua = unsafe { Lua::unsafe_new() };
@@ -577,6 +602,21 @@ fn test_num_conversion() -> Result<()> {

    assert_eq!(lua.unpack::<i128>(lua.pack(1i128 << 64)?)?, 1i128 << 64);

+    // Negative zero
+    let negative_zero = lua.load("-0.0").eval::<f64>()?;
+    assert_eq!(negative_zero, 0.0);
+    // LuaJIT treats -0.0 as a positive zero
+    #[cfg(not(feature = "luajit"))]
+    assert!(negative_zero.is_sign_negative());
+
+    // In Lua <5.3 all numbers are floats
+    #[cfg(not(any(feature = "lua54", feature = "lua53", feature = "luajit")))]
+    {
+        let negative_zero = lua.load("-0").eval::<f64>()?;
+        assert_eq!(negative_zero, 0.0);
+        assert!(negative_zero.is_sign_negative());
+    }
+
    Ok(())
 }

@@ -1202,6 +1242,17 @@ fn test_register_module() -> Result<()> {
            res.unwrap_err().to_string(),
            "runtime error: module name must begin with '@'"
        );
+
+        // Luau registered modules (aliases) are case-insensitive
+        let res = lua.register_module("@My_Module", &t);
+        assert!(res.is_ok());
+        lua.load(
+            r#"
+            local my_module = require("@MY_MODule")
+            assert(my_module.name == "my_module")
+        "#,
+        )
+        .exec()?;
    }

    Ok(())
@@ -1251,14 +1302,18 @@ fn test_inspect_stack() -> Result<()> {
    let lua = Lua::new();

    // Not inside any function
-    assert!(lua.inspect_stack(0).is_none());
+    assert!(lua.inspect_stack(0, |_| ()).is_none());

    let logline = lua.create_function(|lua, msg: StdString| {
-        let debug = lua.inspect_stack(1).unwrap(); // caller
-        let source = debug.source().short_src;
-        let source = source.as_deref().unwrap_or("?");
-        let line = debug.curr_line();
-        Ok(format!("{}:{} {}", source, line, msg))
+        let r = lua
+            .inspect_stack(1, |debug| {
+                let source = debug.source().short_src;
+                let source = source.as_deref().unwrap_or("?");
+                let line = debug.current_line().unwrap();
+                format!("{}:{} {}", source, line, msg)
+            })
+            .unwrap();
+        Ok(r)
    })?;
    lua.globals().set("logline", logline)?;

@@ -1281,8 +1336,7 @@ fn test_inspect_stack() -> Result<()> {
    .exec()?;

    let stack_info = lua.create_function(|lua, ()| {
-        let debug = lua.inspect_stack(1).unwrap(); // caller
-        let stack_info = debug.stack();
+        let stack_info = lua.inspect_stack(1, |debug| debug.stack()).unwrap();
        Ok(format!("{stack_info:?}"))
    })?;
    lua.globals().set("stack_info", stack_info)?;
@@ -1312,6 +1366,25 @@ fn test_inspect_stack() -> Result<()> {
    )
    .exec()?;

+    // Test retrieving currently running function
+    let running_function =
+        lua.create_function(|lua, ()| Ok(lua.inspect_stack(1, |debug| debug.function())))?;
+    lua.globals().set("running_function", running_function)?;
+    lua.load(
+        r#"
+        local function baz()
+            return running_function()
+        end
+        if jit == nil then
+            assert(baz() == baz)
+        else
+            -- luajit inline the "baz" function and returns the chunk itself
+            assert(baz() == running_function())
+        end
+    "#,
+    )
+    .exec()?;
+
    Ok(())
 }

@@ -1,6 +1,6 @@
 use std::panic::catch_unwind;

-use mlua::{Error, Function, Lua, Result, Thread, ThreadStatus};
+use mlua::{Error, Function, IntoLua, Lua, Result, Thread, ThreadStatus, Value};

 #[test]
 fn test_thread() -> Result<()> {
@@ -252,3 +252,24 @@ fn test_thread_resume_error() -> Result<()> {

    Ok(())
 }
+
+#[test]
+fn test_thread_resume_bad_arg() -> Result<()> {
+    let lua = Lua::new();
+
+    struct BadArg;
+
+    impl IntoLua for BadArg {
+        fn into_lua(self, _lua: &Lua) -> Result<Value> {
+            Err(Error::runtime("bad arg"))
+        }
+    }
+
+    let f = lua.create_thread(lua.create_function(|_, ()| Ok("okay"))?)?;
+    let res = f.resume::<()>((123, BadArg));
+    assert!(matches!(res, Err(Error::RuntimeError(msg)) if msg == "bad arg"));
+    let res = f.resume::<String>(()).unwrap();
+    assert_eq!(res, "okay");
+
+    Ok(())
+}
@@ -525,6 +525,11 @@ fn test_fields() -> Result<()> {
                Ok(())
            });

+            // Field that emulates method
+            fields.add_field_function_get("val_fget", |lua, ud| {
+                lua.create_function(move |_, ()| Ok(ud.borrow::<MyUserData>()?.0))
+            });
+
            // Use userdata "uservalue" storage
            fields.add_field_function_get("uval", |_, ud| ud.user_value::<Option<String>>());
            fields.add_field_function_set("uval", |_, ud, s: Option<String>| ud.set_user_value(s));
@@ -537,6 +542,10 @@ fn test_fields() -> Result<()> {
                })
            })
        }
+
+        fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+            methods.add_method("dummy", |_, _, ()| Ok(()));
+        }
    }

    globals.set("ud", MyUserData(7))?;
@@ -546,6 +555,7 @@ fn test_fields() -> Result<()> {
        assert(ud.val == 7)
        ud.val = 10
        assert(ud.val == 10)
+        assert(ud:val_fget() == 10)

        assert(ud.uval == nil)
        ud.uval = "hello"
@@ -255,16 +255,7 @@ fn test_value_conversions() -> Result<()> {
        Value::String(lua.create_string("hello")?).as_string().unwrap(),
        "hello"
    );
-    assert_eq!(
-        Value::String(lua.create_string("hello")?).as_str().unwrap(),
-        "hello"
-    );
-    assert_eq!(
-        Value::String(lua.create_string("hello")?)
-            .as_string_lossy()
-            .unwrap(),
-        "hello"
-    );
+    assert_eq!(Value::String(lua.create_string("hello")?).to_string()?, "hello");
    assert!(Value::Table(lua.create_table()?).is_table());
    assert!(Value::Table(lua.create_table()?).as_table().is_some());
    assert!(Value::Function(lua.create_function(|_, ()| Ok(())).unwrap()).is_function());
Author	SHA1	Message	Date
Alex Orlenko	13ff0ca798	v0.11.3	2025-08-29 23:11:21 +01:00
Alex Orlenko	44f49e35d6	Update CHANGELOG	2025-08-29 00:18:06 +01:00
Alex Orlenko	e1ee4058a6	Add new benchmark to measure complex userdata method calls	2025-08-28 23:56:03 +01:00
Alex Orlenko	f06d0020ea	Add test to emulate method through field	2025-08-28 23:50:18 +01:00
Alex Orlenko	d399559d30	Add `Lua::yield_with` to allow yielding Rust async functions and exchange values between Lua coroutine and Rust. This functionality is similar to `coroutine.yield` and `coroutine.resume` without C restrictions.	2025-08-28 18:41:24 +01:00
Alex Orlenko	30735d5ff1	Fix thread recovery when pushing a bad arg We should not erase thread stack if a bad argument is pushed before resuming the thread.	2025-08-25 23:07:37 +01:00
Alex Orlenko	75c23e5853	Add `lua_cpcall` to Luau ffi (0.688+)	2025-08-25 12:54:17 +01:00
Alex Orlenko	347856b806	Do not try to yield at non-yielable points in Luau interrupt In particular we cannot yeild across metamethod/C-call boundaries. This behaviour matches with Lua 5.3+ yielding from hooks only at safe points. Closes #632	2025-08-25 12:19:50 +01:00
Alex Orlenko	774a63bece	Add `Buffer::cursor()` method This can be useful for providing access to buffers through core IO traits.	2025-08-24 11:29:01 +01:00
Alex Orlenko	c481c87eac	Add `Lua::create_buffer_with_capacity` method This allow creating a preallocated buffer with specified size initialized to zero.	2025-08-23 22:38:55 +01:00
Alex Orlenko	85b280a9d6	Update nightly Rust error message matching	2025-08-23 09:40:13 +01:00
Alex Orlenko	db7b782d3c	Remove lifetimes from short type names	2025-08-23 09:13:31 +01:00
Alex Orlenko	5f38445558	Fix warnings	2025-08-20 16:25:06 +01:00
Alex Orlenko	df0a44d405	Make Lua reference values cheap to clone Instead of locking the VM and making a copy on auxiliary thread, track number of references using Rust ref counter. This should also help reducing number of used references (they are limited to to 1M usually) on auxiliary thread.	2025-08-20 12:05:37 +01:00
Alex Orlenko	f0806a6d62	Lower fastpath table creation limit to 1 << 26 When Lua is configured without memory restrictions, we use fastpath for table creation (unprotected mode). In generally it's safe as long as we `abort()` on allocation failure. However some Lua versions have additional restrictions on table size that we need to adhere in mlua too. Probably Luau has the lowest limits. Fixes #627	2025-08-13 22:49:40 +01:00
Alex Orlenko	3516f4c6ca	v0.11.2	2025-08-10 00:53:45 +01:00
Alex Orlenko	ca73583714	Update CHANGELOG	2025-08-10 00:53:01 +01:00
Alex Orlenko	36560435f7	Add `push_into_stack_multi` fastpath to `Variadic`	2025-08-10 00:35:51 +01:00
Alex Orlenko	763c2b2564	Update `repl` example: don't print newline if no values returned	2025-08-10 00:20:20 +01:00
Alex Orlenko	bafdb6138c	Update dependencies	2025-08-10 00:19:54 +01:00
Alex Orlenko	c9d6a610e1	mlua-sys: v0.8.3	2025-08-10 00:11:05 +01:00
Alex Orlenko	bd63f63bc9	Use ascii lowercase for module aliases This matches with Luau 0.686 changes	2025-08-09 19:14:31 +01:00
piz-ewing	c035c23a15	fix: normalize_chunk_name handles Windows paths with drive letter (#623 ) Co-authored-by: ewing <ewing@MacBook-Pro.local>	2025-08-04 22:34:36 +01:00
Alex Orlenko	cb153a52b2	Make Luau registered aliases case-insensitive Executing `require("@my_module")` or `require("@My_Module")` should give the same result and use case-insensitive name. See #620 for details	2025-07-26 22:23:16 +01:00
Alex Orlenko	b1c69d3005	Use `to_bits` comparison to check if a float value can be represented as an integer losslessly. This allows to simplify the code while still maintaining "negative zeros" edge case. Thanks @JasonHise for the suggestion.	2025-07-25 21:25:08 +01:00
Alex Orlenko	841bd332e4	Fix LuaJIT negative zero tests	2025-07-25 15:24:04 +01:00
Alex Orlenko	815d1bd7c9	Better handling negative zeros to match Lua 5.3+ behavior In Lua 5.3+ the function `lua_isinteger` returns "false" for -0.0 numbers. In earlier Lua versions we should follow the same behavior to avoid losing the sign when converting to Integer. Close #618	2025-07-25 14:32:47 +01:00
Alex Orlenko	78331ceebe	v0.11.1	2025-07-15 22:43:18 +01:00
Alex Orlenko	f945a35cbd	Execute metatable destructor in `Table::set_metatable` at the end of invocation Before this change, destructor was executed shortly after pushing metatable to ref_thread.	2025-07-15 19:14:46 +01:00
Alex Orlenko	459edb6816	Always grow aux ref stack considering the reserve	2025-07-15 16:32:22 +01:00
Alex Orlenko	00328b0b64	Protect `Lua::push_c_function` for Lua <5.2	2025-07-15 16:11:31 +01:00
Alex Orlenko	928d94d255	v0.11.0	2025-07-14 15:33:02 +01:00
Alex Orlenko	583c35a172	Prepare for v0.11.0	2025-07-12 22:47:20 +01:00
Alex Orlenko	1791c599f4	mlua-sys: v0.8.2	2025-07-12 22:46:37 +01:00
Alex Orlenko	1e48817a64	Fix deregistering previously-registered userdata	2025-07-12 19:20:15 +01:00
Alex Orlenko	8d219503dd	Opt-out from `R: MaybeSend` in `AsyncThread<R>`	2025-07-12 15:34:04 +01:00
Alex Orlenko	95367855c1	Return `AsyncCallFuture<R>` instead of opaque `impl Future` from `ObjectLike` trait.	2025-07-12 15:30:58 +01:00
Alex Orlenko	49389c4aa4	Wrap `Function::coverage` callback to `RefCell` (Luau)	2025-07-12 13:34:39 +01:00
Alex Orlenko	13dc2b5352	Don't release Lua lock prematurely when when accessing `Buffer` bytes (Luau)	2025-07-12 13:08:33 +01:00
Alex Orlenko	7afbf74128	Add `MaybeSend` bound to async methods on `ObjectLike` trait (sealed)	2025-07-12 12:45:36 +01:00
Alex Orlenko	06c3bd9d69	Fix serde README section (close #613 )	2025-07-12 11:50:11 +01:00
Alex Orlenko	1ddaea60ce	Bump luau-src to 0.15.4+luau682	2025-07-12 11:27:41 +01:00
Alex Orlenko	a653d08768	Simplify `Compiler::add_library_constant` (combine `lib` and `member`)	2025-07-09 00:11:46 +01:00
Alex Orlenko	2b6b0144a1	Merge `Compiler::set_vector_lib` into `set_vector_ctor`	2025-07-08 23:55:45 +01:00
Alex Orlenko	4cfe0be945	Update CHANGELOG	2025-07-08 23:22:18 +01:00
Alex Orlenko	a9a4814c3c	Use StdString for consistency in `chunk.rs`	2025-07-08 22:25:23 +01:00
Alex Orlenko	b1f73ec29d	Update Luau `Compiler` methods to better control extra options: - Add `add_mutable_global` - Add `add_userdata_type` - Replace `set_library_constants` with `add_library_constant` - Add `add_disabled_builtin`	2025-07-08 22:22:44 +01:00
Alex Orlenko	61a2141151	Don't panic when fourth library searcher does not exists. When disabling C modules, we remove the last two searchers (C & C all-in-one). In Pluto the C searches may not exist by design, in this case check that 4th searcher is present before removing it. Closes #530	2025-07-08 13:37:48 +01:00
Alex Orlenko	dea38f27a5	Change `!cfg!(..)` to `cfg!(not(..))` for better readability	2025-07-08 10:42:15 +01:00
Sculas	04aaa18dc8	feat: Allow external build scripts to link Lua libraries (#529 ) Allow external build scripts to link Lua libraries	2025-07-08 10:30:26 +01:00
Alex Orlenko	d8455c038a	Update CHANGELOG	2025-07-08 10:12:03 +01:00
Alex Orlenko	ca22ea3be7	Deprecate `Debug::curr_line()` in favour of `Debug::current_line()` that returns `Option`	2025-07-08 10:09:26 +01:00
Alex Orlenko	cf05593d66	Fix `Debug::is_tail_call`	2025-07-08 10:05:37 +01:00
Alex Orlenko	d011a1f851	Update CHANGELOG	2025-07-07 23:15:46 +01:00
Alex Orlenko	1ec4661bf9	mlua_derive: v0.11.0	2025-07-07 22:58:41 +01:00
Alex Orlenko	d3b2999d2f	Remove `MaybeSend` requirement from `Require` trait and add to `Lua::create_require_function` instead	2025-07-07 22:58:24 +01:00
Alex Orlenko	72f6536efb	Check table requested capacity limits before enabling unprotected mode. Lua tables have limits and can overflow, which must be captured in protected mode.	2025-07-07 22:57:30 +01:00
Alex Orlenko	646827a6bb	Update `Table::set_metatable` - Return Err (instead of panic) when trying to change readonly table (Luau) - Slightly optimize performance	2025-07-06 11:37:02 +01:00
Alex Orlenko	1882931cd9	Optimize `Table::metatable`	2025-07-06 10:57:26 +01:00
Alex Orlenko	c90cac5189	Add `Lua::set_globals` method to replace global environment. Closes #611	2025-07-06 10:57:25 +01:00
Alex Orlenko	c0d839d8d2	Make `Thread::state` pub (hidden)	2025-07-05 22:36:47 +01:00
Alex Orlenko	80471c6dad	Optimize `AnyUserData::metatable`	2025-07-05 11:33:11 +01:00
Alex Orlenko	4b9d1cf271	Replace `impl ToString` with `Into<StdString>` This is a more canonical way to accept any types of stirng but not arbitrary types that implement `Display`	2025-07-05 11:21:18 +01:00
Alex Orlenko	55c07f3b28	Some minor changes in Luau TextRequirer (comments, naming, etc)	2025-07-03 14:42:24 +01:00
Alex Orlenko	ef4eabd327	Don't use `Value::as_str()` internally	2025-07-01 22:51:16 +01:00
Alex Orlenko	a3302afdc1	Deprecate `Value::as_str` and `Value::as_string_lossy` These methods don't follow Rust naming convention, see https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv	2025-07-01 22:35:40 +01:00
Alex Orlenko	dfb4e9a668	Fix LuaJIT stack inspection tests	2025-07-01 21:40:06 +01:00
Alex Orlenko	92db0f6d3a	Fix `Lua::inspect_stack` callback proto	2025-06-30 23:28:04 +01:00
Alex Orlenko	a3697ab1db	Add `Debug::function` method to get function running at a given level. Close #607	2025-06-30 23:25:36 +01:00
Alex Orlenko	052740db15	Save `lua_State` at the moment of constructing `Debug` instead of resolving it dynamically	2025-06-30 22:38:46 +01:00
Alex Orlenko	faf547c154	Refactor `Lua::inspect_stack` and debug interface. It was possible to cause a crash when getting a `Debug` instance and keeping it while deallocating the Lua stack frames.	2025-06-30 12:21:10 +01:00
Alex Orlenko	0de7cd1c7d	Don't move or wrap `ffi::lua_Debug` struct when inspecting stack This can cause a crash if `ffi::lua_Debug` changed between `lua_getstack` and `lua_getinfo` calls. Fixes #610	2025-06-29 11:49:34 +01:00