v0.12.0-rc.2

clippy
Support to_alias_override/to_alias_fallback in Require trait (Luau)
2026-06-08 16:05:43 +00:00 · 2026-06-06 14:28:31 +01:00 · 2026-06-06 14:28:31 +01:00 · 2026-06-06 14:11:59 +01:00 · 2026-06-01 00:25:12 +01:00 · 2026-05-31 13:45:48 +01:00
230 changed files with 15256 additions and 4946 deletions
@@ -0,0 +1,68 @@
+name: Documentation (main)
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Build Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Build documentation
+        env:
+          RUSTDOCFLAGS: "--cfg docsrs"
+        run: |
+          cargo +nightly doc --no-deps \
+            --features "lua55,vendored,async,send,serde,macros,anyhow,userdata-wrappers"
+
+      - name: Create index redirect
+        run: |
+          echo '<!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <title>Redirecting to mlua documentation</title>
+              <meta http-equiv="refresh" content="0; URL=mlua/index.html">
+              <link rel="canonical" href="mlua/index.html">
+            </head>
+            <body>
+              <p>Redirecting to <a href="mlua/index.html">mlua documentation</a>...</p>
+            </body>
+          </html>' > target/doc/index.html
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: target/doc
+
+  deploy:
+    name: Deploy to GitHub Pages
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
@@ -9,12 +9,12 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
          - os: macos-latest
-            target: x86_64-apple-darwin
+            target: aarch64-apple-darwin
          - os: windows-latest
            target: x86_64-pc-windows-msvc
    steps:
@@ -27,39 +27,23 @@ jobs:
      - name: Build ${{ matrix.lua }} vendored
        run: |
          cargo build --features "${{ matrix.lua }},vendored"
-          cargo build --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
-          cargo build --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send"
+          cargo build --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
+          cargo build --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send"
        shell: bash
      - name: Build ${{ matrix.lua }} pkg-config
-        if: ${{ matrix.os == 'ubuntu-latest' }}
+        if: ${{ matrix.os == 'ubuntu-latest' && matrix.lua != 'lua55' }}
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends liblua5.4-dev liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
          cargo build --features "${{ matrix.lua }}"

-  build_aarch64_cross_macos:
-    name: Cross-compile to aarch64-apple-darwin
-    runs-on: macos-latest
-    needs: build
-    strategy:
-      matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit]
-    steps:
-      - uses: actions/checkout@main
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          target: aarch64-apple-darwin
-      - name: Cross-compile
-        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
-
  build_aarch64_cross_ubuntu:
    name: Cross-compile to aarch64-unknown-linux-gnu
    runs-on: ubuntu-latest
    needs: build
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit]
    steps:
      - uses: actions/checkout@main
      - uses: dtolnay/rust-toolchain@stable
@@ -72,7 +56,7 @@ jobs:
          sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
        shell: bash
      - name: Cross-compile
-        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
        shell: bash

  build_armv7_cross_ubuntu:
@@ -81,7 +65,7 @@ jobs:
    needs: build
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51]
+        lua: [lua55, lua54, lua53, lua52, lua51]
    steps:
      - uses: actions/checkout@main
      - uses: dtolnay/rust-toolchain@stable
@@ -94,7 +78,7 @@ jobs:
          sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
        shell: bash
      - name: Cross-compile
-        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
        shell: bash

  test:
@@ -105,12 +89,12 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
          - os: macos-latest
-            target: x86_64-apple-darwin
+            target: aarch64-apple-darwin
          - os: windows-latest
            target: x86_64-pc-windows-msvc
    steps:
@@ -123,14 +107,14 @@ jobs:
      - name: Run ${{ matrix.lua }} tests
        run: |
          cargo test --features "${{ matrix.lua }},vendored"
-          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
-          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send"
+          cargo test --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
+          cargo test --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send"
        shell: bash
-      - name: Run compile tests (macos lua54)
-        if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
+      - name: Run compile tests (macos lua55)
+        if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua55' }}
        run: |
-          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" -- --ignored
-          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros" -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" --tests -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serde,macros" --tests -- --ignored
        shell: bash

  test_with_sanitizer:
@@ -141,7 +125,7 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
@@ -154,8 +138,8 @@ jobs:
      - uses: Swatinem/rust-cache@v2
      - name: Run ${{ matrix.lua }} tests with address sanitizer
        run: |
-          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
-          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
        shell: bash
        env:
          RUSTFLAGS: -Z sanitizer=address
@@ -168,7 +152,7 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
@@ -181,7 +165,7 @@ jobs:
      - uses: Swatinem/rust-cache@v2
      - name: Run ${{ matrix.lua }} tests with forced memory limit
        run: |
-          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
        shell: bash
        env:
          RUSTFLAGS: --cfg=force_memory_limit
@@ -194,12 +178,12 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest]
        rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit]
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
          - os: macos-latest
-            target: x86_64-apple-darwin
+            target: aarch64-apple-darwin
    steps:
      - uses: actions/checkout@main
      - uses: dtolnay/rust-toolchain@stable
@@ -240,7 +224,7 @@ jobs:
    needs: build
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51, luau]
+        lua: [lua55, lua54, lua53, lua52, lua51, luau]
    steps:
      - uses: actions/checkout@main
      - uses: dtolnay/rust-toolchain@stable
@@ -254,7 +238,42 @@ jobs:
      - name: Run ${{ matrix.lua }} tests
        run: |
          cargo test --tests --features "${{ matrix.lua }},vendored"
-          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
+
+  test_wasm32_wasip2:
+    name: Test on wasm32-wasip2
+    runs-on: ubuntu-latest
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua55, lua54, lua53, lua52, lua51]
+    steps:
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: nightly-2025-10-02
+          target: wasm32-wasip2
+      - name: Install wasi-sdk/Wasmtime
+        working-directory: ${{ runner.tool_cache }}
+        run: |
+          wasi_sdk=29
+          wasmtime=v40.0.1
+
+          curl -LO https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-$wasi_sdk/wasi-sdk-$wasi_sdk.0-x86_64-linux.tar.gz
+          tar xf wasi-sdk-$wasi_sdk.0-x86_64-linux.tar.gz
+          WASI_SDK_PATH=`pwd`/wasi-sdk-$wasi_sdk.0-x86_64-linux
+          echo "WASI_SDK_PATH=$WASI_SDK_PATH" >> $GITHUB_ENV
+          echo "CC_wasm32_wasip2=$WASI_SDK_PATH/bin/clang" >> $GITHUB_ENV
+          echo "CARGO_TARGET_WASM32_WASIP2_LINKER=$WASI_SDK_PATH/bin/clang" >> $GITHUB_ENV
+          echo "CARGO_TARGET_WASM32_WASIP2_RUSTFLAGS=-Clink-arg=-Wl,--export=cabi_realloc" >> $GITHUB_ENV
+
+          curl -LO https://github.com/bytecodealliance/wasmtime/releases/download/$wasmtime/wasmtime-$wasmtime-x86_64-linux.tar.xz
+          tar xf wasmtime-$wasmtime-x86_64-linux.tar.xz
+          echo "CARGO_TARGET_WASM32_WASIP2_RUNNER=`pwd`/wasmtime-$wasmtime-x86_64-linux/wasmtime -W exceptions" >> $GITHUB_ENV
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --target wasm32-wasip2 --tests --features "${{ matrix.lua }},vendored"
+          cargo test --target wasm32-wasip2 --tests --features "${{ matrix.lua }},vendored,serde,macros,anyhow,userdata-wrappers"

  rustfmt:
    name: Rustfmt
@@ -271,7 +290,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        lua: [lua55, lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
    steps:
      - uses: actions/checkout@main
      - uses: dtolnay/rust-toolchain@stable
@@ -281,4 +300,4 @@ jobs:
      - uses: giraffate/clippy-action@v1
        with:
          reporter: 'github-pr-review'
-          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
@@ -0,0 +1,22 @@
+name: Spelling Check
+on:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  CLICOLOR: 1
+
+jobs:
+  spelling:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Actions Repository
+      uses: actions/checkout@main
+    - name: Check spelling
+      uses: crate-ci/typos@v1.42.1
+      with:
+        config: ./typos.toml
@@ -1,4 +1,142 @@
-## v0.10.2 (Jan 27th, 2025)
+## v0.12.0-rc.2 (Jun 06, 2026)
+
+- Add `#[derive(UserData)]` and `#[mlua::userdata_impl]` macros
+- Support thread create/resume/yield callbacks for all Lua versions (including Luau)
+- Support `to_alias_override`/`to_alias_fallback` in `Require` trait (Luau)
+- Prevent `XRc` overflow when dropping `RawLua` with foreign Lua state
+- implement `Not` for `StdLib` (#699)
+- Fix `String::to_pointer` return NULL in Lua <5.4
+
+## v0.12.0-rc.1 (Apr 21, 2026)
+
+- Rust 2024 edition
+- Removed `Error::ToLuaConversionError` variant as it was unused (and not practically useful)
+- New modules to group data types: `chunk`, `debug`, `error`, `function`, `table`, `string`, `state`, `thread`, `userdata`, `luau`
+- Support `__todebugstring` metamethod for pretty formatting userdata value (for debugging)
+- New `MaybeSync` trait that is required for userdata types
+- Removed lifetime from `BorrowedStr` and `BorrowedBytes`
+- New `Thread` methods: `is_resumable`, `is_running`, `is_finished`, `is_error`
+- Added `Thread::state` to get raw Lua state pointer
+- Luau `TextRequirer` is renamed to `FsRequirer`
+- GC interface refactor: `Lua::gc_inc/Lua::gc_gen` is replaced with `gc_set_mode`
+- Added `GcIncParams` and `GcGenParams` for GC tuning
+- New `UserDataMethods::add_method_once` and `UserDataMethods::add_async_method_once`
+- Initial Luau integer64 type support
+- Changed interface of `Function::wrap/wrap_mut/wrap_async` to support any Error type
+- Changed `AnyUserData::type_name` to return `LuaString` instead
+- Added `UserDataOwned<T>` wrapper to take ownership of userdata `T` and implements `FromLua`
+
+## v0.11.6 (Jan 27, 2026)
+
+- Added Lua 5.5 support (`lua55` feature flag)
+- Luau updated to 0.705+
+- Added `AnyUserData::is_proxy` method to check if userdata is a proxy
+- Added `num_params`, `num_upvalues`, `is_vararg` to `FunctionInfo`
+
+## v0.11.5 (Nov 22, 2025)
+
+- Luau updated to 0.701
+- Added `Lua::set_memory_category` and `Lua::heap_dump` functions to profile (Luau) memory
+- Added `Lua::type_metatable` helper to get metatable of a primitive type
+- Added `Lua::traceback` function to generate stack traces at different levels
+- Added `add_method_once` /`add_async_method_once` UserData methods (experimental)
+- Make `AnyUserData::type_name` public
+- impl `IntoLuaMulti` for `&MultiValue`
+- Bugfixes and async perf improvements
+
+## v0.11.4 (Sep 29, 2025)
+
+- Make `Value::to_serializable` public
+- Add new serde option `detect_mixed_tables` (to encode mixed array+map tables)
+- Add `ObjectLike::get_path` helper (for tables and userdata)
+
+## 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)
+- `Function::deep_clone` now returns `Result<Function>` as this operation can trigger memory errors
+- Luau "Require" resolves included Lua files relative to the current directory (#605)
+- Fixed bug when finalizing `AsyncThread` on drop (`call_async` methods family)
+
+## v0.11.0-beta.2 (Jun 12, 2025)
+
+- Lua 5.4 updated to 5.4.8
+- Terminate Rust `Future` when `AsyncThread` is dropped (without relying on Lua GC)
+- Added `loadstring` function to Luau
+- Make `AsChunk` trait dyn-friendly
+- Luau `Require` trait synced with Luau 0.674
+- Luau `Require` trait methods now can return `Error` variant (in `NavigateError` enum)
+- Added `__type` to `Error`'s userdata metatable (for `typeof` function)
+- `parking_log/send_guard` is moved to `userdata-wrappers` feature flag
+- New `serde` feature flag to replace `serialize` (the old one is still available)
+
+## v0.11.0-beta.1 (May 7th, 2025)
+
+- New "require-by-string" for Luau (with `Require` trait and async support)
+- Added `Thread::resume_error` support for Luau
+- 52 bit integers support for Luau (this is a breaking change)
+- New features for Luau compiler (constants, disabled builtins, known members)
+- `AsyncThread<A, R>` changed to `AsyncThread<R>` (`A` pushed to stack immediately)
+- Lifetime `'a` moved from `AsChunk<'a>` to `AsChunk::source where Self: 'a`
+- `Lua::scope` pass `&Scope` instead of `&mut Scope` to closure
+- Added global hooks support (Lua 5.1+)
+- Added per-thread hooks support (Lua 5.1+)
+- `Lua::init_from_ptr` renamed to `Lua::get_or_init_from_ptr` and returns `&Lua`
+- `Lua:load_from_function` is deprecated (this is `register_module` now)
+- Added `Lua::register_module` and `Lua::preload_module`
+
+## v0.10.4 (May 5th, 2025)
+
+- Luau updated to 0.672
+- New serde option `encode_empty_tables_as_array` to serialize empty tables as arrays
+- Added `WeakLua` and `Lua::weak()` to create weak references to Lua state
+- Trigger abort when Luau userdata destructors are panic (Luau GC does not support it)
+- Added `AnyUserData::type_id()` method to get the type id of the userdata
+- Added `Chunk::name()`, `Chunk::environment()` and `Chunk::mode()` functions
+- Support borrowing underlying wrapped types for `UserDataRef` and `UserDataRefMut` (under `userdata-wrappers` feature)
+- Added large (52bit) integers support for Luau
+- Enable `serde` for `bstr` if `serialize` feature flag is enabled
+- Recursive warnings (Lua 5.4) are no longer allowed
+- Implemented `IntoLua`/`FromLua` for `BorrowedString` and `BorrowedBytes`
+- Implemented `IntoLua`/`FromLua` for `char`
+- Enable `Thread::reset()` for all Lua versions (limited support for 5.1-5.3)
+- Bugfixes and improvements
+
+## v0.10.3 (Jan 27th, 2025)

 - Set `Default` for `Value` to be `Nil`
 - Allow exhaustive match on `Value` (#502)
@@ -304,7 +442,7 @@ Other:

 ## v0.8.0
 Changes since 0.7.4
- Roblox Luau support
+- Luau support
 - Removed C glue
 - Added async support to `__index` and `__newindex` metamethods
 - Added `Function::info()` to get information about functions (#149).
@@ -354,7 +492,7 @@ Breaking changes:

 ## v0.8.0-beta.1

- Roblox Luau support
+- Luau support
 - Refactored ffi module. C glue is no longer required
 - Added async support to `__index` and `__newindex` metamethods

@@ -467,7 +605,7 @@ Breaking changes:
 - [**Breaking**] Removed `AnyUserData::has_metamethod()`
 - Added `Thread::reset()` for luajit/lua54 to recycle threads.
  It's possible to attach a new function to a thread (coroutine).
- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optinally capturing Rust variables.
+- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optionally capturing Rust variables.
 - Improved error reporting (`Error`'s `__tostring` method formats full stacktraces). This is useful in the module mode.

 ## v0.6.0-beta.1
@@ -523,7 +661,7 @@ Breaking changes:

 - Lua 5.4 support with `MetaMethod::Close`.
 - `lua53` feature is disabled by default. Now preferred Lua version have to be chosen explicitly.
- Provide safety guaraness for Lua state, which means that potenially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equalient for the previous `Lua::new()` function is `Lua::unsafe_new()`.
+- Provide safety guarantees for Lua state, which means that potentially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equivalent to the previous `Lua::new()` function is `Lua::unsafe_new()`.
 - New `send` feature to require `Send`.
 - New `module` feature, that disables linking to Lua Core Libraries. Required for modules.
 - Don't allow `'callback` outlive `'lua` in `Lua::create_function()` to fix [the unsoundness](tests/compile/static_callback_args.rs).
@@ -1,22 +1,22 @@
 [package]
 name = "mlua"
-version = "0.10.3" # remember to update mlua_derive
+version = "0.12.0-rc.2" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
-rust-version = "1.79.0"
-edition = "2021"
-repository = "https://github.com/khvzak/mlua"
+rust-version = "1.88"
+edition = "2024"
+repository = "https://github.com/mlua-rs/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
 keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
 description = """
-High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+High level bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
 with async/await features and support of writing native Lua modules in Rust.
 """

 [package.metadata.docs.rs]
-features = ["lua54", "vendored", "async", "send", "serialize", "macros"]
+features = ["lua55", "vendored", "async", "send", "serde", "macros"]
 rustdoc-args = ["--cfg", "docsrs"]

 [workspace]
@@ -26,27 +26,31 @@ members = [
 ]

 [features]
+lua55 = ["ffi/lua55"]
 lua54 = ["ffi/lua54"]
 lua53 = ["ffi/lua53"]
 lua52 = ["ffi/lua52"]
 lua51 = ["ffi/lua51"]
 luajit = ["ffi/luajit"]
 luajit52 = ["luajit", "ffi/luajit52"]
-luau = ["ffi/luau", "dep:libloading"]
+luau = ["ffi/luau"]
 luau-jit = ["luau", "ffi/luau-codegen"]
 luau-vector4 = ["luau", "ffi/luau-vector4"]
 vendored = ["ffi/vendored"]
-module = ["dep:mlua_derive", "ffi/module"]
+module = ["mlua_derive", "ffi/module"]
 async = ["dep:futures-util"]
-send = ["parking_lot/send_guard", "error-send"]
+send = ["error-send"]
 error-send = []
-serialize = ["dep:serde", "dep:erased-serde", "dep:serde-value"]
-macros = ["mlua_derive/macros"]
+serde = ["dep:serde", "dep:erased-serde", "dep:serde-value", "bstr/serde"]
+macros = ["mlua_derive/macros", "dep:inventory"]
 anyhow = ["dep:anyhow", "error-send"]
-userdata-wrappers = []
+userdata-wrappers = ["parking_lot/send_guard"]
+
+# deprecated features
+serialize = ["serde"]

 [dependencies]
-mlua_derive = { version = "=0.10.1", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.12.0-rc.1", optional = true, path = "mlua_derive" }
 bstr = { version = "1.0", features = ["std"], default-features = false }
 either = "1.0"
 num-traits = { version = "0.2.14" }
@@ -57,28 +61,27 @@ erased-serde = { version = "0.4", optional = true }
 serde-value = { version = "0.7", optional = true }
 parking_lot = { version = "0.12", features = ["arc_lock"] }
 anyhow = { version = "1.0", optional = true }
+inventory = { version = "0.3", optional = true }
+libc = "0.2"

-ffi = { package = "mlua-sys", version = "0.6.6", path = "mlua-sys" }
-
-[target.'cfg(unix)'.dependencies]
-libloading = { version = "0.8", optional = true }
+ffi = { package = "mlua-sys", version = "0.11.0-rc.1", path = "mlua-sys" }

 [dev-dependencies]
 trybuild = "1.0"
-hyper = { version = "1.2", features = ["full"] }
-hyper-util = { version = "0.1.3", features = ["full"] }
-http-body-util = "0.1.1"
-reqwest = { version = "0.12", features = ["json"] }
 tokio = { version = "1.0", features = ["macros", "rt", "time"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 maplit = "1.0"
-tempfile = "3"
 static_assertions = "1.0"

-[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-criterion = { version = "0.5", features = ["async_tokio"] }
-rustyline = "14.0"
+[target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
+hyper = { version = "1.2", features = ["full"] }
+hyper-util = { version = "0.1.3", features = ["full"] }
+http-body-util = "0.1.1"
+reqwest = { version = "0.13", features = ["json"] }
+tempfile = "3"
+criterion = { version = "0.8", features = ["async_tokio"] }
+rustyline = "18.0"
 tokio = { version = "1.0", features = ["full"] }

 [lints.rust]
@@ -92,7 +95,7 @@ required-features = ["async"]
 [[bench]]
 name = "serde"
 harness = false
-required-features = ["serialize"]
+required-features = ["serde"]

 [[example]]
 name = "async_http_client"
@@ -100,7 +103,7 @@ required-features = ["async", "macros"]

 [[example]]
 name = "async_http_reqwest"
-required-features = ["async", "serialize", "macros"]
+required-features = ["async", "serde", "macros"]

 [[example]]
 name = "async_http_server"
@@ -115,8 +118,8 @@ name = "guided_tour"
 required-features = ["macros"]

 [[example]]
-name = "serialize"
-required-features = ["serialize"]
+name = "serde"
+required-features = ["serde"]

 [[example]]
 name = "userdata"
@@ -1,8 +1,8 @@
 # mlua
 [![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io] ![MSRV]

-[Build Status]: https://github.com/khvzak/mlua/workflows/CI/badge.svg
-[github-actions]: https://github.com/khvzak/mlua/actions
+[Build Status]: https://github.com/mlua-rs/mlua/workflows/CI/badge.svg
+[github-actions]: https://github.com/mlua-rs/mlua/actions
 [Latest Version]: https://img.shields.io/crates/v/mlua.svg
 [crates.io]: https://crates.io/crates/mlua
 [API Documentation]: https://docs.rs/mlua/badge.svg
@@ -17,29 +17,28 @@
 [Benchmarks]: https://github.com/khvzak/script-bench-rs
 [FAQ]: FAQ.md

-> **Note**
->
-> See v0.10 [release notes](https://github.com/khvzak/mlua/blob/main/docs/release_notes/v0.10.md).
+## The main branch is the development version of `mlua`. Please see the [v0.11](https://github.com/mlua-rs/mlua/tree/v0.11) branch for the stable versions of `mlua`.

-`mlua` is bindings to [Lua](https://www.lua.org) programming language for Rust with a goal to provide
-_safe_ (as far as it's possible), high level, easy to use, practical and flexible API.
+`mlua` is a set of bindings to the [Lua](https://www.lua.org) programming language for Rust with a goal of providing a
+_safe_ (as much as possible), high level, easy to use, practical and flexible API.

-Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Roblox Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
+Started as an `rlua` fork, `mlua` supports Lua 5.5, 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Luau] and allows writing native Lua modules in Rust as well as using Lua in a standalone mode.

-`mlua` tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platform and cross-compilation to `aarch64` (other targets are also supported).
+`mlua` is tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platforms and cross-compilation to `aarch64` (other targets are also supported).

-WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for all Lua versions excluding JIT.
+WebAssembly (WASM) is supported through the `wasm32-unknown-emscripten` target for all Lua/Luau versions excluding JIT.

-[GitHub Actions]: https://github.com/khvzak/mlua/actions
-[Roblox Luau]: https://luau.org
+[GitHub Actions]: https://github.com/mlua-rs/mlua/actions
+[Luau]: https://luau.org

 ## Usage

 ### Feature flags

-`mlua` uses feature flags to reduce the amount of dependencies, compiled code and allow to choose only required set of features.
+`mlua` uses feature flags to reduce the number of dependencies and compiled code, and allow choosing only the required set of features.
 Below is a list of the available feature flags. By default `mlua` does not enable any features.

+* `lua55`: enable Lua [5.5] support
 * `lua54`: enable Lua [5.4] support
 * `lua53`: enable Lua [5.3] support
 * `lua52`: enable Lua [5.2] support
@@ -49,24 +48,25 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `luau`: enable [Luau] support (auto vendored mode)
 * `luau-jit`: enable [Luau] support with JIT backend.
 * `luau-vector4`: enable [Luau] support with 4-dimensional vector.
-* `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
+* `vendored`: build static Lua(JIT) libraries from sources during `mlua` compilation using [lua-src] or [luajit-src]
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
 * `send`: make `mlua::Lua: Send + Sync` (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
 * `error-send`: make `mlua:Error: Send + Sync`
-* `serialize`: add serialization and deserialization support to `mlua` types using [serde] framework
+* `serde`: add serialization and deserialization support to `mlua` types using [serde]
 * `macros`: enable procedural macros (such as `chunk!`)
 * `anyhow`: enable `anyhow::Error` conversion into Lua
 * `userdata-wrappers`: opt into `impl UserData` for `Rc<T>`/`Arc<T>`/`Rc<RefCell<T>>`/`Arc<Mutex<T>>` where `T: UserData`

+[5.5]: https://www.lua.org/manual/5.5/manual.html
 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
 [5.2]: https://www.lua.org/manual/5.2/manual.html
 [5.1]: https://www.lua.org/manual/5.1/manual.html
 [LuaJIT]: https://luajit.org/
-[Luau]: https://github.com/Roblox/luau
-[lua-src]: https://github.com/khvzak/lua-src-rs
-[luajit-src]: https://github.com/khvzak/luajit-src-rs
+[Luau]: https://github.com/luau-lang/luau
+[lua-src]: https://github.com/mlua-rs/lua-src-rs
+[luajit-src]: https://github.com/mlua-rs/luajit-src-rs
 [tokio]: https://github.com/tokio-rs/tokio
 [async-std]: https://github.com/async-rs/async-std
 [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
@@ -76,7 +76,7 @@ Below is a list of the available feature flags. By default `mlua` does not enabl

 `mlua` supports async/await for all Lua versions including Luau.

-This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and require running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.
+This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and requires running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.

 **Examples**:
 - [HTTP Client](examples/async_http_client.rs)
@@ -91,18 +91,18 @@ This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6
 cargo run --example async_http_client --features=lua54,async,macros

 # async http client (reqwest)
-cargo run --example async_http_reqwest --features=lua54,async,macros,serialize
+cargo run --example async_http_reqwest --features=lua54,async,macros,serde

 # async http server
 cargo run --example async_http_server --features=lua54,async,macros,send
 curl -v http://localhost:3000
 ```

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

-With `serialize` 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 [`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
@@ -112,28 +112,28 @@ With `serialize` feature flag enabled, `mlua` allows you to serialize/deserializ

 You have to enable one of the features: `lua54`, `lua53`, `lua52`, `lua51`, `luajit(52)` or `luau`, according to the chosen Lua version.

-By default `mlua` uses `pkg-config` tool to find lua includes and libraries for the chosen Lua version.
-In most cases it works as desired, although sometimes could be more preferable to use a custom lua library.
-To achieve this, mlua supports `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
+By default `mlua` uses `pkg-config` to find Lua includes and libraries for the chosen Lua version.
+In most cases it works as desired, although sometimes it may be preferable to use a custom Lua library.
+To achieve this, mlua supports the `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
 `LUA_LINK` is optional and may be `dylib` (a dynamic library) or `static` (a static library, `.a` archive).

-An example how to use them:
+An example of how to use them:
 ``` sh
 my_project $ LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
 ```

-`mlua` also supports vendored lua/luajit using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
+`mlua` also supports vendored Lua/LuaJIT using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
 [luajit-src](https://crates.io/crates/luajit-src).
-Just enable the `vendored` feature and cargo will automatically build and link specified lua/luajit version. This is the easiest way to get started with `mlua`.
+Just enable the `vendored` feature and cargo will automatically build and link the specified Lua/LuaJIT version. This is the easiest way to get started with `mlua`.

 ### Standalone mode
-In a standalone mode `mlua` allows to add to your application scripting support with a gently configured Lua runtime to ensure  safety and soundness.
+In standalone mode, `mlua` allows adding scripting support to your application with a properly configured Lua runtime to ensure safety and soundness.

-Add to `Cargo.toml` :
+Add to `Cargo.toml`:

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

 `main.rs`
@@ -157,21 +157,21 @@ fn main() -> LuaResult<()> {
 ```

 ### Module mode
-In a module mode `mlua` allows to create a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.4/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10).
+In module mode, `mlua` allows creating a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.4/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to the unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10).

 [Example](examples/module)

-Add to `Cargo.toml` :
+Add to `Cargo.toml`:

 ``` toml
 [lib]
 crate-type = ["cdylib"]

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

-`lib.rs` :
+`lib.rs`:

 ``` rust
 use mlua::prelude::*;
@@ -214,14 +214,14 @@ rustflags = [
 ```
 On Linux you can build modules normally with `cargo build --release`.

-On Windows the target module will be linked with `lua5x.dll` library (depending on your feature flags).
+On Windows the target module will be linked with the `lua5x.dll` library (depending on your feature flags).
 Your main application should provide this library.

-Module builds don't require Lua lib or headers to be installed on the system.
+Module builds don't require Lua binaries or headers to be installed on the system.

 ### Publishing to luarocks.org

-There is a LuaRocks build backend for mlua modules [`luarocks-build-rust-mlua`].
+There is a LuaRocks build backend for mlua modules: [`luarocks-build-rust-mlua`].

 Modules written in Rust and published to luarocks:
 - [`decasify`](https://github.com/alerque/decasify)
@@ -234,10 +234,10 @@ Modules written in Rust and published to luarocks:

 ## Safety

-One of the `mlua` goals is to provide *safe* API between Rust and Lua.
-Every place where the Lua C API may trigger an error longjmp in any way is protected by `lua_pcall`,
-and the user of the library is protected from directly interacting with unsafe things like the Lua stack,
-and there is overhead associated with this safety.
+One of `mlua`'s goals is to provide a *safe* API between Rust and Lua.
+Every place where the Lua C API may trigger an error longjmp is protected by `lua_pcall`,
+and the user of the library is protected from directly interacting with unsafe things like the Lua stack.
+There is overhead associated with this safety.

 Unfortunately, `mlua` does not provide absolute safety even without using `unsafe` .
 This library contains a huge amount of unsafe code. There are almost certainly bugs still lurking in this library!
@@ -245,8 +245,8 @@ It is surprisingly, fiendishly difficult to use the Lua C API without the potent

 ## Panic handling

-`mlua` wraps panics that are generated inside Rust callbacks in a regular Lua error. Panics could be
-resumed then by returning or propagating the Lua error to Rust code.
+`mlua` wraps panics that are generated inside Rust callbacks in a regular Lua error. Panics can then be
+resumed by returning or propagating the Lua error to Rust code.

 For example:
 ``` rust
@@ -265,16 +265,16 @@ let _ = lua.load(r#"
 unreachable!()
 ```

-Optionally `mlua` can disable Rust panics catching in Lua via `pcall`/`xpcall` and automatically resume
+Optionally, `mlua` can disable Rust panic catching in Lua via `pcall`/`xpcall` and automatically resume
 them across the Lua API boundary. This is controlled via `LuaOptions` and done by wrapping the Lua `pcall`/`xpcall`
-functions on a way to prevent catching errors that are wrapped Rust panics.
+functions to prevent catching errors that are wrapped Rust panics.

 `mlua` should also be panic safe in another way as well, which is that any `Lua` instances or handles
-remains usable after a user generated panic, and such panics should not break internal invariants or
+remain usable after a user generated panic, and such panics should not break internal invariants or
 leak Lua stack space. This is mostly important to safely use `mlua` types in Drop impls, as you should not be
 using panics for general error handling.

-Below is a list of `mlua` behaviors that should be considered a bug.
+Below is a list of `mlua` behaviors that should be considered bugs.
 If you encounter them, a bug report would be very welcome:

  + If you can cause UB with `mlua` without typing the word "unsafe", this is a bug.
@@ -287,12 +287,12 @@ If you encounter them, a bug report would be very welcome:

 ## Sandboxing

-Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in controlled environment.
+Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in a controlled environment.

-`mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
+`mlua` provides the `Lua::sandbox` method for enabling sandbox mode (Luau only).

 [Luau Sandboxing]: https://luau.org/sandbox

 ## License

-This project is licensed under the [MIT license](LICENSE)
+This project is licensed under the [MIT license](LICENSE).
@@ -1,7 +1,7 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;

-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use tokio::runtime::Runtime;
 use tokio::task;

@@ -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,42 @@ 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)
+            });
+
+            #[cfg(feature = "luau")]
+            registry.enable_namecall();
+        }
+    }
+
+    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 +451,7 @@ criterion_group! {
        table_traversal_pairs,
        table_traversal_for_each,
        table_traversal_sequence,
+        table_ref_clone,

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

@@ -1,6 +1,6 @@
 use std::time::Duration;

-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};

 use mlua::prelude::*;

@@ -0,0 +1,149 @@
+Implements the [`UserData`] trait for a Rust type.
+
+This derive macro generates an implementation of [`UserData`] that exposes
+struct fields to Lua and integrates with `#[mlua::userdata_impl]` for
+registering methods.
+
+Named fields are exposed as readable and writable fields in Lua by default.
+Use `#[lua(...)]` on individual fields or methods to control how they are
+registered.
+
+```rust,ignore
+use mlua::{Lua, Result, UserData};
+
+#[derive(UserData)]
+struct Rectangle {
+    length: u32,
+    width: u32,
+}
+
+#[mlua::userdata_impl]
+impl Rectangle {
+    #[lua(infallible)]
+    fn new(length: u32, width: u32) -> Self {
+        Self { length, width }
+    }
+
+    #[lua(getter, name = "area", infallible)]
+    fn calculate_area(&self) -> u32 {
+        self.length * self.width
+    }
+
+    fn diagonal(&self) -> Result<f64> {
+        Ok(((self.length.pow(2) + self.width.pow(2)) as f64).sqrt())
+    }
+}
+```
+
+# Struct field attributes
+
+Each named field can be annotated with `#[lua(...)]`:
+
+| Attribute      | Description                                           |
+| -------------- | ----------------------------------------------------- |
+| `get`          | Expose a getter. The field becomes readable from Lua. |
+| `set`          | Expose a setter. The field becomes writable from Lua. |
+| `skip`         | Do not expose this field.                             |
+| `name = "..."` | Override the Lua-facing name for the field.           |
+
+If neither `get` nor `set` is specified, both are enabled.
+
+Fields exposed as readable (via `get` or by default) must implement `Clone`.
+The generated getter clones the field value when accessed from Lua.
+
+# Methods registration
+
+Use `#[mlua::userdata_impl]` on an `impl` block to register methods,
+metamethods, and constants. All public items in the block are registered
+automatically.
+
+## Method detection
+
+The receiver type determines how a method is registered:
+
+| Receiver    | Registration      |
+| ----------- | ----------------- |
+| `&self`     | `add_method`      |
+| `&mut self` | `add_method_mut`  |
+| `self`      | `add_method_once` |
+| None        | `add_function`    |
+
+A first parameter of type `&Lua` (or `&mlua::Lua`) is treated as the
+Lua state reference and passed automatically.
+
+## Method and constant attributes
+
+Each item in the impl block can be annotated with `#[lua(...)]`:
+
+| Attribute      | Applies to         | Description                                                                            |
+| -------------- | ------------------ | -------------------------------------------------------------------------------------- |
+| `skip`         | Methods, constants | Exclude this item from registration.                                                   |
+| `name = "..."` | Methods, constants | Override the Lua-facing name.                                                          |
+| `infallible`   | Methods            | Wrap the return value in `Ok(...)`.                                                    |
+| `getter`       | Methods            | Register as a field getter. Must take `&self` and no Lua-facing arguments.             |
+| `setter`       | Methods            | Register as a field setter. Must take `&[mut] self` and one value argument.            |
+| `field`        | Methods, constants | Register as a static field. Methods must take no receiver and no Lua-facing arguments. |
+| `meta`         | Methods, constants | Register as a metamethod. May be combined with `field` for meta static fields.         |
+
+At most one of `getter`, `setter`, `field` may be specified on a method.
+
+## Constants
+
+Constants in an `#[mlua::userdata_impl]` block are registered as static
+fields:
+
+```rust,ignore
+#[mlua::userdata_impl]
+impl MyType {
+    const VERSION: &str = "1.0";
+    const COUNT: u32 = 42;
+}
+```
+
+Use `#[lua(meta)]` on a constant to register it as a meta static field.
+
+## Metamethods
+
+Annotate a method with `#[lua(meta)]` to register it as a Lua metamethod.
+The metamethod name is inferred from the function name when it starts with
+`__`. Use `name = "..."` to specify the name explicitly.
+
+```rust,ignore
+#[mlua::userdata_impl]
+impl MyType {
+    #[lua(meta, infallible)]
+    fn __add(&self, other: &Self) -> Self { ... }
+
+    #[lua(meta, name = "__call", infallible)]
+    fn construct(lua: &Lua, value: u32) -> Self { ... }
+}
+```
+
+## Reference parameters
+
+Reference parameters in method signatures are automatically mapped to
+the appropriate callback wrapper types:
+
+| Parameter type | Callback type       |
+| -------------- | ------------------- |
+| `&str`         | `BorrowedStr`       |
+| `&[u8]`        | `BorrowedBytes`     |
+| `&T`           | `UserDataRef<T>`    |
+| `&mut T`       | `UserDataRefMut<T>` |
+
+## Async methods
+
+Async methods are supported and registered via the corresponding async
+variants (`add_async_method`, `add_async_method_mut`, etc.).
+
+# Limitations
+
+Generics are not supported. Wrap a generic type in a concrete newtype
+instead.
+
+Union types cannot derive `UserData`.
+
+Enum types are accepted but generate no field registrations. All method
+registration must be done via `#[mlua::userdata_impl]`.
+
+[`UserData`]: crate::UserData
@@ -0,0 +1,52 @@
+Create a type that implements [`AsChunk`] and can capture Rust variables.
+
+This macro allows to write Lua code directly in Rust code.
+
+Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
+User's Rust types needs to implement [`UserData`] or [`IntoLua`] traits.
+
+Captured variables are **moved** into the chunk.
+
+```rust
+use mlua::{Lua, Result, chunk};
+
+fn main() -> Result<()> {
+    let lua = Lua::new();
+    let name = "Rustacean";
+    lua.load(chunk! {
+        print("hello, " .. $name)
+    }).exec()
+}
+```
+
+## Syntax issues
+
+Since the Rust tokenizer will tokenize Lua code, this imposes some restrictions.
+The main thing to remember is:
+
+- Use double quoted strings (`""`) instead of single quoted strings (`''`).
+
+  (Single quoted strings only work if they contain a single character, since in Rust,
+  `'a'` is a character literal).
+
+- Using Lua comments `--` is not desirable in **stable** Rust and can have bad side effects.
+
+  This is because procedural macros have Line/Column information available only in
+  **nightly** Rust. Instead, Lua chunks represented as a big single line of code in stable Rust.
+
+  As workaround, Rust comments `//` can be used.
+
+Other minor limitations:
+
+- Certain escape codes in string literals don't work. (Specifically: `\a`, `\b`, `\f`, `\v`,
+  `\123` (octal escape codes), `\u`, and `\U`).
+
+  These are accepted: : `\\`, `\n`, `\t`, `\r`, `\xAB` (hex escape codes), and `\0`.
+
+- The `//` (floor division) operator is unusable, as its start a comment.
+
+Everything else should work.
+
+[`AsChunk`]: crate::chunk::AsChunk
+[`UserData`]: crate::UserData
+[`IntoLua`]: crate::IntoLua
@@ -0,0 +1,41 @@
+Registers Lua module entrypoint.
+
+You can register multiple entrypoints as required.
+
+```rust,ignore
+use mlua::{Lua, Result, Table};
+
+#[mlua::lua_module]
+fn my_module(lua: &Lua) -> Result<Table> {
+    let exports = lua.create_table()?;
+    exports.set("hello", "world")?;
+    Ok(exports)
+}
+```
+
+Internally in the code above the compiler defines C function `luaopen_my_module`.
+
+You can also pass options to the attribute:
+
+* name - name of the module, defaults to the name of the function
+
+```rust,ignore
+#[mlua::lua_module(name = "alt_module")]
+fn my_module(lua: &Lua) -> Result<Table> {
+    ...
+}
+```
+
+* skip_memory_check - skip memory allocation checks for some operations.
+
+In module mode, mlua runs in an unknown environment and cannot tell whether there are any memory
+limits or not. As a result, some operations that require memory allocation run in protected
+mode. Setting this attribute will improve performance of such operations with risk of having
+uncaught exceptions and memory leaks.
+
+```rust,ignore
+#[mlua::lua_module(skip_memory_check)]
+fn my_module(lua: &Lua) -> Result<Table> {
+    ...
+}
+```
@@ -1,9 +1,9 @@
 ## mlua v0.10 release notes

-The v0.10 version of mlua has goal to improve the user experience while keeping the same performance and safety guarantees.
+The v0.10 version of mlua has a goal to improve the user experience while keeping the same performance and safety guarantees.
 This document highlights the most notable features. For a full list of changes, see the [CHANGELOG].

-[CHANGELOG]: https://github.com/khvzak/mlua/blob/main/CHANGELOG.md
+[CHANGELOG]: https://github.com/mlua-rs/mlua/blob/main/CHANGELOG.md

 ### New features

@@ -40,7 +40,7 @@ assert_eq!(lua.globals().get::<i32>("i")?, 20);

 Under the hood, to synchronize access to the Lua state, mlua uses [`ReentrantMutex`] which can be recursively locked by a single thread. Only one thread can execute Lua code at a time, but it's possible to share Lua values between threads.

-This has some performance penalties (about 10-20%) compared to the lock free mode. This flag is disabled by default and does not supported in module mode.
+This has some performance penalties (about 10-20%) compared to the lock free mode. This flag is disabled by default and is not supported in module mode.

 [`ReentrantMutex`]: https://docs.rs/parking_lot/latest/parking_lot/type.ReentrantMutex.html

@@ -144,7 +144,7 @@ The following `Scope` methods were changed:
 Instead, scope has comprehensive support for borrowed userdata: `create_any_userdata_ref`, `create_any_userdata_ref_mut`, `create_userdata_ref`, `create_userdata_ref_mut`.

 `UserDataRef` and `UserDataRefMut` are no longer acceptable for scoped userdata access as they require owned underlying data.
-In mlua v0.9 this can cause read-after-free bug in some edge cases.
+In mlua v0.9 this could cause a read-after-free bug in some edge cases.

 To temporarily borrow underlying data, the `AnyUserData::borrow_scoped` and `AnyUserData::borrow_mut_scoped` methods were introduced:

@@ -3,7 +3,7 @@
 The v0.9 version of mlua is a major release that includes a number of API changes and improvements. This release is a stepping stone towards the v1.0.
 This document highlights the most important changes. For a full list of changes, see the [CHANGELOG].

-[CHANGELOG]: https://github.com/khvzak/mlua/blob/main/CHANGELOG.md
+[CHANGELOG]: https://github.com/mlua-rs/mlua/blob/main/CHANGELOG.md

 ### New features

@@ -152,9 +152,9 @@ It will automatically trigger JIT compilation for new Lua chunks. To disable it,

 #### 1. Better error reporting

-When calling a Rust function from Lua and passing wrong arguments, previous mlua versions reported a error message without any context or reference to the particular argument.
+When calling a Rust function from Lua and passing wrong arguments, previous mlua versions reported an error message without any context or reference to the particular argument.

-In v0.9 it reports a error message with the argument index and expected type:
+In v0.9 it reports an error message with the argument index and expected type:

 ```rust
 let func = lua.create_function(|_, _a: i32| Ok(()))?;
@@ -304,7 +304,7 @@ assert_eq!(f.call::<_, mlua::String>(())?, "hello");

 The new mlua version has a number of performance improvements. Please check the [benchmarks results] to see how mlua compares to rlua and rhai.

-[benchmarks results]: https://github.com/khvzak/script-bench-rs
+[benchmarks results]: https://github.com/mlua-rs/script-bench-rs

 ### Changes in `module` mode

@@ -327,7 +327,7 @@ Under the hood a new function `luaopen_alt_module` will be created for the Lua m

 - `skip_memory_check` - skip memory allocation checks for some operations.

-In module mode, mlua runs in unknown environment and cannot say are there any memory limits or not. As result, some operations that require memory allocation runs in
+In module mode, mlua runs in an unknown environment and cannot tell whether there are any memory limits or not. As a result, some operations that require memory allocation run in
 protected mode. Setting this attribute will improve performance of such operations with risk of having uncaught exceptions and memory leaks.

 #### Improved Windows target
@@ -336,7 +336,7 @@ In previous mlua versions, building a Lua module for Windows requires having Lua
 In contrast, on Linux and macOS, modules can be built without any external dependencies using the `-undefined=dynamic_lookup` linker flag.

 With Rust 1.71+ it's now possible to lift this restriction for Windows as well. You can build modules normally and they will be linked with
-`lua54.dll`/`lua53.dll`/`lua52.dll`/`lua51.dll` depending on the enabled Lua version.
+`lua5x.dll` depending on the enabled Lua version.

 You still need to have the dll although, linked to application where the module will be loaded.

@@ -5,7 +5,7 @@ use hyper::body::Incoming;
 use hyper_util::client::legacy::Client as HyperClient;
 use hyper_util::rt::TokioExecutor;

-use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
+use mlua::{ExternalResult, Lua, Result, UserData, UserDataMethods, chunk};

 struct BodyReader(Incoming);

@@ -1,4 +1,4 @@
-use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result, Value};
+use mlua::{ExternalResult, Lua, LuaSerdeExt, Result, Value, chunk};

 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
@@ -11,7 +11,7 @@ use hyper::{Request, Response};
 use hyper_util::rt::TokioIo;
 use tokio::net::TcpListener;

-use mlua::{chunk, Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods};
+use mlua::{Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods, chunk};

 /// Wrapper around incoming request that implements UserData
 struct LuaRequest(SocketAddr, Request<Incoming>);
@@ -4,7 +4,7 @@ use std::net::SocketAddr;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};

-use mlua::{chunk, BString, Function, Lua, UserData, UserDataMethods};
+use mlua::{BString, Function, Lua, UserData, UserDataMethods, chunk};

 struct LuaTcpStream(TcpStream);

@@ -1,7 +1,7 @@
 use std::f32;
 use std::iter::FromIterator;

-use mlua::{chunk, FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic};
+use mlua::{FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic, chunk};

 fn main() -> Result<()> {
    // You can create a new Lua state with `Lua::new()`. This loads the default Lua std library
@@ -10,6 +10,7 @@ crate-type = ["cdylib"]
 [workspace]

 [features]
+lua55 = ["mlua/lua55"]
 lua54 = ["mlua/lua54"]
 lua53 = ["mlua/lua53"]
 lua52 = ["mlua/lua52"]
@@ -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,45 +1,46 @@
-use mlua::{chunk, Lua, MetaMethod, Result, UserData};
+use mlua::{Lua, Result, UserData, chunk};

-#[derive(Default)]
+#[derive(Default, UserData)]
 struct Rectangle {
    length: u32,
    width: u32,
 }

-impl UserData for Rectangle {
-    fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
-        fields.add_field_method_get("length", |_, this| Ok(this.length));
-        fields.add_field_method_set("length", |_, this, val| {
-            this.length = val;
-            Ok(())
-        });
-        fields.add_field_method_get("width", |_, this| Ok(this.width));
-        fields.add_field_method_set("width", |_, this, val| {
-            this.width = val;
-            Ok(())
-        });
+#[mlua::userdata_impl]
+impl Rectangle {
+    const NAME: &str = "Rectangle";
+
+    #[lua(infallible)]
+    fn new(length: u32, width: u32) -> Self {
+        Self { length, width }
    }

-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
-        methods.add_method("area", |_, this, ()| Ok(this.length * this.width));
-        methods.add_method("diagonal", |_, this, ()| {
-            Ok((this.length.pow(2) as f64 + this.width.pow(2) as f64).sqrt())
-        });
+    #[lua(getter, name = "area", infallible)]
+    fn calculate_area(&self) -> u32 {
+        self.length * self.width
+    }

-        // Constructor
-        methods.add_meta_function(MetaMethod::Call, |_, ()| Ok(Rectangle::default()));
+    fn diagonal(&self) -> Result<f64> {
+        Ok((self.length.pow(2) as f64 + self.width.pow(2) as f64).sqrt())
+    }
+
+    // Constructor via `__call` metamethod
+    #[lua(meta, infallible)]
+    fn __call(length: u32, width: u32) -> Self {
+        Rectangle::new(length, width)
    }
 }

 fn main() -> Result<()> {
    let lua = Lua::new();
-    let rectangle = Rectangle::default();
+    lua.globals().set("Rectangle", lua.create_proxy::<Rectangle>()?)?;
    lua.load(chunk! {
-        local rect = $rectangle()
-        rect.width = 10
-        rect.length = 5
-        assert(rect:area() == 50)
-        assert(rect:diagonal() - 11.1803 < 0.0001)
+        local rect = Rectangle(10, 5)
+        rect.width = rect.width + 5
+        rect.length = rect.length + 5
+        assert(rect.NAME == "Rectangle")
+        assert(rect.area == 150)
+        assert(math.floor(rect:diagonal()) == 18)
    })
    .exec()
 }
@@ -1,10 +1,10 @@
 [package]
 name = "mlua-sys"
-version = "0.6.7"
+version = "0.11.0-rc.1"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-rust-version = "1.71"
-edition = "2021"
-repository = "https://github.com/khvzak/mlua"
+rust-version = "1.88"
+edition = "2024"
+repository = "https://github.com/mlua-rs/mlua"
 documentation = "https://docs.rs/mlua-sys"
 readme = "README.md"
 categories = ["external-ffi-bindings"]
@@ -12,14 +12,15 @@ license = "MIT"
 links = "lua"
 build = "build/main.rs"
 description = """
-Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+Low level (FFI) bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
 """

 [package.metadata.docs.rs]
-features = ["lua54", "vendored"]
+features = ["lua55", "vendored"]
 rustdoc-args = ["--cfg", "docsrs"]

 [features]
+lua55 = []
 lua54 = []
 lua53 = []
 lua52 = []
@@ -30,17 +31,19 @@ luau = ["luau0-src"]
 luau-codegen = ["luau"]
 luau-vector4 = ["luau"]
 vendored = ["lua-src", "luajit-src"]
+external = []
 module = []

 [dependencies]
+libc = "0.2"

 [build-dependencies]
 cc = "1.0"
 cfg-if = "1.0"
 pkg-config = "0.3.17"
-lua-src = { version = ">= 547.0.0, < 547.1.0", optional = true }
-luajit-src = { version = ">= 210.5.0, < 210.6.0", optional = true }
-luau0-src = { version = "0.12.0", optional = true }
+lua-src = { version = ">= 550.1.0, < 550.2.0", optional = true }
+luajit-src = { version = ">= 210.7.0, < 210.8.0", optional = true }
+luau0-src = { version = "0.20.0", optional = true }

 [lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }
@@ -1,8 +1,9 @@
 # mlua-sys

-Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox [Luau].
+Low level (FFI) bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including [LuaJIT]) and [Luau].

 Intended to be consumed by the [mlua] crate.

-[Luau]: https://github.com/Roblox/luau
+[LuaJIT]: https://github.com/LuaJIT/LuaJIT
+[Luau]: https://github.com/luau-lang/luau
 [mlua]: https://crates.io/crates/mlua
@@ -31,18 +31,16 @@ pub fn probe_lua() {

    // Find using `pkg-config`

+    #[cfg(feature = "lua55")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.5", "5.6", ["lua5.5", "lua-5.5", "lua55"], "5.5");
    #[cfg(feature = "lua54")]
-    let (incl_bound, excl_bound, alt_probe, ver) =
-        ("5.4", "5.5", ["lua5.4", "lua-5.4", "lua54"], "5.4");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", ["lua5.4", "lua-5.4", "lua54"], "5.4");
    #[cfg(feature = "lua53")]
-    let (incl_bound, excl_bound, alt_probe, ver) =
-        ("5.3", "5.4", ["lua5.3", "lua-5.3", "lua53"], "5.3");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", ["lua5.3", "lua-5.3", "lua53"], "5.3");
    #[cfg(feature = "lua52")]
-    let (incl_bound, excl_bound, alt_probe, ver) =
-        ("5.2", "5.3", ["lua5.2", "lua-5.2", "lua52"], "5.2");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", ["lua5.2", "lua-5.2", "lua52"], "5.2");
    #[cfg(feature = "lua51")]
-    let (incl_bound, excl_bound, alt_probe, ver) =
-        ("5.1", "5.2", ["lua5.1", "lua-5.1", "lua51"], "5.1");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", ["lua5.1", "lua-5.1", "lua51"], "5.1");
    #[cfg(feature = "luajit")]
    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", [], "JIT");

@@ -54,9 +52,7 @@ pub fn probe_lua() {

    if lua.is_err() {
        for pkg in alt_probe {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(true)
-                .probe(pkg);
+            lua = pkg_config::Config::new().cargo_metadata(true).probe(pkg);

            if lua.is_ok() {
                break;
@@ -1,6 +1,9 @@
 #![allow(dead_code)]

 pub fn probe_lua() {
+    #[cfg(feature = "lua55")]
+    let artifacts = lua_src::Build::new().build(lua_src::Lua55);
+
    #[cfg(feature = "lua54")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua54);

@@ -1,19 +1,21 @@
 cfg_if::cfg_if! {
-    if #[cfg(all(feature = "lua54", not(any(feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+    if #[cfg(all(feature = "lua55", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
        include!("main_inner.rs");
-    } else if #[cfg(all(feature = "lua53", not(any(feature = "lua54", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+    } else if #[cfg(all(feature = "lua54", not(any(feature = "lua55", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
        include!("main_inner.rs");
-    } else if #[cfg(all(feature = "lua52", not(any(feature = "lua54", feature = "lua53", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+    } else if #[cfg(all(feature = "lua53", not(any(feature = "lua55", feature = "lua54", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
        include!("main_inner.rs");
-    } else if #[cfg(all(feature = "lua51", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit", feature = "luau"))))] {
+    } else if #[cfg(all(feature = "lua52", not(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua51", feature = "luajit", feature = "luau"))))] {
        include!("main_inner.rs");
-    } else if #[cfg(all(feature = "luajit", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luau"))))] {
+    } else if #[cfg(all(feature = "lua51", not(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit", feature = "luau"))))] {
        include!("main_inner.rs");
-    } else if #[cfg(all(feature = "luau", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit"))))] {
+    } else if #[cfg(all(feature = "luajit", not(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "luau", not(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit"))))] {
        include!("main_inner.rs");
    } else {
        fn main() {
-            compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau");
+            compile_error!("You can enable only one of the features: lua55, lua54, lua53, lua52, lua51, luajit, luajit52, luau");
        }
    }
 }
@@ -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();
 }
@@ -1,12 +1,16 @@
-//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau.
+//! Low level bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau.

-#![allow(non_camel_case_types, non_snake_case, dead_code)]
+#![allow(non_camel_case_types, non_snake_case)]
 #![allow(clippy::missing_safety_doc)]
+#![allow(unsafe_op_in_unsafe_fn)]
 #![doc(test(attr(deny(warnings))))]
 #![cfg_attr(docsrs, feature(doc_cfg))]

 use std::os::raw::c_int;

+#[cfg(any(feature = "lua55", doc))]
+pub use lua55::*;
+
 #[cfg(any(feature = "lua54", doc))]
 pub use lua54::*;

@@ -22,7 +26,7 @@ pub use lua51::*;
 #[cfg(any(feature = "luau", doc))]
 pub use luau::*;

-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+#[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52"))]
 #[doc(hidden)]
 pub const LUA_MAX_UPVALUES: c_int = 255;

@@ -39,14 +43,22 @@ pub const LUA_MAX_UPVALUES: c_int = 200;
 #[doc(hidden)]
 pub const LUA_TRACEBACK_STACK: c_int = 11;

-// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/common/alloc.rs
-// The minimum alignment guaranteed by the architecture. This value is used to
-// add fast paths for low alignment values.
-#[cfg(any(
+// The minimum alignment guaranteed by the architecture.
+// Copied from https://github.com/rust-lang/rust/blob/main/library/std/src/sys/alloc/mod.rs
+#[doc(hidden)]
+#[rustfmt::skip]
+pub const SYS_MIN_ALIGN: usize = if cfg!(any(
+    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
+    all(target_arch = "xtensa", target_os = "espidf"),
+)) {
+    // The allocator on the esp-idf and zkvm platforms guarantees 4 byte alignment.
+    4
+} else if cfg!(any(
    target_arch = "x86",
    target_arch = "arm",
    target_arch = "m68k",
    target_arch = "csky",
+    target_arch = "loongarch32",
    target_arch = "mips",
    target_arch = "mips32r6",
    target_arch = "powerpc",
@@ -54,12 +66,11 @@ pub const LUA_TRACEBACK_STACK: c_int = 11;
    target_arch = "sparc",
    target_arch = "wasm32",
    target_arch = "hexagon",
-    all(target_arch = "riscv32", not(any(target_os = "espidf", target_os = "zkvm"))),
-    all(target_arch = "xtensa", not(target_os = "espidf")),
-))]
-#[doc(hidden)]
-pub const SYS_MIN_ALIGN: usize = 8;
-#[cfg(any(
+    target_arch = "riscv32",
+    target_arch = "xtensa",
+)) {
+    8
+} else if cfg!(any(
    target_arch = "x86_64",
    target_arch = "aarch64",
    target_arch = "arm64ec",
@@ -70,20 +81,19 @@ pub const SYS_MIN_ALIGN: usize = 8;
    target_arch = "sparc64",
    target_arch = "riscv64",
    target_arch = "wasm64",
-))]
-#[doc(hidden)]
-pub const SYS_MIN_ALIGN: usize = 16;
-// The allocator on the esp-idf and zkvm platforms guarantee 4 byte alignment.
-#[cfg(any(
-    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
-    all(target_arch = "xtensa", target_os = "espidf"),
-))]
-#[doc(hidden)]
-pub const SYS_MIN_ALIGN: usize = 4;
+)) {
+    16
+} else {
+    panic!("no value for SYS_MIN_ALIGN")
+};

 #[macro_use]
 mod macros;

+#[cfg(any(feature = "lua55", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua55")))]
+pub mod lua55;
+
 #[cfg(any(feature = "lua54", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
 pub mod lua54;
@@ -2,6 +2,7 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3

+use std::ffi::CStr;
 use std::os::raw::{c_char, c_int, c_void};
 use std::{mem, ptr};

@@ -20,8 +21,8 @@ unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
    }
 }

-const COMPAT53_LEVELS1: c_int = 12; // size of the first part of the stack
-const COMPAT53_LEVELS2: c_int = 10; // size of the second part of the stack
+const COMPAT53_LEVELS1: c_int = 10; // size of the first part of the stack
+const COMPAT53_LEVELS2: c_int = 11; // size of the second part of the stack

 unsafe fn compat53_countlevels(L: *mut lua_State) -> c_int {
    let mut ar: lua_Debug = mem::zeroed();
@@ -54,11 +55,7 @@ unsafe fn compat53_checkmode(
        while *st != 0 && *st != c {
            st = st.offset(1);
        }
-        if *st == c {
-            st
-        } else {
-            ptr::null()
-        }
+        if *st == c { st } else { ptr::null() }
    }

    if !mode.is_null() && strchr(mode, *modename).is_null() {
@@ -88,11 +85,10 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
                lua_pop(L, 1); // remove value (but keep name)
                return 1;
            } else if compat53_findfield(L, objidx, level - 1) != 0 {
-                // try recursively
-                lua_remove(L, -2); // remove table (but keep name)
-                lua_pushliteral(L, ".");
-                lua_insert(L, -2); // place '.' between the two names
-                lua_concat(L, 3);
+                // stack: lib_name, lib_table, field_name (top)
+                lua_pushliteral(L, c"."); // place '.' between the two names
+                lua_replace(L, -3); // (in the slot occupied by table)
+                lua_concat(L, 3); // lib_name.field_name
                return 1;
            }
        }
@@ -101,13 +97,20 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
    0 // not found
 }

-unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, ar: *mut lua_Debug) -> c_int {
+unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, L1: *mut lua_State, ar: *mut lua_Debug) -> c_int {
    let top = lua_gettop(L);
-    lua_getinfo(L, cstr!("f"), ar); // push function
+    lua_getinfo(L1, cstr!("f"), ar); // push function
+    lua_xmove(L1, L, 1); // and move onto L
    lua_pushvalue(L, LUA_GLOBALSINDEX);
+    luaL_checkstack(L, 6, cstr!("not enough stack")); // slots for 'findfield'
    if compat53_findfield(L, top + 1, 2) != 0 {
+        let name = lua_tostring(L, -1);
+        if CStr::from_ptr(name).to_bytes().starts_with(b"_G.") {
+            lua_pushstring(L, name.add(3)); // push name without prefix
+            lua_remove(L, -2); // remove original name
+        }
        lua_copy(L, -1, top + 1); // move name to proper place
-        lua_pop(L, 2); // remove pushed values
+        lua_settop(L, top + 1); // remove pushed values
        1
    } else {
        lua_settop(L, top); // remove function and global table
@@ -115,27 +118,23 @@ unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, ar: *mut lua_Debug) ->
    }
 }

-unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
-    if *(*ar).namewhat != b'\0' as c_char {
-        // is there a name?
-        lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
+unsafe fn compat53_pushfuncname(L: *mut lua_State, L1: *mut lua_State, ar: *mut lua_Debug) {
+    // try first a global name
+    if compat53_pushglobalfuncname(L, L1, ar) != 0 {
+        lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
+        lua_remove(L, -2); // remove name
+    } else if *(*ar).namewhat != b'\0' as c_char {
+        // use name from code
+        lua_pushfstring(L, cstr!("%s '%s'"), (*ar).namewhat, (*ar).name);
    } else if *(*ar).what == b'm' as c_char {
        // main?
-        lua_pushliteral(L, "main chunk");
-    } else if *(*ar).what == b'C' as c_char {
-        if compat53_pushglobalfuncname(L, ar) != 0 {
-            lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
-            lua_remove(L, -2); // remove name
-        } else {
-            lua_pushliteral(L, "?");
-        }
+        lua_pushliteral(L, c"main chunk");
+    } else if *(*ar).what != b'C' as c_char {
+        // for Lua functions, use <file:line>
+        let short_src = (*ar).short_src.as_ptr();
+        lua_pushfstring(L, cstr!("function <%s:%d>"), short_src, (*ar).linedefined);
    } else {
-        lua_pushfstring(
-            L,
-            cstr!("function <%s:%d>"),
-            (*ar).short_src.as_ptr(),
-            (*ar).linedefined,
-        );
+        lua_pushliteral(L, c"?");
    }
 }

@@ -186,7 +185,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;
        }
    }
@@ -377,7 +377,7 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
        if !msg.is_null() {
            luaL_error(L, cstr!("stack overflow (%s)"), msg);
        } else {
-            lua_pushliteral(L, "stack overflow");
+            lua_pushliteral(L, c"stack overflow");
            lua_error(L);
        }
    }
@@ -458,32 +458,36 @@ pub unsafe fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const
    let mut ar: lua_Debug = mem::zeroed();
    let top = lua_gettop(L);
    let numlevels = compat53_countlevels(L1);
-    let mark = if numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 {
-        COMPAT53_LEVELS1
-    } else {
-        0
-    };
+    #[rustfmt::skip]
+    let mut limit = if numlevels - level > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 { COMPAT53_LEVELS1 } else { -1 };

    if !msg.is_null() {
        lua_pushfstring(L, cstr!("%s\n"), msg);
    }
-    lua_pushliteral(L, "stack traceback:");
+    lua_pushliteral(L, c"stack traceback:");
    while lua_getstack(L1, level, &mut ar) != 0 {
-        level += 1;
-        if level == mark {
+        if limit == 0 {
            // too many levels?
-            lua_pushliteral(L, "\n\t..."); // add a '...'
-            level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
+            let n = numlevels - level - COMPAT53_LEVELS2;
+            // add warning about skip ("n + 1" because we skip current level too)
+            lua_pushfstring(L, cstr!("\n\t...\t(skipping %d levels)"), n + 1); // add warning about skip
+            level += n; // and skip to last levels
        } else {
-            lua_getinfo(L1, cstr!("Slnt"), &mut ar);
-            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src.as_ptr());
-            if ar.currentline > 0 {
-                lua_pushfstring(L, cstr!("%d:"), ar.currentline);
+            lua_getinfo(L1, cstr!("Sln"), &mut ar);
+            if *ar.what != b't' as c_char {
+                if ar.currentline <= 0 {
+                    lua_pushfstring(L, cstr!("\n\t%s: in "), ar.short_src.as_ptr());
+                } else {
+                    lua_pushfstring(L, cstr!("\n\t%s:%d: in "), ar.short_src.as_ptr(), ar.currentline);
+                }
+                compat53_pushfuncname(L, L1, &mut ar);
+                lua_concat(L, lua_gettop(L) - top);
+            } else {
+                lua_pushstring(L, cstr!("\n\t(...tail calls...)"));
            }
-            lua_pushliteral(L, " in ");
-            compat53_pushfuncname(L, &mut ar);
-            lua_concat(L, lua_gettop(L) - top);
        }
+        level += 1;
+        limit -= 1;
    }
    lua_concat(L, lua_gettop(L) - top);
 }
@@ -493,16 +497,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
        match lua_type(L, idx) {
            LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
            }
            LUA_TSTRING | LUA_TNUMBER => {
                lua_pushvalue(L, idx);
            }
            LUA_TBOOLEAN => {
                if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                }
            }
            t => {
@@ -548,7 +552,7 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch

 pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
    if lua_getfield(L, -1, modname) == LUA_TNIL {
        lua_pop(L, 1);
        lua_pushcfunction(L, openf);
@@ -8,6 +8,9 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;

+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
 #[repr(C)]
 pub struct luaL_Reg {
    pub name: *const c_char,
@@ -15,7 +18,7 @@ pub struct luaL_Reg {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
    #[link_name = "luaL_getmetafield"]
    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -58,7 +61,7 @@ pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);

@@ -104,8 +107,6 @@ pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *
    luaL_optlstring(L, n, d, ptr::null_mut())
 }

-// Deprecated from 5.3: luaL_checkint, luaL_optint, luaL_checklong, luaL_optlong
-
 #[inline(always)]
 pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
    lua::lua_typename(L, lua::lua_type(L, i))
@@ -135,8 +136,62 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
 }

-// TODO: luaL_opt
+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}

 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+#[cfg(target_arch = "wasm32")]
+const BUFSIZ: usize = 1024; // WASI libc's BUFSIZ is 1024
+#[cfg(not(target_arch = "wasm32"))]
+const BUFSIZ: usize = libc::BUFSIZ as usize;
+
+// The buffer size used by the lauxlib buffer system.
+// The "16384" workaround is taken from the LuaJIT source code.
+pub const LUAL_BUFFERSIZE: usize = if BUFSIZ > 16384 { 8192 } else { BUFSIZ };
+
+#[repr(C)]
+pub struct luaL_Buffer {
+    pub p: *mut c_char, // current position in buffer
+    pub lvl: c_int,     // number of strings in the stack
+    pub L: *mut lua_State,
+    pub buffer: [c_char; LUAL_BUFFERSIZE],
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
+    pub fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const c_char, l: usize);
+    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const c_char);
+    pub fn luaL_addvalue(B: *mut luaL_Buffer);
+    pub fn luaL_pushresult(B: *mut luaL_Buffer);
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addchar(B: *mut luaL_Buffer, c: c_char) {
+    let buffer_end = (*B).buffer.as_mut_ptr().add(LUAL_BUFFERSIZE);
+    if (*B).p >= buffer_end {
+        luaL_prepbuffer(B);
+    }
+    *(*B).p = c;
+    (*B).p = (*B).p.add(1);
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addsize(B: *mut luaL_Buffer, n: usize) {
+    (*B).p = (*B).p.add(n);
+}
@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.

+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_void};
 use std::ptr;
@@ -83,13 +84,13 @@ pub type lua_Reader =
 pub type lua_Writer =
    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;

-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // State manipulation
    //
@@ -219,7 +220,7 @@ pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

@@ -227,7 +228,7 @@ extern "C-unwind" {
 // Miscellaneous functions
 //
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    #[link_name = "lua_error"]
    fn lua_error_(L: *mut lua_State) -> c_int;
    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
@@ -269,7 +270,10 @@ pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
    lua_pushcclosure(L, f, 0)
 }

-// TODO: lua_strlen
+#[inline(always)]
+pub unsafe fn lua_strlen(L: *mut lua_State, i: c_int) -> usize {
+    lua_objlen(L, i)
+}

 #[inline(always)]
 pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
@@ -312,10 +316,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }

 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }

 #[inline(always)]
@@ -371,7 +373,7 @@ pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -1,27 +1,27 @@
 //! Contains definitions from `lualib.h`.

-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};

 use super::lua::lua_State;

-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");

 #[cfg(feature = "luajit")]
-pub const LUA_BITLIBNAME: &str = "bit";
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit");
 #[cfg(feature = "luajit")]
-pub const LUA_JITLIBNAME: &str = "jit";
+pub const LUA_JITLIBNAME: *const c_char = cstr!("jit");
 #[cfg(feature = "luajit")]
-pub const LUA_FFILIBNAME: &str = "ffi";
+pub const LUA_FFILIBNAME: *const c_char = cstr!("ffi");

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaopen_base(L: *mut lua_State) -> c_int;
    pub fn luaopen_table(L: *mut lua_State) -> c_int;
    pub fn luaopen_io(L: *mut lua_State) -> c_int;
@@ -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;
        }
    }
@@ -124,7 +125,7 @@ pub unsafe fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int {

 #[inline(always)]
 pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
-    let n = n.try_into().expect("cannot convert index to lua_Integer");
+    let n = n.try_into().expect("cannot convert index to c_int");
    lua_rawgeti_(L, idx, n);
    lua_type(L, -1)
 }
@@ -152,7 +153,7 @@ pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {

 #[inline(always)]
 pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
-    let n = n.try_into().expect("cannot convert index from lua_Integer");
+    let n = n.try_into().expect("cannot convert index to c_int");
    lua_rawseti_(L, idx, n)
 }

@@ -199,16 +200,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
        match lua_type(L, idx) {
            LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
            }
            LUA_TSTRING | LUA_TNUMBER => {
                lua_pushvalue(L, idx);
            }
            LUA_TBOOLEAN => {
                if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                }
            }
            t => {
@@ -232,7 +233,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)

 pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
    if lua_getfield(L, -1, modname) == LUA_TNIL {
        lua_pop(L, 1);
        lua_pushcfunction(L, openf);
@@ -8,6 +8,12 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Un
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;

+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
+
 #[repr(C)]
 pub struct luaL_Reg {
    pub name: *const c_char,
@@ -15,7 +21,7 @@ pub struct luaL_Reg {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);

    #[link_name = "luaL_getmetafield"]
@@ -26,7 +32,7 @@ extern "C-unwind" {
    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
-        -> *const c_char;
+    -> *const c_char;
    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -63,7 +69,7 @@ pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);

@@ -76,7 +82,7 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -160,13 +166,76 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
 }

-// luaL_opt would be implemented here but it is undocumented, so it's omitted
-
 #[inline(always)]
 pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
    luaL_loadbufferx(L, s, sz, n, ptr::null())
 }

+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}
+
 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+#[cfg(target_arch = "wasm32")]
+const BUFSIZ: usize = 1024; // WASI libc's BUFSIZ is 1024
+#[cfg(not(target_arch = "wasm32"))]
+const BUFSIZ: usize = libc::BUFSIZ as usize;
+
+// The buffer size used by the lauxlib buffer system.
+// The "16384" workaround is taken from the LuaJIT source code.
+pub const LUAL_BUFFERSIZE: usize = if BUFSIZ > 16384 { 8192 } else { BUFSIZ };
+
+#[repr(C)]
+pub struct luaL_Buffer {
+    pub b: *mut c_char, // buffer address
+    pub size: usize,    // buffer size
+    pub n: usize,       // number of characters in buffer
+    pub L: *mut lua_State,
+    pub initb: [c_char; LUAL_BUFFERSIZE], // initial buffer space
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
+    pub fn luaL_prepbuffsize(B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const c_char, l: usize);
+    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const c_char);
+    pub fn luaL_addvalue(B: *mut luaL_Buffer);
+    pub fn luaL_pushresult(B: *mut luaL_Buffer);
+    pub fn luaL_pushresultsize(B: *mut luaL_Buffer, sz: usize);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+}
+
+// Macro implementations as inline functions
+
+#[inline(always)]
+pub unsafe fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut c_char {
+    luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addchar(B: *mut luaL_Buffer, c: c_char) {
+    if (*B).n >= (*B).size {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).b.add((*B).n) = c;
+    (*B).n += 1;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addsize(B: *mut luaL_Buffer, n: usize) {
+    (*B).n += n;
+}
@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.

+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
 use std::ptr;
@@ -88,13 +89,13 @@ pub type lua_Reader =
 pub type lua_Writer =
    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;

-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // State manipulation
    //
@@ -160,14 +161,14 @@ pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_arith(L: *mut lua_State, op: c_int);
    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -256,7 +257,7 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Coroutine functions
    //
@@ -288,12 +289,12 @@ pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Miscellaneous functions
    //
@@ -395,10 +396,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }

 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }

 #[inline(always)]
@@ -449,7 +448,7 @@ pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -1,21 +1,21 @@
 //! Contains definitions from `lualib.h`.

-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};

 use super::lua::lua_State;

-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaopen_base(L: *mut lua_State) -> c_int;
    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
    pub fn luaopen_table(L: *mut lua_State) -> c_int;
@@ -1,7 +1,7 @@
 //! Contains definitions from `lauxlib.h`.

 use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::{mem, ptr};

 use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;

 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");

 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");

 #[repr(C)]
 pub struct luaL_Reg {
@@ -21,7 +21,7 @@ pub struct luaL_Reg {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);

    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -31,7 +31,7 @@ extern "C-unwind" {
    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
-        -> *const c_char;
+    -> *const c_char;
    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -65,7 +65,7 @@ pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);

@@ -78,7 +78,7 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -166,13 +166,72 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
    luaL_tolstring_(L, lua::lua_absindex(L, idx), len)
 }

-// luaL_opt would be implemented here but it is undocumented, so it's omitted
-
 #[inline(always)]
 pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
    luaL_loadbufferx(L, s, sz, n, ptr::null())
 }

+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}
+
 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+// The buffer size used by the lauxlib buffer system.
+// In Lua 5.3: LUAL_BUFFERSIZE = (int)(0x80 * sizeof(void*) * sizeof(lua_Integer))
+#[rustfmt::skip]
+pub const LUAL_BUFFERSIZE: usize = 0x80 * mem::size_of::<*const ()>() * mem::size_of::<lua_Integer>();
+
+#[repr(C)]
+pub struct luaL_Buffer {
+    pub b: *mut c_char, // buffer address
+    pub size: usize,    // buffer size
+    pub n: usize,       // number of characters in buffer
+    pub L: *mut lua_State,
+    pub initb: [c_char; LUAL_BUFFERSIZE], // initial buffer space
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
+    pub fn luaL_prepbuffsize(B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const c_char, l: usize);
+    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const c_char);
+    pub fn luaL_addvalue(B: *mut luaL_Buffer);
+    pub fn luaL_pushresult(B: *mut luaL_Buffer);
+    pub fn luaL_pushresultsize(B: *mut luaL_Buffer, sz: usize);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+}
+
+// Macro implementations as inline functions
+
+#[inline(always)]
+pub unsafe fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut c_char {
+    luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addchar(B: *mut luaL_Buffer, c: c_char) {
+    if (*B).n >= (*B).size {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).b.add((*B).n) = c;
+    (*B).n += 1;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addsize(B: *mut luaL_Buffer, n: usize) {
+    (*B).n += n;
+}
@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.

+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_void};
 use std::{mem, ptr};
@@ -95,13 +96,13 @@ pub type lua_Reader =
 pub type lua_Writer =
    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;

-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // State manipulation
    //
@@ -171,14 +172,14 @@ pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_arith(L: *mut lua_State, op: c_int);
    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -264,7 +265,7 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Coroutine functions
    //
@@ -299,12 +300,12 @@ pub const LUA_GCSETSTEPMUL: c_int = 7;
 pub const LUA_GCISRUNNING: c_int = 9;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Miscellaneous functions
    //
@@ -407,10 +408,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }

 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }

 #[inline(always)]
@@ -478,7 +477,7 @@ pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -1,22 +1,22 @@
 //! Contains definitions from `lualib.h`.

-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};

 use super::lua::lua_State;

-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaopen_base(L: *mut lua_State) -> c_int;
    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
    pub fn luaopen_table(L: *mut lua_State) -> c_int;
@@ -1,7 +1,7 @@
 //! Contains definitions from `lauxlib.h`.

-use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::os::raw::{c_char, c_double, c_int, c_long, c_void};
+use std::{mem, ptr};

 use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;

 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");

 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");

 #[repr(C)]
 pub struct luaL_Reg {
@@ -21,7 +21,7 @@ pub struct luaL_Reg {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);

    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -30,7 +30,7 @@ extern "C-unwind" {
    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
-        -> *const c_char;
+    -> *const c_char;
    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -64,7 +64,7 @@ pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);

@@ -77,7 +77,7 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -91,7 +91,7 @@ extern "C-unwind" {

    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;

-    // TODO: luaL_addgsub
+    pub fn luaL_addgsub(B: *mut luaL_Buffer, s: *const c_char, p: *const c_char, r: *const c_char);

    pub fn luaL_gsub(
        L: *mut lua_State,
@@ -162,8 +162,6 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
 }

-// luaL_opt would be implemented here but it is undocumented, so it's omitted
-
 #[inline(always)]
 pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
    luaL_loadbufferx(L, s, sz, n, ptr::null())
@@ -188,6 +186,96 @@ pub unsafe fn luaL_loadbufferenv(
    status
 }

+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}
+
 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+// The buffer size used by the lauxlib buffer system.
+// LUAL_BUFFERSIZE = (int)(16 * sizeof(void*) * sizeof(lua_Number))
+#[rustfmt::skip]
+pub const LUAL_BUFFERSIZE: usize = 16 * mem::size_of::<*const ()>() * mem::size_of::<lua_Number>();
+
+// Union used for the initial buffer with maximum alignment.
+// This ensures proper alignment for the buffer data.
+#[repr(C)]
+pub union luaL_BufferInit {
+    // Alignment matches LUAI_MAXALIGN
+    pub _align_n: lua_Number,
+    pub _align_u: c_double,
+    pub _align_s: *mut c_void,
+    pub _align_i: lua_Integer,
+    pub _align_l: c_long,
+    // Initial buffer space
+    pub b: [c_char; LUAL_BUFFERSIZE],
+}
+
+#[repr(C)]
+pub struct luaL_Buffer {
+    pub b: *mut c_char, // buffer address
+    pub size: usize,    // buffer size
+    pub n: usize,       // number of characters in buffer
+    pub L: *mut lua_State,
+    pub init: luaL_BufferInit, // initial buffer (union with alignment)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
+    pub fn luaL_prepbuffsize(B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const c_char, l: usize);
+    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const c_char);
+    pub fn luaL_addvalue(B: *mut luaL_Buffer);
+    pub fn luaL_pushresult(B: *mut luaL_Buffer);
+    pub fn luaL_pushresultsize(B: *mut luaL_Buffer, sz: usize);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+}
+
+// Macro implementations as inline functions
+
+#[inline(always)]
+pub unsafe fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut c_char {
+    luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addchar(B: *mut luaL_Buffer, c: c_char) {
+    if (*B).n >= (*B).size {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).b.add((*B).n) = c;
+    (*B).n += 1;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addsize(B: *mut luaL_Buffer, n: usize) {
+    (*B).n += n;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_buffsub(B: *mut luaL_Buffer, n: usize) {
+    (*B).n -= n;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_bufflen(B: *mut luaL_Buffer) -> usize {
+    (*B).n
+}
+
+#[inline(always)]
+pub unsafe fn luaL_buffaddr(B: *mut luaL_Buffer) -> *mut c_char {
+    (*B).b
+}
@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.

+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_ushort, c_void};
 use std::{mem, ptr};
@@ -94,16 +95,16 @@ pub type lua_Reader =
 pub type lua_Writer =
    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;

-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

 /// Type for warning functions
 pub type lua_WarnFunction = unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // State manipulation
    //
@@ -185,14 +186,14 @@ pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_arith(L: *mut lua_State, op: c_int);
    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -278,7 +279,7 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Coroutine functions
    //
@@ -302,7 +303,7 @@ pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
 // Warning-related functions
 //
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
 }
@@ -323,12 +324,12 @@ pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
 }

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // Miscellaneous functions
    //
@@ -434,10 +435,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }

 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }

 #[inline(always)]
@@ -520,7 +519,7 @@ pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -1,21 +1,21 @@
 //! Contains definitions from `lualib.h`.

-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};

 use super::lua::lua_State;

-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");

 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaopen_base(L: *mut lua_State) -> c_int;
    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
    pub fn luaopen_table(L: *mut lua_State) -> c_int;
@@ -0,0 +1,299 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_double, c_int, c_long, c_uint, c_void};
+use std::{mem, ptr};
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_loadfilex'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
+
+    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+    -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
+    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+    pub fn luaL_alloc(L: *mut lua_State, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    #[link_name = "luaL_makeseed"]
+    pub fn luaL_makeseed_(L: *mut lua_State) -> c_uint;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    pub fn luaL_addgsub(B: *mut luaL_Buffer, s: *const c_char, p: *const c_char, r: *const c_char);
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
+
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua::lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == lua::LUA_OK && env != 0 {
+        lua::lua_pushvalue(L, env);
+        lua::lua_setupvalue(L, -2, 1);
+    }
+    status
+}
+
+pub unsafe fn luaL_makeseed(L: *mut lua_State) -> c_uint {
+    #[cfg(macos)]
+    return libc::arc4random();
+    #[cfg(linux)]
+    {
+        let mut seed = 0u32;
+        let buf = &mut seed as *mut _ as *mut c_void;
+        if libc::getrandom(buf, 4, libc::GRND_NONBLOCK) == 4 {
+            return seed;
+        }
+    }
+    luaL_makeseed_(L)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}
+
+//
+// Generic Buffer Manipulation
+//
+
+// The buffer size used by the lauxlib buffer system.
+// LUAL_BUFFERSIZE = (int)(16 * sizeof(void*) * sizeof(lua_Number))
+#[rustfmt::skip]
+pub const LUAL_BUFFERSIZE: usize = 16 * mem::size_of::<*const ()>() * mem::size_of::<lua_Number>();
+
+// Union used for the initial buffer with maximum alignment.
+// This ensures proper alignment for the buffer data.
+#[repr(C)]
+pub union luaL_BufferInit {
+    // Alignment matches LUAI_MAXALIGN
+    pub _align_n: lua_Number,
+    pub _align_u: c_double,
+    pub _align_s: *mut c_void,
+    pub _align_i: lua_Integer,
+    pub _align_l: c_long,
+    // Initial buffer space
+    pub b: [c_char; LUAL_BUFFERSIZE],
+}
+
+#[repr(C)]
+pub struct luaL_Buffer {
+    pub b: *mut c_char, // buffer address
+    pub size: usize,    // buffer size
+    pub n: usize,       // number of characters in buffer
+    pub L: *mut lua_State,
+    pub init: luaL_BufferInit, // initial buffer (union with alignment)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
+    pub fn luaL_prepbuffsize(B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const c_char, l: usize);
+    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const c_char);
+    pub fn luaL_addvalue(B: *mut luaL_Buffer);
+    pub fn luaL_pushresult(B: *mut luaL_Buffer);
+    pub fn luaL_pushresultsize(B: *mut luaL_Buffer, sz: usize);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Buffer, sz: usize) -> *mut c_char;
+}
+
+// Macro implementations as inline functions
+
+#[inline(always)]
+pub unsafe fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut c_char {
+    luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addchar(B: *mut luaL_Buffer, c: c_char) {
+    if (*B).n >= (*B).size {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).b.add((*B).n) = c;
+    (*B).n += 1;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_addsize(B: *mut luaL_Buffer, n: usize) {
+    (*B).n += n;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_buffsub(B: *mut luaL_Buffer, n: usize) {
+    (*B).n -= n;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_bufflen(B: *mut luaL_Buffer) -> usize {
+    (*B).n
+}
+
+#[inline(always)]
+pub unsafe fn luaL_buffaddr(B: *mut luaL_Buffer) -> *mut c_char {
+    (*B).b
+}
@@ -0,0 +1,578 @@
+//! Contains definitions from `lua.h`.
+
+use std::ffi::CStr;
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
+use std::{mem, ptr};
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+#[doc(hidden)]
+pub const LUAI_MAXSTACK: c_int = c_int::MAX;
+
+// Size of a raw memory area associated with  a Lua state with very fast access.
+pub const LUA_EXTRASPACE: usize = mem::size_of::<*const ()>();
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -(c_int::MAX / 2 + 1000);
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTYPES: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+// index 1 is reserved for the reference mechanism
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 3;
+pub const LUA_RIDX_LAST: lua_Integer = 3;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = i64;
+
+/// A Lua unsigned integer, usually equivalent to `u64`
+pub type lua_Unsigned = u64;
+
+/// Type for continuation-function contexts
+pub type lua_KContext = isize;
+
+/// Type for native C functions that can be passed to Lua
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
+
+/// Type for continuation functions
+pub type lua_KFunction =
+    unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+
+// Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
+pub type lua_Reader =
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
+pub type lua_Writer =
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions (no unwinding)
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+
+/// Type for warning functions
+pub type lua_WarnFunction = unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void, seed: c_uint) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+    pub fn lua_closethread(L: *mut lua_State, from: *mut lua_State) -> c_int;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    #[link_name = "lua_rawlen"]
+    fn lua_rawlen_(L: *mut lua_State, idx: c_int) -> lua_Unsigned;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+}
+
+// lua_rawlen's return type changed from size_t to lua_Unsigned int in Lua 5.4.
+// This adapts the crate API to the new Lua ABI.
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_rawlen_(L, idx) as usize
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPMOD: c_int = 3;
+pub const LUA_OPPOW: c_int = 4;
+pub const LUA_OPDIV: c_int = 5;
+pub const LUA_OPIDIV: c_int = 6;
+pub const LUA_OPBAND: c_int = 7;
+pub const LUA_OPBOR: c_int = 8;
+pub const LUA_OPBXOR: c_int = 9;
+pub const LUA_OPSHL: c_int = 10;
+pub const LUA_OPSHR: c_int = 11;
+pub const LUA_OPUNM: c_int = 12;
+pub const LUA_OPBNOT: c_int = 13;
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, len: usize) -> *const c_char;
+    pub fn lua_pushexternalstring(
+        L: *mut lua_State,
+        s: *const c_char,
+        len: usize,
+        falloc: Option<lua_Alloc>,
+        ud: *mut c_void,
+    ) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_getglobal(L: *mut lua_State, name: *const c_char) -> c_int;
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
+
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdatauv(L: *mut lua_State, sz: usize, nuvalue: c_int) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, name: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+    pub fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Warning-related functions
+//
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
+    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
+}
+
+//
+// Garbage-collection options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCISRUNNING: c_int = 6;
+pub const LUA_GCGEN: c_int = 7;
+pub const LUA_GCINC: c_int = 8;
+pub const LUA_GCPARAM: c_int = 9;
+
+// Parameters for GC generational mode
+pub const LUA_GCPMINORMUL: c_int = 0; // control minor collections
+pub const LUA_GCPMAJORMINOR: c_int = 1; // control shift major->minor
+pub const LUA_GCPMINORMAJOR: c_int = 2; // control shift minor->major
+
+// Parameters for GC incremental mode
+pub const LUA_GCPPAUSE: c_int = 3; // size of pause between successive GCs
+pub const LUA_GCPSTEPMUL: c_int = 4; // GC "speed"
+pub const LUA_GCPSTEPSIZE: c_int = 5; // GC granularity
+
+pub const LUA_GCPNUM: c_int = 6; // number of parameters
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    //
+    // Miscellaneous functions
+    //
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    pub fn lua_len(L: *mut lua_State, idx: c_int);
+    pub fn lua_numbertocstring(L: *mut lua_State, idx: c_int, buff: *mut c_char) -> c_uint;
+    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
+    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
+
+    pub fn lua_toclose(L: *mut lua_State, idx: c_int);
+    pub fn lua_closeslot(L: *mut lua_State, idx: c_int);
+}
+
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+#[inline(always)]
+pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
+    (L as *mut c_char).sub(LUA_EXTRASPACE) as *mut c_void
+}
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
+    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, -1);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
+    lua_copy(L, -1, idx);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
+#[inline(always)]
+pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
+    lua_newuserdatauv(L, sz, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_getiuservalue(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_setiuservalue(L, idx, 1)
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
+pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
+    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
+
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
+    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
+    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,             // (n)
+    pub namewhat: *const c_char,         // (n) 'global', 'local', 'field', 'method'
+    pub what: *const c_char,             // (S) 'Lua', 'C', 'main', 'tail'
+    pub source: *const c_char,           // (S)
+    pub srclen: usize,                   // (S)
+    pub currentline: c_int,              // (l)
+    pub linedefined: c_int,              // (S)
+    pub lastlinedefined: c_int,          // (S)
+    pub nups: c_uchar,                   // (u) number of upvalues
+    pub nparams: c_uchar,                // (u) number of parameters
+    pub isvararg: c_char,                // (u)
+    pub extraargs: c_uchar,              // (t) number of extra arguments
+    pub istailcall: c_char,              // (t)
+    pub ftransfer: c_int,                // (r) index of first value transferred
+    pub ntransfer: c_int,                // (r) number of transferred values
+    pub short_src: [c_char; LUA_IDSIZE], // (S)
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}
@@ -0,0 +1,55 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::{c_char, c_int};
+
+use super::lua::lua_State;
+
+pub const LUA_GLIBK: c_int = 1;
+
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
+pub const LUA_LOADLIBK: c_int = LUA_GLIBK << 1;
+
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_COLIBK: c_int = LUA_GLIBK << 2;
+
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_DBLIBK: c_int = LUA_GLIBK << 3;
+
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_IOLIBK: c_int = LUA_GLIBK << 4;
+
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_MATHLIBK: c_int = LUA_GLIBK << 5;
+
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_OSLIBK: c_int = LUA_GLIBK << 6;
+
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_STRLIBK: c_int = LUA_GLIBK << 7;
+
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_TABLIBK: c_int = LUA_GLIBK << 8;
+
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_UTF8LIBK: c_int = LUA_GLIBK << 9;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua55", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openselectedlibs(L: *mut lua_State, load: c_int, preload: c_int);
+}
+
+pub unsafe fn luaL_openlibs(L: *mut lua_State) {
+    luaL_openselectedlibs(L, !0, 0);
+}
@@ -0,0 +1,9 @@
+//! Low level bindings to Lua 5.5.
+
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;
@@ -1,4 +1,4 @@
-//! MLua compatibility layer for Roblox Luau.
+//! MLua compatibility layer for Luau.
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3

@@ -10,6 +10,8 @@ use super::lauxlib::*;
 use super::lua::*;
 use super::luacode::*;

+pub const LUA_RESUMEERROR: c_int = -1;
+
 unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
    while a < b {
        lua_pushvalue(L, a);
@@ -21,8 +23,8 @@ unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
    }
 }

-const COMPAT53_LEVELS1: c_int = 12; // size of the first part of the stack
-const COMPAT53_LEVELS2: c_int = 10; // size of the second part of the stack
+const COMPAT53_LEVELS1: c_int = 10; // size of the first part of the stack
+const COMPAT53_LEVELS2: c_int = 11; // size of the second part of the stack

 unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) -> c_int {
    if level == 0 || lua_istable(L, -1) == 0 {
@@ -39,11 +41,10 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
                lua_pop(L, 1); // remove value (but keep name)
                return 1;
            } else if compat53_findfield(L, objidx, level - 1) != 0 {
-                // try recursively
-                lua_remove(L, -2); // remove table (but keep name)
-                lua_pushliteral(L, ".");
-                lua_insert(L, -2); // place '.' between the two names
-                lua_concat(L, 3);
+                // stack: lib_name, lib_table, field_name (top)
+                lua_pushliteral(L, c"."); // place '.' between the two names
+                lua_replace(L, -3); // (in the slot occupied by table)
+                lua_concat(L, 3); // lib_name.field_name
                return 1;
            }
        }
@@ -52,14 +53,25 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
    0 // not found
 }

-unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int {
+unsafe fn compat53_pushglobalfuncname(
+    L: *mut lua_State,
+    L1: *mut lua_State,
+    level: c_int,
+    ar: *mut lua_Debug,
+) -> c_int {
    let top = lua_gettop(L);
-    // push function
-    lua_getinfo(L, level, cstr!("f"), ar);
+    lua_getinfo(L1, level, cstr!("f"), ar); // push function
+    lua_xmove(L1, L, 1); // and move onto L
    lua_pushvalue(L, LUA_GLOBALSINDEX);
+    luaL_checkstack(L, 6, cstr!("not enough stack")); // slots for 'findfield'
    if compat53_findfield(L, top + 1, 2) != 0 {
+        let name = lua_tostring(L, -1);
+        if CStr::from_ptr(name).to_bytes().starts_with(b"_G.") {
+            lua_pushstring(L, name.add(3)); // push name without prefix
+            lua_remove(L, -2); // remove original name
+        }
        lua_copy(L, -1, top + 1); // move name to proper place
-        lua_pop(L, 2); // remove pushed values
+        lua_settop(L, top + 1); // remove pushed values
        1
    } else {
        lua_settop(L, top); // remove function and global table
@@ -67,15 +79,18 @@ unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, level: c_int, ar: *mut
    }
 }

-unsafe fn compat53_pushfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) {
+unsafe fn compat53_pushfuncname(L: *mut lua_State, L1: *mut lua_State, level: c_int, ar: *mut lua_Debug) {
    if !(*ar).name.is_null() {
        // is there a name?
        lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
-    } else if compat53_pushglobalfuncname(L, level, ar) != 0 {
+    } else if compat53_pushglobalfuncname(L, L1, level, ar) != 0 {
        lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
        lua_remove(L, -2); // remove name
+    } else if *(*ar).what != b'C' as c_char {
+        // for Lua functions, use <file:line>
+        lua_pushfstring(L, cstr!("function <%s:%d>"), (*ar).short_src, (*ar).linedefined);
    } else {
-        lua_pushliteral(L, "?");
+        lua_pushliteral(L, c"?");
    }
 }

@@ -118,13 +133,19 @@ 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;
        }
    }
    0
 }

+#[inline(always)]
+pub unsafe fn lua_pushinteger(L: *mut lua_State, i: lua_Integer) {
+    lua_pushnumber(L, i as lua_Number);
+}
+
 #[inline(always)]
 pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
    lua_tointegerx(L, i, ptr::null_mut())
@@ -176,21 +197,20 @@ pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_i

 #[inline(always)]
 pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
    lua_rawgeti_(L, idx, n)
 }

 #[inline(always)]
 pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
-    let abs_i = lua_absindex(L, idx);
-    lua_pushlightuserdata(L, p as *mut c_void);
-    lua_rawget(L, abs_i)
+    lua_rawgetptagged(L, idx, p, 0)
 }

 #[inline(always)]
 pub unsafe fn lua_getuservalue(L: *mut lua_State, mut idx: c_int) -> c_int {
    luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
    idx = lua_absindex(L, idx);
-    lua_pushliteral(L, "__mlua_uservalues");
+    lua_pushliteral(L, c"__mlua_uservalues");
    if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
        return LUA_TNIL;
    }
@@ -211,29 +231,26 @@ pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {

 #[inline(always)]
 pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
    lua_rawseti_(L, idx, n)
 }

 #[inline(always)]
 pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
-    let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
-    lua_pushlightuserdata(L, p as *mut c_void);
-    lua_insert(L, -2);
-    lua_rawset(L, abs_i);
+    lua_rawsetptagged(L, idx, p, 0)
 }

 #[inline(always)]
 pub unsafe fn lua_setuservalue(L: *mut lua_State, mut idx: c_int) {
    luaL_checkstack(L, 4, cstr!("not enough stack slots available"));
    idx = lua_absindex(L, idx);
-    lua_pushliteral(L, "__mlua_uservalues");
+    lua_pushliteral(L, c"__mlua_uservalues");
    lua_pushvalue(L, -1);
    if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
        lua_pop(L, 1);
        lua_createtable(L, 0, 2); // main table
        lua_createtable(L, 0, 1); // metatable
-        lua_pushliteral(L, "k");
+        lua_pushliteral(L, c"k");
        lua_setfield(L, -2, cstr!("__mode"));
        lua_setmetatable(L, -2);
        lua_pushvalue(L, -2);
@@ -284,6 +301,19 @@ pub unsafe fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, n
    ret
 }

+#[inline(always)]
+pub unsafe fn lua_resumex(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
+    let ret = if narg == LUA_RESUMEERROR {
+        lua_resumeerror(L, from)
+    } else {
+        lua_resume_(L, from, narg)
+    };
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
+
 //
 // lauxlib ported functions
 //
@@ -294,12 +324,30 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
        if !msg.is_null() {
            luaL_error(L, cstr!("stack overflow (%s)"), msg);
        } else {
-            lua_pushliteral(L, "stack overflow");
+            lua_pushliteral(L, c"stack overflow");
            lua_error(L);
        }
    }
 }

+#[inline(always)]
+pub unsafe fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer {
+    let mut isnum = 0;
+    let int = lua_tointegerx(L, narg, &mut isnum);
+    if isnum == 0 {
+        luaL_typeerror(L, narg, lua_typename(L, LUA_TNUMBER));
+    }
+    int
+}
+
+pub unsafe fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer {
+    if lua_isnoneornil(L, narg) != 0 {
+        def
+    } else {
+        luaL_checkinteger(L, narg)
+    }
+}
+
 #[inline(always)]
 pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
    if luaL_getmetafield_(L, obj, e) != 0 {
@@ -328,11 +376,11 @@ pub unsafe fn luaL_loadbufferenv(
    mode: *const c_char,
    mut env: c_int,
 ) -> c_int {
-    extern "C" {
+    unsafe extern "C" {
        fn free(p: *mut c_void);
    }

-    unsafe extern "C-unwind" fn data_dtor(data: *mut c_void) {
+    unsafe extern "C" fn data_dtor(_: *mut lua_State, data: *mut c_void) {
        free(*(data as *mut *mut c_char) as *mut c_void);
    }

@@ -348,7 +396,7 @@ pub unsafe fn luaL_loadbufferenv(
        }
    }

-    if chunk_is_text {
+    let status = if chunk_is_text {
        if env < 0 {
            env -= 1;
        }
@@ -357,14 +405,21 @@ pub unsafe fn luaL_loadbufferenv(
        ptr::write(data_ud, data);
        // By deferring the `free(data)` to the userdata destructor, we ensure that
        // even if `luau_load` throws an error, the `data` is still released.
-        let ok = luau_load(L, name, data, size, env) == 0;
+        let status = luau_load(L, name, data, size, env);
        lua_replace(L, -2); // replace data with the result
-        if !ok {
-            return LUA_ERRSYNTAX;
+        status
+    } else {
+        luau_load(L, name, data, size, env)
+    };
+
+    if status != 0 {
+        if lua_isstring(L, -1) != 0 && CStr::from_ptr(lua_tostring(L, -1)) == c"not enough memory" {
+            // A case for Luau >= 0.679
+            return LUA_ERRMEM;
        }
-    } else if luau_load(L, name, data, size, env) != 0 {
        return LUA_ERRSYNTAX;
    }
+
    LUA_OK
 }

@@ -404,36 +459,42 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {

 pub unsafe fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, mut level: c_int) {
    let mut ar: lua_Debug = mem::zeroed();
-    let top = lua_gettop(L);
    let numlevels = lua_stackdepth(L);
-    let mark = if numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 {
-        COMPAT53_LEVELS1
-    } else {
-        0
-    };
+    #[rustfmt::skip]
+    let mut limit = if numlevels - level > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 { COMPAT53_LEVELS1 } else { -1 };
+
+    let mut buf: luaL_Strbuf = mem::zeroed();
+    luaL_buffinit(L, &mut buf);

    if !msg.is_null() {
-        lua_pushfstring(L, cstr!("%s\n"), msg);
+        luaL_addstring(&mut buf, msg);
+        luaL_addstring(&mut buf, cstr!("\n"));
    }
-    lua_pushliteral(L, "stack traceback:");
-    while lua_getinfo(L1, level, cstr!(""), &mut ar) != 0 {
-        if level + 1 == mark {
+    luaL_addstring(&mut buf, cstr!("stack traceback:"));
+    while lua_getinfo(L1, level, cstr!("sln"), &mut ar) != 0 {
+        if limit == 0 {
            // too many levels?
-            lua_pushliteral(L, "\n\t..."); // add a '...'
-            level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
+            let n = numlevels - level - COMPAT53_LEVELS2;
+            // add warning about skip ("n + 1" because we skip current level too)
+            lua_pushfstring(L, cstr!("\n\t...\t(skipping %d levels)"), n + 1);
+            luaL_addvalue(&mut buf);
+            level += n; // and skip to last levels
        } else {
-            lua_getinfo(L1, level, cstr!("sln"), &mut ar);
-            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src);
+            luaL_addstring(&mut buf, cstr!("\n\t"));
+            luaL_addstring(&mut buf, ar.short_src);
+            luaL_addstring(&mut buf, cstr!(":"));
            if ar.currentline > 0 {
-                lua_pushfstring(L, cstr!("%d:"), ar.currentline);
+                luaL_addunsigned(&mut buf, ar.currentline as _);
+                luaL_addstring(&mut buf, cstr!(":"));
            }
-            lua_pushliteral(L, " in ");
-            compat53_pushfuncname(L, level, &mut ar);
-            lua_concat(L, lua_gettop(L) - top);
+            luaL_addstring(&mut buf, cstr!(" in "));
+            compat53_pushfuncname(L, L1, level, &mut ar);
+            luaL_addvalue(&mut buf);
        }
        level += 1;
+        limit -= 1;
    }
-    lua_concat(L, lua_gettop(L) - top);
+    luaL_pushresult(&mut buf);
 }

 pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
@@ -441,16 +502,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
        match lua_type(L, idx) {
            LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
            }
            LUA_TSTRING | LUA_TNUMBER => {
                lua_pushvalue(L, idx);
            }
            LUA_TBOOLEAN => {
                if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                }
            }
            t => {
@@ -496,7 +557,7 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch

 pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
    if lua_getfield(L, -1, modname) == LUA_TNIL {
        lua_pop(L, 1);
        lua_pushcfunction(L, openf);
@@ -3,7 +3,10 @@
 use std::os::raw::{c_char, c_float, c_int, c_void};
 use std::ptr;

-use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX};
+use super::lua::{self, LUA_REGISTRYINDEX, lua_CFunction, lua_Number, lua_State, lua_Unsigned};
+
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");

 #[repr(C)]
 pub struct luaL_Reg {
@@ -11,7 +14,7 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
    #[link_name = "luaL_getmetafield"]
    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -33,8 +36,12 @@ extern "C-unwind" {
    pub fn luaL_checkboolean(L: *mut lua_State, narg: c_int) -> c_int;
    pub fn luaL_optboolean(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;

-    pub fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer;
-    pub fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer;
+    #[link_name = "luaL_checkinteger"]
+    pub fn luaL_checkinteger_(L: *mut lua_State, narg: c_int) -> c_int;
+    pub fn luaL_checkinteger64(L: *mut lua_State, narg: c_int) -> i64;
+    #[link_name = "luaL_optinteger"]
+    pub fn luaL_optinteger_(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
+    pub fn luaL_optinteger64(L: *mut lua_State, narg: c_int, def: i64) -> i64;
    pub fn luaL_checkunsigned(L: *mut lua_State, narg: c_int) -> lua_Unsigned;
    pub fn luaL_optunsigned(L: *mut lua_State, narg: c_int, def: lua_Unsigned) -> lua_Unsigned;

@@ -69,10 +76,20 @@ extern "C-unwind" {

    pub fn luaL_newstate() -> *mut lua_State;

-    // TODO: luaL_findtable
+    pub fn luaL_findtable(
+        L: *mut lua_State,
+        idx: c_int,
+        fname: *const c_char,
+        szhint: c_int,
+    ) -> *const c_char;

    pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;

+    pub fn luaL_callyieldable(L: *mut lua_State, nargs: c_int, nresults: c_int) -> c_int;
+
+    #[link_name = "luaL_traceback"]
+    pub fn luaL_traceback_(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
+
    // sandbox libraries and globals
    #[link_name = "luaL_sandbox"]
    pub fn luaL_sandbox_(L: *mut lua_State);
@@ -107,7 +124,19 @@ pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *
    luaL_optlstring(L, n, d, ptr::null_mut())
 }

-// TODO: luaL_opt
+#[inline(always)]
+pub unsafe fn luaL_opt<T>(
+    L: *mut lua_State,
+    f: unsafe extern "C-unwind" fn(*mut lua_State, c_int) -> T,
+    n: c_int,
+    d: T,
+) -> T {
+    if lua::lua_isnoneornil(L, n) != 0 {
+        d
+    } else {
+        f(L, n)
+    }
+}

 #[inline(always)]
 pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) -> c_int {
@@ -141,7 +170,7 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
    }

    // set all builtin metatables to read-only
-    lua_pushliteral(L, "");
+    lua_pushliteral(L, c"");
    if lua_getmetatable(L, -1) != 0 {
        lua_setreadonly(L, -1, enabled);
        lua_pop(L, 2);
@@ -173,7 +202,7 @@ pub struct luaL_Strbuf {
 // For compatibility
 pub type luaL_Buffer = luaL_Strbuf;

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Strbuf);
    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
    pub fn luaL_prepbuffsize(B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
@@ -200,3 +229,18 @@ pub unsafe fn luaL_addstring(B: *mut luaL_Strbuf, s: *const c_char) {
    }
    luaL_addlstring(B, s, len);
 }
+
+pub unsafe fn luaL_addunsigned(B: *mut luaL_Strbuf, mut n: lua_Unsigned) {
+    let mut buf: [c_char; 32] = [0; 32];
+    let mut i = 32;
+    loop {
+        i -= 1;
+        let digit = (n % 10) as u8;
+        buf[i] = (b'0' + digit) as c_char;
+        n /= 10;
+        if n == 0 {
+            break;
+        }
+    }
+    luaL_addlstring(B, buf.as_ptr().add(i), 32 - i);
+}
@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.

+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
 use std::{mem, ptr};
@@ -11,10 +12,10 @@ pub const LUA_MULTRET: c_int = -1;
 const LUAI_MAXCSTACK: c_int = 1000000;

 // Number of valid Lua userdata tags
-const LUA_UTAG_LIMIT: c_int = 128;
+pub const LUA_UTAG_LIMIT: c_int = 128;

 // Number of valid Lua lightuserdata tags
-const LUA_LUTAG_LIMIT: c_int = 128;
+pub const LUA_LUTAG_LIMIT: c_int = 128;

 //
 // Pseudo-indices
@@ -36,6 +37,16 @@ pub const LUA_ERRRUN: c_int = 2;
 pub const LUA_ERRSYNTAX: c_int = 3;
 pub const LUA_ERRMEM: c_int = 4;
 pub const LUA_ERRERR: c_int = 5;
+pub const LUA_BREAK: c_int = 6; // yielded for a debug breakpoint
+
+//
+// Coroutine status
+//
+pub const LUA_CORUN: c_int = 0; // running
+pub const LUA_COSUS: c_int = 1; // suspended
+pub const LUA_CONOR: c_int = 2; // 'normal' (it resumed another coroutine)
+pub const LUA_COFIN: c_int = 3; // finished
+pub const LUA_COERR: c_int = 4; // finished with error

 /// A raw Lua state associated with a thread.
 #[repr(C)]
@@ -54,14 +65,15 @@ pub const LUA_TBOOLEAN: c_int = 1;

 pub const LUA_TLIGHTUSERDATA: c_int = 2;
 pub const LUA_TNUMBER: c_int = 3;
-pub const LUA_TVECTOR: c_int = 4;
+pub const LUA_TINTEGER: c_int = 4;
+pub const LUA_TVECTOR: c_int = 5;

-pub const LUA_TSTRING: c_int = 5;
-pub const LUA_TTABLE: c_int = 6;
-pub const LUA_TFUNCTION: c_int = 7;
-pub const LUA_TUSERDATA: c_int = 8;
-pub const LUA_TTHREAD: c_int = 9;
-pub const LUA_TBUFFER: c_int = 10;
+pub const LUA_TSTRING: c_int = 6;
+pub const LUA_TTABLE: c_int = 7;
+pub const LUA_TFUNCTION: c_int = 8;
+pub const LUA_TUSERDATA: c_int = 9;
+pub const LUA_TTHREAD: c_int = 10;
+pub const LUA_TBUFFER: c_int = 11;

 /// Guaranteed number of Lua stack slots available to a C function.
 pub const LUA_MINSTACK: c_int = 20;
@@ -69,8 +81,11 @@ pub const LUA_MINSTACK: c_int = 20;
 /// A Lua number, usually equivalent to `f64`.
 pub type lua_Number = c_double;

-/// A Lua integer, equivalent to `i32`.
-pub type lua_Integer = c_int;
+/// A Lua integer, usually equivalent to `i64`
+#[cfg(target_pointer_width = "32")]
+pub type lua_Integer = i32;
+#[cfg(target_pointer_width = "64")]
+pub type lua_Integer = i64;

 /// A Lua unsigned integer, equivalent to `u32`.
 pub type lua_Unsigned = c_uint;
@@ -79,20 +94,19 @@ pub type lua_Unsigned = c_uint;
 pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 pub type lua_Continuation = unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int) -> c_int;

-/// Type for userdata destructor functions.
-pub type lua_Udestructor = unsafe extern "C-unwind" fn(*mut c_void);
-pub type lua_Destructor = unsafe extern "C-unwind" fn(L: *mut lua_State, *mut c_void);
+/// Type for userdata destructor functions (no unwinding).
+pub type lua_Destructor = unsafe extern "C" fn(L: *mut lua_State, *mut c_void);

-/// Type for memory-allocation functions.
+/// Type for memory-allocation functions (no unwinding).
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

 /// Returns Luau release version (eg. `0.xxx`).
 pub const fn luau_version() -> Option<&'static str> {
    option_env!("LUAU_VERSION")
 }

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    //
    // State manipulation
    //
@@ -136,14 +150,22 @@ extern "C-unwind" {

    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
    #[link_name = "lua_tointegerx"]
-    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> c_int;
    pub fn lua_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
    pub fn lua_tovector(L: *mut lua_State, idx: c_int) -> *const c_float;
    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tointeger64(L: *mut lua_State, idx: c_int, isinteger: *mut c_int) -> i64;
    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
    pub fn lua_tostringatom(L: *mut lua_State, idx: c_int, atom: *mut c_int) -> *const c_char;
+    pub fn lua_tolstringatom(
+        L: *mut lua_State,
+        idx: c_int,
+        len: *mut usize,
+        atom: *mut c_int,
+    ) -> *const c_char;
    pub fn lua_namecallatom(L: *mut lua_State, atom: *mut c_int) -> *const c_char;
-    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
+    #[link_name = "lua_objlen"]
+    pub fn lua_objlen_(L: *mut lua_State, idx: c_int) -> c_int;
    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
    pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
    pub fn lua_tolightuserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
@@ -160,7 +182,9 @@ extern "C-unwind" {
    //
    pub fn lua_pushnil(L: *mut lua_State);
    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
-    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    #[link_name = "lua_pushinteger"]
+    pub fn lua_pushinteger_(L: *mut lua_State, n: c_int);
+    pub fn lua_pushinteger64(L: *mut lua_State, n: i64);
    pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
    #[cfg(not(feature = "luau-vector4"))]
    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
@@ -186,7 +210,7 @@ extern "C-unwind" {
    pub fn lua_pushlightuserdatatagged(L: *mut lua_State, p: *mut c_void, tag: c_int);
    pub fn lua_newuserdatatagged(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
    pub fn lua_newuserdatataggedwithmetatable(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
-    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Udestructor) -> *mut c_void;
+    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Destructor) -> *mut c_void;

    pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;

@@ -199,6 +223,7 @@ extern "C-unwind" {
    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
    #[link_name = "lua_rawgeti"]
    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+    pub fn lua_rawgetptagged(L: *mut lua_State, idx: c_int, p: *const c_void, tag: c_int) -> c_int;
    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);

    pub fn lua_setreadonly(L: *mut lua_State, idx: c_int, enabled: c_int);
@@ -213,9 +238,11 @@ extern "C-unwind" {
    //
    pub fn lua_settable(L: *mut lua_State, idx: c_int);
    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawsetfield(L: *mut lua_State, idx: c_int, k: *const c_char);
    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
    #[link_name = "lua_rawseti"]
    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_rawsetptagged(L: *mut lua_State, idx: c_int, p: *const c_void, tag: c_int);
    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;

@@ -231,6 +258,7 @@ 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
@@ -244,6 +272,12 @@ extern "C-unwind" {
    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
    pub fn lua_getthreaddata(L: *mut lua_State) -> *mut c_void;
    pub fn lua_setthreaddata(L: *mut lua_State, data: *mut c_void);
+    pub fn lua_costatus(L: *mut lua_State, co: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_objlen_(L, idx) as usize
 }

 //
@@ -260,14 +294,14 @@ pub const LUA_GCSETGOAL: c_int = 7;
 pub const LUA_GCSETSTEPMUL: c_int = 8;
 pub const LUA_GCSETSTEPSIZE: c_int = 9;

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

 //
 // Memory statistics
 //
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_setmemcat(L: *mut lua_State, category: c_int);
    pub fn lua_totalbytes(L: *mut lua_State, category: c_int) -> usize;
 }
@@ -275,22 +309,23 @@ extern "C-unwind" {
 //
 // Miscellaneous functions
 //
-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_error(L: *mut lua_State) -> !;
    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
    pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
    pub fn lua_concat(L: *mut lua_State, n: c_int);
-    // TODO: lua_encodepointer
+    pub fn lua_encodepointer(L: *mut lua_State, p: usize) -> usize;
    pub fn lua_clock() -> c_double;
    pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
    pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Destructor>);
    pub fn lua_getuserdatadtor(L: *mut lua_State, tag: c_int) -> Option<lua_Destructor>;
-    pub fn lua_setuserdatametatable(L: *mut lua_State, tag: c_int, idx: c_int);
+    pub fn lua_setuserdatametatable(L: *mut lua_State, tag: c_int);
    pub fn lua_getuserdatametatable(L: *mut lua_State, tag: c_int);
    pub fn lua_setlightuserdataname(L: *mut lua_State, tag: c_int, name: *const c_char);
    pub fn lua_getlightuserdataname(L: *mut lua_State, tag: c_int) -> *const c_char;
    pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
    pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
+    pub fn lua_clonetable(L: *mut lua_State, idx: c_int);
    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
 }

@@ -300,7 +335,7 @@ extern "C-unwind" {
 pub const LUA_NOREF: c_int = -1;
 pub const LUA_REFNIL: c_int = 0;

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn lua_ref(L: *mut lua_State, idx: c_int) -> c_int;
    pub fn lua_unref(L: *mut lua_State, r#ref: c_int);
 }
@@ -310,13 +345,13 @@ extern "C-unwind" {
 //

 #[inline(always)]
-pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
-    lua_tonumberx(L, i, ptr::null_mut())
+pub unsafe fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number {
+    lua_tonumberx(L, idx, ptr::null_mut())
 }

 #[inline(always)]
-pub unsafe fn lua_tointeger_(L: *mut lua_State, i: c_int) -> lua_Integer {
-    lua_tointegerx_(L, i, ptr::null_mut())
+pub unsafe fn lua_tointeger_(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_tointegerx_(L, idx, ptr::null_mut())
 }

 #[inline(always)]
@@ -340,15 +375,20 @@ pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
 }

 #[inline(always)]
-pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State) -> *mut T {
-    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State, data: T) -> *mut T {
+    unsafe extern "C" fn destructor<T>(_: *mut lua_State, ud: *mut c_void) {
        ptr::drop_in_place(ud as *mut T);
    }

-    lua_newuserdatadtor(L, mem::size_of::<T>(), destructor::<T>) as *mut T
+    let ud_ptr = lua_newuserdatadtor(L, const { mem::size_of::<T>() }, destructor::<T>) as *mut T;
+    ptr::write(ud_ptr, data);
+    ud_ptr
 }

-// TODO: lua_strlen
+#[inline(always)]
+pub unsafe fn lua_strlen(L: *mut lua_State, i: c_int) -> usize {
+    lua_objlen(L, i)
+}

 #[inline(always)]
 pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
@@ -375,6 +415,11 @@ pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
 }

+#[inline(always)]
+pub unsafe fn lua_isinteger64(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TINTEGER) as c_int
+}
+
 #[inline(always)]
 pub unsafe fn lua_isvector(L: *mut lua_State, n: c_int) -> c_int {
    (lua_type(L, n) == LUA_TVECTOR) as c_int
@@ -401,10 +446,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }

 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }

 #[inline(always)]
@@ -466,7 +509,13 @@ pub type lua_Coverage = unsafe extern "C-unwind" fn(
    size: usize,
 );

-extern "C-unwind" {
+pub type lua_CounterFunction =
+    unsafe extern "C-unwind" fn(context: *mut c_void, function: *const c_char, linedefined: c_int);
+
+pub type lua_CounterValue =
+    unsafe extern "C-unwind" fn(context: *mut c_void, kind: c_int, line: c_int, hits: u64);
+
+unsafe extern "C-unwind" {
    pub fn lua_stackdepth(L: *mut lua_State) -> c_int;
    pub fn lua_getinfo(L: *mut lua_State, level: c_int, what: *const c_char, ar: *mut lua_Debug) -> c_int;
    pub fn lua_getargument(L: *mut lua_State, level: c_int, n: c_int) -> c_int;
@@ -480,6 +529,14 @@ extern "C-unwind" {

    pub fn lua_getcoverage(L: *mut lua_State, funcindex: c_int, context: *mut c_void, callback: lua_Coverage);

+    pub fn lua_getcounters(
+        L: *mut lua_State,
+        funcindex: c_int,
+        context: *mut c_void,
+        functionvisit: lua_CounterFunction,
+        countervisit: lua_CounterValue,
+    );
+
    pub fn lua_debugtrace(L: *mut lua_State) -> *const c_char;
 }

@@ -516,8 +573,8 @@ pub struct lua_Callbacks {

    /// gets called when L is created (LP == parent) or destroyed (LP == NULL)
    pub userthread: Option<unsafe extern "C-unwind" fn(LP: *mut lua_State, L: *mut lua_State)>,
-    /// gets called when a string is created; returned atom can be retrieved via tostringatom
-    pub useratom: Option<unsafe extern "C-unwind" fn(s: *const c_char, l: usize) -> i16>,
+    /// gets called when a string is created to assign an atom id
+    pub useratom: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, s: *const c_char, l: usize) -> i16>,

    /// gets called when BREAK instruction is encountered
    pub debugbreak: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
@@ -532,12 +589,17 @@ pub struct lua_Callbacks {
    pub onallocate: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, osize: usize, nsize: usize)>,
 }

-extern "C" {
+unsafe extern "C" {
    pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
 }

 // Functions from customization lib
-extern "C" {
+unsafe extern "C" {
    pub fn luau_setfflag(name: *const c_char, value: c_int) -> c_int;
    pub fn lua_getmetatablepointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+    pub fn lua_gcdump(
+        L: *mut lua_State,
+        file: *mut c_void,
+        category_name: Option<unsafe extern "C" fn(L: *mut lua_State, memcat: u8) -> *const c_char>,
+    );
 }
@@ -76,15 +76,16 @@ pub type lua_LibraryMemberConstantCallback = unsafe extern "C-unwind" fn(
    constant: *mut lua_CompileConstant,
 );

-extern "C" {
+unsafe extern "C" {
    pub fn luau_set_compile_constant_nil(cons: *mut lua_CompileConstant);
    pub fn luau_set_compile_constant_boolean(cons: *mut lua_CompileConstant, b: c_int);
    pub fn luau_set_compile_constant_number(cons: *mut lua_CompileConstant, n: f64);
+    pub fn luau_set_compile_constant_integer64(cons: *mut lua_CompileConstant, l: i64);
    pub fn luau_set_compile_constant_vector(cons: *mut lua_CompileConstant, x: f32, y: f32, z: f32, w: f32);
    pub fn luau_set_compile_constant_string(cons: *mut lua_CompileConstant, s: *const c_char, l: usize);
 }

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    #[link_name = "luau_compile"]
    pub fn luau_compile_(
        source: *const c_char,
@@ -94,7 +95,7 @@ extern "C-unwind" {
    ) -> *mut c_char;
 }

-extern "C" {
+unsafe extern "C" {
    fn free(p: *mut c_void);
 }

@@ -4,7 +4,7 @@ use std::os::raw::c_int;

 use super::lua::lua_State;

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luau_codegen_supported() -> c_int;
    pub fn luau_codegen_create(state: *mut lua_State);
    pub fn luau_codegen_compile(state: *mut lua_State, idx: c_int);
@@ -1,21 +1,22 @@
 //! Contains definitions from `lualib.h`.

-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};

 use super::lua::lua_State;

-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_BUFFERLIBNAME: &str = "buffer";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_VECLIBNAME: &str = "vector";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_BUFFERLIBNAME: *const c_char = cstr!("buffer");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_VECLIBNAME: *const c_char = cstr!("vector");
+pub const LUA_INTLIBNAME: *const c_char = cstr!("integer");

-extern "C-unwind" {
+unsafe extern "C-unwind" {
    pub fn luaopen_base(L: *mut lua_State) -> c_int;
    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
    pub fn luaopen_table(L: *mut lua_State) -> c_int;
@@ -27,6 +28,7 @@ extern "C-unwind" {
    pub fn luaopen_math(L: *mut lua_State) -> c_int;
    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
    pub fn luaopen_vector(L: *mut lua_State) -> c_int;
+    pub fn luaopen_integer(L: *mut lua_State) -> c_int;

    // open all builtin libraries
    pub fn luaL_openlibs(L: *mut lua_State);
@@ -0,0 +1,219 @@
+//! Contains definitions from `Require.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+
+use super::lua::lua_State;
+
+pub const LUA_REGISTERED_MODULES_TABLE: *const c_char = cstr!("_REGISTEREDMODULES");
+
+#[repr(C)]
+pub enum luarequire_NavigateResult {
+    Success,
+    Ambiguous,
+    NotFound,
+}
+
+// Functions returning WriteSuccess are expected to set their size_out argument
+// to the number of bytes written to the buffer. If WriteBufferTooSmall is
+// returned, size_out should be set to the required buffer size.
+#[repr(C)]
+pub enum luarequire_WriteResult {
+    Success,
+    BufferTooSmall,
+    Failure,
+}
+
+/// Represents whether a configuration file is present, and if so, its syntax.
+#[repr(C)]
+pub enum luarequire_ConfigStatus {
+    Absent,
+    // Signals the presence of multiple configuration files
+    Ambiguous,
+    PresentJson,
+    PresentLuau,
+}
+
+#[repr(C)]
+pub struct luarequire_Configuration {
+    // Returns whether requires are permitted from the given chunkname.
+    pub is_require_allowed: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> bool,
+
+    // Resets the internal state to point at the requirer module.
+    pub reset: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Resets the internal state to point at an aliased module, given its exact path from a configuration
+    // file. This function is only called when an alias's path cannot be resolved relative to its
+    // configuration file.
+    pub jump_to_alias: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Provides an initial alias override opportunity prior to searching for configuration files.
+    // If NAVIGATE_SUCCESS is returned, the internal state must be updated to point at the
+    // aliased location.
+    // Can be left undefined.
+    pub to_alias_override: Option<
+        unsafe extern "C-unwind" fn(
+            L: *mut lua_State,
+            ctx: *mut c_void,
+            alias_unprefixed: *const c_char,
+        ) -> luarequire_NavigateResult,
+    >,
+
+    // Provides a final override opportunity if an alias cannot be found in configuration files. If
+    // NAVIGATE_SUCCESS is returned, this must update the internal state to point at the aliased module.
+    // Can be left undefined.
+    pub to_alias_fallback: Option<
+        unsafe extern "C-unwind" fn(
+            L: *mut lua_State,
+            ctx: *mut c_void,
+            alias_unprefixed: *const c_char,
+        ) -> luarequire_NavigateResult,
+    >,
+
+    // Navigates through the context by making mutations to the internal state.
+    pub to_parent:
+        unsafe extern "C-unwind" fn(L: *mut lua_State, ctx: *mut c_void) -> luarequire_NavigateResult,
+    pub to_child: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        name: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Returns whether the context is currently pointing at a module.
+    pub is_module_present: unsafe extern "C-unwind" fn(L: *mut lua_State, ctx: *mut c_void) -> bool,
+
+    // Provides a chunkname for the current module. This will be accessible through the debug library. This
+    // function is only called if is_module_present returns true.
+    pub get_chunkname: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Provides a loadname that identifies the current module and is passed to load. This function
+    // is only called if is_module_present returns true.
+    pub get_loadname: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Provides a cache key representing the current module. This function is only called if
+    // is_module_present returns true.
+    pub get_cache_key: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Returns whether a configuration file is present in the current context, and if so, its syntax.
+    // If not present, require-by-string will call to_parent until either a configuration file is present or
+    // NAVIGATE_FAILURE is returned (at root).
+    pub get_config_status:
+        unsafe extern "C-unwind" fn(L: *mut lua_State, ctx: *mut c_void) -> luarequire_ConfigStatus,
+
+    // Parses the configuration file in the current context for the given alias and returns its
+    // value or WRITE_FAILURE if not found. This function is only called if get_config_status
+    // returns true. If this function pointer is set, get_config must not be set. Opting in to this
+    // function pointer disables parsing configuration files internally and can be used for finer
+    // control over the configuration file parsing process.
+    pub get_alias: Option<
+        unsafe extern "C-unwind" fn(
+            L: *mut lua_State,
+            ctx: *mut c_void,
+            alias: *const c_char,
+            buffer: *mut c_char,
+            buffer_size: usize,
+            size_out: *mut usize,
+        ) -> luarequire_WriteResult,
+    >,
+
+    // Provides the contents of the configuration file in the current context.
+    // This function is only called if get_config_status does not return CONFIG_ABSENT. If this function
+    // pointer is set, get_alias must not be set. Opting in to this function pointer enables parsing
+    // configuration files internally.
+    pub get_config: Option<
+        unsafe extern "C-unwind" fn(
+            L: *mut lua_State,
+            ctx: *mut c_void,
+            buffer: *mut c_char,
+            buffer_size: usize,
+            size_out: *mut usize,
+        ) -> luarequire_WriteResult,
+    >,
+
+    // Returns the maximum number of milliseconds to allow for executing a given Luau-syntax configuration
+    // file. This function is only called if get_config_status returns CONFIG_PRESENT_LUAU and can be left
+    // undefined if support for Luau-syntax configuration files is not needed. A default value of 2000ms is
+    // used. Negative values are treated as infinite.
+    pub get_luau_config_timeout:
+        Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ctx: *mut c_void) -> c_int>,
+
+    // Executes the module and places the result on the stack. Returns the number of results placed on the
+    // stack.
+    // Returning -1 directs the requiring thread to yield. In this case, this thread should be resumed with
+    // the module result pushed onto its stack.
+    pub load: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+        chunkname: *const c_char,
+        loadname: *const c_char,
+    ) -> c_int,
+}
+
+// Populates function pointers in the given luarequire_Configuration.
+pub type luarequire_Configuration_init = unsafe extern "C-unwind" fn(config: *mut luarequire_Configuration);
+
+unsafe extern "C-unwind" {
+    // Initializes and pushes the require closure onto the stack without registration.
+    pub fn luarequire_pushrequire(
+        L: *mut lua_State,
+        config_init: luarequire_Configuration_init,
+        ctx: *mut c_void,
+    ) -> c_int;
+
+    // Initializes the require library and registers it globally.
+    pub fn luaopen_require(L: *mut lua_State, config_init: luarequire_Configuration_init, ctx: *mut c_void);
+
+    // Initializes and pushes a "proxyrequire" closure onto the stack.
+    //
+    // The closure takes two parameters: the string path to resolve and the chunkname of an existing
+    // module.
+    pub fn luarequire_pushproxyrequire(
+        L: *mut lua_State,
+        config_init: luarequire_Configuration_init,
+        ctx: *mut c_void,
+    ) -> c_int;
+
+    // Registers an aliased require path to a result.
+    //
+    // After registration, the given result will always be immediately returned when the given path is
+    // required.
+    // Expects the path and table to be passed as arguments on the stack.
+    pub fn luarequire_registermodule(L: *mut lua_State) -> c_int;
+
+    // Clears the entry associated with the given cache key from the require cache.
+    // Expects the cache key to be passed as an argument on the stack.
+    pub fn luarequire_clearcacheentry(L: *mut lua_State) -> c_int;
+
+    // Clears all entries from the require cache.
+    pub fn luarequire_clearcache(L: *mut lua_State) -> c_int;
+}
@@ -6,6 +6,7 @@ pub use lua::*;
 pub use luacode::*;
 pub use luacodegen::*;
 pub use lualib::*;
+pub use luarequire::*;

 pub mod compat;
 pub mod lauxlib;
@@ -13,3 +14,4 @@ pub mod lua;
 pub mod luacode;
 pub mod luacodegen;
 pub mod lualib;
+pub mod luarequire;
@@ -1,10 +1,11 @@
 [package]
 name = "mlua_derive"
-version = "0.10.1"
+version = "0.12.0-rc.1"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2021"
+rust-version = "1.88"
+edition = "2024"
 description = "Procedural macros for the mlua crate."
-repository = "https://github.com/khvzak/mlua"
+repository = "https://github.com/mlua-rs/mlua"
 keywords = ["lua", "mlua"]
 license = "MIT"

@@ -12,13 +13,11 @@ license = "MIT"
 proc-macro = true

 [features]
-macros = ["proc-macro-error2", "itertools", "regex", "once_cell"]
+macros = ["proc-macro-error2", "itertools"]

 [dependencies]
 quote = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 proc-macro-error2 = { version = "2.0.1", optional = true }
 syn = { version = "2.0", features = ["full"] }
-itertools = { version = "0.13", optional = true }
-regex = { version = "1.4", optional = true }
-once_cell = { version = "1.0", optional = true }
+itertools = { version = "0.14", optional = true }
@@ -1,105 +0,0 @@
-use proc_macro::{TokenStream, TokenTree};
-
-use crate::token::{Pos, Token, Tokens};
-
-#[derive(Debug, Clone)]
-pub(crate) struct Capture {
-    key: Token,
-    rust: TokenTree,
-}
-
-impl Capture {
-    fn new(key: Token, rust: TokenTree) -> Self {
-        Self { key, rust }
-    }
-
-    /// Token string inside `chunk!`
-    pub(crate) fn key(&self) -> &Token {
-        &self.key
-    }
-
-    /// As rust variable, e.g. `x`
-    pub(crate) fn as_rust(&self) -> &TokenTree {
-        &self.rust
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Captures(Vec<Capture>);
-
-impl Captures {
-    pub(crate) fn new() -> Self {
-        Self(Vec::new())
-    }
-
-    pub(crate) fn add(&mut self, token: &Token) -> Capture {
-        let tt = token.tree();
-        let key = token.clone();
-
-        match self.0.iter().find(|arg| arg.key() == &key) {
-            Some(arg) => arg.clone(),
-            None => {
-                let arg = Capture::new(key, tt.clone());
-                self.0.push(arg.clone());
-                arg
-            }
-        }
-    }
-
-    pub(crate) fn captures(&self) -> &[Capture] {
-        &self.0
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Chunk {
-    source: String,
-    caps: Captures,
-}
-
-impl Chunk {
-    pub(crate) fn new(tokens: TokenStream) -> Self {
-        let tokens = Tokens::retokenize(tokens);
-
-        let mut source = String::new();
-        let mut caps = Captures::new();
-
-        let mut pos: Option<Pos> = None;
-        for t in tokens {
-            if t.is_cap() {
-                caps.add(&t);
-            }
-
-            let (line, col) = (t.start().line, t.start().column);
-            let (prev_line, prev_col) = pos
-                .take()
-                .map(|lc| (lc.line, lc.column))
-                .unwrap_or_else(|| (line, col));
-
-            #[allow(clippy::comparison_chain)]
-            if line > prev_line {
-                source.push('\n');
-            } else if line == prev_line {
-                for _ in 0..col.saturating_sub(prev_col) {
-                    source.push(' ');
-                }
-            }
-            source.push_str(&t.to_string());
-
-            pos = Some(t.end());
-        }
-
-        Self {
-            source: source.trim_end().to_string(),
-            caps,
-        }
-    }
-
-    pub(crate) fn source(&self) -> &str {
-        &self.source
-    }
-
-    pub(crate) fn captures(&self) -> &[Capture] {
-        self.caps.captures()
-    }
-}
@@ -0,0 +1,160 @@
+use std::ops::Deref;
+
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{ToTokens, quote};
+
+use self::token::{Pos, Token, Tokens};
+
+mod token;
+
+#[derive(Debug, Clone)]
+pub(crate) struct Capture(Token);
+
+impl Deref for Capture {
+    type Target = Token;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Capture {
+    fn new(token: &Token) -> Self {
+        Self(token.clone())
+    }
+
+    pub(crate) fn name(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl ToTokens for Capture {
+    fn to_tokens(&self, tokens: &mut TokenStream2) {
+        let ts: TokenStream = self.0.tree().clone().into();
+        tokens.extend(TokenStream2::from(ts));
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Captures(Vec<Capture>);
+
+impl Captures {
+    pub(crate) fn new() -> Self {
+        Self(Vec::new())
+    }
+
+    pub(crate) fn add(&mut self, token: &Token) {
+        if self.0.iter().any(|arg| &**arg == token) {
+            return;
+        }
+        self.0.push(Capture::new(token));
+    }
+
+    pub(crate) fn captures(&self) -> &[Capture] {
+        &self.0
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Chunk {
+    source: String,
+    caps: Captures,
+}
+
+impl Chunk {
+    pub(crate) fn new(tokens: TokenStream) -> Self {
+        let tokens = Tokens::retokenize(tokens);
+
+        let mut source = String::new();
+        let mut caps = Captures::new();
+
+        let mut prev_end: Option<Pos> = None;
+        for t in tokens {
+            if t.is_cap() {
+                caps.add(&t);
+            }
+
+            let (line, col) = (t.start().line, t.start().column);
+            if let Some(prev) = prev_end {
+                if line > prev.line {
+                    source.push('\n');
+                    source.push_str(&" ".repeat(col.saturating_sub(1)));
+                } else if line == prev.line {
+                    source.push_str(&" ".repeat(col.saturating_sub(prev.column)));
+                }
+            } else {
+                source.push_str(&" ".repeat(col.saturating_sub(1)));
+            }
+            source.push_str(&t.to_string());
+
+            prev_end = Some(t.end());
+        }
+
+        Self {
+            source: source.trim_end().to_string(),
+            caps,
+        }
+    }
+
+    pub(crate) fn captures(&self) -> &[Capture] {
+        self.caps.captures()
+    }
+
+    pub(crate) fn expand(&self) -> TokenStream2 {
+        let source = &self.source;
+
+        let caps_len = self.captures().len();
+        let caps = self.captures().iter().map(|cap| {
+            let cap_name = cap.name();
+            quote! { env.raw_set(#cap_name, #cap)?; }
+        });
+
+        quote! {{
+            use mlua::{AsChunk, ChunkMode, Lua, Result, Table};
+            use ::std::borrow::Cow;
+            use ::std::cell::Cell;
+            use ::std::io::Result as IoResult;
+
+            struct InnerChunk<F: FnOnce(&Lua) -> Result<Table>>(Cell<Option<F>>);
+
+            impl<F> AsChunk for InnerChunk<F>
+            where
+                F: FnOnce(&Lua) -> Result<Table>,
+            {
+                fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
+                    if #caps_len > 0 {
+                        if let Some(make_env) = self.0.take() {
+                            return make_env(lua).map(Some);
+                        }
+                    }
+                    Ok(None)
+                }
+
+                fn mode(&self) -> Option<ChunkMode> {
+                    Some(ChunkMode::Text)
+                }
+
+                fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+                    Ok(Cow::Borrowed((#source).as_bytes()))
+                }
+            }
+
+            let make_env = move |lua: &Lua| -> Result<Table> {
+                let globals = lua.globals();
+                let env = lua.create_table()?;
+                let meta = lua.create_table()?;
+                meta.raw_set("__index", &globals)?;
+                meta.raw_set("__newindex", &globals)?;
+
+                // Add captured variables
+                #(#caps)*
+
+                env.set_metatable(Some(meta))?;
+                Ok(env)
+            };
+
+            InnerChunk(Cell::new(Some(make_env)))
+        }}
+    }
+}
@@ -3,10 +3,8 @@ use std::fmt::{self, Display, Formatter};
 use std::vec::IntoIter;

 use itertools::Itertools;
-use once_cell::sync::Lazy;
 use proc_macro::{Delimiter, Span, TokenStream, TokenTree};
 use proc_macro2::Span as Span2;
-use regex::Regex;

 #[derive(Clone, Copy, Debug)]
 pub(crate) struct Pos {
@@ -39,46 +37,16 @@ fn span_pos(span: &Span) -> (Pos, Pos) {
    let start = span2.start();
    let end = span2.end();

-    // In stable, line/column information is not provided
-    // and set to 0 (line is 1-indexed)
+    // Rust 1.88 stabilized Span APIs, so this branch must be unreachable
    if start.line == 0 || end.line == 0 {
-        return fallback_span_pos(span);
+        proc_macro_error2::abort_call_site!(
+            "cannot retrieve span location information; mlua requires nightly Rust or stable >= 1.88"
+        );
    }

    (Pos::new(start.line, start.column), Pos::new(end.line, end.column))
 }

-fn parse_pos(span: &Span) -> Option<(usize, usize)> {
-    // Workaround to somehow retrieve location information in span in stable rust :(
-
-    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"bytes\(([0-9]+)\.\.([0-9]+)\)").unwrap());
-
-    match RE.captures(&format!("{span:?}")) {
-        Some(caps) => match (caps.get(1), caps.get(2)) {
-            (Some(start), Some(end)) => Some((
-                match start.as_str().parse() {
-                    Ok(v) => v,
-                    _ => return None,
-                },
-                match end.as_str().parse() {
-                    Ok(v) => v,
-                    _ => return None,
-                },
-            )),
-            _ => None,
-        },
-        None => None,
-    }
-}
-
-fn fallback_span_pos(span: &Span) -> (Pos, Pos) {
-    let (start, end) = match parse_pos(span) {
-        Some(v) => v,
-        None => proc_macro_error2::abort_call_site!("Cannot retrieve span information; please use nightly"),
-    };
-    (Pos::new(1, start), Pos::new(1, end))
-}
-
 /// Attribute of token.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum TokenAttr {
@@ -108,8 +76,9 @@ impl Eq for Token {}
 impl Token {
    fn new(tree: TokenTree) -> Self {
        let (start, end) = span_pos(&tree.span());
+        let source = tree.span().source_text().unwrap_or_else(|| tree.to_string());
        Self {
-            source: tree.to_string(),
+            source,
            start,
            end,
            tree,
@@ -168,14 +137,17 @@ impl Tokens {
        Tokens(
            tt.into_iter()
                .flat_map(Tokens::from)
-                .peekable()
                .batching(|iter| {
-                    // Find variable tokens
+                    // Find variable tokens: `$` + `ident` => `$ident`
                    let t = iter.next()?;
                    if t.is("$") {
-                        // `$` + `ident` => `$ident`
-                        let t = iter.next().expect("$ must trail an identifier");
-                        Some(t.attr(TokenAttr::Cap))
+                        if let Some(next) = iter.next()
+                            && matches!(next.tree, TokenTree::Ident(_))
+                        {
+                            Some(next.attr(TokenAttr::Cap))
+                        } else {
+                            proc_macro_error2::abort!(t.tree.span(), "`$` must be followed by an identifier");
+                        }
                    } else {
                        Some(t)
                    }
@@ -1,6 +1,6 @@
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
+use syn::{DeriveInput, parse_macro_input};

 pub fn from_lua(input: TokenStream) -> TokenStream {
    let DeriveInput { ident, generics, .. } = parse_macro_input!(input as DeriveInput);
@@ -13,19 +13,19 @@ pub fn from_lua(input: TokenStream) -> TokenStream {
    };

    quote! {
-      impl #impl_generics ::mlua::FromLua for #ident #ty_generics #where_clause {
-        #[inline]
-        fn from_lua(value: ::mlua::Value, _: &::mlua::Lua) -> ::mlua::Result<Self> {
-          match value {
-            ::mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
-            _ => Err(::mlua::Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: #ident_str.to_string(),
-                message: None,
-            }),
-          }
+        impl #impl_generics ::mlua::FromLua for #ident #ty_generics #where_clause {
+            #[inline]
+            fn from_lua(value: ::mlua::Value, _: &::mlua::Lua) -> ::mlua::Result<Self> {
+                match value {
+                    ::mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
+                    _ => Err(::mlua::Error::FromLuaConversionError {
+                        from: value.type_name(),
+                        to: #ident_str.to_string(),
+                        message: None,
+                    }),
+                }
+            }
        }
-      }
    }
    .into()
 }
@@ -1,148 +1,30 @@
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::quote;
-use syn::meta::ParseNestedMeta;
-use syn::{parse_macro_input, ItemFn, LitStr, Result};
+
+mod module;

 #[cfg(feature = "macros")]
-use {
-    crate::chunk::Chunk, proc_macro::TokenTree, proc_macro2::TokenStream as TokenStream2,
-    proc_macro_error2::proc_macro_error,
-};
+use {crate::chunk::Chunk, proc_macro_error2::proc_macro_error};

-#[derive(Default)]
-struct ModuleAttributes {
-    name: Option<Ident>,
-    skip_memory_check: bool,
-}
-
-impl ModuleAttributes {
-    fn parse(&mut self, meta: ParseNestedMeta) -> Result<()> {
-        if meta.path.is_ident("name") {
-            match meta.value() {
-                Ok(value) => {
-                    self.name = Some(value.parse::<LitStr>()?.parse()?);
-                }
-                Err(_) => {
-                    return Err(meta.error("`name` attribute must have a value"));
-                }
-            }
-        } else if meta.path.is_ident("skip_memory_check") {
-            if meta.value().is_ok() {
-                return Err(meta.error("`skip_memory_check` attribute have no values"));
-            }
-            self.skip_memory_check = true;
-        } else {
-            return Err(meta.error("unsupported module attribute"));
+#[cfg(feature = "macros")]
+macro_rules! try_compile {
+    ($expr:expr) => {
+        match $expr {
+            Ok(val) => val,
+            Err(err) => return err.to_compile_error().into(),
        }
-        Ok(())
-    }
+    };
 }

 #[proc_macro_attribute]
 pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let mut args = ModuleAttributes::default();
-    if !attr.is_empty() {
-        let args_parser = syn::meta::parser(|meta| args.parse(meta));
-        parse_macro_input!(attr with args_parser);
-    }
-
-    let func = parse_macro_input!(item as ItemFn);
-    let func_name = &func.sig.ident;
-    let module_name = args.name.unwrap_or_else(|| func_name.clone());
-    let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
-    let skip_memory_check = if args.skip_memory_check {
-        quote! { lua.skip_memory_check(true); }
-    } else {
-        quote! {}
-    };
-
-    let wrapped = quote! {
-        mlua::require_module_feature!();
-
-        #func
-
-        #[no_mangle]
-        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> ::std::os::raw::c_int {
-            mlua::Lua::entrypoint1(state, move |lua| {
-                #skip_memory_check
-                #func_name(lua)
-            })
-        }
-    };
-
-    wrapped.into()
-}
-
-#[cfg(feature = "macros")]
-fn to_ident(tt: &TokenTree) -> TokenStream2 {
-    let s: TokenStream = tt.clone().into();
-    s.into()
+    module::lua_module(attr, item)
 }

 #[cfg(feature = "macros")]
 #[proc_macro]
 #[proc_macro_error]
 pub fn chunk(input: TokenStream) -> TokenStream {
-    let chunk = Chunk::new(input);
-
-    let source = chunk.source();
-
-    let caps_len = chunk.captures().len();
-    let caps = chunk.captures().iter().map(|cap| {
-        let cap_name = cap.as_rust().to_string();
-        let cap = to_ident(cap.as_rust());
-        quote! { env.raw_set(#cap_name, #cap)?; }
-    });
-
-    let wrapped_code = quote! {{
-        use mlua::{AsChunk, ChunkMode, Lua, Result, Table};
-        use ::std::borrow::Cow;
-        use ::std::cell::Cell;
-        use ::std::io::Result as IoResult;
-
-        struct InnerChunk<F: FnOnce(&Lua) -> Result<Table>>(Cell<Option<F>>);
-
-        impl<F> AsChunk<'static> for InnerChunk<F>
-        where
-            F: FnOnce(&Lua) -> Result<Table>,
-        {
-            fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
-                if #caps_len > 0 {
-                    if let Some(make_env) = self.0.take() {
-                        return make_env(lua).map(Some);
-                    }
-                }
-                Ok(None)
-            }
-
-            fn mode(&self) -> Option<ChunkMode> {
-                Some(ChunkMode::Text)
-            }
-
-            fn source(self) -> IoResult<Cow<'static, [u8]>> {
-                Ok(Cow::Borrowed((#source).as_bytes()))
-            }
-        }
-
-        let make_env = move |lua: &Lua| -> Result<Table> {
-            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)?;
-
-            // Add captured variables
-            #(#caps)*
-
-            env.set_metatable(Some(meta));
-            Ok(env)
-        };
-
-        InnerChunk(Cell::new(Some(make_env)))
-    }};
-
-    wrapped_code.into()
+    Chunk::new(input).expand().into()
 }

 #[cfg(feature = "macros")]
@@ -151,9 +33,23 @@ pub fn from_lua(input: TokenStream) -> TokenStream {
    from_lua::from_lua(input)
 }

+/// Derive macro for implementing `UserData` for a Rust type.
+#[cfg(feature = "macros")]
+#[proc_macro_derive(UserData, attributes(lua))]
+pub fn userdata(item: TokenStream) -> TokenStream {
+    userdata::userdata_type(item)
+}
+
+/// Attribute macro for exposing impl block methods to Lua userdata.
+#[cfg(feature = "macros")]
+#[proc_macro_attribute]
+pub fn userdata_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
+    userdata::userdata_impl::userdata_impl(attr, item)
+}
+
 #[cfg(feature = "macros")]
 mod chunk;
 #[cfg(feature = "macros")]
 mod from_lua;
 #[cfg(feature = "macros")]
-mod token;
+mod userdata;
@@ -0,0 +1,68 @@
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span};
+use quote::quote;
+use syn::meta::ParseNestedMeta;
+use syn::{ItemFn, LitStr, Result, parse_macro_input};
+
+#[derive(Default)]
+struct ModuleAttributes {
+    name: Option<Ident>,
+    skip_memory_check: bool,
+}
+
+impl ModuleAttributes {
+    fn parse(&mut self, meta: ParseNestedMeta) -> Result<()> {
+        if meta.path.is_ident("name") {
+            match meta.value() {
+                Ok(value) => {
+                    self.name = Some(value.parse::<LitStr>()?.parse()?);
+                }
+                Err(_) => {
+                    return Err(meta.error("`name` attribute must have a value"));
+                }
+            }
+        } else if meta.path.is_ident("skip_memory_check") {
+            if meta.value().is_ok() {
+                return Err(meta.error("`skip_memory_check` attribute have no values"));
+            }
+            self.skip_memory_check = true;
+        } else {
+            return Err(meta.error("unsupported module attribute"));
+        }
+        Ok(())
+    }
+}
+
+pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut args = ModuleAttributes::default();
+    if !attr.is_empty() {
+        let args_parser = syn::meta::parser(|meta| args.parse(meta));
+        parse_macro_input!(attr with args_parser);
+    }
+
+    let func = parse_macro_input!(item as ItemFn);
+    let func_name = &func.sig.ident;
+    let module_name = args.name.unwrap_or_else(|| func_name.clone());
+    let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
+    let skip_memory_check = if args.skip_memory_check {
+        quote! { lua.skip_memory_check(true); }
+    } else {
+        quote! {}
+    };
+
+    let wrapped = quote! {
+        mlua::require_module_feature!();
+
+        #func
+
+        #[unsafe(no_mangle)]
+        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> ::std::os::raw::c_int {
+            mlua::Lua::entrypoint1(state, move |lua| {
+                #skip_memory_check
+                #func_name(lua)
+            })
+        }
+    };
+
+    wrapped.into()
+}
@@ -0,0 +1,93 @@
+use proc_macro2::Span;
+use syn::meta::ParseNestedMeta;
+use syn::{Ident, LitStr, Result};
+
+/// Parsed `#[lua(...)]` attribute.
+///
+/// Some flags are context-dependent:
+/// - Struct fields: `get`, `set`, `name`, `skip`
+/// - Impl methods: `getter`, `setter`, `field`, `meta`, `infallible`, `name`, `skip`
+#[derive(Default)]
+pub(crate) struct LuaAttr {
+    pub(crate) span: Option<Span>,
+    pub(crate) name: Option<String>,
+    pub(crate) infallible: bool,
+    pub(crate) skip: bool,
+
+    // Struct field context flags
+    pub(crate) get: bool,
+    pub(crate) set: bool,
+
+    // Impl method context flags
+    pub(crate) getter: bool,
+    pub(crate) setter: bool,
+    pub(crate) field: bool,
+    pub(crate) meta: bool,
+}
+
+impl LuaAttr {
+    pub(crate) fn parse_inner(&mut self, meta: ParseNestedMeta) -> Result<()> {
+        match &meta.path {
+            path if path.is_ident("skip") => {
+                if meta.value().is_ok() {
+                    return Err(meta.error("`skip` does not take a value"));
+                }
+                self.skip = true;
+            }
+            path if path.is_ident("infallible") => {
+                if meta.value().is_ok() {
+                    return Err(meta.error("`infallible` does not take a value"));
+                }
+                self.infallible = true;
+            }
+            path if path.is_ident("get") => self.get = true,
+            path if path.is_ident("set") => self.set = true,
+            path if path.is_ident("getter") => self.getter = true,
+            path if path.is_ident("setter") => self.setter = true,
+            path if path.is_ident("field") => self.field = true,
+            path if path.is_ident("meta") => self.meta = true,
+            path if path.is_ident("name") => {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                self.name = Some(lit.value());
+            }
+            _ => {
+                return Err(meta.error(
+                    "unsupported lua attribute, expected: ".to_string()
+                        + "`skip`, `infallible`, `get`, `set`, `getter`, `setter`, `field`, `meta`, `name`",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    /// Returns the effective Lua name.
+    pub(crate) fn name(&self, ident: &Ident) -> String {
+        self.name.clone().unwrap_or_else(|| ident.to_string())
+    }
+
+    /// Returns the span to use for error reporting.
+    pub(crate) fn span(&self) -> Span {
+        self.span.unwrap_or_else(Span::call_site)
+    }
+
+    /// Returns the effective Lua metamethod name.
+    ///
+    /// If `name` is set via attribute, use it. Otherwise, if the function name
+    /// starts with `__`, use that. Returns an error if neither is available.
+    pub(crate) fn effective_meta_name(&self, fn_ident: &Ident) -> Result<String> {
+        if let Some(ref name) = self.name {
+            return Ok(name.clone());
+        }
+        let fn_name = fn_ident.to_string();
+        if fn_name.starts_with("__") {
+            return Ok(fn_name);
+        }
+        Err(syn::Error::new(
+            fn_ident.span(),
+            format!(
+                "could not infer metamethod name from `{fn_name}`, either add `name = \"...\"` to `#[lua(meta, ...)]` or prefix the function with `__`"
+            ),
+        ))
+    }
+}
@@ -0,0 +1,165 @@
+mod attr;
+pub(crate) mod userdata_impl;
+
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::spanned::Spanned;
+use syn::{Attribute, Data, DeriveInput, Error, Fields, FieldsNamed, Meta, parse_macro_input};
+
+use self::attr::LuaAttr;
+
+/// Wrap registration tokens with any `#[cfg]`/`#[cfg_attr]` attributes from the original item.
+pub(crate) fn with_cfg(tokens: proc_macro2::TokenStream, attrs: &[Attribute]) -> proc_macro2::TokenStream {
+    let cfgs: Vec<_> = (attrs.iter())
+        .filter(|attr| attr.path().is_ident("cfg") || attr.path().is_ident("cfg_attr"))
+        .collect();
+    if cfgs.is_empty() {
+        return tokens;
+    }
+    quote! {
+        #(#cfgs)*
+        #tokens
+    }
+}
+
+/// Parse all `#[lua(...)]` attributes on a field, merging them into one `LuaAttr`.
+fn parse_field_lua_attr(attrs: &[Attribute]) -> syn::Result<LuaAttr> {
+    let mut lua_attr = LuaAttr::default();
+    for attr in attrs {
+        if !attr.path().is_ident("lua") {
+            continue;
+        }
+        match &attr.meta {
+            Meta::List(_) => {
+                lua_attr.span = Some(attr.span());
+                attr.parse_nested_meta(|meta| lua_attr.parse_inner(meta))?;
+                validate_field_lua_attr(&lua_attr)?;
+            }
+            Meta::Path(_) => {}
+            Meta::NameValue(_) => {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "`#[lua = \"...\"]` is not supported: use `#[lua(attr = \"...\")]`",
+                ));
+            }
+        }
+    }
+    Ok(lua_attr)
+}
+
+fn validate_field_lua_attr(attr: &LuaAttr) -> syn::Result<()> {
+    for (set, name) in [
+        (attr.getter, "getter"),
+        (attr.setter, "setter"),
+        (attr.field, "field"),
+        (attr.meta, "meta"),
+        (attr.infallible, "infallible"),
+    ] {
+        if set {
+            return Err(syn::Error::new(
+                attr.span(),
+                format!("`{name}` is not valid for struct fields"),
+            ));
+        }
+    }
+    Ok(())
+}
+
+pub fn userdata_type(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+    let type_name = &input.ident;
+
+    let named_fields: Option<&FieldsNamed> = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => Some(fields),
+            Fields::Unnamed(_) | Fields::Unit => None,
+        },
+        Data::Enum(_) => None,
+        Data::Union(_) => {
+            return Error::new_spanned(&input, "`#[derive(UserData)]` cannot be applied to unions")
+                .to_compile_error()
+                .into();
+        }
+    };
+
+    // Check for generic parameters (not supported)
+    let has_generics = !input.generics.params.is_empty();
+    if has_generics {
+        return Error::new_spanned(
+            &input.generics,
+            "`#[derive(UserData)]` does not support generic type parameters. Wrap the generic type in a concrete newtype instead."
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let mut field_registrations = Vec::new();
+    if let Some(fields) = &named_fields {
+        for field in &fields.named {
+            let field_name = field.ident.as_ref().unwrap();
+
+            let lua_attr = try_compile!(parse_field_lua_attr(&field.attrs));
+            if lua_attr.skip {
+                continue;
+            }
+
+            let lua_name = lua_attr.name.unwrap_or_else(|| field_name.to_string());
+
+            // Assume get/set by default (unless explicitly specified)
+            let (has_get, has_set) = if lua_attr.get || lua_attr.set {
+                (lua_attr.get, lua_attr.set)
+            } else {
+                (true, true)
+            };
+
+            if has_get {
+                let tokens = quote! {
+                    registry.add_field_method_get(#lua_name, |_lua, this| Ok(this.#field_name.clone()));
+                };
+                field_registrations.push(with_cfg(tokens, &field.attrs));
+            }
+            if has_set {
+                let tokens = quote! {
+                    registry.add_field_method_set(#lua_name, |_lua, this, val| {
+                        this.#field_name = val;
+                        Ok(())
+                    });
+                };
+                field_registrations.push(with_cfg(tokens, &field.attrs));
+            }
+        }
+    }
+
+    let registration_type_name = format_ident!("__MluaUserDataRegistration_{type_name}");
+    let register_fields_fn_name = format_ident!("__mlua_register_{type_name}_fields");
+
+    let output = quote! {
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        struct #registration_type_name {
+            register: fn(&mut ::mlua::userdata::UserDataRegistry<#type_name>),
+        }
+
+        ::mlua::__inventory::collect!(#registration_type_name);
+
+        #[allow(non_snake_case)]
+        fn #register_fields_fn_name(registry: &mut ::mlua::userdata::UserDataRegistry<#type_name>) {
+            use ::mlua::userdata::UserDataFields as _;
+            #(#field_registrations)*
+        }
+
+        ::mlua::__inventory::submit! {
+            #registration_type_name { register: #register_fields_fn_name }
+        }
+
+        impl ::mlua::userdata::UserData for #type_name {
+            fn register(registry: &mut ::mlua::userdata::UserDataRegistry<Self>) {
+                for item in ::mlua::__inventory::iter::<#registration_type_name> {
+                    (item.register)(registry);
+                }
+            }
+        }
+    };
+
+    output.into()
+}
@@ -0,0 +1,730 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{format_ident, quote};
+use syn::spanned::Spanned;
+use syn::{
+    Attribute, FnArg, Ident, ImplItem, ItemImpl, Meta, Signature, Type, parse_macro_input, parse_quote,
+};
+
+use super::attr::LuaAttr;
+use super::with_cfg;
+
+/// `&T` reference types that mlua provides as wrapper types via `FromLua`.
+static BORROW_WRAPPERS: &[(&str, &str)] = &[
+    ("str", "::mlua::string::BorrowedStr"),
+    ("[u8]", "::mlua::string::BorrowedBytes"),
+];
+
+enum SelfKind {
+    Ref(RefKind),
+    Owned,
+    None,
+}
+
+enum RefKind {
+    Ref,
+    Mut,
+}
+
+struct ArgInfo {
+    ident: Ident,
+    userdata_ref: Option<RefKind>,
+    callback_type: Type,
+}
+
+struct MethodInfo {
+    self_kind: SelfKind,
+    has_lua: bool,
+    args: Vec<ArgInfo>,
+}
+
+/// Extract the inner type from a reference type.
+fn ref_inner_type(ty: &Type) -> Type {
+    match ty {
+        Type::Reference(ref_ty) => (*ref_ty.elem).clone(),
+        _ => ty.clone(),
+    }
+}
+
+/// Check if the type is `&Lua` or `&mlua::Lua`.
+fn is_lua_ref(ty: &Type) -> bool {
+    let Type::Reference(ref_ty) = ty else { return false };
+    match &*ref_ty.elem {
+        Type::Path(p) if p.path.segments.len() == 1 => p.path.segments[0].ident == "Lua",
+        Type::Path(p) if p.path.segments.len() == 2 => {
+            p.path.segments[0].ident == "mlua" && p.path.segments[1].ident == "Lua"
+        }
+        _ => false,
+    }
+}
+
+/// Classify a `&[mut] T` parameter, returning the callback wrapper type.
+///
+/// Known borrow types come from the mapping table `BORROW_WRAPPERS`.
+/// Everything else gets `UserDataRef[Mut]<T>`.
+fn classify_ref_type(ty: &Type) -> Option<Type> {
+    let Type::Reference(ref_ty) = ty else { return None };
+
+    // Check known borrow wrappers:
+    // - For `&T` check the path name
+    // - For `&[T]` unpack the slice and format the element as `[T]` for lookup
+    if ref_ty.mutability.is_none() {
+        let lookup_name: Option<String> = match &*ref_ty.elem {
+            Type::Path(path) => path.path.segments.last().map(|seg| seg.ident.to_string()),
+            Type::Slice(slice) => {
+                if let Type::Path(path) = &*slice.elem {
+                    path.path.segments.last().map(|seg| format!("[{}]", seg.ident))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        };
+        if let Some(ref name) = lookup_name {
+            for &(inner, wrapper) in BORROW_WRAPPERS {
+                if name == inner {
+                    let wrapper = syn::parse_str(wrapper).expect("invalid wrapper type");
+                    return Some(wrapper);
+                }
+            }
+        }
+    }
+    // Mutable references to slices are not supported.
+    if matches!(&*ref_ty.elem, Type::Slice(_)) && ref_ty.mutability.is_some() {
+        return None;
+    }
+
+    let inner = ref_inner_type(ty);
+    if ref_ty.mutability.is_none() {
+        Some(parse_quote! { ::mlua::userdata::UserDataRef<#inner> })
+    } else {
+        Some(parse_quote! { ::mlua::userdata::UserDataRefMut<#inner> })
+    }
+}
+
+/// Analyze method signature.
+///
+/// Determine `self` kind and collect the callback arguments.
+/// Auto-detects `&Lua` as the first non-self parameter.
+fn analyze_self_and_args(sig: &Signature) -> syn::Result<MethodInfo> {
+    let mut self_kind = SelfKind::None;
+    let mut has_lua = false;
+    let mut args = Vec::new();
+    let mut check_first_typed = true;
+
+    for param in &sig.inputs {
+        match param {
+            FnArg::Receiver(recv) if recv.reference.is_some() && recv.mutability.is_some() => {
+                self_kind = SelfKind::Ref(RefKind::Mut);
+            }
+            FnArg::Receiver(recv) if recv.reference.is_some() => {
+                self_kind = SelfKind::Ref(RefKind::Ref);
+            }
+            FnArg::Receiver(_) => {
+                self_kind = SelfKind::Owned;
+            }
+            FnArg::Typed(typed) => {
+                if check_first_typed && is_lua_ref(&typed.ty) {
+                    has_lua = true;
+                    check_first_typed = false;
+                    continue;
+                }
+                check_first_typed = false;
+                if let syn::Pat::Ident(pat_ident) = &*typed.pat {
+                    let arg_type = &*typed.ty;
+                    let ref_kind = match arg_type {
+                        Type::Reference(r) if r.mutability.is_some() => Some(RefKind::Mut),
+                        Type::Reference(_) => Some(RefKind::Ref),
+                        _ => None,
+                    };
+                    let callback_type = match &ref_kind {
+                        Some(_) => match classify_ref_type(arg_type) {
+                            Some(ty) => ty,
+                            None => {
+                                return Err(syn::Error::new_spanned(
+                                    arg_type,
+                                    "this reference type is not supported as a callback parameter",
+                                ));
+                            }
+                        },
+                        None => arg_type.clone(),
+                    };
+                    args.push(ArgInfo {
+                        ident: pat_ident.ident.clone(),
+                        userdata_ref: ref_kind,
+                        callback_type,
+                    });
+                }
+            }
+        }
+    }
+
+    Ok(MethodInfo {
+        self_kind,
+        has_lua,
+        args,
+    })
+}
+
+fn strip_item_attrs(attrs: &[Attribute]) -> Vec<Attribute> {
+    (attrs.iter())
+        .filter(|attr| !attr.path().is_ident("lua"))
+        .cloned()
+        .collect()
+}
+
+fn parse_lua_attr(attrs: &[Attribute]) -> syn::Result<LuaAttr> {
+    let mut lua_attr = LuaAttr::default();
+    for attr in attrs {
+        if !attr.path().is_ident("lua") {
+            continue;
+        }
+        match &attr.meta {
+            Meta::List(_) => {
+                lua_attr.span = Some(attr.span());
+                attr.parse_nested_meta(|meta| lua_attr.parse_inner(meta))?;
+                validate_lua_attr(&lua_attr)?;
+            }
+            Meta::Path(_) => {}
+            Meta::NameValue(_) => {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "`#[lua = \"...\"]` is not supported: use `#[lua(attr = \"...\")]`",
+                ));
+            }
+        }
+    }
+    Ok(lua_attr)
+}
+
+fn validate_lua_attr(attr: &LuaAttr) -> syn::Result<()> {
+    for (set, name) in [(attr.get, "get"), (attr.set, "set")] {
+        if set {
+            return Err(syn::Error::new(
+                attr.span(),
+                format!("`{name}` is not valid for methods"),
+            ));
+        }
+    }
+    Ok(())
+}
+
+pub fn userdata_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
+    if !attr.is_empty() {
+        return syn::Error::new_spanned(
+            proc_macro2::TokenStream::from(attr),
+            "`#[userdata_impl]` does not accept arguments",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let mut input = parse_macro_input!(item as ItemImpl);
+
+    let type_path = match &*input.self_ty {
+        Type::Path(type_path) => &type_path.path,
+        _ => {
+            return syn::Error::new_spanned(&input.self_ty, "`#[userdata_impl]` requires a simple path type")
+                .to_compile_error()
+                .into();
+        }
+    };
+    let type_name = (type_path.segments)
+        .last()
+        .map(|seg| seg.ident.clone())
+        .ok_or_else(|| syn::Error::new_spanned(&input.self_ty, "cannot determine type name"));
+    let type_name = try_compile!(type_name);
+
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+    let unique_suffix = COUNTER.fetch_add(1, Ordering::Relaxed);
+    let register_fn_name = format_ident!("__mlua_register_{type_name}_{unique_suffix}");
+    let registration_type_name = format_ident!("__MluaUserDataRegistration_{type_name}");
+
+    let mut registration_calls = Vec::new();
+    for item in &input.items {
+        match item {
+            ImplItem::Const(const_item) => {
+                let lua_attr = try_compile!(parse_lua_attr(&const_item.attrs));
+                if lua_attr.skip {
+                    continue;
+                }
+                if lua_attr.getter || lua_attr.setter {
+                    return syn::Error::new(
+                        lua_attr.span(),
+                        "const items do not support `getter` or `setter`",
+                    )
+                    .to_compile_error()
+                    .into();
+                }
+                let const_name = &const_item.ident;
+                let lua_name = lua_attr.name(const_name);
+                if lua_attr.meta {
+                    let tokens = quote! {
+                        registry.add_meta_field(#lua_name, #type_path::#const_name);
+                    };
+                    registration_calls.push(with_cfg(tokens, &const_item.attrs));
+                } else {
+                    let tokens = quote! {
+                        registry.add_field(#lua_name, #type_path::#const_name);
+                    };
+                    registration_calls.push(with_cfg(tokens, &const_item.attrs));
+                }
+            }
+            ImplItem::Fn(method) => {
+                let lua_attr = try_compile!(parse_lua_attr(&method.attrs));
+                if lua_attr.skip {
+                    continue;
+                }
+
+                // Validate mutually exclusive role flags.
+                // `getter`, `setter`, `field` are exclusive.
+                // `meta` on its own means a metamethod.
+                // `meta` combined with `field` means a meta static field.
+                // `meta` with `getter` or `setter` is invalid.
+                let primary = [lua_attr.getter, lua_attr.setter, lua_attr.field];
+                let primary_count = primary.iter().filter(|&&x| x).count();
+                if primary_count > 1 {
+                    return syn::Error::new(
+                        lua_attr.span(),
+                        "at most one of `getter`, `setter`, `field` can be specified",
+                    )
+                    .to_compile_error()
+                    .into();
+                }
+                if lua_attr.meta && primary_count == 1 && !lua_attr.field {
+                    return syn::Error::new(lua_attr.span(), "`meta` can only be combined with `field`")
+                        .to_compile_error()
+                        .into();
+                }
+
+                let fn_name = &method.sig.ident;
+                let info = try_compile!(analyze_self_and_args(&method.sig));
+                let is_async = method.sig.asyncness.is_some();
+
+                if lua_attr.getter {
+                    if is_async {
+                        return syn::Error::new_spanned(&method.sig, "async field getter is not supported")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if !matches!(info.self_kind, SelfKind::Ref(RefKind::Ref)) {
+                        return syn::Error::new_spanned(&method.sig, "field getter must take `&self`")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if !info.args.is_empty() {
+                        return syn::Error::new_spanned(
+                            &method.sig,
+                            "field getter must not take additional arguments",
+                        )
+                        .to_compile_error()
+                        .into();
+                    }
+                    let tokens = gen_field_getter(type_path, fn_name, &lua_attr, &info);
+                    registration_calls.push(with_cfg(tokens, &method.attrs));
+                    continue;
+                }
+                if lua_attr.setter {
+                    if is_async {
+                        return syn::Error::new_spanned(&method.sig, "async field setter is not supported")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if !matches!(info.self_kind, SelfKind::Ref(_)) {
+                        return syn::Error::new_spanned(&method.sig, "field setter must take `&[mut] self`")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if info.args.len() != 1 {
+                        return syn::Error::new_spanned(
+                            &method.sig,
+                            "field setter must take exactly one value argument",
+                        )
+                        .to_compile_error()
+                        .into();
+                    }
+                    let tokens = gen_field_setter(type_path, fn_name, &lua_attr, &info);
+                    registration_calls.push(with_cfg(tokens, &method.attrs));
+                    continue;
+                }
+                if lua_attr.field {
+                    if is_async {
+                        return syn::Error::new_spanned(&method.sig, "async field function is not supported")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if !matches!(info.self_kind, SelfKind::None) {
+                        return syn::Error::new_spanned(&method.sig, "field function must not take `self`")
+                            .to_compile_error()
+                            .into();
+                    }
+                    if !info.args.is_empty() {
+                        return syn::Error::new_spanned(
+                            &method.sig,
+                            "field function must not take arguments",
+                        )
+                        .to_compile_error()
+                        .into();
+                    }
+                    let lua_name = lua_attr.name(fn_name);
+                    if lua_attr.meta {
+                        let tokens = quote! {
+                            registry.add_meta_field(#lua_name, #type_path::#fn_name());
+                        };
+                        registration_calls.push(with_cfg(tokens, &method.attrs));
+                    } else {
+                        let tokens = quote! {
+                            registry.add_field(#lua_name, #type_path::#fn_name());
+                        };
+                        registration_calls.push(with_cfg(tokens, &method.attrs));
+                    }
+                    continue;
+                }
+
+                if lua_attr.meta {
+                    if matches!(info.self_kind, SelfKind::Owned) {
+                        return syn::Error::new_spanned(
+                            &method.sig,
+                            "meta methods cannot take `self`, use `&[mut] self` instead",
+                        )
+                        .to_compile_error()
+                        .into();
+                    }
+                    if is_async {
+                        let tokens = gen_async_meta(type_path, fn_name, &lua_attr, &info);
+                        registration_calls.push(with_cfg(tokens, &method.attrs));
+                    } else {
+                        let tokens = gen_meta(type_path, fn_name, &lua_attr, &info);
+                        registration_calls.push(with_cfg(tokens, &method.attrs));
+                    }
+                    continue;
+                }
+
+                if is_async {
+                    let tokens = gen_async_regular_method(type_path, fn_name, &lua_attr, &info);
+                    registration_calls.push(with_cfg(tokens, &method.attrs));
+                } else {
+                    let tokens = gen_regular_method(type_path, fn_name, &lua_attr, &info);
+                    registration_calls.push(with_cfg(tokens, &method.attrs));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    for item in &mut input.items {
+        match item {
+            ImplItem::Const(c) => c.attrs = strip_item_attrs(&c.attrs),
+            ImplItem::Fn(m) => m.attrs = strip_item_attrs(&m.attrs),
+            _ => {}
+        }
+    }
+    input.attrs = strip_item_attrs(&input.attrs);
+
+    let output = quote! {
+        #[allow(non_snake_case)]
+        fn #register_fn_name(registry: &mut ::mlua::userdata::UserDataRegistry<#type_path>) {
+            use ::mlua::userdata::{UserDataFields as _, UserDataMethods as _};
+            #(#registration_calls)*
+        }
+
+        ::mlua::__inventory::submit! {
+            #registration_type_name { register: #register_fn_name }
+        }
+
+        #input
+    };
+
+    output.into()
+}
+
+/// Generate the closure argument destructuring pattern.
+fn gen_closure_destructure(info: &MethodInfo) -> TokenStream2 {
+    if info.args.is_empty() {
+        return quote! { () };
+    }
+    let idents: Vec<_> = (info.args)
+        .iter()
+        .map(|a| {
+            let ident = &a.ident;
+            if matches!(a.userdata_ref, Some(RefKind::Mut)) {
+                quote! { mut #ident }
+            } else {
+                quote! { #ident }
+            }
+        })
+        .collect();
+    let types: Vec<_> = info.args.iter().map(|a| &a.callback_type).collect();
+    quote! { (#(#idents),*): (#(#types),*) }
+}
+
+/// Generate call arguments for invoking the original method.
+fn gen_call_args(info: &MethodInfo) -> TokenStream2 {
+    let mut call_args: Vec<TokenStream2> = Vec::new();
+
+    match info.self_kind {
+        SelfKind::None => {}
+        _ => call_args.push(quote! { this }),
+    }
+
+    if info.has_lua {
+        call_args.push(quote! { lua });
+    }
+
+    for arg in &info.args {
+        let ident = &arg.ident;
+        match arg.userdata_ref {
+            Some(RefKind::Ref) => call_args.push(quote! { &*#ident }),
+            Some(RefKind::Mut) => call_args.push(quote! { &mut *#ident }),
+            None => call_args.push(quote! { #ident }),
+        }
+    }
+
+    quote! { #(#call_args),* }
+}
+
+/// Generate call arguments for invoking the original async method.
+fn gen_async_call_args(info: &MethodInfo) -> TokenStream2 {
+    let mut call_args: Vec<TokenStream2> = Vec::new();
+
+    match info.self_kind {
+        SelfKind::None => {}
+        SelfKind::Ref(RefKind::Ref) => call_args.push(quote! { &this }),
+        SelfKind::Ref(RefKind::Mut) => call_args.push(quote! { &mut this }),
+        SelfKind::Owned => call_args.push(quote! { this }),
+    }
+
+    if info.has_lua {
+        call_args.push(quote! { lua });
+    }
+
+    for arg in &info.args {
+        let ident = &arg.ident;
+        match arg.userdata_ref {
+            Some(RefKind::Ref) => call_args.push(quote! { &*#ident }),
+            Some(RefKind::Mut) => call_args.push(quote! { &mut *#ident }),
+            None => call_args.push(quote! { #ident }),
+        }
+    }
+
+    quote! { #(#call_args),* }
+}
+
+/// Generate the closure params for the registration callback.
+fn gen_closure_params(info: &MethodInfo) -> TokenStream2 {
+    let destructure = gen_closure_destructure(info);
+    match info.self_kind {
+        SelfKind::None => quote! { |lua, #destructure| },
+        _ => quote! { |lua, this, #destructure| },
+    }
+}
+
+/// Generate the closure params for an async registration callback.
+fn gen_async_closure_params(info: &MethodInfo) -> TokenStream2 {
+    let destructure = gen_closure_destructure(info);
+    match info.self_kind {
+        SelfKind::None => quote! { |lua, #destructure| },
+        SelfKind::Ref(RefKind::Mut) => quote! { |lua, mut this, #destructure| },
+        _ => quote! { |lua, this, #destructure| },
+    }
+}
+
+fn gen_field_getter(
+    type_path: &syn::Path,
+    fn_name: &Ident,
+    lua_attr: &LuaAttr,
+    info: &MethodInfo,
+) -> TokenStream2 {
+    let lua_name = lua_attr.name(fn_name);
+    let call_args = gen_call_args(info);
+
+    if lua_attr.infallible {
+        return quote! {
+            registry.add_field_method_get(#lua_name, |lua, this| {
+                let _ = lua; // silence unused variable warning
+                Ok(#type_path::#fn_name(#call_args))
+            });
+        };
+    }
+
+    quote! {
+        registry.add_field_method_get(#lua_name, |lua, this| {
+            let _ = lua; // silence unused variable warning
+            #type_path::#fn_name(#call_args)
+        });
+    }
+}
+
+fn gen_field_setter(
+    type_path: &syn::Path,
+    fn_name: &Ident,
+    lua_attr: &LuaAttr,
+    info: &MethodInfo,
+) -> TokenStream2 {
+    let lua_name = lua_attr.name(fn_name);
+    let call_args = gen_call_args(info);
+
+    if lua_attr.infallible {
+        let val_ident = info.args.first().map(|a| &a.ident);
+        return quote! {
+            registry.add_field_method_set(#lua_name, |lua, this, #val_ident| {
+                let _ = lua; // silence unused variable warning
+                Ok(#type_path::#fn_name(#call_args))
+            });
+        };
+    }
+
+    let val_ident = info.args.first().map(|a| &a.ident);
+    quote! {
+        registry.add_field_method_set(#lua_name, |lua, this, #val_ident| {
+            let _ = lua; // silence unused variable warning
+            #type_path::#fn_name(#call_args)
+        });
+    }
+}
+
+fn gen_meta(type_path: &syn::Path, fn_name: &Ident, lua_attr: &LuaAttr, info: &MethodInfo) -> TokenStream2 {
+    let meta_name = match lua_attr.effective_meta_name(fn_name) {
+        Ok(name) => name,
+        Err(err) => return err.to_compile_error(),
+    };
+    let closure_params = if matches!(info.self_kind, SelfKind::None) {
+        // Lua always passes `self` to the stack arg, just ignore it.
+        if info.args.is_empty() {
+            quote! { |lua, _this: ::mlua::AnyUserData| }
+        } else {
+            let idents: Vec<_> = info.args.iter().map(|a| &a.ident).collect();
+            let types: Vec<_> = info.args.iter().map(|a| &a.callback_type).collect();
+            quote! { |lua, (_this, #(#idents),*): (::mlua::AnyUserData, #(#types),*) | }
+        }
+    } else {
+        gen_closure_params(info)
+    };
+    let call_args = gen_call_args(info);
+    let fn_path = quote! { #type_path::#fn_name };
+
+    let body = if lua_attr.infallible {
+        quote! { Ok(#fn_path(#call_args)) }
+    } else {
+        quote! { #fn_path(#call_args) }
+    };
+    match info.self_kind {
+        SelfKind::None => quote! {
+            registry.add_meta_function(#meta_name, #closure_params { #body });
+        },
+        SelfKind::Ref(RefKind::Mut) => quote! {
+            registry.add_meta_method_mut(#meta_name, #closure_params { #body });
+        },
+        _ => quote! {
+            registry.add_meta_method(#meta_name, #closure_params { #body });
+        },
+    }
+}
+
+fn gen_regular_method(
+    type_path: &syn::Path,
+    fn_name: &Ident,
+    lua_attr: &LuaAttr,
+    info: &MethodInfo,
+) -> TokenStream2 {
+    let fn_path = quote! { #type_path::#fn_name };
+    let closure_params = gen_closure_params(info);
+    let call_args = gen_call_args(info);
+    let lua_name = lua_attr.name(fn_name);
+
+    let body = if lua_attr.infallible {
+        quote! { Ok(#fn_path(#call_args)) }
+    } else {
+        quote! { #fn_path(#call_args) }
+    };
+    match info.self_kind {
+        SelfKind::Ref(RefKind::Ref) => quote! {
+            registry.add_method(#lua_name, #closure_params { #body });
+        },
+        SelfKind::Ref(RefKind::Mut) => quote! {
+            registry.add_method_mut(#lua_name, #closure_params { #body });
+        },
+        SelfKind::Owned => quote! {
+            registry.add_method_once(#lua_name, #closure_params { #body });
+        },
+        SelfKind::None => quote! {
+            registry.add_function(#lua_name, #closure_params { #body });
+        },
+    }
+}
+
+fn gen_async_regular_method(
+    type_path: &syn::Path,
+    fn_name: &Ident,
+    lua_attr: &LuaAttr,
+    info: &MethodInfo,
+) -> TokenStream2 {
+    let fn_path = quote! { #type_path::#fn_name };
+    let closure_params = gen_async_closure_params(info);
+    let call_args = gen_async_call_args(info);
+    let lua_name = lua_attr.name(fn_name);
+
+    let body = if lua_attr.infallible {
+        quote! { async move { Ok(#fn_path(#call_args).await) } }
+    } else {
+        quote! { async move { #fn_path(#call_args).await } }
+    };
+    match info.self_kind {
+        SelfKind::Ref(RefKind::Ref) => quote! {
+            registry.add_async_method(#lua_name, #closure_params #body);
+        },
+        SelfKind::Ref(RefKind::Mut) => quote! {
+            registry.add_async_method_mut(#lua_name, #closure_params #body);
+        },
+        SelfKind::Owned => quote! {
+            registry.add_async_method_once(#lua_name, #closure_params #body);
+        },
+        SelfKind::None => quote! {
+            registry.add_async_function(#lua_name, #closure_params #body);
+        },
+    }
+}
+
+fn gen_async_meta(
+    type_path: &syn::Path,
+    fn_name: &Ident,
+    lua_attr: &LuaAttr,
+    info: &MethodInfo,
+) -> TokenStream2 {
+    let meta_name = match lua_attr.effective_meta_name(fn_name) {
+        Ok(name) => name,
+        Err(err) => return err.to_compile_error(),
+    };
+    let closure_params = if matches!(info.self_kind, SelfKind::None) {
+        if info.args.is_empty() {
+            quote! { |lua, _this: ::mlua::AnyUserData| }
+        } else {
+            let idents: Vec<_> = info.args.iter().map(|a| &a.ident).collect();
+            let types: Vec<_> = info.args.iter().map(|a| &a.callback_type).collect();
+            quote! { |lua, (_this, #(#idents),*): (::mlua::AnyUserData, #(#types),*) | }
+        }
+    } else {
+        gen_async_closure_params(info)
+    };
+    let call_args = gen_async_call_args(info);
+    let fn_path = quote! { #type_path::#fn_name };
+
+    let body = if lua_attr.infallible {
+        quote! { async move { Ok(#fn_path(#call_args).await) } }
+    } else {
+        quote! { async move { #fn_path(#call_args).await } }
+    };
+    match info.self_kind {
+        SelfKind::None => quote! {
+            registry.add_async_meta_function(#meta_name, #closure_params #body);
+        },
+        SelfKind::Ref(RefKind::Mut) => quote! {
+            registry.add_async_meta_method_mut(#meta_name, #closure_params #body);
+        },
+        _ => quote! {
+            registry.add_async_meta_method(#meta_name, #closure_params #body);
+        },
+    }
+}
@@ -1,6 +1,9 @@
-#[cfg(feature = "serialize")]
+use std::io;
+
+#[cfg(feature = "serde")]
 use serde::ser::{Serialize, Serializer};

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

 /// A Luau buffer type.
@@ -16,16 +19,17 @@ 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.
-    #[doc(hidden)]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
@@ -35,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
@@ -46,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 an 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");
@@ -68,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!()
    }
 }

-#[cfg(feature = "serialize")]
+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))
    }
 }

@@ -1,11 +1,16 @@
+//! Lua chunk loading and execution.
+//!
+//! This module provides types for loading Lua source code or bytecode into a [`Chunk`],
+//! configuring how it is compiled and executed, and converting it into a callable [`Function`].
+//!
+//! Chunks can be loaded from strings, byte slices, or files via the [`AsChunk`] trait.
+
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::io::Result as IoResult;
-use std::marker::PhantomData;
 use std::panic::Location;
 use std::path::{Path, PathBuf};
-use std::string::String as StdString;

 use crate::error::{Error, Result};
 use crate::function::Function;
@@ -17,11 +22,11 @@ use crate::value::Value;
 /// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
-pub trait AsChunk<'a> {
+pub trait AsChunk {
    /// Returns optional chunk name
    ///
    /// See [`Chunk::set_name`] for possible name prefixes.
-    fn name(&self) -> Option<StdString> {
+    fn name(&self) -> Option<String> {
        None
    }

@@ -39,70 +44,105 @@ pub trait AsChunk<'a> {
    }

    /// Returns chunk data (can be text or binary)
-    fn source(self) -> IoResult<Cow<'a, [u8]>>;
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a;
 }

-impl<'a> AsChunk<'a> for &'a str {
-    fn source(self) -> IoResult<Cow<'a, [u8]>> {
-        Ok(Cow::Borrowed(self.as_ref()))
-    }
-}
-
-impl AsChunk<'static> for StdString {
-    fn source(self) -> IoResult<Cow<'static, [u8]>> {
-        Ok(Cow::Owned(self.into_bytes()))
-    }
-}
-
-impl<'a> AsChunk<'a> for &'a StdString {
-    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+impl AsChunk for &str {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
        Ok(Cow::Borrowed(self.as_bytes()))
    }
 }

-impl<'a> AsChunk<'a> for &'a [u8] {
-    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+impl AsChunk for String {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Owned(self.clone().into_bytes()))
+    }
+}
+
+impl AsChunk for &String {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        Ok(Cow::Borrowed(self.as_bytes()))
+    }
+}
+
+impl AsChunk for &[u8] {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
        Ok(Cow::Borrowed(self))
    }
 }

-impl AsChunk<'static> for Vec<u8> {
-    fn source(self) -> IoResult<Cow<'static, [u8]>> {
-        Ok(Cow::Owned(self))
+impl AsChunk for Vec<u8> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Owned(self.clone()))
    }
 }

-impl<'a> AsChunk<'a> for &'a Vec<u8> {
-    fn source(self) -> IoResult<Cow<'a, [u8]>> {
-        Ok(Cow::Borrowed(self.as_ref()))
+impl AsChunk for &Vec<u8> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        Ok(Cow::Borrowed(self))
    }
 }

-impl AsChunk<'static> for &Path {
-    fn name(&self) -> Option<StdString> {
+impl AsChunk for &Path {
+    fn name(&self) -> Option<String> {
        Some(format!("@{}", self.display()))
    }

-    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
        std::fs::read(self).map(Cow::Owned)
    }
 }

-impl AsChunk<'static> for PathBuf {
-    fn name(&self) -> Option<StdString> {
+impl AsChunk for PathBuf {
+    fn name(&self) -> Option<String> {
        Some(format!("@{}", self.display()))
    }

-    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
        std::fs::read(self).map(Cow::Owned)
    }
 }

+impl<C: AsChunk + ?Sized> AsChunk for Box<C> {
+    fn name(&self) -> Option<String> {
+        (**self).name()
+    }
+
+    fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
+        (**self).environment(lua)
+    }
+
+    fn mode(&self) -> Option<ChunkMode> {
+        (**self).mode()
+    }
+
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        (**self).source()
+    }
+}
+
 /// Returned from [`Lua::load`] and is used to finalize loading and executing Lua main chunks.
 #[must_use = "`Chunk`s do nothing unless one of `exec`, `eval`, `call`, or `into_function` are called on them"]
 pub struct Chunk<'a> {
    pub(crate) lua: WeakLua,
-    pub(crate) name: StdString,
+    pub(crate) name: String,
    pub(crate) env: Result<Option<Table>>,
    pub(crate) mode: Option<ChunkMode>,
    pub(crate) source: IoResult<Cow<'a, [u8]>>,
@@ -117,6 +157,50 @@ pub enum ChunkMode {
    Binary,
 }

+/// Represents a constant value that can be used by Luau compiler.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub enum CompileConstant {
+    Nil,
+    Boolean(bool),
+    Number(crate::Number),
+    Vector(crate::Vector),
+    String(String),
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<bool> for CompileConstant {
+    fn from(b: bool) -> Self {
+        CompileConstant::Boolean(b)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+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<(String, String), CompileConstant>;
+
 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
@@ -131,6 +215,9 @@ pub struct Compiler {
    vector_type: Option<String>,
    mutable_globals: Vec<String>,
    userdata_types: Vec<String>,
+    libraries_with_known_members: Vec<String>,
+    library_constants: Option<LibraryMemberConstantMap>,
+    disabled_builtins: Vec<String>,
 }

 #[cfg(any(feature = "luau", doc))]
@@ -155,6 +242,9 @@ impl Compiler {
            vector_type: None,
            mutable_globals: Vec::new(),
            userdata_types: Vec::new(),
+            libraries_with_known_members: Vec::new(),
+            library_constants: None,
+            disabled_builtins: Vec::new(),
        }
    }

@@ -187,6 +277,7 @@ impl Compiler {
    /// Possible values:
    /// * 0 - generate for native modules (default)
    /// * 1 - generate for all modules
+    #[must_use]
    pub const fn set_type_info_level(mut self, level: u8) -> Self {
        self.type_info_level = level;
        self
@@ -204,20 +295,23 @@ impl Compiler {
        self
    }

-    #[doc(hidden)]
-    #[must_use]
-    pub fn set_vector_lib(mut self, lib: impl Into<String>) -> Self {
-        self.vector_lib = Some(lib.into());
-        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_ctor(mut self, ctor: impl Into<String>) -> Self {
-        self.vector_ctor = Some(ctor.into());
+        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_type(mut self, r#type: impl Into<String>) -> Self {
@@ -225,19 +319,76 @@ impl Compiler {
        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<String>) -> 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(mut self, globals: Vec<String>) -> Self {
-        self.mutable_globals = globals;
+    pub fn set_mutable_globals<S: Into<String>>(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<String>) -> 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(mut self, types: Vec<String>) -> Self {
-        self.userdata_types = types;
+    pub fn set_userdata_types<S: Into<String>>(mut self, types: impl IntoIterator<Item = S>) -> Self {
+        self.userdata_types = types.into_iter().map(|s| s.into()).collect();
+        self
+    }
+
+    /// 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 `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 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_default()
+            .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<String>) -> 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: impl IntoIterator<Item = S>) -> Self {
+        self.disabled_builtins = builtins.into_iter().map(|s| s.into()).collect();
        self
    }

@@ -245,7 +396,9 @@ impl Compiler {
    ///
    /// Returns [`Error::SyntaxError`] if the source code is invalid.
    pub fn compile(&self, source: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        use std::os::raw::c_int;
+        use std::cell::RefCell;
+        use std::ffi::CStr;
+        use std::os::raw::{c_char, c_int};
        use std::ptr;

        let vector_lib = self.vector_lib.clone();
@@ -277,6 +430,44 @@ impl Compiler {

        vec2cstring_ptr!(mutable_globals, mutable_globals_ptr);
        vec2cstring_ptr!(userdata_types, userdata_types_ptr);
+        vec2cstring_ptr!(libraries_with_known_members, libraries_with_known_members_ptr);
+        vec2cstring_ptr!(disabled_builtins, disabled_builtins_ptr);
+
+        thread_local! {
+            static LIBRARY_MEMBER_CONSTANT_MAP: RefCell<LibraryMemberConstantMap> = Default::default();
+        }
+
+        #[cfg(feature = "luau")]
+        unsafe extern "C-unwind" fn library_member_constant_callback(
+            library: *const c_char,
+            member: *const c_char,
+            constant: *mut ffi::lua_CompileConstant,
+        ) {
+            let library = CStr::from_ptr(library).to_string_lossy();
+            let member = CStr::from_ptr(member).to_string_lossy();
+            LIBRARY_MEMBER_CONSTANT_MAP.with_borrow(|map| {
+                if let Some(cons) = map.get(&(library.to_string(), member.to_string())) {
+                    match cons {
+                        CompileConstant::Nil => ffi::luau_set_compile_constant_nil(constant),
+                        CompileConstant::Boolean(b) => {
+                            ffi::luau_set_compile_constant_boolean(constant, *b as c_int)
+                        }
+                        CompileConstant::Number(n) => ffi::luau_set_compile_constant_number(constant, *n),
+                        CompileConstant::Vector(v) => {
+                            #[cfg(not(feature = "luau-vector4"))]
+                            ffi::luau_set_compile_constant_vector(constant, v.x(), v.y(), v.z(), 0.0);
+                            #[cfg(feature = "luau-vector4")]
+                            ffi::luau_set_compile_constant_vector(constant, v.x(), v.y(), v.z(), v.w());
+                        }
+                        CompileConstant::String(s) => ffi::luau_set_compile_constant_string(
+                            constant,
+                            s.as_ptr() as *const c_char,
+                            s.len(),
+                        ),
+                    }
+                }
+            })
+        }

        let bytecode = unsafe {
            let mut options = ffi::lua_CompileOptions::default();
@@ -289,13 +480,21 @@ impl Compiler {
            options.vectorType = vector_type.map_or(ptr::null(), |s| s.as_ptr());
            options.mutableGlobals = mutable_globals_ptr;
            options.userdataTypes = userdata_types_ptr;
+            options.librariesWithKnownMembers = libraries_with_known_members_ptr;
+            if let Some(map) = self.library_constants.as_ref()
+                && !self.libraries_with_known_members.is_empty()
+            {
+                LIBRARY_MEMBER_CONSTANT_MAP.with_borrow_mut(|gmap| *gmap = map.clone());
+                options.libraryMemberConstantCallback = Some(library_member_constant_callback);
+            }
+            options.disabledBuiltins = disabled_builtins_ptr;
            ffi::luau_compile(source.as_ref(), options)
        };

        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 = String::from_utf8_lossy(&bytecode[2..]).into_owned();
            return Err(Error::SyntaxError {
                incomplete_input: message.ends_with("<eof>"),
                message,
@@ -307,6 +506,11 @@ impl Compiler {
 }

 impl Chunk<'_> {
+    /// Returns the name of this chunk.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
    /// Sets the name of this chunk, which results in more informative error traces.
    ///
    /// Possible name prefixes:
@@ -318,6 +522,11 @@ impl Chunk<'_> {
        self
    }

+    /// Returns the environment of this chunk.
+    pub fn environment(&self) -> Option<&Table> {
+        self.env.as_ref().ok()?.as_ref()
+    }
+
    /// Sets the environment of the loaded chunk to the given value.
    ///
    /// In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the
@@ -334,6 +543,11 @@ impl Chunk<'_> {
        self
    }

+    /// Returns the mode (auto-detected by default) of this chunk.
+    pub fn mode(&self) -> ChunkMode {
+        self.detect_mode()
+    }
+
    /// Sets whether the chunk is text or binary (autodetected by default).
    ///
    /// Be aware, Lua does not check the consistency of the code inside binary chunks.
@@ -346,8 +560,6 @@ impl Chunk<'_> {
    /// Sets or overwrites a Luau compiler used for this chunk.
    ///
    /// See [`Compiler`] for details and possible options.
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub fn set_compiler(mut self, compiler: Compiler) -> Self {
@@ -366,8 +578,6 @@ impl Chunk<'_> {
    ///
    /// See [`exec`] for more details.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`exec`]: Chunk::exec
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
@@ -398,8 +608,6 @@ impl Chunk<'_> {
    ///
    /// See [`eval`] for more details.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`eval`]: Chunk::eval
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
@@ -427,8 +635,6 @@ impl Chunk<'_> {
    ///
    /// See [`call`] for more details.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`call`]: Chunk::call
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
@@ -460,19 +666,19 @@ impl Chunk<'_> {
    ///
    /// It does nothing if the chunk is already binary or invalid.
    fn compile(&mut self) {
-        if let Ok(ref source) = self.source {
-            if self.detect_mode() == ChunkMode::Text {
-                #[cfg(feature = "luau")]
-                if let Ok(data) = self.compiler.get_or_insert_with(Default::default).compile(source) {
-                    self.source = Ok(Cow::Owned(data));
-                    self.mode = Some(ChunkMode::Binary);
-                }
-                #[cfg(not(feature = "luau"))]
-                if let Ok(func) = self.lua.lock().load_chunk(None, None, None, source.as_ref()) {
-                    let data = func.dump(false);
-                    self.source = Ok(Cow::Owned(data));
-                    self.mode = Some(ChunkMode::Binary);
-                }
+        if let Ok(ref source) = self.source
+            && self.detect_mode() == ChunkMode::Text
+        {
+            #[cfg(feature = "luau")]
+            if let Ok(data) = self.compiler.get_or_insert_default().compile(source) {
+                self.source = Ok(Cow::Owned(data));
+                self.mode = Some(ChunkMode::Binary);
+            }
+            #[cfg(not(feature = "luau"))]
+            if let Ok(func) = self.lua.lock().load_chunk(None, None, None, source.as_ref()) {
+                let data = func.dump(false);
+                self.source = Ok(Cow::Owned(data));
+                self.mode = Some(ChunkMode::Binary);
            }
        }
    }
@@ -485,33 +691,33 @@ impl Chunk<'_> {

        // Try to fetch compiled chunk from cache
        let mut text_source = None;
-        if let Ok(ref source) = self.source {
-            if self.detect_mode() == ChunkMode::Text {
-                let lua = self.lua.lock();
-                if let Some(cache) = lua.app_data_ref_unguarded::<ChunksCache>() {
-                    if let Some(data) = cache.0.get(source.as_ref()) {
-                        self.source = Ok(Cow::Owned(data.clone()));
-                        self.mode = Some(ChunkMode::Binary);
-                        return self;
-                    }
-                }
-                text_source = Some(source.as_ref().to_vec());
+        if let Ok(ref source) = self.source
+            && self.detect_mode() == ChunkMode::Text
+        {
+            let lua = self.lua.lock();
+            if let Some(cache) = lua.priv_app_data_ref::<ChunksCache>()
+                && let Some(data) = cache.0.get(source.as_ref())
+            {
+                self.source = Ok(Cow::Owned(data.clone()));
+                self.mode = Some(ChunkMode::Binary);
+                return self;
            }
+            text_source = Some(source.as_ref().to_vec());
        }

        // Compile and cache the chunk
        if let Some(text_source) = text_source {
            self.compile();
-            if let Ok(ref binary_source) = self.source {
-                if self.detect_mode() == ChunkMode::Binary {
-                    let lua = self.lua.lock();
-                    if let Some(mut cache) = lua.app_data_mut_unguarded::<ChunksCache>() {
-                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
-                    } else {
-                        let mut cache = ChunksCache(HashMap::new());
-                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
-                        let _ = lua.try_set_app_data(cache);
-                    };
+            if let Ok(ref binary_source) = self.source
+                && self.detect_mode() == ChunkMode::Binary
+            {
+                let lua = self.lua.lock();
+                if let Some(mut cache) = lua.priv_app_data_mut::<ChunksCache>() {
+                    cache.0.insert(text_source, binary_source.to_vec());
+                } else {
+                    let mut cache = ChunksCache(HashMap::new());
+                    cache.0.insert(text_source, binary_source.to_vec());
+                    lua.set_priv_app_data(cache);
                }
            }
        }
@@ -543,21 +749,20 @@ impl Chunk<'_> {
    }

    fn detect_mode(&self) -> ChunkMode {
-        match (self.mode, &self.source) {
-            (Some(mode), _) => mode,
-            (None, Ok(source)) => {
-                #[cfg(not(feature = "luau"))]
-                if source.starts_with(ffi::LUA_SIGNATURE) {
-                    return ChunkMode::Binary;
-                }
-                #[cfg(feature = "luau")]
-                if *source.first().unwrap_or(&u8::MAX) < b'\n' {
-                    return ChunkMode::Binary;
-                }
-                ChunkMode::Text
-            }
-            (None, Err(_)) => ChunkMode::Text, // any value is fine
+        if let Some(mode) = self.mode {
+            return mode;
        }
+        if let Ok(source) = &self.source {
+            #[cfg(not(feature = "luau"))]
+            if source.starts_with(ffi::LUA_SIGNATURE) {
+                return ChunkMode::Binary;
+            }
+            #[cfg(feature = "luau")]
+            if *source.first().unwrap_or(&u8::MAX) < b'\n' {
+                return ChunkMode::Binary;
+            }
+        }
+        ChunkMode::Text
    }

    fn convert_name(name: String) -> Result<CString> {
@@ -572,29 +777,26 @@ impl Chunk<'_> {
    }
 }

-struct WrappedChunk<'a, T: AsChunk<'a>> {
+struct WrappedChunk<T: AsChunk> {
    chunk: T,
    caller: &'static Location<'static>,
-    _marker: PhantomData<&'a T>,
 }

-impl<'a> Chunk<'a> {
+impl Chunk<'_> {
    /// Wraps a chunk of Lua code, returning an opaque type that implements [`IntoLua`] trait.
    ///
    /// The resulted `IntoLua` implementation will convert the chunk into a Lua function without
    /// executing it.
-    #[doc(hidden)]
    #[track_caller]
-    pub fn wrap(chunk: impl AsChunk<'a> + 'a) -> impl IntoLua + 'a {
+    pub fn wrap(chunk: impl AsChunk) -> impl IntoLua {
        WrappedChunk {
            chunk,
            caller: Location::caller(),
-            _marker: PhantomData,
        }
    }
 }

-impl<'a, T: AsChunk<'a>> IntoLua for WrappedChunk<'a, T> {
+impl<T: AsChunk> IntoLua for WrappedChunk<T> {
    fn into_lua(self, lua: &Lua) -> Result<Value> {
        lua.load_with_location(self.chunk, self.caller)
            .into_function()
@@ -4,20 +4,19 @@ use std::ffi::{CStr, CString, OsStr, OsString};
 use std::hash::{BuildHasher, Hash};
 use std::os::raw::c_int;
 use std::path::{Path, PathBuf};
-use std::string::String as StdString;
 use std::{slice, str};

-use bstr::{BStr, BString, ByteSlice, ByteVec};
+use bstr::{BStr, BString, ByteVec};
 use num_traits::cast;

 use crate::error::{Error, Result};
 use crate::function::Function;
 use crate::state::{Lua, RawLua};
-use crate::string::String;
+use crate::string::{BorrowedBytes, BorrowedStr, LuaString};
 use crate::table::Table;
 use crate::thread::Thread;
 use crate::traits::{FromLua, IntoLua, ShortTypeName as _};
-use crate::types::{Either, LightUserData, MaybeSend, RegistryKey};
+use crate::types::{Either, LightUserData, MaybeSend, MaybeSync, RegistryKey};
 use crate::userdata::{AnyUserData, UserData};
 use crate::value::{Nil, Value};

@@ -47,14 +46,14 @@ impl FromLua for Value {
    }
 }

-impl IntoLua for String {
+impl IntoLua for LuaString {
    #[inline]
    fn into_lua(self, _: &Lua) -> Result<Value> {
        Ok(Value::String(self))
    }
 }

-impl IntoLua for &String {
+impl IntoLua for &LuaString {
    #[inline]
    fn into_lua(self, _: &Lua) -> Result<Value> {
        Ok(Value::String(self.clone()))
@@ -67,16 +66,12 @@ impl IntoLua for &String {
    }
 }

-impl FromLua for String {
+impl FromLua for LuaString {
    #[inline]
-    fn from_lua(value: Value, lua: &Lua) -> Result<String> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<LuaString> {
        let ty = value.type_name();
        lua.coerce_string(value)?
-            .ok_or_else(|| Error::FromLuaConversionError {
-                from: ty,
-                to: "string".to_string(),
-                message: Some("expected string or number".to_string()),
-            })
+            .ok_or_else(|| Error::from_lua_conversion(ty, "string", "expected string or number".to_string()))
    }

    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
@@ -84,13 +79,89 @@ impl FromLua for String {
        let type_id = ffi::lua_type(state, idx);
        if type_id == ffi::LUA_TSTRING {
            ffi::lua_xpush(state, lua.ref_thread(), idx);
-            return Ok(String(lua.pop_ref_thread()));
+            return Ok(LuaString(lua.pop_ref_thread()));
        }
        // Fallback to default
        Self::from_lua(lua.stack_value(idx, Some(type_id)), lua.lua())
    }
 }

+impl IntoLua for BorrowedStr {
+    #[inline]
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::String(LuaString(self.vref)))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.vref);
+        Ok(())
+    }
+}
+
+impl IntoLua for &BorrowedStr {
+    #[inline]
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::String(LuaString(self.vref.clone())))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.vref);
+        Ok(())
+    }
+}
+
+impl FromLua for BorrowedStr {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
+        let s = LuaString::from_lua(value, lua)?;
+        BorrowedStr::try_from(&s)
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let s = LuaString::from_stack(idx, lua)?;
+        BorrowedStr::try_from(&s)
+    }
+}
+
+impl IntoLua for BorrowedBytes {
+    #[inline]
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::String(LuaString(self.vref)))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.vref);
+        Ok(())
+    }
+}
+
+impl IntoLua for &BorrowedBytes {
+    #[inline]
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::String(LuaString(self.vref.clone())))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.vref);
+        Ok(())
+    }
+}
+
+impl FromLua for BorrowedBytes {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
+        let s = LuaString::from_lua(value, lua)?;
+        Ok(BorrowedBytes::from(&s))
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let s = LuaString::from_stack(idx, lua)?;
+        Ok(BorrowedBytes::from(&s))
+    }
+}
+
 impl IntoLua for Table {
    #[inline]
    fn into_lua(self, _: &Lua) -> Result<Value> {
@@ -116,11 +187,7 @@ impl FromLua for Table {
    fn from_lua(value: Value, _: &Lua) -> Result<Table> {
        match value {
            Value::Table(table) => Ok(table),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "table".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "table", None)),
        }
    }
 }
@@ -150,11 +217,7 @@ impl FromLua for Function {
    fn from_lua(value: Value, _: &Lua) -> Result<Function> {
        match value {
            Value::Function(table) => Ok(table),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "function".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "function", None)),
        }
    }
 }
@@ -184,11 +247,7 @@ impl FromLua for Thread {
    fn from_lua(value: Value, _: &Lua) -> Result<Thread> {
        match value {
            Value::Thread(t) => Ok(t),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "thread".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "thread", None)),
        }
    }
 }
@@ -218,16 +277,12 @@ impl FromLua for AnyUserData {
    fn from_lua(value: Value, _: &Lua) -> Result<AnyUserData> {
        match value {
            Value::UserData(ud) => Ok(ud),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "userdata".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "userdata", None)),
        }
    }
 }

-impl<T: UserData + MaybeSend + 'static> IntoLua for T {
+impl<T: UserData + MaybeSend + MaybeSync + 'static> IntoLua for T {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::UserData(lua.create_userdata(self)?))
@@ -340,11 +395,11 @@ impl FromLua for LightUserData {
    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
            Value::LightUserData(ud) => Ok(ud),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "lightuserdata".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                "lightuserdata",
+                None,
+            )),
        }
    }
 }
@@ -363,11 +418,7 @@ impl FromLua for crate::Vector {
    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
            Value::Vector(v) => Ok(v),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "vector".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "vector", None)),
        }
    }
 }
@@ -400,37 +451,41 @@ impl FromLua for crate::Buffer {
    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
            Value::Buffer(buf) => Ok(buf),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "buffer".to_string(),
-                message: None,
-            }),
+            _ => Err(Error::from_lua_conversion(value.type_name(), "buffer", None)),
        }
    }
 }

-impl IntoLua for StdString {
+impl IntoLua for String {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        #[cfg(feature = "lua55")]
+        if true {
+            return Ok(Value::String(lua.create_external_string(self)?));
+        }
+
        Ok(Value::String(lua.create_string(self)?))
    }

    #[inline]
    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        #[cfg(feature = "lua55")]
+        if lua.unlikely_memory_error() {
+            return crate::util::push_external_string(lua.state(), self.into(), false);
+        }
+
        push_bytes_into_stack(self, lua)
    }
 }

-impl FromLua for StdString {
+impl FromLua for String {
    #[inline]
    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        let ty = value.type_name();
        Ok(lua
            .coerce_string(value)?
-            .ok_or_else(|| Error::FromLuaConversionError {
-                from: ty,
-                to: Self::type_name(),
-                message: Some("expected string or number".to_string()),
+            .ok_or_else(|| {
+                Error::from_lua_conversion(ty, Self::type_name(), "expected string or number".to_string())
            })?
            .to_str()?
            .to_owned())
@@ -446,11 +501,7 @@ impl FromLua for StdString {
            let bytes = slice::from_raw_parts(data as *const u8, size);
            return str::from_utf8(bytes)
                .map(|s| s.to_owned())
-                .map_err(|e| Error::FromLuaConversionError {
-                    from: "string",
-                    to: Self::type_name(),
-                    message: Some(e.to_string()),
-                });
+                .map_err(|e| Error::from_lua_conversion("string", Self::type_name(), e.to_string()));
        }
        // Fallback to default
        Self::from_lua(lua.stack_value(idx, Some(type_id)), lua.lua())
@@ -472,7 +523,10 @@ impl IntoLua for &str {
 impl IntoLua for Cow<'_, str> {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
-        Ok(Value::String(lua.create_string(self.as_bytes())?))
+        match self {
+            Cow::Borrowed(s) => s.into_lua(lua),
+            Cow::Owned(s) => s.into_lua(lua),
+        }
    }
 }

@@ -489,10 +543,8 @@ impl FromLua for Box<str> {
        let ty = value.type_name();
        Ok(lua
            .coerce_string(value)?
-            .ok_or_else(|| Error::FromLuaConversionError {
-                from: ty,
-                to: Self::type_name(),
-                message: Some("expected string or number".to_string()),
+            .ok_or_else(|| {
+                Error::from_lua_conversion(ty, Self::type_name(), "expected string or number".to_string())
            })?
            .to_str()?
            .to_owned()
@@ -503,6 +555,11 @@ impl FromLua for Box<str> {
 impl IntoLua for CString {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        #[cfg(feature = "lua55")]
+        if true {
+            return Ok(Value::String(lua.create_external_string(self)?));
+        }
+
        Ok(Value::String(lua.create_string(self.as_bytes())?))
    }
 }
@@ -511,21 +568,12 @@ impl FromLua for CString {
    #[inline]
    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        let ty = value.type_name();
-        let string = lua
-            .coerce_string(value)?
-            .ok_or_else(|| Error::FromLuaConversionError {
-                from: ty,
-                to: Self::type_name(),
-                message: Some("expected string or number".to_string()),
-            })?;
-
+        let string = lua.coerce_string(value)?.ok_or_else(|| {
+            Error::from_lua_conversion(ty, Self::type_name(), "expected string or number".to_string())
+        })?;
        match CStr::from_bytes_with_nul(&string.as_bytes_with_nul()) {
            Ok(s) => Ok(s.into()),
-            Err(_) => Err(Error::FromLuaConversionError {
-                from: ty,
-                to: Self::type_name(),
-                message: Some("invalid C-style string".to_string()),
-            }),
+            Err(err) => Err(Error::from_lua_conversion(ty, Self::type_name(), err.to_string())),
        }
    }
 }
@@ -540,13 +588,21 @@ impl IntoLua for &CStr {
 impl IntoLua for Cow<'_, CStr> {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
-        Ok(Value::String(lua.create_string(self.to_bytes())?))
+        match self {
+            Cow::Borrowed(s) => s.into_lua(lua),
+            Cow::Owned(s) => s.into_lua(lua),
+        }
    }
 }

 impl IntoLua for BString {
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        #[cfg(feature = "lua55")]
+        if true {
+            return Ok(Value::String(lua.create_external_string(self)?));
+        }
+
        Ok(Value::String(lua.create_string(self)?))
    }
 }
@@ -557,13 +613,11 @@ 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 {
-                    from: ty,
-                    to: Self::type_name(),
-                    message: Some("expected string or number".to_string()),
+                .ok_or_else(|| {
+                    Error::from_lua_conversion(ty, Self::type_name(), "expected string or number".to_string())
                })?
                .as_bytes())
            .into()),
@@ -614,23 +668,22 @@ impl FromLua for OsString {
        let bs = BString::from_lua(value, lua)?;
        Vec::from(bs)
            .into_os_string()
-            .map_err(|err| Error::FromLuaConversionError {
-                from: ty,
-                to: "OsString".into(),
-                message: Some(err.to_string()),
-            })
+            .map_err(|err| Error::from_lua_conversion(ty, "OsString", err.to_string()))
    }
 }

 impl IntoLua for &OsStr {
+    #[cfg(unix)]
    #[inline]
    fn into_lua(self, lua: &Lua) -> Result<Value> {
-        let s = <[u8]>::from_os_str(self).ok_or_else(|| Error::ToLuaConversionError {
-            from: "OsStr".into(),
-            to: "string",
-            message: Some("invalid utf-8 encoding".into()),
-        })?;
-        Ok(Value::String(lua.create_string(s)?))
+        use std::os::unix::ffi::OsStrExt;
+        Ok(Value::String(lua.create_string(self.as_bytes())?))
+    }
+
+    #[cfg(not(unix))]
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        self.display().to_string().into_lua(lua)
    }
 }

@@ -655,6 +708,42 @@ impl IntoLua for &Path {
    }
 }

+impl IntoLua for char {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        let mut char_bytes = [0; 4];
+        self.encode_utf8(&mut char_bytes);
+        Ok(Value::String(lua.create_string(&char_bytes[..self.len_utf8()])?))
+    }
+}
+
+impl FromLua for char {
+    fn from_lua(value: Value, _lua: &Lua) -> Result<Self> {
+        let ty = value.type_name();
+        match value {
+            Value::Integer(i) => cast(i).and_then(char::from_u32).ok_or_else(|| {
+                let msg = "integer out of range when converting to char";
+                Error::from_lua_conversion(ty, "char", msg.to_string())
+            }),
+            Value::String(s) => {
+                let str = s.to_str()?;
+                let mut str_iter = str.chars();
+                match (str_iter.next(), str_iter.next()) {
+                    (Some(char), None) => Ok(char),
+                    _ => {
+                        let msg = "expected string to have exactly one char when converting to char";
+                        Err(Error::from_lua_conversion(ty, "char", msg.to_string()))
+                    }
+                }
+            }
+            _ => {
+                let msg = "expected string or integer";
+                Err(Error::from_lua_conversion(ty, Self::type_name(), msg.to_string()))
+            }
+        }
+    }
+}
+
 #[inline]
 unsafe fn push_bytes_into_stack<T>(this: T, lua: &RawLua) -> Result<()>
 where
@@ -675,15 +764,9 @@ macro_rules! lua_convert_int {
        impl IntoLua for $x {
            #[inline]
            fn into_lua(self, _: &Lua) -> Result<Value> {
-                cast(self)
+                Ok(cast(self)
                    .map(Value::Integer)
-                    .or_else(|| cast(self).map(Value::Number))
-                    // This is impossible error because conversion to Number never fails
-                    .ok_or_else(|| Error::ToLuaConversionError {
-                        from: stringify!($x).to_string(),
-                        to: "number",
-                        message: Some("out of range".to_owned()),
-                    })
+                    .unwrap_or_else(|| Value::Number(self as ffi::lua_Number)))
            }

            #[inline]
@@ -707,24 +790,14 @@ macro_rules! lua_convert_int {
                        if let Some(i) = lua.coerce_integer(value.clone())? {
                            cast(i)
                        } else {
-                            cast(
-                                lua.coerce_number(value)?
-                                    .ok_or_else(|| Error::FromLuaConversionError {
-                                        from: ty,
-                                        to: stringify!($x).to_string(),
-                                        message: Some(
-                                            "expected number or string coercible to number".to_string(),
-                                        ),
-                                    })?,
-                            )
+                            cast(lua.coerce_number(value)?.ok_or_else(|| {
+                                let msg = "expected number or string coercible to number";
+                                Error::from_lua_conversion(ty, stringify!($x), msg.to_string())
+                            })?)
                        }
                    }
                })
-                .ok_or_else(|| Error::FromLuaConversionError {
-                    from: ty,
-                    to: stringify!($x).to_string(),
-                    message: Some("out of range".to_owned()),
-                })
+                .ok_or_else(|| Error::from_lua_conversion(ty, stringify!($x), "out of range".to_string()))
            }

            unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
@@ -734,13 +807,18 @@ macro_rules! lua_convert_int {
                    let mut ok = 0;
                    let i = ffi::lua_tointegerx(state, idx, &mut ok);
                    if ok != 0 {
-                        return cast(i).ok_or_else(|| Error::FromLuaConversionError {
-                            from: "integer",
-                            to: stringify!($x).to_string(),
-                            message: Some("out of range".to_owned()),
+                        return cast(i).ok_or_else(|| {
+                            Error::from_lua_conversion("integer", stringify!($x), "out of range".to_string())
                        });
                    }
                }
+                #[cfg(feature = "luau")]
+                if type_id == ffi::LUA_TINTEGER {
+                    let i = ffi::lua_tointeger64(state, idx, std::ptr::null_mut());
+                    return cast(i).ok_or_else(|| {
+                        Error::from_lua_conversion("integer", stringify!($x), "out of range".to_string())
+                    });
+                }
                // Fallback to default
                Self::from_lua(lua.stack_value(idx, Some(type_id)), lua.lua())
            }
@@ -766,13 +844,7 @@ macro_rules! lua_convert_float {
        impl IntoLua for $x {
            #[inline]
            fn into_lua(self, _: &Lua) -> Result<Value> {
-                cast(self)
-                    .ok_or_else(|| Error::ToLuaConversionError {
-                        from: stringify!($x).to_string(),
-                        to: "number",
-                        message: Some("out of range".to_string()),
-                    })
-                    .map(Value::Number)
+                Ok(Value::Number(self as _))
            }
        }

@@ -780,34 +852,17 @@ macro_rules! lua_convert_float {
            #[inline]
            fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
                let ty = value.type_name();
-                lua.coerce_number(value)?
-                    .ok_or_else(|| Error::FromLuaConversionError {
-                        from: ty,
-                        to: stringify!($x).to_string(),
-                        message: Some("expected number or string coercible to number".to_string()),
-                    })
-                    .and_then(|n| {
-                        cast(n).ok_or_else(|| Error::FromLuaConversionError {
-                            from: ty,
-                            to: stringify!($x).to_string(),
-                            message: Some("number out of range".to_string()),
-                        })
-                    })
+                lua.coerce_number(value)?.map(|n| n as $x).ok_or_else(|| {
+                    let msg = "expected number or string coercible to number";
+                    Error::from_lua_conversion(ty, stringify!($x), msg.to_string())
+                })
            }

            unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
                let state = lua.state();
                let type_id = ffi::lua_type(state, idx);
                if type_id == ffi::LUA_TNUMBER {
-                    let mut ok = 0;
-                    let i = ffi::lua_tonumberx(state, idx, &mut ok);
-                    if ok != 0 {
-                        return cast(i).ok_or_else(|| Error::FromLuaConversionError {
-                            from: "number",
-                            to: stringify!($x).to_string(),
-                            message: Some("out of range".to_owned()),
-                        });
-                    }
+                    return Ok(ffi::lua_tonumber(state, idx) as _);
                }
                // Fallback to default
                Self::from_lua(lua.stack_value(idx, Some(type_id)), lua.lua())
@@ -860,18 +915,16 @@ where
            },
            Value::Table(table) => {
                let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
-                vec.try_into()
-                    .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
-                        from: "table",
-                        to: Self::type_name(),
-                        message: Some(format!("expected table of length {N}, got {}", vec.len())),
-                    })
+                vec.try_into().map_err(|vec: Vec<T>| {
+                    let msg = format!("expected table of length {N}, got {}", vec.len());
+                    Error::from_lua_conversion("table", Self::type_name(), msg)
+                })
+            }
+            _ => {
+                let msg = format!("expected table of length {N}");
+                let err = Error::from_lua_conversion(value.type_name(), Self::type_name(), msg.to_string());
+                Err(err)
            }
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            }),
        }
    }
 }
@@ -902,11 +955,11 @@ impl<T: FromLua> FromLua for Vec<T> {
    fn from_lua(value: Value, _lua: &Lua) -> Result<Self> {
        match value {
            Value::Table(table) => table.sequence_values().collect(),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            }),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                Self::type_name(),
+                "expected table".to_string(),
+            )),
        }
    }
 }
@@ -921,14 +974,13 @@ impl<K: Eq + Hash + IntoLua, V: IntoLua, S: BuildHasher> IntoLua for HashMap<K,
 impl<K: Eq + Hash + FromLua, V: FromLua, S: BuildHasher + Default> FromLua for HashMap<K, V, S> {
    #[inline]
    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.pairs().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            })
+        match value {
+            Value::Table(table) => table.pairs().collect(),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                Self::type_name(),
+                "expected table".to_string(),
+            )),
        }
    }
 }
@@ -943,14 +995,13 @@ impl<K: Ord + IntoLua, V: IntoLua> IntoLua for BTreeMap<K, V> {
 impl<K: Ord + FromLua, V: FromLua> FromLua for BTreeMap<K, V> {
    #[inline]
    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.pairs().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            })
+        match value {
+            Value::Table(table) => table.pairs().collect(),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                Self::type_name(),
+                "expected table".to_string(),
+            )),
        }
    }
 }
@@ -970,11 +1021,11 @@ impl<T: Eq + Hash + FromLua, S: BuildHasher + Default> FromLua for HashSet<T, S>
        match value {
            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
            Value::Table(table) => table.pairs::<T, Value>().map(|res| res.map(|(k, _)| k)).collect(),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            }),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                Self::type_name(),
+                "expected table".to_string(),
+            )),
        }
    }
 }
@@ -994,11 +1045,11 @@ impl<T: Ord + FromLua> FromLua for BTreeSet<T> {
        match value {
            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
            Value::Table(table) => table.pairs::<T, Value>().map(|res| res.map(|(k, _)| k)).collect(),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: Self::type_name(),
-                message: Some("expected table".to_string()),
-            }),
+            _ => Err(Error::from_lua_conversion(
+                value.type_name(),
+                Self::type_name(),
+                "expected table".to_string(),
+            )),
        }
    }
 }
@@ -1068,11 +1119,11 @@ impl<L: FromLua, R: FromLua> FromLua for Either<L, R> {
            // Try the right type
            Err(_) => match R::from_lua(value, lua).map(Either::Right) {
                Ok(r) => Ok(r),
-                Err(_) => Err(Error::FromLuaConversionError {
-                    from: value_type_name,
-                    to: Self::type_name(),
-                    message: None,
-                }),
+                Err(_) => Err(Error::from_lua_conversion(
+                    value_type_name,
+                    Self::type_name(),
+                    None,
+                )),
            },
        }
    }
@@ -1084,12 +1135,12 @@ impl<L: FromLua, R: FromLua> FromLua for Either<L, R> {
            Err(_) => match R::from_stack(idx, lua).map(Either::Right) {
                Ok(r) => Ok(r),
                Err(_) => {
-                    let value_type_name = CStr::from_ptr(ffi::luaL_typename(lua.state(), idx));
-                    Err(Error::FromLuaConversionError {
-                        from: value_type_name.to_str().unwrap(),
-                        to: Self::type_name(),
-                        message: None,
-                    })
+                    let state = lua.state();
+                    let from_type_name = CStr::from_ptr(ffi::lua_typename(state, ffi::lua_type(state, idx)))
+                        .to_str()
+                        .unwrap_or("unknown");
+                    let err = Error::from_lua_conversion(from_type_name, Self::type_name(), None);
+                    Err(err)
                }
            },
        }
@@ -1,66 +1,39 @@
+//! Lua debugging interface.
+//!
+//! This module provides access to the Lua debug interface, allowing inspection of the call stack,
+//! and function information. The main types are [`struct@Debug`] for accessing debug information
+//! and [`HookTriggers`] for configuring debug hooks.
+
 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::{StackGuard, assert_stack, linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};

 /// 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 +47,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 +58,48 @@ impl<'a> Debug<'a> {
        }
    }

-    /// Corresponds to the `n` what mask.
-    pub fn names(&self) -> DebugNames {
+    /// 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,119 +109,107 @@ impl<'a> Debug<'a> {
        }
    }

-    /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource {
+    /// 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.
-    pub fn curr_line(&self) -> i32 {
+    /// 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 = "lua55", feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", 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 _,
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as _,
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar.get()).isvararg != 0,
+                num_upvalues: (*self.ar).nups as _,
+                #[cfg(not(any(feature = "lua51", feature = "luajit")))]
+                num_params: (*self.ar).nparams as _,
+                #[cfg(not(any(feature = "lua51", feature = "luajit")))]
+                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_upvalues: (*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.
+#[cfg(not(feature = "luau"))]
+#[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum DebugEvent {
    Call,
@@ -235,6 +220,9 @@ pub enum DebugEvent {
    Unknown(c_int),
 }

+/// Contains the name information of a function in the call stack.
+///
+/// Returned by the [`Debug::names`] method.
 #[derive(Clone, Debug)]
 pub struct DebugNames<'a> {
    /// A (reasonable) name of the function (`None` if the name cannot be found).
@@ -245,6 +233,9 @@ pub struct DebugNames<'a> {
    pub name_what: Option<&'static str>,
 }

+/// Contains the source information of a function in the call stack.
+///
+/// Returned by the [`Debug::source`] method.
 #[derive(Clone, Debug)]
 pub struct DebugSource<'a> {
    /// Source of the chunk that created the function.
@@ -260,19 +251,20 @@ pub struct DebugSource<'a> {
    pub what: &'static str,
 }

+/// Contains stack information about a function in the call stack.
+///
+/// Returned by the [`Debug::stack`] method.
 #[derive(Copy, Clone, Debug)]
 pub struct DebugStack {
-    /// Number of upvalues.
-    pub num_ups: u8,
-    /// Number of parameters.
-    ///
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    /// The number of upvalues of the function.
+    pub num_upvalues: u8,
+    /// The number of parameters of the function (always 0 for C).
+    #[cfg(any(not(any(feature = "lua51", feature = "luajit")), doc))]
+    #[cfg_attr(docsrs, doc(cfg(not(any(feature = "lua51", feature = "luajit")))))]
    pub num_params: u8,
-    /// Whether the function is a vararg function.
-    ///
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    /// Whether the function is a variadic function (always true for C).
+    #[cfg(any(not(any(feature = "lua51", feature = "luajit")), doc))]
+    #[cfg_attr(docsrs, doc(cfg(not(any(feature = "lua51", feature = "luajit")))))]
    pub is_vararg: bool,
 }

@@ -350,6 +342,7 @@ impl HookTriggers {
    }

    // Compute the mask to pass to `lua_sethook`.
+    #[cfg(not(feature = "luau"))]
    pub(crate) const fn mask(&self) -> c_int {
        let mut mask: c_int = 0;
        if self.on_calls {
@@ -369,6 +362,7 @@ impl HookTriggers {

    // Returns the `count` parameter to pass to `lua_sethook`, if applicable. Otherwise, zero is
    // returned.
+    #[cfg(not(feature = "luau"))]
    pub(crate) const fn count(&self) -> c_int {
        match self.every_nth_instruction {
            Some(n) => n as c_int,
@@ -378,7 +372,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 {
@@ -393,7 +387,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;
    }
@@ -1,10 +1,14 @@
+//! Lua error handling.
+//!
+//! This module provides the [`Error`] type returned by all fallible `mlua` operations, together
+//! with extension traits for adapting Rust errors for use within Lua.
+
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
 use std::net::AddrParseError;
 use std::result::Result as StdResult;
 use std::str::Utf8Error;
-use std::string::String as StdString;
 use std::sync::Arc;

 use crate::private::Sealed;
@@ -22,7 +26,7 @@ pub enum Error {
    /// Syntax error while parsing Lua source code.
    SyntaxError {
        /// The error message as returned by Lua.
-        message: StdString,
+        message: String,
        /// `true` if the error can likely be fixed by appending more input to the source code.
        ///
        /// This is useful for implementing REPLs as they can query the user for more input if this
@@ -34,20 +38,20 @@ pub enum Error {
    /// The Lua VM returns this error when a builtin operation is performed on incompatible types.
    /// Among other things, this includes invoking operators on wrong types (such as calling or
    /// indexing a `nil` value).
-    RuntimeError(StdString),
+    RuntimeError(String),
    /// Lua memory error, aka `LUA_ERRMEM`
    ///
    /// The Lua VM returns this error when the allocator does not return the requested memory, aka
    /// it is an out-of-memory error.
-    MemoryError(StdString),
+    MemoryError(String),
    /// Lua garbage collector error, aka `LUA_ERRGCMM`.
    ///
    /// The Lua VM returns this error when there is an error running a `__gc` metamethod.
    #[cfg(any(feature = "lua53", feature = "lua52", doc))]
    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua53", feature = "lua52"))))]
-    GarbageCollectorError(StdString),
+    GarbageCollectorError(String),
    /// Potentially unsafe action in safe mode.
-    SafetyError(StdString),
+    SafetyError(String),
    /// Memory control is not available.
    ///
    /// This error can only happen when Lua state was not created by us and does not have the
@@ -80,23 +84,14 @@ pub enum Error {
    /// (which is stored in the corresponding field).
    BadArgument {
        /// Function that was called.
-        to: Option<StdString>,
+        to: Option<String>,
        /// Argument position (usually starts from 1).
        pos: usize,
        /// Argument name.
-        name: Option<StdString>,
+        name: Option<String>,
        /// Underlying error returned when converting argument to a Lua value.
        cause: Arc<Error>,
    },
-    /// A Rust value could not be converted to a Lua value.
-    ToLuaConversionError {
-        /// Name of the Rust type that could not be converted.
-        from: String,
-        /// Name of the Lua type that could not be created.
-        to: &'static str,
-        /// A message indicating why the conversion failed in more detail.
-        message: Option<StdString>,
-    },
    /// A Lua value could not be converted to the expected Rust type.
    FromLuaConversionError {
        /// Name of the Lua type that could not be converted.
@@ -104,7 +99,7 @@ pub enum Error {
        /// Name of the Rust type that could not be created.
        to: String,
        /// A string containing more detailed error information.
-        message: Option<StdString>,
+        message: Option<String>,
    },
    /// [`Thread::resume`] was called on an unresumable coroutine.
    ///
@@ -154,17 +149,17 @@ pub enum Error {
    /// A [`MetaMethod`] operation is restricted (typically for `__gc` or `__metatable`).
    ///
    /// [`MetaMethod`]: crate::MetaMethod
-    MetaMethodRestricted(StdString),
+    MetaMethodRestricted(String),
    /// A [`MetaMethod`] (eg. `__index` or `__newindex`) has invalid type.
    ///
    /// [`MetaMethod`]: crate::MetaMethod
    MetaMethodTypeError {
        /// Name of the metamethod.
-        method: StdString,
+        method: String,
        /// Passed value type.
        type_name: &'static str,
        /// A string containing more detailed error information.
-        message: Option<StdString>,
+        message: Option<String>,
    },
    /// A [`RegistryKey`] produced from a different Lua state was used.
    ///
@@ -173,7 +168,7 @@ pub enum Error {
    /// A Rust callback returned `Err`, raising the contained `Error` as a Lua error.
    CallbackError {
        /// Lua call stack backtrace.
-        traceback: StdString,
+        traceback: String,
        /// Original error returned by the Rust code.
        cause: Arc<Error>,
    },
@@ -183,13 +178,13 @@ pub enum Error {
    /// and returned again.
    PreviouslyResumedPanic,
    /// Serialization error.
-    #[cfg(feature = "serialize")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-    SerializeError(StdString),
+    #[cfg(feature = "serde")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+    SerializeError(String),
    /// Deserialization error.
-    #[cfg(feature = "serialize")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-    DeserializeError(StdString),
+    #[cfg(feature = "serde")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+    DeserializeError(String),
    /// A custom error.
    ///
    /// This can be used for returning user-defined errors from callbacks.
@@ -201,7 +196,7 @@ pub enum Error {
    /// An error with additional context.
    WithContext {
        /// A string containing additional context.
-        context: StdString,
+        context: String,
        /// Underlying error.
        cause: Arc<Error>,
    },
@@ -225,7 +220,7 @@ impl fmt::Display for Error {
            }
            Error::SafetyError(msg) => {
                write!(fmt, "safety error: {msg}")
-            },
+            }
            Error::MemoryControlNotAvailable => {
                write!(fmt, "memory control is not available")
            }
@@ -238,10 +233,7 @@ impl fmt::Display for Error {
                fmt,
                "out of Lua stack, too many arguments to a Lua function or too many return values from a callback"
            ),
-            Error::BindError => write!(
-                fmt,
-                "too many arguments to Function::bind"
-            ),
+            Error::BindError => write!(fmt, "too many arguments to Function::bind"),
            Error::BadArgument { to, pos, name, cause } => {
                if let Some(name) = name {
                    write!(fmt, "bad argument `{name}`")?;
@@ -252,13 +244,6 @@ impl fmt::Display for Error {
                    write!(fmt, " to `{to}`")?;
                }
                write!(fmt, ": {cause}")
-            },
-            Error::ToLuaConversionError { from, to, message } => {
-                write!(fmt, "error converting {from} to Lua {to}")?;
-                match message {
-                    None => Ok(()),
-                    Some(message) => write!(fmt, " ({message})"),
-                }
            }
            Error::FromLuaConversionError { from, to, message } => {
                write!(fmt, "error converting Lua {from} to {to}")?;
@@ -273,7 +258,11 @@ impl fmt::Display for Error {
            Error::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
            Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
            Error::MetaMethodRestricted(method) => write!(fmt, "metamethod {method} is restricted"),
-            Error::MetaMethodTypeError { method, type_name, message } => {
+            Error::MetaMethodTypeError {
+                method,
+                type_name,
+                message,
+            } => {
                write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
                match message {
                    None => Ok(()),
@@ -286,7 +275,11 @@ impl fmt::Display for Error {
            Error::CallbackError { cause, traceback } => {
                // Trace errors down to the root
                let (mut cause, mut full_traceback) = (cause, None);
-                while let Error::CallbackError { cause: cause2, traceback: traceback2 } = &**cause {
+                while let Error::CallbackError {
+                    cause: cause2,
+                    traceback: traceback2,
+                } = &**cause
+                {
                    cause = cause2;
                    full_traceback = Some(traceback2);
                }
@@ -297,7 +290,7 @@ impl fmt::Display for Error {
                    // Try to find local traceback within the full traceback
                    if let Some(pos) = full_traceback.find(traceback) {
                        write!(fmt, "{}", &full_traceback[..pos])?;
-                        writeln!(fmt, ">{}", &full_traceback[pos..].trim_end())?;
+                        writeln!(fmt, ">{}", full_traceback[pos..].trim_end())?;
                    } else {
                        writeln!(fmt, "{}", full_traceback.trim_end())?;
                    }
@@ -309,14 +302,14 @@ impl fmt::Display for Error {
            Error::PreviouslyResumedPanic => {
                write!(fmt, "previously resumed panic returned again")
            }
-            #[cfg(feature = "serialize")]
+            #[cfg(feature = "serde")]
            Error::SerializeError(err) => {
                write!(fmt, "serialize error: {err}")
-            },
-            #[cfg(feature = "serialize")]
+            }
+            #[cfg(feature = "serde")]
            Error::DeserializeError(err) => {
                write!(fmt, "deserialize error: {err}")
-            },
+            }
            Error::ExternalError(err) => err.fmt(fmt),
            Error::WithContext { context, cause } => {
                writeln!(fmt, "{context}")?;
@@ -352,7 +345,11 @@ impl Error {
    /// Wraps an external error object.
    #[inline]
    pub fn external<T: Into<Box<DynStdError>>>(err: T) -> Self {
-        Error::ExternalError(err.into().into())
+        let boxed = err.into();
+        match boxed.downcast::<Self>() {
+            Ok(err) => *err,
+            Err(boxed) => Error::ExternalError(boxed.into()),
+        }
    }

    /// Attempts to downcast the external error object to a concrete type by reference.
@@ -394,6 +391,7 @@ impl Error {
        }
    }

+    #[inline]
    pub(crate) fn from_lua_conversion(
        from: &'static str,
        to: impl ToString,
@@ -494,14 +492,14 @@ impl From<Utf8Error> for Error {
    }
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl serde::ser::Error for Error {
    fn custom<T: fmt::Display>(msg: T) -> Self {
        Self::SerializeError(msg.to_string())
    }
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl serde::de::Error for Error {
    fn custom<T: fmt::Display>(msg: T) -> Self {
        Self::DeserializeError(msg.to_string())
@@ -561,10 +559,8 @@ impl<'a> Iterator for Chain<'a> {

 #[cfg(test)]
 mod assertions {
-    use super::*;
-
    #[cfg(not(feature = "error-send"))]
-    static_assertions::assert_not_impl_any!(Error: Send, Sync);
+    static_assertions::assert_not_impl_any!(super::Error: Send, Sync);
    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(Error: Send, Sync);
+    static_assertions::assert_impl_all!(super::Error: Send, Sync);
 }
@@ -1,22 +1,100 @@
+//! Lua function handling.
+//!
+//! This module provides types for working with Lua functions from Rust, including
+//! both Lua-defined functions and native Rust callbacks.
+//!
+//! # Calling Functions
+//!
+//! Use [`Function::call`] to invoke a Lua function synchronously:
+//!
+//! ```
+//! # use mlua::{Function, Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//!
+//! // Get a built-in function
+//! let print: Function = lua.globals().get("print")?;
+//! print.call::<()>("Hello from Rust!")?;
+//!
+//! // Call a function that returns values
+//! let tonumber: Function = lua.globals().get("tonumber")?;
+//! let n: i32 = tonumber.call("42")?;
+//! assert_eq!(n, 42);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! For asynchronous execution, use `Function::call_async` (requires `async` feature):
+//!
+//! ```ignore
+//! let result: String = my_async_func.call_async(args).await?;
+//! ```
+//!
+//! # Creating Functions
+//!
+//! Functions can be created from Rust closures using [`Lua::create_function`]:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//!
+//! let greet = lua.create_function(|_, name: String| {
+//!     Ok(format!("Hello, {}!", name))
+//! })?;
+//!
+//! lua.globals().set("greet", greet)?;
+//! let result: String = lua.load(r#"greet("World")"#).eval()?;
+//! assert_eq!(result, "Hello, World!");
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! For simpler cases, use [`Function::wrap`] or [`Function::wrap_raw`] to convert a Rust function
+//! directly:
+//!
+//! ```
+//! # use mlua::{Function, Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//!
+//! fn add(a: i32, b: i32) -> i32 { a + b }
+//!
+//! lua.globals().set("add", Function::wrap_raw(add))?;
+//! let sum: i32 = lua.load("add(2, 3)").eval()?;
+//! assert_eq!(sum, 5);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Function Environments
+//!
+//! Lua functions have an associated environment table that determines how global
+//! variables are resolved. Use [`Function::environment`] and [`Function::set_environment`]
+//! to inspect or modify this environment.
+
 use std::cell::RefCell;
 use std::os::raw::{c_int, c_void};
+use std::result::Result as StdResult;
 use std::{mem, ptr, slice};

-use crate::error::{Error, Result};
+use crate::error::{Error, ExternalError, ExternalResult, Result};
 use crate::state::Lua;
 use crate::table::Table;
-use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut};
+use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti};
 use crate::types::{Callback, LuaType, MaybeSend, ValueRef};
 use crate::util::{
-    assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str, StackGuard,
+    StackGuard, assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str,
 };
 use crate::value::Value;

 #[cfg(feature = "async")]
 use {
-    crate::traits::LuaNativeAsyncFn,
+    crate::thread::AsyncThread,
    crate::types::AsyncCallback,
    std::future::{self, Future},
+    std::pin::{Pin, pin},
+    std::task::{Context, Poll},
 };

 /// Handle to an internal Lua function.
@@ -29,6 +107,7 @@ pub struct Function(pub(crate) ValueRef);
 ///
 /// [`Lua Debug Interface`]: https://www.lua.org/manual/5.4/manual.html#4.7
 #[derive(Clone, Debug)]
+#[non_exhaustive]
 pub struct FunctionInfo {
    /// A (reasonable) name of the function (`None` if the name cannot be found).
    pub name: Option<String>,
@@ -47,6 +126,16 @@ pub struct FunctionInfo {
    pub line_defined: Option<usize>,
    /// The line number where the definition of the function ends (not set by Luau).
    pub last_line_defined: Option<usize>,
+    /// The number of upvalues of the function.
+    pub num_upvalues: u8,
+    /// The number of parameters of the function (always 0 for C).
+    #[cfg(any(not(any(feature = "lua51", feature = "luajit")), doc))]
+    #[cfg_attr(docsrs, doc(cfg(not(any(feature = "lua51", feature = "luajit")))))]
+    pub num_params: u8,
+    /// Whether the function is a variadic function (always true for C).
+    #[cfg(any(not(any(feature = "lua51", feature = "luajit")), doc))]
+    #[cfg_attr(docsrs, doc(cfg(not(any(feature = "lua51", feature = "luajit")))))]
+    pub is_vararg: bool,
 }

 /// Luau function coverage snapshot.
@@ -128,9 +217,8 @@ impl Function {
    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
    /// and drives the execution.
    ///
-    /// Internally it wraps the function to an [`AsyncThread`].
-    ///
-    /// Requires `feature = "async"`
+    /// Internally it wraps the function to an [`AsyncThread`]. The returned type implements
+    /// `Future<Output = Result<R>>` and can be awaited.
    ///
    /// # Examples
    ///
@@ -146,28 +234,27 @@ impl Function {
    ///     Ok(())
    /// })?;
    ///
-    /// sleep.call_async(10).await?;
+    /// sleep.call_async::<()>(10).await?;
    ///
    /// # Ok(())
    /// # }
    /// ```
    ///
-    /// [`AsyncThread`]: crate::AsyncThread
+    /// [`AsyncThread`]: crate::thread::AsyncThread
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    pub fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
    where
        R: FromLuaMulti,
    {
        let lua = self.0.lua.lock();
-        let thread_res = unsafe {
-            lua.create_recycled_thread(self).map(|th| {
-                let mut th = th.into_async(args);
+        AsyncCallFuture(unsafe {
+            lua.create_recycled_thread(self).and_then(|th| {
+                let mut th = th.into_async(args)?;
                th.set_recyclable(true);
-                th
+                Ok(th)
            })
-        };
-        async move { thread_res?.await }
+        })
    }

    /// Returns a function that, when called, calls `self`, passing `args` as the first set of
@@ -252,7 +339,7 @@ impl Function {
            "#,
        )
        .try_cache()
-        .set_name("__mlua_bind")
+        .set_name("=__mlua_bind")
        .call((self, args_wrapper))
    }

@@ -275,12 +362,12 @@ impl Function {

            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
            ffi::lua_getfenv(state, -1);
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52"))]
            for i in 1..=255 {
                // Traverse upvalues until we find the _ENV one
                match ffi::lua_getupvalue(state, -1, i) {
                    s if s.is_null() => break,
-                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => break,
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => break,
                    _ => ffi::lua_pop(state, 1),
                }
            }
@@ -315,11 +402,11 @@ impl Function {
                lua.push_ref(&env.0);
                ffi::lua_setfenv(state, -2);
            }
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52"))]
            for i in 1..=255 {
                match ffi::lua_getupvalue(state, -1, i) {
                    s if s.is_null() => return Ok(false),
-                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => {
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => {
                        ffi::lua_pop(state, 1);
                        // Create an anonymous function with the new environment
                        let f_with_env = lua
@@ -342,7 +429,8 @@ impl Function {

    /// Returns information about the function.
    ///
-    /// Corresponds to the `>Sn` what mask for [`lua_getinfo`] when applied to the function.
+    /// Corresponds to the `>Snu` (`>Sn` for Luau) what mask for
+    /// [`lua_getinfo`] when applied to the function.
    ///
    /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
    pub fn info(&self) -> FunctionInfo {
@@ -354,11 +442,16 @@ impl Function {

            let mut ar: ffi::lua_Debug = mem::zeroed();
            lua.push_ref(&self.0);
+
            #[cfg(not(feature = "luau"))]
-            let res = ffi::lua_getinfo(state, cstr!(">Sn"), &mut ar);
+            let res = ffi::lua_getinfo(state, cstr!(">Snu"), &mut ar);
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(res != 0, "lua_getinfo failed with `>Snu`");
+
            #[cfg(feature = "luau")]
-            let res = ffi::lua_getinfo(state, -1, cstr!("sn"), &mut ar);
-            mlua_assert!(res != 0, "lua_getinfo failed with `>Sn`");
+            let res = ffi::lua_getinfo(state, -1, cstr!("snau"), &mut ar);
+            #[cfg(feature = "luau")]
+            mlua_assert!(res != 0, "lua_getinfo failed with `snau`");

            FunctionInfo {
                name: ptr_to_lossy_str(ar.name).map(|s| s.into_owned()),
@@ -380,6 +473,14 @@ impl Function {
                last_line_defined: linenumber_to_usize(ar.lastlinedefined),
                #[cfg(feature = "luau")]
                last_line_defined: None,
+                #[cfg(not(feature = "luau"))]
+                num_upvalues: ar.nups as _,
+                #[cfg(feature = "luau")]
+                num_upvalues: ar.nupvals,
+                #[cfg(not(any(feature = "lua51", feature = "luajit")))]
+                num_params: ar.nparams,
+                #[cfg(not(any(feature = "lua51", feature = "luajit")))]
+                is_vararg: ar.isvararg != 0,
            }
        }
    }
@@ -399,11 +500,14 @@ impl Function {
            _state: *mut ffi::lua_State,
            buf: *const c_void,
            buf_len: usize,
-            data: *mut c_void,
+            data_ptr: *mut c_void,
        ) -> c_int {
-            let data = &mut *(data as *mut Vec<u8>);
-            let buf = slice::from_raw_parts(buf as *const u8, buf_len);
-            data.extend_from_slice(buf);
+            // If `data` is null, then it's a signal that write is finished.
+            if !data_ptr.is_null() && buf_len > 0 {
+                let data = &mut *(data_ptr as *mut Vec<u8>);
+                let buf = slice::from_raw_parts(buf as *const u8, buf_len);
+                data.extend_from_slice(buf);
+            }
            0
        }

@@ -430,12 +534,10 @@ impl Function {
    ///
    /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
    ///
-    /// Requires `feature = "luau"`
-    ///
    /// [`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),
    {
@@ -455,13 +557,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();
@@ -471,7 +576,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>);
        }
    }
@@ -491,20 +597,26 @@ impl Function {
    /// Copies the function prototype and all its upvalues to the
    /// newly created function.
    /// This function returns shallow clone (same handle) for Rust/C functions.
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn deep_clone(&self) -> Self {
+    pub fn deep_clone(&self) -> Result<Self> {
        let lua = self.0.lua.lock();
-        let ref_thread = lua.ref_thread();
+        let state = lua.state();
        unsafe {
-            if ffi::lua_iscfunction(ref_thread, self.0.index) != 0 {
-                return self.clone();
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(self.clone());
            }

-            ffi::lua_clonefunction(ref_thread, self.0.index);
-            Function(lua.pop_ref_thread())
+            if lua.unlikely_memory_error() {
+                ffi::lua_clonefunction(state, -1);
+            } else {
+                protect_lua!(state, 1, 1, fn(state) ffi::lua_clonefunction(state, -1))?;
+            }
+            Ok(Function(lua.pop_ref()))
        }
    }
 }
@@ -518,30 +630,32 @@ impl Function {
    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`]
    /// trait.
    #[inline]
-    pub fn wrap<F, A, R>(func: F) -> impl IntoLua
+    pub fn wrap<F, A, R, E>(func: F) -> impl IntoLua
    where
-        F: LuaNativeFn<A, Output = Result<R>> + MaybeSend + 'static,
+        F: LuaNativeFn<A, Output = StdResult<R, E>> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
+        E: ExternalError,
    {
        WrappedFunction(Box::new(move |lua, nargs| unsafe {
            let args = A::from_stack_args(nargs, 1, None, lua)?;
-            func.call(args)?.push_into_stack_multi(lua)
+            func.call(args).into_lua_err()?.push_into_stack_multi(lua)
        }))
    }

    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
-    pub fn wrap_mut<F, A, R>(func: F) -> impl IntoLua
+    pub fn wrap_mut<F, A, R, E>(func: F) -> impl IntoLua
    where
-        F: LuaNativeFnMut<A, Output = Result<R>> + MaybeSend + 'static,
+        F: LuaNativeFnMut<A, Output = StdResult<R, E>> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
+        E: ExternalError,
    {
        let func = RefCell::new(func);
        WrappedFunction(Box::new(move |lua, nargs| unsafe {
            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
            let args = A::from_stack_args(nargs, 1, None, lua)?;
-            func.call(args)?.push_into_stack_multi(lua)
+            func.call(args).into_lua_err()?.push_into_stack_multi(lua)
        }))
    }

@@ -554,6 +668,7 @@ impl Function {
    pub fn wrap_raw<F, A>(func: F) -> impl IntoLua
    where
        F: LuaNativeFn<A> + MaybeSend + 'static,
+        F::Output: IntoLuaMulti,
        A: FromLuaMulti,
    {
        WrappedFunction(Box::new(move |lua, nargs| unsafe {
@@ -570,6 +685,7 @@ impl Function {
    pub fn wrap_raw_mut<F, A>(func: F) -> impl IntoLua
    where
        F: LuaNativeFnMut<A> + MaybeSend + 'static,
+        F::Output: IntoLuaMulti,
        A: FromLuaMulti,
    {
        let func = RefCell::new(func);
@@ -584,11 +700,12 @@ impl Function {
    /// trait.
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn wrap_async<F, A, R>(func: F) -> impl IntoLua
+    pub fn wrap_async<F, A, R, E>(func: F) -> impl IntoLua
    where
-        F: LuaNativeAsyncFn<A, Output = Result<R>> + MaybeSend + 'static,
+        F: LuaNativeAsyncFn<A, Output = StdResult<R, E>> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti,
+        E: ExternalError,
    {
        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
            let args = match A::from_stack_args(nargs, 1, None, rawlua) {
@@ -597,7 +714,7 @@ impl Function {
            };
            let lua = rawlua.lua();
            let fut = func.call(args);
-            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+            Box::pin(async move { fut.await.into_lua_err()?.push_into_stack_multi(lua.raw_lua()) })
        }))
    }

@@ -611,6 +728,7 @@ impl Function {
    pub fn wrap_raw_async<F, A>(func: F) -> impl IntoLua
    where
        F: LuaNativeAsyncFn<A> + MaybeSend + 'static,
+        F::Output: IntoLuaMulti,
        A: FromLuaMulti,
    {
        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
@@ -644,6 +762,120 @@ impl LuaType for Function {
    const TYPE_ID: c_int = ffi::LUA_TFUNCTION;
 }

+/// Future for asynchronous function calls.
+#[cfg(feature = "async")]
+#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+#[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>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+        match &mut this.0 {
+            Ok(thread) => pin!(thread).poll(cx),
+            Err(err) => Poll::Ready(Err(err.clone())),
+        }
+    }
+}
+
+/// A trait for types that can be used as Lua functions.
+pub trait LuaNativeFn<A: FromLuaMulti> {
+    type Output;
+
+    fn call(&self, args: A) -> Self::Output;
+}
+
+/// A trait for types with mutable state that can be used as Lua functions.
+pub trait LuaNativeFnMut<A: FromLuaMulti> {
+    type Output;
+
+    fn call(&mut self, args: A) -> Self::Output;
+}
+
+/// A trait for types that returns a future and can be used as Lua functions.
+#[cfg(feature = "async")]
+pub trait LuaNativeAsyncFn<A: FromLuaMulti> {
+    type Output;
+
+    fn call(&self, args: A) -> impl Future<Output = Self::Output> + MaybeSend + 'static;
+}
+
+macro_rules! impl_lua_native_fn {
+    ($($A:ident),*) => {
+        impl<FN, $($A,)* R> LuaNativeFn<($($A,)*)> for FN
+        where
+            FN: Fn($($A,)*) -> R + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&self, args: ($($A,)*)) -> Self::Output {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+
+        impl<FN, $($A,)* R> LuaNativeFnMut<($($A,)*)> for FN
+        where
+            FN: FnMut($($A,)*) -> R + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&mut self, args: ($($A,)*)) -> Self::Output {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+
+        #[cfg(feature = "async")]
+        impl<FN, $($A,)* Fut, R> LuaNativeAsyncFn<($($A,)*)> for FN
+        where
+            FN: Fn($($A,)*) -> Fut + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+            Fut: Future<Output = R> + MaybeSend + 'static,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&self, args: ($($A,)*)) -> impl Future<Output = Self::Output> + MaybeSend + 'static {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+    };
+}
+
+impl_lua_native_fn!();
+impl_lua_native_fn!(A);
+impl_lua_native_fn!(A, B);
+impl_lua_native_fn!(A, B, C);
+impl_lua_native_fn!(A, B, C, D);
+impl_lua_native_fn!(A, B, C, D, E);
+impl_lua_native_fn!(A, B, C, D, E, F);
+impl_lua_native_fn!(A, B, C, D, E, F, G);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+
 #[cfg(test)]
 mod assertions {
    use super::*;
@@ -652,4 +884,7 @@ mod assertions {
    static_assertions::assert_not_impl_any!(Function: Send);
    #[cfg(feature = "send")]
    static_assertions::assert_impl_all!(Function: Send, Sync);
+
+    #[cfg(all(feature = "async", feature = "send"))]
+    static_assertions::assert_impl_all!(AsyncCallFuture<()>: Send);
 }
@@ -35,7 +35,7 @@
 //! The [`Value`] enum and other types implement [`serde::Serialize`] trait to support serializing
 //! Lua values into Rust values.
 //!
-//! Requires `feature = "serialize"`.
+//! Requires `feature = "serde"`.
 //!
 //! # Async/await support
 //!
@@ -61,83 +61,111 @@
 //! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
+//! [`AsyncThread`]: crate::thread::AsyncThread

 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(not(send), allow(clippy::arc_with_non_send_sync))]
+#![allow(unsafe_op_in_unsafe_fn)]

 #[macro_use]
 mod macros;

 mod buffer;
-mod chunk;
 mod conversion;
-mod error;
-mod function;
-mod hook;
-#[cfg(feature = "luau")]
-mod luau;
 mod memory;
 mod multi;
 mod scope;
-mod state;
 mod stdlib;
-mod string;
-mod table;
-mod thread;
 mod traits;
 mod types;
-mod userdata;
 mod util;
 mod value;
 mod vector;

+pub mod chunk;
+pub mod debug;
+pub mod error;
+pub mod function;
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub mod luau;
 pub mod prelude;
+pub mod state;
+pub mod string;
+pub mod table;
+pub mod thread;
+pub mod userdata;

 pub use bstr::BString;
 pub use ffi::{self, lua_CFunction, lua_State};
+#[cfg(feature = "macros")]
+#[doc(hidden)]
+pub use inventory as __inventory;

-pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
-pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
-pub use crate::function::{Function, FunctionInfo};
-pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
+#[doc(inline)]
+pub use crate::error::{Error, Result};
+#[doc(inline)]
+pub use crate::function::Function;
 pub use crate::multi::{MultiValue, Variadic};
 pub use crate::scope::Scope;
-pub use crate::state::{GCMode, Lua, LuaOptions};
+#[doc(inline)]
+pub use crate::state::{Lua, LuaOptions, WeakLua};
 pub use crate::stdlib::StdLib;
-pub use crate::string::{BorrowedBytes, BorrowedStr, String};
-pub use crate::table::{Table, TablePairs, TableSequence};
-pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::traits::{
-    FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut, ObjectLike,
-};
+#[doc(inline)]
+pub use crate::string::{BorrowedBytes, BorrowedStr, LuaString};
+#[doc(inline)]
+pub use crate::table::Table;
+#[doc(inline)]
+pub use crate::thread::Thread;
+#[doc(inline)]
+pub use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, ObjectLike};
 pub use crate::types::{
-    AppDataRef, AppDataRefMut, Either, Integer, LightUserData, MaybeSend, Number, RegistryKey, VmState,
-};
-pub use crate::userdata::{
-    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods, UserDataRef,
-    UserDataRefMut, UserDataRegistry,
+    AppDataRef, AppDataRefMut, Either, Integer, LightUserData, MaybeSend, MaybeSync, Number, RegistryKey,
+    VmState,
 };
+#[doc(inline)]
+pub use crate::userdata::AnyUserData;
 pub use crate::value::{Nil, Value};

+// Re-export some types to keep backward compatibility and avoid breaking changes in the public API.
+#[doc(hidden)]
+pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
+#[cfg(feature = "luau")]
+#[doc(hidden)]
+pub use crate::chunk::{CompileConstant, Compiler};
+#[doc(hidden)]
+pub use crate::error::{ErrorContext, ExternalError, ExternalResult};
+#[doc(hidden)]
+pub use crate::string::LuaString as String;
+#[doc(hidden)]
+pub use crate::table::{TablePairs, TableSequence};
+#[doc(hidden)]
+pub use crate::thread::{ThreadEvent, ThreadStatus, ThreadTriggers};
+#[doc(hidden)]
+pub use crate::userdata::{
+    MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods, UserDataOwned, UserDataRef,
+    UserDataRefMut, UserDataRegistry,
+};
+
 #[cfg(not(feature = "luau"))]
-pub use crate::hook::HookTriggers;
+#[doc(inline)]
+pub use crate::debug::HookTriggers;

 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub use crate::{buffer::Buffer, chunk::Compiler, function::CoverageInfo, vector::Vector};
+pub use crate::{buffer::Buffer, vector::Vector};

-#[cfg(feature = "async")]
-#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-pub use crate::{thread::AsyncThread, traits::LuaNativeAsyncFn};
-
-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+pub use crate::serde::{DeserializeOptions, SerializeOptions};
+#[cfg(feature = "serde")]
 #[doc(inline)]
-pub use crate::serde::{de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt};
+pub use crate::{serde::LuaSerdeExt, value::SerializableValue};

-#[cfg(feature = "serialize")]
-#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 pub mod serde;

 #[cfg(feature = "mlua_derive")]
@@ -145,54 +173,7 @@ pub mod serde;
 #[macro_use]
 extern crate mlua_derive;

-/// Create a type that implements [`AsChunk`] and can capture Rust variables.
-///
-/// This macro allows to write Lua code directly in Rust code.
-///
-/// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User's Rust types needs to implement [`UserData`] or [`IntoLua`] traits.
-///
-/// Captured variables are **moved** into the chunk.
-///
-/// ```
-/// use mlua::{Lua, Result, chunk};
-///
-/// fn main() -> Result<()> {
-///     let lua = Lua::new();
-///     let name = "Rustacean";
-///     lua.load(chunk! {
-///         print("hello, " .. $name)
-///     }).exec()
-/// }
-/// ```
-///
-/// ## Syntax issues
-///
-/// Since the Rust tokenizer will tokenize Lua code, this imposes some restrictions.
-/// The main thing to remember is:
-///
-/// - Use double quoted strings (`""`) instead of single quoted strings (`''`).
-///
-///   (Single quoted strings only work if they contain a single character, since in Rust,
-///   `'a'` is a character literal).
-///
-/// - Using Lua comments `--` is not desirable in **stable** Rust and can have bad side effects.
-///
-///   This is because procedural macros have Line/Column information available only in
-///   **nightly** Rust. Instead, Lua chunks represented as a big single line of code in stable Rust.
-///
-///   As workaround, Rust comments `//` can be used.
-///
-/// Other minor limitations:
-///
-/// - Certain escape codes in string literals don't work. (Specifically: `\a`, `\b`, `\f`, `\v`,
-///   `\123` (octal escape codes), `\u`, and `\U`).
-///
-///   These are accepted: : `\\`, `\n`, `\t`, `\r`, `\xAB` (hex escape codes), and `\0`.
-///
-/// - The `//` (floor division) operator is unusable, as its start a comment.
-///
-/// Everything else should work.
+#[doc = include_str!("../docs/chunk.md")]
 #[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
@@ -205,48 +186,18 @@ pub use mlua_derive::chunk;
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::FromLua;

-/// Registers Lua module entrypoint.
-///
-/// You can register multiple entrypoints as required.
-///
-/// ```
-/// use mlua::{Lua, Result, Table};
-///
-/// #[mlua::lua_module]
-/// fn my_module(lua: &Lua) -> Result<Table> {
-///     let exports = lua.create_table()?;
-///     exports.set("hello", "world")?;
-///     Ok(exports)
-/// }
-/// ```
-///
-/// Internally in the code above the compiler defines C function `luaopen_my_module`.
-///
-/// You can also pass options to the attribute:
-///
-/// * name - name of the module, defaults to the name of the function
-///
-/// ```ignore
-/// #[mlua::lua_module(name = "alt_module")]
-/// fn my_module(lua: &Lua) -> Result<Table> {
-///     ...
-/// }
-/// ```
-///
-/// * skip_memory_check - skip memory allocation checks for some operations.
-///
-/// In module mode, mlua runs in unknown environment and cannot say are there any memory
-/// limits or not. As result, some operations that require memory allocation runs in
-/// protected mode. Setting this attribute will improve performance of such operations
-/// with risk of having uncaught exceptions and memory leaks.
-///
-/// ```ignore
-/// #[mlua::lua_module(skip_memory_check)]
-/// fn my_module(lua: &Lua) -> Result<Table> {
-///     ...
-/// }
-/// ```
-#[cfg(any(feature = "module", docsrs))]
+#[doc = include_str!("../docs/UserData.md")]
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+pub use mlua_derive::UserData;
+
+#[doc(hidden)]
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+pub use mlua_derive::userdata_impl;
+
+#[doc = include_str!("../docs/lua_module.md")]
+#[cfg(all(feature = "mlua_derive", any(feature = "module", doc)))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;

@@ -0,0 +1,178 @@
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::mem;
+use std::os::raw::c_char;
+
+use crate::state::ExtraData;
+
+use super::json::{self, Json};
+
+/// Represents a heap dump of a Luau memory state.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub struct HeapDump {
+    data: Json<'static>, // refers to the contents of `buf`
+    buf: Box<str>,
+}
+
+impl HeapDump {
+    /// Dumps the current Lua heap state.
+    pub(crate) unsafe fn new(state: *mut ffi::lua_State) -> Option<Self> {
+        unsafe extern "C" fn category_name(state: *mut ffi::lua_State, cat: u8) -> *const c_char {
+            (&*ExtraData::get(state))
+                .mem_categories
+                .get(cat as usize)
+                .map(|s| s.as_ptr())
+                .unwrap_or(cstr!("unknown"))
+        }
+
+        let mut buf = Vec::new();
+        unsafe {
+            let file = libc::tmpfile();
+            if file.is_null() {
+                return None;
+            }
+            ffi::lua_gcdump(state, file as *mut _, Some(category_name));
+            libc::fseek(file, 0, libc::SEEK_END);
+            let len = libc::ftell(file) as usize;
+            libc::rewind(file);
+            if len > 0 {
+                buf.reserve(len);
+                libc::fread(buf.as_mut_ptr() as *mut _, 1, len, file);
+                buf.set_len(len);
+            }
+            libc::fclose(file);
+        }
+
+        let buf = String::from_utf8(buf).ok()?.into_boxed_str();
+        let data = json::parse(unsafe { mem::transmute::<&str, &'static str>(&buf) }).ok()?;
+        Some(HeapDump { data, buf })
+    }
+
+    /// Returns the raw JSON representation of the heap dump.
+    ///
+    /// The JSON structure is an internal detail and may change in future versions.
+    #[doc(hidden)]
+    pub fn to_json(&self) -> &str {
+        &self.buf
+    }
+
+    /// Returns the total size of the Lua heap in bytes.
+    pub fn size(&self) -> u64 {
+        self.data["stats"]["size"].as_u64().unwrap_or_default()
+    }
+
+    /// Returns a mapping from object type to (count, total size in bytes).
+    ///
+    /// If `category` is provided, only objects in that category are considered.
+    pub fn size_by_type<'a>(&'a self, category: Option<&str>) -> HashMap<&'a str, (usize, u64)> {
+        self.size_by_type_inner(category).unwrap_or_default()
+    }
+
+    fn size_by_type_inner<'a>(&'a self, category: Option<&str>) -> Option<HashMap<&'a str, (usize, u64)>> {
+        let category_id = match category {
+            // If we cannot find the category, return empty result
+            Some(cat) => Some(self.find_category_id(cat)?),
+            None => None,
+        };
+
+        let mut size_by_type = HashMap::new();
+        let objects = self.data["objects"].as_object()?;
+        for obj in objects.values() {
+            if let Some(cat_id) = category_id
+                && obj["cat"].as_i64()? != cat_id
+            {
+                continue;
+            }
+            update_size(&mut size_by_type, obj["type"].as_str()?, obj["size"].as_u64()?);
+        }
+        Some(size_by_type)
+    }
+
+    /// Returns a mapping from category name to total size in bytes.
+    pub fn size_by_category(&self) -> HashMap<&str, u64> {
+        let mut size_by_category = HashMap::new();
+        if let Some(categories) = self.data["stats"]["categories"].as_object() {
+            for cat in categories.values() {
+                if let Some(cat_name) = cat["name"].as_str() {
+                    size_by_category.insert(cat_name, cat["size"].as_u64().unwrap_or_default());
+                }
+            }
+        }
+        size_by_category
+    }
+
+    /// Returns a mapping from userdata type to (count, total size in bytes).
+    pub fn size_by_userdata<'a>(&'a self, category: Option<&str>) -> HashMap<&'a str, (usize, u64)> {
+        self.size_by_userdata_inner(category).unwrap_or_default()
+    }
+
+    fn size_by_userdata_inner<'a>(
+        &'a self,
+        category: Option<&str>,
+    ) -> Option<HashMap<&'a str, (usize, u64)>> {
+        let category_id = match category {
+            // If we cannot find the category, return empty result
+            Some(cat) => Some(self.find_category_id(cat)?),
+            None => None,
+        };
+
+        let mut size_by_userdata = HashMap::new();
+        let objects = self.data["objects"].as_object()?;
+        for obj in objects.values() {
+            if obj["type"] != "userdata" {
+                continue;
+            }
+            if let Some(cat_id) = category_id
+                && obj["cat"].as_i64()? != cat_id
+            {
+                continue;
+            }
+
+            // Determine userdata type from metatable
+            let mut ud_type = "unknown";
+            if let Some(metatable_addr) = obj["metatable"].as_str()
+                && let Some(t) = get_key(objects, &objects[metatable_addr], "__type")
+            {
+                ud_type = t;
+            }
+            update_size(&mut size_by_userdata, ud_type, obj["size"].as_u64()?);
+        }
+        Some(size_by_userdata)
+    }
+
+    /// Finds the category ID for a given category name.
+    fn find_category_id(&self, category: &str) -> Option<i64> {
+        let categories = self.data["stats"]["categories"].as_object()?;
+        for (cat_id, cat) in categories {
+            if cat["name"].as_str() == Some(category) {
+                return cat_id.parse().ok();
+            }
+        }
+        None
+    }
+}
+
+/// Updates the size mapping for a given key.
+fn update_size<K: Eq + Hash>(size_type: &mut HashMap<K, (usize, u64)>, key: K, size: u64) {
+    let (count, total_size) = size_type.entry(key).or_insert((0, 0));
+    *count += 1;
+    *total_size += size;
+}
+
+/// Retrieves the value associated with a given `key` from a Lua table `tbl`.
+fn get_key<'a>(objects: &'a HashMap<&'a str, Json>, tbl: &Json, key: &str) -> Option<&'a str> {
+    let pairs = tbl["pairs"].as_array()?;
+    for kv in pairs.chunks_exact(2) {
+        #[rustfmt::skip]
+        let (Some(key_addr), Some(val_addr)) = (kv[0].as_str(), kv[1].as_str()) else { continue; };
+        if objects[key_addr]["type"] == "string" && objects[key_addr]["data"].as_str() == Some(key) {
+            if objects[val_addr]["type"] == "string" {
+                return objects[val_addr]["data"].as_str();
+            } else {
+                break;
+            }
+        }
+    }
+    None
+}
@@ -0,0 +1,327 @@
+use std::array;
+use std::collections::HashMap;
+use std::iter::Peekable;
+use std::ops::Index;
+use std::str::CharIndices;
+
+// A simple JSON parser and representation.
+// This parser supports only a subset of JSON specification and is intended for Luau's use cases.
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum Json<'a> {
+    Null,
+    Bool(bool),
+    Integer(i64),
+    Number(f64),
+    String(&'a str),
+    Array(Vec<Json<'a>>),
+    Object(HashMap<&'a str, Json<'a>>),
+}
+
+impl<'a> Index<&str> for Json<'a> {
+    type Output = Json<'a>;
+
+    fn index(&self, key: &str) -> &Self::Output {
+        match self {
+            Json::Object(map) => map.get(key).unwrap_or(&Json::Null),
+            _ => &Json::Null,
+        }
+    }
+}
+
+impl PartialEq<&str> for Json<'_> {
+    fn eq(&self, other: &&str) -> bool {
+        matches!(self, Json::String(s) if s == other)
+    }
+}
+
+impl<'a> Json<'a> {
+    pub(crate) fn as_str(&self) -> Option<&'a str> {
+        match self {
+            Json::String(s) => Some(s),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_i64(&self) -> Option<i64> {
+        match self {
+            Json::Integer(i) => Some(*i),
+            Json::Number(n) if n.fract() == 0.0 => Some(*n as i64),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_u64(&self) -> Option<u64> {
+        self.as_i64()
+            .and_then(|i| if i >= 0 { Some(i as u64) } else { None })
+    }
+
+    pub(crate) fn as_array(&self) -> Option<&[Json<'a>]> {
+        match self {
+            Json::Array(arr) => Some(arr),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_object(&self) -> Option<&HashMap<&'a str, Json<'a>>> {
+        match self {
+            Json::Object(map) => Some(map),
+            _ => None,
+        }
+    }
+}
+
+pub(crate) fn parse<'a>(s: &'a str) -> Result<Json<'a>, &'static str> {
+    let s = s.trim_ascii();
+    let mut chars = s.char_indices().peekable();
+    let value = parse_value(s, &mut chars)?;
+    Ok(value)
+}
+
+fn parse_value<'a>(s: &'a str, chars: &mut Peekable<CharIndices>) -> Result<Json<'a>, &'static str> {
+    skip_whitespace(chars);
+    match chars.peek() {
+        Some((_, '{')) => parse_object(s, chars),
+        Some((_, '[')) => parse_array(s, chars),
+        Some((_, '"')) => parse_string(s, chars).map(Json::String),
+        Some((_, 't' | 'f')) => parse_bool(chars),
+        Some((_, 'n')) => parse_null(chars),
+        Some((_, '-' | '0'..='9')) => parse_number(chars),
+        Some(_) => Err("unexpected character"),
+        None => Err("unexpected end of input"),
+    }
+}
+
+fn parse_object<'a>(s: &'a str, chars: &mut Peekable<CharIndices>) -> Result<Json<'a>, &'static str> {
+    chars.next(); // consume '{'
+
+    let mut map = HashMap::new();
+    skip_whitespace(chars);
+    if matches!(chars.peek(), Some((_, '}'))) {
+        chars.next();
+        return Ok(Json::Object(map));
+    }
+    loop {
+        skip_whitespace(chars);
+        let key = parse_string(s, chars)?;
+        skip_whitespace(chars);
+        if !matches!(chars.next(), Some((_, ':'))) {
+            return Err("expected ':'");
+        }
+        let value = parse_value(s, chars)?;
+        map.insert(key, value);
+        skip_whitespace(chars);
+        match chars.next() {
+            Some((_, ',')) => continue,
+            Some((_, '}')) => break,
+            _ => return Err("expected ',' or '}'"),
+        }
+    }
+    Ok(Json::Object(map))
+}
+
+fn parse_array<'a>(s: &'a str, chars: &mut Peekable<CharIndices>) -> Result<Json<'a>, &'static str> {
+    chars.next(); // consume '['
+
+    let mut arr = Vec::new();
+    skip_whitespace(chars);
+    if matches!(chars.peek(), Some((_, ']'))) {
+        chars.next();
+        return Ok(Json::Array(arr));
+    }
+    loop {
+        skip_whitespace(chars);
+        arr.push(parse_value(s, chars)?);
+        skip_whitespace(chars);
+        match chars.next() {
+            Some((_, ',')) => continue,
+            Some((_, ']')) => return Ok(Json::Array(arr)),
+            _ => return Err("expected ',' or ']'"),
+        }
+    }
+}
+
+fn parse_string<'a>(s: &'a str, chars: &mut Peekable<CharIndices>) -> Result<&'a str, &'static str> {
+    if !matches!(chars.next(), Some((_, '"'))) {
+        return Err("expected string starting with '\"'");
+    }
+    let start = chars.peek().map(|(i, _)| *i).unwrap_or(0);
+    for (i, c) in chars {
+        if c == '"' {
+            return Ok(&s[start..i]);
+        }
+    }
+    Err("unterminated string")
+}
+
+fn parse_number(chars: &mut Peekable<CharIndices>) -> Result<Json<'static>, &'static str> {
+    let mut is_float = false;
+    let mut num = String::new();
+    while let Some((_, c @ ('0'..='9' | '-' | '.' | 'e' | 'E' | '+'))) = chars.peek() {
+        num.push(*c);
+        is_float = is_float || matches!(c, '.' | 'e' | 'E');
+        chars.next();
+    }
+    if !is_float {
+        let i = num.parse::<i64>().map_err(|_| "invalid integer")?;
+        return Ok(Json::Integer(i));
+    }
+    let n = num.parse::<f64>().map_err(|_| "invalid number")?;
+    Ok(Json::Number(n))
+}
+
+fn parse_bool(chars: &mut Peekable<CharIndices>) -> Result<Json<'static>, &'static str> {
+    let bool = next_chars(chars);
+    if bool == [Some('t'), Some('r'), Some('u'), Some('e')] {
+        return Ok(Json::Bool(true));
+    }
+    if bool == [Some('f'), Some('a'), Some('l'), Some('s')] && matches!(chars.next(), Some((_, 'e'))) {
+        return Ok(Json::Bool(false));
+    }
+    Err("invalid boolean literal")
+}
+
+fn parse_null(chars: &mut Peekable<CharIndices>) -> Result<Json<'static>, &'static str> {
+    if next_chars(chars) == [Some('n'), Some('u'), Some('l'), Some('l')] {
+        return Ok(Json::Null);
+    }
+    Err("invalid \"null\" literal")
+}
+
+fn skip_whitespace(chars: &mut Peekable<CharIndices>) {
+    while let Some((_, ' ' | '\n' | '\r' | '\t')) = chars.peek() {
+        chars.next();
+    }
+}
+
+fn next_chars<const N: usize>(chars: &mut Peekable<CharIndices>) -> [Option<char>; N] {
+    array::from_fn(|_| chars.next().map(|(_, c)| c))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse() {
+        assert_eq!(parse("null").unwrap(), Json::Null);
+        assert_eq!(parse("true").unwrap(), Json::Bool(true));
+        assert_eq!(parse("false").unwrap(), Json::Bool(false));
+        assert_eq!(parse("42").unwrap(), Json::Integer(42));
+        assert_eq!(parse("42.0").unwrap(), Json::Number(42.0));
+        assert_eq!(parse(r#""hello""#).unwrap(), Json::String("hello"));
+        assert_eq!(
+            parse("[1,2.0,3]").unwrap(),
+            Json::Array(vec![Json::Integer(1), Json::Number(2.0), Json::Integer(3)])
+        );
+        let mut obj = HashMap::new();
+        obj.insert("key", Json::String("value"));
+        assert_eq!(parse(r#"{"key":"value"}"#).unwrap(), Json::Object(obj));
+    }
+
+    #[test]
+    fn test_whitespace_handling() {
+        assert_eq!(parse("  null  ").unwrap(), Json::Null);
+        assert_eq!(parse("  true  ").unwrap(), Json::Bool(true));
+        assert_eq!(
+            parse(" [ 1 , 2.0 , 3 ] ").unwrap(),
+            Json::Array(vec![Json::Integer(1), Json::Number(2.0), Json::Integer(3)])
+        );
+        let mut obj = HashMap::new();
+        obj.insert("key", Json::String("value"));
+        assert_eq!(parse(r#"  { "key" : "value" }  "#).unwrap(), Json::Object(obj));
+    }
+
+    #[test]
+    fn test_empty_collections() {
+        assert_eq!(parse("[]").unwrap(), Json::Array(vec![]));
+        assert_eq!(parse("{}").unwrap(), Json::Object(HashMap::new()));
+        assert_eq!(parse("[ ]").unwrap(), Json::Array(vec![]));
+        assert_eq!(parse("{ }").unwrap(), Json::Object(HashMap::new()));
+    }
+
+    #[test]
+    fn test_nested_structures() {
+        assert_eq!(
+            parse(r#"{"nested":{"inner":"value"}}"#).unwrap(),
+            Json::Object({
+                let mut outer = HashMap::new();
+                let mut inner = HashMap::new();
+                inner.insert("inner", Json::String("value"));
+                outer.insert("nested", Json::Object(inner));
+                outer
+            })
+        );
+        assert_eq!(
+            parse("[[1,2],[3,4]]").unwrap(),
+            Json::Array(vec![
+                Json::Array(vec![Json::Integer(1), Json::Integer(2)]),
+                Json::Array(vec![Json::Integer(3), Json::Integer(4)])
+            ])
+        );
+    }
+
+    #[test]
+    fn test_numbers() {
+        assert_eq!(parse("0").unwrap(), Json::Integer(0));
+        assert_eq!(parse("-42").unwrap(), Json::Integer(-42));
+        assert_eq!(parse("3.14").unwrap(), Json::Number(3.14));
+        assert_eq!(parse("-3.14").unwrap(), Json::Number(-3.14));
+        assert_eq!(parse("1e10").unwrap(), Json::Number(1e10));
+        assert_eq!(parse("1E10").unwrap(), Json::Number(1E10));
+        assert_eq!(parse("1e-10").unwrap(), Json::Number(1e-10));
+        assert_eq!(parse("1.5e+10").unwrap(), Json::Number(1.5e+10));
+    }
+
+    #[test]
+    fn test_strings() {
+        assert_eq!(parse(r#""""#).unwrap(), Json::String(""));
+        assert_eq!(parse(r#""hello world""#).unwrap(), Json::String("hello world"));
+        assert_eq!(
+            parse(r#""with spaces and 123""#).unwrap(),
+            Json::String("with spaces and 123")
+        );
+    }
+
+    #[test]
+    fn test_mixed_array() {
+        assert_eq!(
+            parse(r#"[null, true, false, 35.1, 42, "text", [], {}]"#).unwrap(),
+            Json::Array(vec![
+                Json::Null,
+                Json::Bool(true),
+                Json::Bool(false),
+                Json::Number(35.1),
+                Json::Integer(42),
+                Json::String("text"),
+                Json::Array(vec![]),
+                Json::Object(HashMap::new())
+            ])
+        );
+    }
+
+    #[test]
+    fn test_object_multiple_keys() {
+        let mut obj = HashMap::new();
+        obj.insert("a", Json::Integer(1));
+        obj.insert("b", Json::Bool(true));
+        obj.insert("c", Json::Null);
+        assert_eq!(parse(r#"{"a":1,"b":true,"c":null}"#).unwrap(), Json::Object(obj));
+    }
+
+    #[test]
+    fn test_error_cases() {
+        assert!(parse("").is_err());
+        assert!(parse("nul").is_err());
+        assert!(parse("tru").is_err()); // typos:ignore
+        assert!(parse("fals").is_err()); // typos:ignore
+        assert!(parse(r#""unterminated"#).is_err());
+        assert!(parse("[1,2,]").is_err());
+        assert!(parse(r#"{"key""#).is_err());
+        assert!(parse(r#"{"key":"value""#).is_err());
+        assert!(parse(r#"{"key":"value",}"#).is_err());
+        assert!(parse("invalid").is_err());
+        assert!(parse("[1 2]").is_err());
+        assert!(parse(r#"{"key":"value" "key2":"value2"}"#).is_err());
+    }
+}
@@ -1,16 +1,90 @@
-use std::ffi::CStr;
-use std::os::raw::c_int;
+//! Luau-specific extensions and types.
+//!
+//! This module provides Luau-specific functionality including custom [`require`] implementations,
+//! heap memory analysis, and Luau VM integration utilities.
+//!
+//! [`require`]: crate::Lua::create_require_function

-use crate::error::Result;
-use crate::state::Lua;
+use std::ffi::{CStr, CString};
+use std::os::raw::c_int;
+use std::ptr;
+
+use crate::chunk::ChunkMode;
+use crate::error::{Error, Result};
+use crate::function::Function;
+use crate::state::{ExtraData, Lua, callback_error_ext};
+use crate::traits::{FromLuaMulti, IntoLua};
+use crate::types::MaybeSend;
+
+pub use heap_dump::HeapDump;
+pub use require::{FsRequirer, NavigateError, Require};

 // Since Luau has some missing standard functions, we re-implement them here

 impl Lua {
+    /// Create a custom Luau `require` function using provided [`Require`] implementation to find
+    /// and load modules.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn create_require_function<R: Require + MaybeSend + 'static>(&self, require: R) -> Result<Function> {
+        require::create_require_function(self, require)
+    }
+
+    /// Set the memory category for subsequent allocations from this Lua state.
+    ///
+    /// The category "main" is reserved for the default memory category.
+    /// Maximum of 255 categories can be registered.
+    /// The category is set per Lua thread (state) and affects all allocations made from that
+    /// thread.
+    ///
+    /// Return error if too many categories are registered or if the category name is invalid.
+    ///
+    /// See [`Lua::heap_dump`] for tracking memory usage by category.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_memory_category(&self, category: &str) -> Result<()> {
+        let lua = self.lock();
+
+        if category.contains(|c| !matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_')) {
+            return Err(Error::runtime("invalid memory category name"));
+        }
+        let cat_id = unsafe {
+            let extra = ExtraData::get(lua.state());
+            match ((*extra).mem_categories.iter().enumerate())
+                .find(|&(_, name)| name.as_bytes() == category.as_bytes())
+            {
+                Some((id, _)) => id as u8,
+                None => {
+                    let new_id = (*extra).mem_categories.len() as u8;
+                    if new_id == 255 {
+                        return Err(Error::runtime("too many memory categories registered"));
+                    }
+                    (*extra).mem_categories.push(CString::new(category).unwrap());
+                    new_id
+                }
+            }
+        };
+        unsafe { ffi::lua_setmemcat(lua.state(), cat_id as i32) };
+
+        Ok(())
+    }
+
+    /// Dumps the current Lua VM heap state.
+    ///
+    /// The returned `HeapDump` can be used to analyze memory usage.
+    /// It's recommended to call [`Lua::gc_collect`] before dumping the heap.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn heap_dump(&self) -> Result<HeapDump> {
+        let lua = self.lock();
+        unsafe { heap_dump::HeapDump::new(lua.state()).ok_or_else(|| Error::runtime("unable to dump heap")) }
+    }
+
    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
        let globals = self.globals();

        globals.raw_set("collectgarbage", self.create_c_function(lua_collectgarbage)?)?;
+        globals.raw_set("loadstring", self.create_c_function(lua_loadstring)?)?;

        // Set `_VERSION` global to include version number
        // The environment variable `LUAU_VERSION` set by the build script
@@ -18,11 +92,10 @@ impl Lua {
            globals.raw_set("_VERSION", format!("Luau {version}"))?;
        }

-        Ok(())
-    }
+        // Enable default `require` implementation
+        let require = self.create_require_function(FsRequirer::new())?;
+        self.globals().raw_set("require", require)?;

-    pub(crate) fn disable_c_modules(&self) -> Result<()> {
-        package::disable_dylibs(self);
        Ok(())
    }
 }
@@ -31,16 +104,17 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
    let option = CStr::from_ptr(option);
    let arg = ffi::luaL_optinteger(state, 2, 0);
+    let is_sandboxed = (*ExtraData::get(state)).sandboxed;
    match option.to_str() {
-        Ok("collect") => {
+        Ok("collect") if !is_sandboxed => {
            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
            0
        }
-        Ok("stop") => {
+        Ok("stop") if !is_sandboxed => {
            ffi::lua_gc(state, ffi::LUA_GCSTOP, 0);
            0
        }
-        Ok("restart") => {
+        Ok("restart") if !is_sandboxed => {
            ffi::lua_gc(state, ffi::LUA_GCRESTART, 0);
            0
        }
@@ -50,12 +124,12 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
            ffi::lua_pushnumber(state, kbytes + kbytes_rem / 1024.0);
            1
        }
-        Ok("step") => {
-            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg);
+        Ok("step") if !is_sandboxed => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg as _);
            ffi::lua_pushboolean(state, res);
            1
        }
-        Ok("isrunning") => {
+        Ok("isrunning") if !is_sandboxed => {
            let res = ffi::lua_gc(state, ffi::LUA_GCISRUNNING, 0);
            ffi::lua_pushboolean(state, res);
            1
@@ -64,6 +138,22 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
    }
 }

-pub(crate) use package::register_package_module;
+unsafe extern "C-unwind" fn lua_loadstring(state: *mut ffi::lua_State) -> c_int {
+    callback_error_ext(state, ptr::null_mut(), false, move |extra, nargs| {
+        let rawlua = (*extra).raw_lua();
+        let (chunk, chunk_name) =
+            <(String, Option<String>)>::from_stack_args(nargs, 1, Some("loadstring"), rawlua)?;
+        let chunk_name = chunk_name.as_deref().unwrap_or("=(loadstring)");
+        (rawlua.lua())
+            .load(chunk)
+            .set_name(chunk_name)
+            .set_mode(ChunkMode::Text)
+            .into_function()?
+            .push_into_stack(rawlua)?;
+        Ok(1)
+    })
+}

-mod package;
+mod heap_dump;
+mod json;
+mod require;
@@ -1,271 +0,0 @@
-use std::ffi::CStr;
-use std::fmt::Write;
-use std::os::raw::c_int;
-use std::path::{PathBuf, MAIN_SEPARATOR_STR};
-use std::string::String as StdString;
-use std::{env, fs};
-
-use crate::chunk::ChunkMode;
-use crate::error::Result;
-use crate::state::Lua;
-use crate::table::Table;
-use crate::traits::IntoLua;
-use crate::value::Value;
-
-#[cfg(unix)]
-use {libloading::Library, rustc_hash::FxHashMap};
-
-//
-// Luau package module
-//
-
-#[cfg(unix)]
-const TARGET_MLUA_LUAU_ABI_VERSION: u32 = 2;
-
-#[cfg(all(unix, feature = "module"))]
-#[no_mangle]
-#[used]
-pub static MLUA_LUAU_ABI_VERSION: u32 = TARGET_MLUA_LUAU_ABI_VERSION;
-
-// We keep reference to the loaded dylibs in application data
-#[cfg(unix)]
-struct LoadedDylibs(FxHashMap<PathBuf, Library>);
-
-#[cfg(unix)]
-impl std::ops::Deref for LoadedDylibs {
-    type Target = FxHashMap<PathBuf, Library>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[cfg(unix)]
-impl std::ops::DerefMut for LoadedDylibs {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-pub(crate) fn register_package_module(lua: &Lua) -> Result<()> {
-    // Create the package table
-    let package = lua.create_table()?;
-
-    // Set `package.path`
-    let mut search_path = env::var("LUAU_PATH")
-        .or_else(|_| env::var("LUA_PATH"))
-        .unwrap_or_default();
-    if search_path.is_empty() {
-        search_path = "?.luau;?.lua".to_string();
-    }
-    package.raw_set("path", search_path)?;
-
-    // Set `package.cpath`
-    #[cfg(unix)]
-    {
-        let mut search_cpath = env::var("LUAU_CPATH")
-            .or_else(|_| env::var("LUA_CPATH"))
-            .unwrap_or_default();
-        if search_cpath.is_empty() {
-            if cfg!(any(target_os = "macos", target_os = "ios")) {
-                search_cpath = "?.dylib".to_string();
-            } else {
-                search_cpath = "?.so".to_string();
-            }
-        }
-        package.raw_set("cpath", search_cpath)?;
-    }
-
-    // Set `package.loaded` (table with a list of loaded modules)
-    let loaded = if let Ok(Some(loaded)) = lua.named_registry_value::<Option<Table>>("_LOADED") {
-        package.raw_set("loaded", &loaded)?;
-        loaded
-    } else {
-        let loaded = lua.create_table()?;
-        package.raw_set("loaded", &loaded)?;
-        lua.set_named_registry_value("_LOADED", &loaded)?;
-        loaded
-    };
-
-    // Set `package.loaders`
-    let loaders = lua.create_sequence_from([lua.create_function(lua_loader)?])?;
-    package.raw_set("loaders", &loaders)?;
-    #[cfg(unix)]
-    {
-        loaders.push(lua.create_function(dylib_loader)?)?;
-        lua.set_app_data(LoadedDylibs(FxHashMap::default()));
-    }
-    lua.set_named_registry_value("_LOADERS", loaders)?;
-
-    // Register the module and `require` function in globals
-    let globals = lua.globals();
-    globals.raw_set("package", &package)?;
-    loaded.raw_set("package", package)?;
-    globals.raw_set("require", unsafe { lua.create_c_function(lua_require)? })?;
-
-    Ok(())
-}
-
-#[allow(unused_variables)]
-pub(crate) fn disable_dylibs(lua: &Lua) {
-    // Presence of `LoadedDylibs` in app data is used as a flag
-    // to check whether binary modules are enabled
-    #[cfg(unix)]
-    lua.remove_app_data::<LoadedDylibs>();
-}
-
-unsafe extern "C-unwind" fn lua_require(state: *mut ffi::lua_State) -> c_int {
-    ffi::lua_settop(state, 1);
-    let name = ffi::luaL_checkstring(state, 1);
-    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED")); // _LOADED is at index 2
-    if ffi::lua_rawgetfield(state, 2, name) != ffi::LUA_TNIL {
-        return 1; // module is already loaded
-    }
-    ffi::lua_pop(state, 1); // remove nil
-
-    // load the module
-    let err_buf = ffi::lua_newuserdata_t::<StdString>(state);
-    err_buf.write(StdString::new());
-    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADERS")); // _LOADERS is at index 3
-    for i in 1.. {
-        if ffi::lua_rawgeti(state, -1, i) == ffi::LUA_TNIL {
-            // no more loaders?
-            if (*err_buf).is_empty() {
-                ffi::luaL_error(state, cstr!("module '%s' not found"), name);
-            } else {
-                let bytes = (*err_buf).as_bytes();
-                let extra = ffi::lua_pushlstring(state, bytes.as_ptr() as *const _, bytes.len());
-                ffi::luaL_error(state, cstr!("module '%s' not found:%s"), name, extra);
-            }
-        }
-        ffi::lua_pushvalue(state, 1); // name arg
-        ffi::lua_call(state, 1, 2); // call loader
-        match ffi::lua_type(state, -2) {
-            ffi::LUA_TFUNCTION => break, // loader found
-            ffi::LUA_TSTRING => {
-                // error message
-                let msg = ffi::lua_tostring(state, -2);
-                let msg = CStr::from_ptr(msg).to_string_lossy();
-                _ = write!(&mut *err_buf, "\n\t{msg}");
-            }
-            _ => {}
-        }
-        ffi::lua_pop(state, 2); // remove both results
-    }
-    ffi::lua_pushvalue(state, 1); // name is 1st argument to module loader
-    ffi::lua_rotate(state, -2, 1); // loader data <-> name
-
-    // stack: ...; loader function; module name; loader data
-    ffi::lua_call(state, 2, 1);
-    // stack: ...; result from loader function
-    if ffi::lua_isnil(state, -1) != 0 {
-        ffi::lua_pop(state, 1);
-        ffi::lua_pushboolean(state, 1); // use true as result
-    }
-    ffi::lua_pushvalue(state, -1); // make copy of entrypoint result
-    ffi::lua_setfield(state, 2, name); /* _LOADED[name] = returned value */
-    1
-}
-
-/// Searches for the given `name` in the given `path`.
-///
-/// `path` is a string containing a sequence of templates separated by semicolons.
-fn package_searchpath(name: &str, search_path: &str, try_prefix: bool) -> Option<PathBuf> {
-    let mut names = vec![name.replace('.', MAIN_SEPARATOR_STR)];
-    if try_prefix && name.contains('.') {
-        let prefix = name.split_once('.').map(|(prefix, _)| prefix).unwrap();
-        names.push(prefix.to_string());
-    }
-    for path in search_path.split(';') {
-        for name in &names {
-            let file_path = PathBuf::from(path.replace('?', name));
-            if let Ok(true) = fs::metadata(&file_path).map(|m| m.is_file()) {
-                return Some(file_path);
-            }
-        }
-    }
-    None
-}
-
-//
-// Module loaders
-//
-
-/// Tries to load a lua (text) file
-fn lua_loader(lua: &Lua, modname: StdString) -> Result<Value> {
-    let package = {
-        let loaded = lua.named_registry_value::<Table>("_LOADED")?;
-        loaded.raw_get::<Table>("package")
-    }?;
-    let search_path = package.get::<StdString>("path").unwrap_or_default();
-
-    if let Some(file_path) = package_searchpath(&modname, &search_path, false) {
-        match fs::read(&file_path) {
-            Ok(buf) => {
-                return lua
-                    .load(buf)
-                    .set_name(format!("={}", file_path.display()))
-                    .set_mode(ChunkMode::Text)
-                    .into_function()
-                    .map(Value::Function);
-            }
-            Err(err) => {
-                return format!("cannot open '{}': {err}", file_path.display()).into_lua(lua);
-            }
-        }
-    }
-
-    Ok(Value::Nil)
-}
-
-/// Tries to load a dynamic library
-#[cfg(unix)]
-fn dylib_loader(lua: &Lua, modname: StdString) -> Result<Value> {
-    let package = {
-        let loaded = lua.named_registry_value::<Table>("_LOADED")?;
-        loaded.raw_get::<Table>("package")
-    }?;
-    let search_cpath = package.get::<StdString>("cpath").unwrap_or_default();
-
-    let find_symbol = |lib: &Library| unsafe {
-        if let Ok(entry) = lib.get::<ffi::lua_CFunction>(format!("luaopen_{modname}\0").as_bytes()) {
-            return lua.create_c_function(*entry).map(Value::Function);
-        }
-        // Try all in one mode
-        if let Ok(entry) =
-            lib.get::<ffi::lua_CFunction>(format!("luaopen_{}\0", modname.replace('.', "_")).as_bytes())
-        {
-            return lua.create_c_function(*entry).map(Value::Function);
-        }
-        "cannot find module entrypoint".into_lua(lua)
-    };
-
-    if let Some(file_path) = package_searchpath(&modname, &search_cpath, true) {
-        let file_path = file_path.canonicalize()?;
-        // Load the library and check for symbol
-        unsafe {
-            let mut loaded_dylibs = match lua.app_data_mut::<LoadedDylibs>() {
-                Some(loaded_dylibs) => loaded_dylibs,
-                None => return "dynamic libraries are disabled in safe mode".into_lua(lua),
-            };
-            // Check if it's already loaded
-            if let Some(lib) = loaded_dylibs.get(&file_path) {
-                return find_symbol(lib);
-            }
-            if let Ok(lib) = Library::new(&file_path) {
-                // Check version
-                let mod_version = lib.get::<*const u32>(b"MLUA_LUAU_ABI_VERSION");
-                let mod_version = mod_version.map(|v| **v).unwrap_or_default();
-                if mod_version != TARGET_MLUA_LUAU_ABI_VERSION {
-                    let err = format!("wrong module ABI version (expected {TARGET_MLUA_LUAU_ABI_VERSION}, got {mod_version})");
-                    return err.into_lua(lua);
-                }
-                let symbol = find_symbol(&lib);
-                loaded_dylibs.insert(file_path, lib);
-                return symbol;
-            }
-        }
-    }
-
-    Ok(Value::Nil)
-}
@@ -0,0 +1,512 @@
+use std::cell::RefCell;
+use std::ffi::CStr;
+use std::io::Result as IoResult;
+use std::ops::{Deref, DerefMut};
+use std::os::raw::{c_char, c_int, c_void};
+use std::result::Result as StdResult;
+use std::{fmt, mem, ptr};
+
+use crate::error::{Error, Result};
+use crate::function::Function;
+use crate::state::{Lua, callback_error_ext};
+use crate::table::Table;
+use crate::types::MaybeSend;
+
+pub use fs::FsRequirer;
+
+/// An error that can occur during navigation in the Luau `require-by-string` system.
+#[derive(Debug, Clone)]
+pub enum NavigateError {
+    Ambiguous,
+    NotFound,
+    Other(Error),
+}
+
+#[cfg(feature = "luau")]
+trait IntoNavigateResult {
+    fn into_nav_result(self) -> Result<ffi::luarequire_NavigateResult>;
+}
+
+#[cfg(feature = "luau")]
+impl IntoNavigateResult for StdResult<(), NavigateError> {
+    fn into_nav_result(self) -> Result<ffi::luarequire_NavigateResult> {
+        match self {
+            Ok(()) => Ok(ffi::luarequire_NavigateResult::Success),
+            Err(NavigateError::Ambiguous) => Ok(ffi::luarequire_NavigateResult::Ambiguous),
+            Err(NavigateError::NotFound) => Ok(ffi::luarequire_NavigateResult::NotFound),
+            Err(NavigateError::Other(err)) => Err(err),
+        }
+    }
+}
+
+impl From<Error> for NavigateError {
+    fn from(err: Error) -> Self {
+        NavigateError::Other(err)
+    }
+}
+
+#[cfg(feature = "luau")]
+type WriteResult = ffi::luarequire_WriteResult;
+
+#[cfg(feature = "luau")]
+type ConfigStatus = ffi::luarequire_ConfigStatus;
+
+/// A trait for handling modules loading and navigation in the Luau `require-by-string` system.
+pub trait Require {
+    /// Returns `true` if "require" is permitted for the given chunk name.
+    fn is_require_allowed(&self, chunk_name: &str) -> bool;
+
+    /// Resets the internal state to point at the requirer module.
+    fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError>;
+
+    /// Resets the internal state to point at an aliased module.
+    ///
+    /// This function received an exact path from a configuration file.
+    /// It's only called when an alias's path cannot be resolved relative to its
+    /// configuration file.
+    fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError>;
+
+    /// Provides an initial alias override opportunity prior to searching for
+    /// configuration files.
+    ///
+    /// If `Ok(())` is returned, alias resolution stops here and the internal state
+    /// must point at the aliased location.
+    fn to_alias_override(&mut self, _alias: &str) -> StdResult<(), NavigateError> {
+        Err(NavigateError::NotFound)
+    }
+
+    /// Provides a final opportunity to resolve an alias if it cannot be found in
+    /// configuration files.
+    ///
+    /// If `Ok(())` is returned, alias resolution stops here and the internal state
+    /// must point at the aliased location.
+    fn to_alias_fallback(&mut self, _alias: &str) -> StdResult<(), NavigateError> {
+        Err(NavigateError::NotFound)
+    }
+
+    // Navigate to parent directory
+    fn to_parent(&mut self) -> StdResult<(), NavigateError>;
+
+    /// Navigate to the given child directory.
+    fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError>;
+
+    /// Returns whether the context is currently pointing at a module.
+    fn has_module(&self) -> bool;
+
+    /// Provides a cache key representing the current module.
+    ///
+    /// This function is only called if `has_module` returns true.
+    fn cache_key(&self) -> String;
+
+    /// Returns whether a configuration is present in the current context.
+    fn has_config(&self) -> bool;
+
+    /// Returns the contents of the configuration file in the current context.
+    ///
+    /// This function is only called if `has_config` returns true.
+    fn config(&self) -> IoResult<Vec<u8>>;
+
+    /// Returns a loader function for the current module, that when called, loads the module
+    /// and returns the result.
+    ///
+    /// Loader can be sync or async.
+    /// This function is only called if `has_module` returns true.
+    fn loader(&self, lua: &Lua) -> Result<Function>;
+}
+
+impl fmt::Debug for dyn Require {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<dyn Require>")
+    }
+}
+
+struct Context {
+    require: Box<dyn Require>,
+    config_cache: Option<IoResult<Vec<u8>>>,
+}
+
+impl Deref for Context {
+    type Target = dyn Require;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.require
+    }
+}
+
+impl DerefMut for Context {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.require
+    }
+}
+
+impl Context {
+    fn new(require: impl Require + MaybeSend + 'static) -> Self {
+        Context {
+            require: Box::new(require),
+            config_cache: None,
+        }
+    }
+}
+
+macro_rules! try_borrow {
+    ($state:expr, $ctx:expr) => {
+        match (*($ctx as *const RefCell<Context>)).try_borrow() {
+            Ok(ctx) => ctx,
+            Err(_) => ffi::luaL_error($state, cstr!("require context is already borrowed")),
+        }
+    };
+}
+
+macro_rules! try_borrow_mut {
+    ($state:expr, $ctx:expr) => {
+        match (*($ctx as *const RefCell<Context>)).try_borrow_mut() {
+            Ok(ctx) => ctx,
+            Err(_) => ffi::luaL_error($state, cstr!("require context is already borrowed")),
+        }
+    };
+}
+
+#[cfg(feature = "luau")]
+pub(super) unsafe extern "C-unwind" fn init_config(config: *mut ffi::luarequire_Configuration) {
+    if config.is_null() {
+        return;
+    }
+
+    unsafe extern "C-unwind" fn is_require_allowed(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> bool {
+        if requirer_chunkname.is_null() {
+            return false;
+        }
+
+        let this = try_borrow!(state, ctx);
+        let chunk_name = CStr::from_ptr(requirer_chunkname).to_string_lossy();
+        this.is_require_allowed(&chunk_name)
+    }
+
+    unsafe extern "C-unwind" fn reset(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let chunk_name = CStr::from_ptr(requirer_chunkname).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.reset(&chunk_name).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn jump_to_alias(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let path = CStr::from_ptr(path).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.jump_to_alias(&path).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_alias_override(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        alias_unprefixed: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let alias = CStr::from_ptr(alias_unprefixed).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_alias_override(&alias).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_alias_fallback(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        alias_unprefixed: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let alias = CStr::from_ptr(alias_unprefixed).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_alias_fallback(&alias).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_parent(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_parent().into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_child(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        name: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let name = CStr::from_ptr(name).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_child(&name).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn is_module_present(state: *mut ffi::lua_State, ctx: *mut c_void) -> bool {
+        let this = try_borrow!(state, ctx);
+        this.has_module()
+    }
+
+    unsafe extern "C-unwind" fn get_chunkname(
+        _state: *mut ffi::lua_State,
+        _ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        write_to_buffer(buffer, buffer_size, size_out, &[])
+    }
+
+    unsafe extern "C-unwind" fn get_loadname(
+        _state: *mut ffi::lua_State,
+        _ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        write_to_buffer(buffer, buffer_size, size_out, &[])
+    }
+
+    unsafe extern "C-unwind" fn get_cache_key(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        let this = try_borrow!(state, ctx);
+        let cache_key = this.cache_key();
+        write_to_buffer(buffer, buffer_size, size_out, cache_key.as_bytes())
+    }
+
+    unsafe extern "C-unwind" fn get_config_status(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+    ) -> ConfigStatus {
+        let mut this = try_borrow_mut!(state, ctx);
+        if this.has_config() {
+            this.config_cache = Some(this.config());
+            if let Some(Ok(data)) = &this.config_cache {
+                return detect_config_format(data);
+            }
+        }
+        ConfigStatus::Absent
+    }
+
+    unsafe extern "C-unwind" fn get_config(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let config = callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            Ok(this.config_cache.take().unwrap_or_else(|| this.config())?)
+        });
+        write_to_buffer(buffer, buffer_size, size_out, &config)
+    }
+
+    unsafe extern "C-unwind" fn load(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        _path: *const c_char,
+        _chunkname: *const c_char,
+        _loadname: *const c_char,
+    ) -> c_int {
+        let this = try_borrow!(state, ctx);
+        callback_error_ext(state, ptr::null_mut(), true, move |extra, _| {
+            let rawlua = (*extra).raw_lua();
+            let loader = this.loader(rawlua.lua())?;
+            rawlua.push(loader)?;
+            Ok(1)
+        })
+    }
+
+    (*config).is_require_allowed = is_require_allowed;
+    (*config).reset = reset;
+    (*config).jump_to_alias = jump_to_alias;
+    (*config).to_alias_override = Some(to_alias_override);
+    (*config).to_alias_fallback = Some(to_alias_fallback);
+    (*config).to_parent = to_parent;
+    (*config).to_child = to_child;
+    (*config).is_module_present = is_module_present;
+    (*config).get_chunkname = get_chunkname;
+    (*config).get_loadname = get_loadname;
+    (*config).get_cache_key = get_cache_key;
+    (*config).get_config_status = get_config_status;
+    (*config).get_alias = None;
+    (*config).get_config = Some(get_config);
+    (*config).load = load;
+}
+
+/// Detect configuration file format (JSON or Luau)
+#[cfg(feature = "luau")]
+fn detect_config_format(data: &[u8]) -> ConfigStatus {
+    let data = data.trim_ascii();
+    if data.starts_with(b"{") {
+        let data = &data[1..].trim_ascii_start();
+        if data.starts_with(b"\"") || data == b"}" {
+            return ConfigStatus::PresentJson;
+        }
+    }
+    ConfigStatus::PresentLuau
+}
+
+/// Helper function to write data to a buffer
+#[cfg(feature = "luau")]
+unsafe fn write_to_buffer(
+    buffer: *mut c_char,
+    buffer_size: usize,
+    size_out: *mut usize,
+    data: &[u8],
+) -> WriteResult {
+    // the buffer must be null terminated as it's a c++ `std::string` data() buffer
+    let is_null_terminated = data.last() == Some(&0);
+    *size_out = data.len() + if is_null_terminated { 0 } else { 1 };
+    if *size_out > buffer_size {
+        return WriteResult::BufferTooSmall;
+    }
+    ptr::copy_nonoverlapping(data.as_ptr(), buffer as *mut _, data.len());
+    if !is_null_terminated {
+        *buffer.add(data.len()) = 0;
+    }
+    WriteResult::Success
+}
+
+#[cfg(feature = "luau")]
+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.. {
+            if ffi::lua_getinfo(state, level, cstr!("s"), &mut ar) == 0 {
+                ffi::luaL_error(state, cstr!("require is not supported in this context"));
+            }
+            if CStr::from_ptr(ar.what) != c"C" {
+                break;
+            }
+        }
+        ffi::lua_pushstring(state, ar.source);
+        1
+    }
+
+    unsafe extern "C-unwind" fn get_cache_key(state: *mut ffi::lua_State) -> c_int {
+        let ctx = ffi::lua_touserdata(state, ffi::lua_upvalueindex(1));
+        let ctx = try_borrow!(state, ctx);
+        let cache_key = ctx.cache_key();
+        ffi::lua_pushlstring(state, cache_key.as_ptr() as *const _, cache_key.len());
+        1
+    }
+
+    let (get_cache_key, find_current_file, proxyrequire, registered_modules, loader_cache) = unsafe {
+        lua.exec_raw::<(Function, Function, Function, Table, Table)>((), move |state| {
+            let context = Context::new(require);
+            let context_ptr = ffi::lua_newuserdata_t(state, RefCell::new(context));
+            ffi::lua_pushcclosured(state, get_cache_key, cstr!("get_cache_key"), 1);
+            ffi::lua_pushcfunctiond(state, find_current_file, cstr!("find_current_file"));
+            ffi::luarequire_pushproxyrequire(state, init_config, context_ptr as *mut _);
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_REGISTERED_MODULES_TABLE);
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("__MLUA_LOADER_CACHE"));
+        })
+    }?;
+
+    unsafe extern "C-unwind" fn error(state: *mut ffi::lua_State) -> c_int {
+        ffi::luaL_where(state, 1);
+        ffi::lua_pushvalue(state, 1);
+        ffi::lua_concat(state, 2);
+        ffi::lua_error(state);
+    }
+
+    unsafe extern "C-unwind" fn r#type(state: *mut ffi::lua_State) -> c_int {
+        ffi::lua_pushstring(state, ffi::lua_typename(state, ffi::lua_type(state, 1)));
+        1
+    }
+
+    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"));
+        })
+    }?;
+
+    // Prepare environment for the "require" function
+    let env = lua.create_table_with_capacity(0, 7)?;
+    env.raw_set("get_cache_key", get_cache_key)?;
+    env.raw_set("find_current_file", find_current_file)?;
+    env.raw_set("proxyrequire", proxyrequire)?;
+    env.raw_set("REGISTERED_MODULES", registered_modules)?;
+    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#"
+        local path = ...
+        if type(path) ~= "string" then
+            error("bad argument #1 to 'require' (string expected, got " .. type(path) .. ")")
+        end
+
+        -- Check if the module (path) is explicitly registered
+        local maybe_result = REGISTERED_MODULES[to_lowercase(path)]
+        if maybe_result ~= nil then
+            return maybe_result
+        end
+
+        local loader = proxyrequire(path, find_current_file())
+        local cache_key = get_cache_key()
+        -- Check if the loader result is already cached
+        local result = LOADER_CACHE[cache_key]
+        if result ~= nil then
+            return result
+        end
+
+        -- Call the loader function and cache the result
+        result = loader()
+        if result == nil then
+            result = true
+        end
+        LOADER_CACHE[cache_key] = result
+        return result
+        "#,
+    )
+    .try_cache()
+    .set_name("=__mlua_require")
+    .set_environment(env)
+    .into_function()
+}
+
+mod fs;
@@ -0,0 +1,278 @@
+use std::collections::VecDeque;
+use std::io::Result as IoResult;
+use std::path::{Component, Path, PathBuf};
+use std::result::Result as StdResult;
+use std::{env, fs};
+
+use crate::error::Result;
+use crate::function::Function;
+use crate::state::Lua;
+
+use super::{NavigateError, Require};
+
+/// The standard implementation of Luau `require-by-string` navigation.
+#[derive(Default, Debug)]
+pub struct FsRequirer {
+    /// 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,
+    /// 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 FsRequirer {
+    /// 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"];
+
+    /// The filename for the JSON configuration file.
+    const LUAURC_CONFIG_FILENAME: &str = ".luaurc";
+
+    /// The filename for the Luau configuration file.
+    const LUAU_CONFIG_FILENAME: &str = ".config.luau";
+
+    /// Creates a new `FsRequirer` instance.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    fn normalize_chunk_name(chunk_name: &str) -> &str {
+        if let Some((path, line)) = chunk_name.rsplit_once(':')
+            && line.parse::<u32>().is_ok()
+        {
+            return path;
+        }
+        chunk_name
+    }
+
+    // Normalizes the path by removing unnecessary components
+    fn normalize_path(path: &Path) -> PathBuf {
+        let mut components = VecDeque::new();
+
+        for comp in path.components() {
+            match comp {
+                Component::Prefix(..) | Component::RootDir => {
+                    components.push_back(comp);
+                }
+                Component::CurDir => {}
+                Component::ParentDir => {
+                    if matches!(components.back(), None | Some(Component::ParentDir)) {
+                        components.push_back(Component::ParentDir);
+                    } else if matches!(components.back(), Some(Component::Normal(..))) {
+                        components.pop_back();
+                    }
+                }
+                Component::Normal(..) => components.push_back(comp),
+            }
+        }
+
+        if matches!(components.front(), None | Some(Component::Normal(..))) {
+            components.push_front(Component::CurDir);
+        }
+
+        // Join the components back together
+        components.into_iter().collect()
+    }
+
+    /// 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 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);
+                }
+            }
+        }
+        if path.is_dir() {
+            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);
+                }
+            }
+
+            if found_path.is_none() {
+                // Directories without init files are considered valid "intermediate" path
+                return Ok(None);
+            }
+        }
+
+        Ok(Some(found_path.ok_or(NavigateError::NotFound)?))
+    }
+}
+
+impl Require for FsRequirer {
+    fn is_require_allowed(&self, chunk_name: &str) -> bool {
+        chunk_name.starts_with(Self::CHUNK_PREFIX)
+    }
+
+    fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
+        if !chunk_name.starts_with(Self::CHUNK_PREFIX) {
+            return Err(NavigateError::NotFound);
+        }
+        let chunk_name = Self::normalize_chunk_name(&chunk_name[1..]);
+        let chunk_path = Self::normalize_path(chunk_name.as_ref());
+
+        if chunk_path.extension() == Some("rs".as_ref()) {
+            // Special case for Rust source files, reset to the current directory
+            let chunk_filename = chunk_path.file_name().unwrap();
+            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.resolved_path = None;
+
+            return Ok(());
+        }
+
+        if chunk_path.is_absolute() {
+            let resolved_path = Self::resolve_module(&chunk_path)?;
+            self.abs_path = chunk_path.clone();
+            self.rel_path = chunk_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 resolved_path = Self::resolve_module(&abs_path)?;
+            self.abs_path = abs_path;
+            self.rel_path = chunk_path;
+            self.resolved_path = resolved_path;
+        }
+
+        Ok(())
+    }
+
+    fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
+        let path = Self::normalize_path(path.as_ref());
+        let resolved_path = Self::resolve_module(&path)?;
+
+        self.abs_path = path.clone();
+        self.rel_path = path;
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    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 resolved_path = Self::resolve_module(&abs_path)?;
+
+        self.abs_path = abs_path;
+        self.rel_path = Self::normalize_path(&rel_parent);
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    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 resolved_path = Self::resolve_module(&abs_path)?;
+
+        self.abs_path = abs_path;
+        self.rel_path = rel_path;
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    fn has_module(&self) -> bool {
+        (self.resolved_path.as_deref())
+            .map(Path::is_file)
+            .unwrap_or(false)
+    }
+
+    fn cache_key(&self) -> String {
+        self.resolved_path.as_deref().unwrap().display().to_string()
+    }
+
+    fn has_config(&self) -> bool {
+        self.abs_path.is_dir() && self.abs_path.join(Self::LUAURC_CONFIG_FILENAME).is_file()
+            || self.abs_path.is_dir() && self.abs_path.join(Self::LUAU_CONFIG_FILENAME).is_file()
+    }
+
+    fn config(&self) -> IoResult<Vec<u8>> {
+        if self.abs_path.join(Self::LUAURC_CONFIG_FILENAME).is_file() {
+            return fs::read(self.abs_path.join(Self::LUAURC_CONFIG_FILENAME));
+        }
+        fs::read(self.abs_path.join(Self::LUAU_CONFIG_FILENAME))
+    }
+
+    fn loader(&self, lua: &Lua) -> Result<Function> {
+        let name = format!("@{}", self.rel_path.display());
+        lua.load(self.resolved_path.as_deref().unwrap())
+            .set_name(name)
+            .into_function()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::FsRequirer;
+
+    #[test]
+    fn test_path_normalize() {
+        for (input, expected) in [
+            // Basic formatting checks
+            ("", "./"),
+            (".", "./"),
+            ("a/relative/path", "./a/relative/path"),
+            // Paths containing extraneous '.' and '/' symbols
+            ("./remove/extraneous/symbols/", "./remove/extraneous/symbols"),
+            ("./remove/extraneous//symbols", "./remove/extraneous/symbols"),
+            ("./remove/extraneous/symbols/.", "./remove/extraneous/symbols"),
+            ("./remove/extraneous/./symbols", "./remove/extraneous/symbols"),
+            ("../remove/extraneous/symbols/", "../remove/extraneous/symbols"),
+            ("../remove/extraneous//symbols", "../remove/extraneous/symbols"),
+            ("../remove/extraneous/symbols/.", "../remove/extraneous/symbols"),
+            ("../remove/extraneous/./symbols", "../remove/extraneous/symbols"),
+            ("/remove/extraneous/symbols/", "/remove/extraneous/symbols"),
+            ("/remove/extraneous//symbols", "/remove/extraneous/symbols"),
+            ("/remove/extraneous/symbols/.", "/remove/extraneous/symbols"),
+            ("/remove/extraneous/./symbols", "/remove/extraneous/symbols"),
+            // Paths containing '..'
+            ("./remove/me/..", "./remove"),
+            ("./remove/me/../", "./remove"),
+            ("../remove/me/..", "../remove"),
+            ("../remove/me/../", "../remove"),
+            ("/remove/me/..", "/remove"),
+            ("/remove/me/../", "/remove"),
+            ("./..", "../"),
+            ("./../", "../"),
+            ("../..", "../../"),
+            ("../../", "../../"),
+            // '..' disappears if path is absolute and component is non-erasable
+            ("/../", "/"),
+        ] {
+            let path = FsRequirer::normalize_path(input.as_ref());
+            assert_eq!(
+                &path,
+                expected.as_ref() as &Path,
+                "wrong normalization for {input}"
+            );
+        }
+    }
+}
@@ -18,16 +18,20 @@ pub(crate) struct MemoryState {
 }

 impl MemoryState {
+    #[cfg(feature = "luau")]
    #[inline]
    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
        let mut mem_state = ptr::null_mut();
-        #[cfg(feature = "luau")]
-        {
-            ffi::lua_getallocf(state, &mut mem_state);
-            mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
-        }
-        #[cfg(not(feature = "luau"))]
-        if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
+        ffi::lua_getallocf(state, &mut mem_state);
+        mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        mem_state as *mut MemoryState
+    }
+
+    #[cfg(not(feature = "luau"))]
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        if !ptr::fn_addr_eq(ffi::lua_getallocf(state, &mut mem_state), ALLOCATOR) {
            mem_state = ptr::null_mut();
        }
        mem_state as *mut MemoryState
@@ -66,7 +70,7 @@ impl MemoryState {
    }

    // Does nothing apart from calling `f()`, we don't need to bypass any limits
-    #[cfg(any(feature = "lua52", feature = "lua53", feature = "lua54"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "lua52"))]
    #[inline]
    pub(crate) unsafe fn relax_limit_with(_state: *mut ffi::lua_State, f: impl FnOnce()) {
        f();
@@ -80,7 +84,7 @@ impl MemoryState {
    }
 }

-unsafe extern "C-unwind" fn allocator(
+unsafe extern "C" fn allocator(
    extra: *mut c_void,
    ptr: *mut c_void,
    osize: usize,
@@ -1,4 +1,4 @@
-use std::collections::{vec_deque, VecDeque};
+use std::collections::{VecDeque, vec_deque};
 use std::iter::FromIterator;
 use std::mem;
 use std::ops::{Deref, DerefMut};
@@ -126,8 +126,7 @@ impl MultiValue {

    /// Creates a `MultiValue` container from vector of values.
    ///
-    /// This methods needs *O*(*n*) data movement if the circular buffer doesn't happen to be at the
-    /// beginning of the allocation.
+    /// This method works in *O*(1) time and does not allocate any additional memory.
    #[inline]
    pub fn from_vec(vec: Vec<Value>) -> MultiValue {
        vec.into()
@@ -135,7 +134,8 @@ impl MultiValue {

    /// Consumes the `MultiValue` and returns a vector of values.
    ///
-    /// This methods works in *O*(1) time and does not allocate any additional memory.
+    /// This method needs *O*(*n*) data movement if the circular buffer doesn't happen to be at the
+    /// beginning of the allocation.
    #[inline]
    pub fn into_vec(self) -> Vec<Value> {
        self.into()
@@ -204,6 +204,23 @@ impl IntoLuaMulti for MultiValue {
    }
 }

+impl IntoLuaMulti for &MultiValue {
+    #[inline]
+    fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
+        Ok(self.clone())
+    }
+
+    #[inline]
+    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 {
+            lua.push_value(value)?;
+        }
+        Ok(nresults)
+    }
+}
+
 impl FromLuaMulti for MultiValue {
    #[inline]
    fn from_lua_multi(values: MultiValue, _: &Lua) -> Result<Self> {
@@ -297,6 +314,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> {
@@ -2,34 +2,49 @@

 #[doc(no_inline)]
 pub use crate::{
-    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Either as LuaEither, Error as LuaError,
-    ErrorContext as LuaErrorContext, ExternalError as LuaExternalError, ExternalResult as LuaExternalResult,
-    FromLua, FromLuaMulti, Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
-    Integer as LuaInteger, IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaNativeFn,
-    LuaNativeFnMut, LuaOptions, MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil,
-    Number as LuaNumber, ObjectLike as LuaObjectLike, RegistryKey as LuaRegistryKey, Result as LuaResult,
-    StdLib as LuaStdLib, String as LuaString, Table as LuaTable, TablePairs as LuaTablePairs,
-    TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus,
-    UserData as LuaUserData, UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
-    UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
-    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry, Value as LuaValue,
-    VmState as LuaVmState,
+    AnyUserData as LuaAnyUserData, BorrowedBytes as LuaBorrowedBytes, BorrowedStr as LuaBorrowedStr,
+    Either as LuaEither, Error as LuaError, FromLua, FromLuaMulti, Function as LuaFunction,
+    Integer as LuaInteger, IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaOptions,
+    LuaString, MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber,
+    ObjectLike as LuaObjectLike, RegistryKey as LuaRegistryKey, Result as LuaResult, StdLib as LuaStdLib,
+    Table as LuaTable, Thread as LuaThread, UserData as LuaUserData, UserDataFields as LuaUserDataFields,
+    UserDataMetatable as LuaUserDataMetatable, UserDataMethods as LuaUserDataMethods,
+    UserDataOwned as LuaUserDataOwned, UserDataRef as LuaUserDataRef, UserDataRefMut as LuaUserDataRefMut,
+    UserDataRegistry as LuaUserDataRegistry, Value as LuaValue, Variadic as LuaVariadic,
+    VmState as LuaVmState, WeakLua, chunk::AsChunk as AsLuaChunk, chunk::Chunk as LuaChunk,
+    chunk::ChunkMode as LuaChunkMode, error::ErrorContext as LuaErrorContext,
+    error::ExternalError as LuaExternalError, error::ExternalResult as LuaExternalResult,
+    function::FunctionInfo as LuaFunctionInfo, function::LuaNativeFn, function::LuaNativeFnMut,
+    state::GcIncParams as LuaGcIncParams, state::GcMode as LuaGcMode, table::TablePairs as LuaTablePairs,
+    table::TableSequence as LuaTableSequence, thread::ThreadStatus as LuaThreadStatus,
 };

 #[cfg(not(feature = "luau"))]
 #[doc(no_inline)]
 pub use crate::HookTriggers as LuaHookTriggers;

+#[cfg(any(feature = "lua54", feature = "lua55"))]
+#[doc(no_inline)]
+pub use crate::state::GcGenParams as LuaGcGenParams;
+
 #[cfg(feature = "luau")]
 #[doc(no_inline)]
-pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector};
+pub use crate::{
+    Vector as LuaVector,
+    chunk::{CompileConstant as LuaCompileConstant, Compiler as LuaCompiler},
+    luau::{
+        FsRequirer as LuaFsRequirer, HeapDump as LuaHeapDump, NavigateError as LuaNavigateError,
+        Require as LuaRequire,
+    },
+};

 #[cfg(feature = "async")]
 #[doc(no_inline)]
-pub use crate::{AsyncThread as LuaAsyncThread, LuaNativeAsyncFn};
+pub use crate::{function::LuaNativeAsyncFn, thread::AsyncThread as LuaAsyncThread};

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 #[doc(no_inline)]
 pub use crate::{
-    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt, SerializeOptions as LuaSerializeOptions,
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt, SerializableValue as LuaSerializableValue,
+    SerializeOptions as LuaSerializeOptions,
 };
@@ -8,9 +8,7 @@ use crate::state::{Lua, LuaGuard, RawLua};
 use crate::traits::{FromLuaMulti, IntoLuaMulti};
 use crate::types::{Callback, CallbackUpvalue, ScopedCallback, ValueRef};
 use crate::userdata::{AnyUserData, UserData, UserDataRegistry, UserDataStorage};
-use crate::util::{
-    self, assert_stack, check_stack, get_metatable_ptr, get_userdata, take_userdata, StackGuard,
-};
+use crate::util::{self, StackGuard, check_stack, get_metatable_ptr, get_userdata, take_userdata};

 /// Constructed by the [`Lua::scope`] method, allows temporarily creating Lua userdata and
 /// callbacks that are not required to be `Send` or `'static`.
@@ -168,7 +166,7 @@ impl<'scope, 'env: 'scope> Scope<'scope, 'env> {
            #[cfg(feature = "luau")]
            let ud_ptr = {
                let data = UserDataStorage::new_scoped(data);
-                util::push_userdata::<UserDataStorage<T>>(state, data, protect)?
+                util::push_userdata(state, data, protect)?
            };
            #[cfg(not(feature = "luau"))]
            let ud_ptr = util::push_uninit_userdata::<UserDataStorage<T>>(state, protect)?;
@@ -216,7 +214,7 @@ impl<'scope, 'env: 'scope> Scope<'scope, 'env> {
            #[cfg(feature = "luau")]
            let ud_ptr = {
                let data = UserDataStorage::new_scoped(data);
-                util::push_userdata::<UserDataStorage<T>>(state, data, protect)?
+                util::push_userdata(state, data, protect)?
            };
            #[cfg(not(feature = "luau"))]
            let ud_ptr = util::push_uninit_userdata::<UserDataStorage<T>>(state, protect)?;
@@ -284,22 +282,18 @@ impl<'scope, 'env: 'scope> Scope<'scope, 'env> {
    /// Shortens the lifetime of the userdata to the lifetime of the scope.
    fn seal_userdata<T: 'env>(&self, ud: &AnyUserData) {
        let destructor: DestructorCallback = Box::new(|rawlua, vref| unsafe {
-            let state = rawlua.state();
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-
            // Ensure that userdata is not destructed
-            match rawlua.push_userdata_ref(&vref) {
+            match rawlua.get_userdata_ref_type_id(&vref) {
                Ok(Some(_)) => {}
                Ok(None) => {
                    // Deregister metatable
-                    let mt_ptr = get_metatable_ptr(state, -1);
+                    let mt_ptr = get_metatable_ptr(rawlua.ref_thread(), vref.index);
                    rawlua.deregister_userdata_metatable(mt_ptr);
                }
                Err(_) => return vec![],
            }

-            let data = take_userdata::<UserDataStorage<T>>(state);
+            let data = take_userdata::<UserDataStorage<T>>(rawlua.ref_thread(), vref.index);
            vec![Box::new(move || drop(data))]
        });
        self.destructors.0.borrow_mut().push((ud.0.clone(), destructor));
@@ -4,7 +4,6 @@ use std::cell::RefCell;
 use std::os::raw::c_void;
 use std::rc::Rc;
 use std::result::Result as StdResult;
-use std::string::String as StdString;

 use rustc_hash::FxHashSet;
 use serde::de::{self, IntoDeserializer};
@@ -15,11 +14,12 @@ use crate::userdata::AnyUserData;
 use crate::value::Value;

 /// A struct for deserializing Lua values into Rust values.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Deserializer {
    value: Value,
    options: Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+    len: Option<usize>, // A length hint for sequences
 }

 /// A struct with options to change default deserializer behavior.
@@ -49,6 +49,24 @@ pub struct Options {
    ///
    /// Default: **false**
    pub sort_keys: bool,
+
+    /// If true, empty Lua tables will be encoded as array, instead of map.
+    ///
+    /// Default: **false**
+    pub encode_empty_tables_as_array: bool,
+
+    /// If true, enable detection of mixed tables.
+    ///
+    /// A mixed table is a table that has both array-like and map-like entries or several borders.
+    /// See [`The Length Operator`] documentation for details about borders.
+    ///
+    /// When this option is disabled, a table with a non-zero length (with one or more borders) will
+    /// be always encoded as an array.
+    ///
+    /// Default: **false**
+    ///
+    /// [`The Length Operator`]: https://www.lua.org/manual/5.4/manual.html#3.4.7
+    pub detect_mixed_tables: bool,
 }

 impl Default for Options {
@@ -64,6 +82,8 @@ impl Options {
            deny_unsupported_types: true,
            deny_recursive_tables: true,
            sort_keys: false,
+            encode_empty_tables_as_array: false,
+            detect_mixed_tables: false,
        }
    }

@@ -93,6 +113,24 @@ impl Options {
        self.sort_keys = enabled;
        self
    }
+
+    /// Sets [`encode_empty_tables_as_array`] option.
+    ///
+    /// [`encode_empty_tables_as_array`]: #structfield.encode_empty_tables_as_array
+    #[must_use]
+    pub const fn encode_empty_tables_as_array(mut self, enabled: bool) -> Self {
+        self.encode_empty_tables_as_array = enabled;
+        self
+    }
+
+    /// Sets [`detect_mixed_tables`] option.
+    ///
+    /// [`detect_mixed_tables`]: #structfield.detect_mixed_tables
+    #[must_use]
+    pub const fn detect_mixed_tables(mut self, enable: bool) -> Self {
+        self.detect_mixed_tables = enable;
+        self
+    }
 }

 impl Deserializer {
@@ -106,7 +144,7 @@ impl Deserializer {
        Deserializer {
            value,
            options,
-            visited: Rc::new(RefCell::new(FxHashSet::default())),
+            ..Default::default()
        }
    }

@@ -115,8 +153,14 @@ impl Deserializer {
            value,
            options,
            visited,
+            ..Default::default()
        }
    }
+
+    fn with_len(mut self, len: usize) -> Self {
+        self.len = Some(len);
+        self
+    }
 }

 impl<'de> serde::Deserializer<'de> for Deserializer {
@@ -140,14 +184,22 @@ impl<'de> serde::Deserializer<'de> for Deserializer {
                Ok(s) => visitor.visit_str(&s),
                Err(_) => visitor.visit_bytes(&s.as_bytes()),
            },
-            Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => self.deserialize_seq(visitor),
-            Value::Table(_) => self.deserialize_map(visitor),
+            Value::Table(ref t) => {
+                if let Some(len) = t.encode_as_array(self.options) {
+                    self.with_len(len).deserialize_seq(visitor)
+                } else {
+                    self.deserialize_map(visitor)
+                }
+            }
            Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
            Value::UserData(ud) if ud.is_serializable() => {
                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(_)
@@ -190,14 +242,14 @@ impl<'de> serde::Deserializer<'de> for Deserializer {
            Value::Table(table) => {
                let _guard = RecursionGuard::new(&table, &self.visited);

-                let mut iter = table.pairs::<StdString, Value>();
+                let mut iter = table.pairs::<String, Value>();
                let (variant, value) = match iter.next() {
                    Some(v) => v?,
                    None => {
                        return Err(de::Error::invalid_value(
                            de::Unexpected::Map,
                            &"map with a single key",
-                        ))
+                        ));
                    }
                };

@@ -249,14 +301,14 @@ impl<'de> serde::Deserializer<'de> for Deserializer {
            Value::Table(t) => {
                let _guard = RecursionGuard::new(&t, &self.visited);

-                let len = t.raw_len();
+                let len = self.len.unwrap_or_else(|| t.raw_len());
                let mut deserializer = SeqDeserializer {
-                    seq: t.sequence_values(),
+                    seq: t.sequence_values().with_len(len),
                    options: self.options,
                    visited: self.visited,
                };
                let seq = visitor.visit_seq(&mut deserializer)?;
-                if deserializer.seq.count() == 0 {
+                if deserializer.seq.next().is_none() {
                    Ok(seq)
                } else {
                    Err(de::Error::invalid_length(len, &"fewer elements in the table"))
@@ -568,7 +620,7 @@ impl<'de> de::MapAccess<'de> for MapDeserializer<'_> {
 }

 struct EnumDeserializer {
-    variant: StdString,
+    variant: String,
    value: Option<Value>,
    options: Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
@@ -13,12 +13,10 @@ use crate::util::check_stack;
 use crate::value::Value;

 /// Trait for serializing/deserializing Lua values using Serde.
-#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 pub trait LuaSerdeExt: Sealed {
    /// A special value (lightuserdata) to encode/decode optional (none) values.
    ///
-    /// Requires `feature = "serialize"`
-    ///
    /// # Example
    ///
    /// ```
@@ -39,10 +37,8 @@ pub trait LuaSerdeExt: Sealed {
    fn null(&self) -> Value;

    /// A metatable attachable to a Lua table to systematically encode it as Array (instead of Map).
-    /// As result, encoded Array will contain only sequence part of the table, with the same length
-    /// as the `#` operator on that table.
-    ///
-    /// Requires `feature = "serialize"`
+    /// As a result, encoded Array will contain only sequence part of the table, with the same
+    /// length as the `#` operator on that table.
    ///
    /// # Example
    ///
@@ -71,8 +67,6 @@ pub trait LuaSerdeExt: Sealed {

    /// Converts `T` into a [`Value`] instance.
    ///
-    /// Requires `feature = "serialize"`
-    ///
    /// [`Value`]: crate::Value
    ///
    /// # Example
@@ -104,8 +98,6 @@ pub trait LuaSerdeExt: Sealed {

    /// Converts `T` into a [`Value`] instance with options.
    ///
-    /// Requires `feature = "serialize"`
-    ///
    /// # Example
    ///
    /// ```
@@ -129,8 +121,6 @@ pub trait LuaSerdeExt: Sealed {

    /// Deserializes a [`Value`] into any serde deserializable object.
    ///
-    /// Requires `feature = "serialize"`
-    ///
    /// # Example
    ///
    /// ```
@@ -158,8 +148,6 @@ pub trait LuaSerdeExt: Sealed {

    /// Deserializes a [`Value`] into any serde deserializable object with options.
    ///
-    /// Requires `feature = "serialize"`
-    ///
    /// # Example
    ///
    /// ```
@@ -254,7 +242,5 @@ static ARRAY_METATABLE_REGISTRY_KEY: u8 = 0;
 pub mod de;
 pub mod ser;

-#[doc(inline)]
-pub use de::Deserializer;
-#[doc(inline)]
-pub use ser::Serializer;
+pub use de::{Deserializer, Options as DeserializeOptions};
+pub use ser::{Options as SerializeOptions, Serializer};
@@ -1,6 +1,6 @@
 //! Serialize a Rust data structure into Lua value.

-use serde::{ser, Serialize};
+use serde::{Serialize, ser};

 use super::LuaSerdeExt;
 use crate::error::{Error, Result};
@@ -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,12 +529,12 @@ 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");
-                if number_s.contains(['.', 'e', 'E']) {
-                    if let Ok(number) = number_s.parse().map(Value::Number) {
-                        return Ok(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'])
+                    && let Ok(number) = number_s.parse().map(Value::Number)
+                {
+                    return Ok(number);
                }
                Ok(number_s
                    .parse()
@@ -12,9 +12,10 @@ use rustc_hash::FxHashMap;
 use crate::error::Result;
 use crate::state::RawLua;
 use crate::stdlib::StdLib;
-use crate::types::{AppData, ReentrantMutex, XRc};
+use crate::thread::ThreadTriggers;
+use crate::types::{AppData, ReentrantMutex, ThreadEventCallback, XRc};
 use crate::userdata::RawUserDataRegistry;
-use crate::util::{get_internal_metatable, push_internal_userdata, TypeKey, WrappedFailure};
+use crate::util::{TypeKey, WrappedFailure, get_internal_metatable, push_internal_userdata};

 #[cfg(any(feature = "luau", doc))]
 use crate::chunk::Compiler;
@@ -28,7 +29,7 @@ use super::{Lua, WeakLua};
 static EXTRA_REGISTRY_KEY: u8 = 0;

 const WRAPPED_FAILURE_POOL_DEFAULT_CAPACITY: usize = 64;
-const REF_STACK_RESERVE: c_int = 1;
+const REF_STACK_RESERVE: c_int = 3;

 /// Data associated with the Lua state.
 pub(crate) struct ExtraData {
@@ -44,8 +45,9 @@ pub(crate) struct ExtraData {
    // When Lua instance dropped, setting `None` would prevent collecting `RegistryKey`s
    pub(super) registry_unref_list: Arc<Mutex<Option<Vec<c_int>>>>,

-    // Container to store arbitrary data (extensions)
+    // Containers to store arbitrary data (extensions)
    pub(super) app_data: AppData,
+    pub(super) app_data_priv: AppData,

    pub(super) safe: bool,
    pub(super) libs: StdLib,
@@ -63,7 +65,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,
@@ -75,18 +77,24 @@ pub(crate) struct ExtraData {
    #[cfg(not(feature = "luau"))]
    pub(super) hook_callback: Option<crate::types::HookCallback>,
    #[cfg(not(feature = "luau"))]
-    pub(super) hook_thread: *mut ffi::lua_State,
-    #[cfg(feature = "lua54")]
+    pub(super) hook_triggers: crate::debug::HookTriggers,
+    #[cfg(any(feature = "lua55", feature = "lua54"))]
    pub(super) warn_callback: Option<crate::types::WarnCallback>,
    #[cfg(feature = "luau")]
    pub(super) interrupt_callback: Option<crate::types::InterruptCallback>,
+    pub(super) thread_triggers: ThreadTriggers,
+    pub(super) thread_event_callback: Option<ThreadEventCallback>,

    #[cfg(feature = "luau")]
-    pub(super) sandboxed: bool,
+    pub(crate) running_gc: bool,
+    #[cfg(feature = "luau")]
+    pub(crate) sandboxed: bool,
    #[cfg(feature = "luau")]
    pub(super) compiler: Option<Compiler>,
    #[cfg(feature = "luau-jit")]
    pub(super) enable_jit: bool,
+    #[cfg(feature = "luau")]
+    pub(crate) mem_categories: Vec<std::ffi::CString>,
 }

 impl Drop for ExtraData {
@@ -153,6 +161,7 @@ impl ExtraData {
            last_checked_userdata_mt: (ptr::null(), None),
            registry_unref_list: Arc::new(Mutex::new(Some(Vec::new()))),
            app_data: AppData::default(),
+            app_data_priv: AppData::default(),
            safe: false,
            libs: StdLib::NONE,
            skip_memory_check: false,
@@ -171,17 +180,23 @@ impl ExtraData {
            #[cfg(not(feature = "luau"))]
            hook_callback: None,
            #[cfg(not(feature = "luau"))]
-            hook_thread: ptr::null_mut(),
-            #[cfg(feature = "lua54")]
+            hook_triggers: Default::default(),
+            #[cfg(any(feature = "lua55", feature = "lua54"))]
            warn_callback: None,
            #[cfg(feature = "luau")]
            interrupt_callback: None,
+            thread_triggers: ThreadTriggers::default(),
+            thread_event_callback: None,
            #[cfg(feature = "luau")]
            sandboxed: false,
            #[cfg(feature = "luau")]
            compiler: None,
            #[cfg(feature = "luau-jit")]
            enable_jit: true,
+            #[cfg(feature = "luau")]
+            running_gc: false,
+            #[cfg(feature = "luau")]
+            mem_categories: vec![std::ffi::CString::new("main").unwrap()],
        }));

        // Store it in the registry
@@ -195,13 +210,10 @@ impl ExtraData {
            raw: XRc::clone(raw),
            collect_garbage: false,
        });
-        if self.owned {
-            XRc::decrement_strong_count(XRc::as_ptr(raw));
-        }
        self.weak.write(WeakLua(XRc::downgrade(raw)));
    }

-    pub(super) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
        #[cfg(feature = "luau")]
        if cfg!(not(feature = "module")) {
            // In the main app we can use `lua_callbacks` to access ExtraData
@@ -240,7 +252,7 @@ impl ExtraData {
    }

    #[inline(always)]
-    pub(super) unsafe fn raw_lua(&self) -> &RawLua {
+    pub(crate) unsafe fn raw_lua(&self) -> &RawLua {
        &*self.lua.assume_init_ref().raw.data_ptr()
    }

@@ -248,4 +260,32 @@ impl ExtraData {
    pub(super) unsafe fn weak(&self) -> &WeakLua {
        self.weak.assume_init_ref()
    }
+
+    /// Pops a reference from top of the auxiliary stack and move it to a first free slot.
+    pub(super) unsafe fn ref_stack_pop(&mut self) -> c_int {
+        if let Some(free) = self.ref_free.pop() {
+            ffi::lua_replace(self.ref_thread, free);
+            return free;
+        }
+
+        // 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 + REF_STACK_RESERVE) == 0 {
+                inc /= 2;
+            }
+            if inc == 0 {
+                // Pop item on top of the stack to avoid stack leaking and successfully run destructors
+                // during unwinding.
+                ffi::lua_pop(self.ref_thread, 1);
+                let top = self.ref_stack_top;
+                // It is a user error to create too many references to exhaust the Lua max stack size
+                // for the ref thread.
+                panic!("cannot create a Lua reference, out of auxiliary stack space (used {top} slots)");
+            }
+            self.ref_stack_size += inc;
+        }
+        self.ref_stack_top += 1;
+        self.ref_stack_top
+    }
 }
@@ -1,16 +1,16 @@
 use std::os::raw::c_int;
-use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::ptr;
 use std::sync::Arc;

 use crate::error::{Error, Result};
 use crate::state::{ExtraData, RawLua};
-use crate::util::{self, get_internal_metatable, WrappedFailure};
+use crate::util::{self, WrappedFailure, get_internal_metatable};

-pub(super) struct StateGuard<'a>(&'a RawLua, *mut ffi::lua_State);
+struct StateGuard<'a>(&'a RawLua, *mut ffi::lua_State);

 impl<'a> StateGuard<'a> {
-    pub(super) fn new(inner: &'a RawLua, mut state: *mut ffi::lua_State) -> Self {
+    fn new(inner: &'a RawLua, mut state: *mut ffi::lua_State) -> Self {
        state = inner.state.replace(state);
        Self(inner, state)
    }
@@ -23,10 +23,11 @@ impl Drop for StateGuard<'_> {
 }

 // An optimized version of `callback_error` that does not allocate `WrappedFailure` userdata
-// and instead reuses unsed values from previous calls (or allocates new).
-pub(super) unsafe fn callback_error_ext<F, R>(
+// and instead reuses unused values from previous calls (or allocates new).
+pub(crate) unsafe fn callback_error_ext<F, R>(
    state: *mut ffi::lua_State,
    mut extra: *mut ExtraData,
+    wrap_error: bool,
    f: F,
 ) -> R
 where
@@ -51,7 +52,7 @@ where
            }

            // We need to check stack for Luau in case when callback is called from interrupt
-            // See https://github.com/Roblox/luau/issues/446 and mlua #142 and #153
+            // See https://github.com/luau-lang/luau/issues/446 and mlua #142 and #153
            #[cfg(feature = "luau")]
            ffi::lua_rawcheckstack(state, 2);
            // Place it to the beginning of the stack
@@ -88,7 +89,7 @@ where
                PreallocatedFailure::New(_) => {
                    ffi::lua_rotate(state, 1, -1);
                    ffi::lua_xmove(state, ref_thread, 1);
-                    let index = ref_stack_pop(extra);
+                    let index = (*extra).ref_stack_pop();
                    (*extra).wrapped_failure_pool.push(index);
                    (*extra).wrapped_failure_top += 1;
                }
@@ -101,7 +102,11 @@ where
    // to store a wrapped failure (error or panic) *before* we proceed.
    let prealloc_failure = PreallocatedFailure::reserve(state, extra);

-    match catch_unwind(AssertUnwindSafe(|| f(extra, nargs))) {
+    match catch_unwind(AssertUnwindSafe(|| {
+        let rawlua = (*extra).raw_lua();
+        let _guard = StateGuard::new(rawlua, state);
+        f(extra, nargs)
+    })) {
        Ok(Ok(r)) => {
            // Return unused `WrappedFailure` to the pool
            prealloc_failure.release(state, extra);
@@ -110,6 +115,13 @@ where
        Ok(Err(err)) => {
            let wrapped_error = prealloc_failure.r#use(state, extra);

+            if !wrap_error {
+                ptr::write(wrapped_error, WrappedFailure::Error(err));
+                get_internal_metatable::<WrappedFailure>(state);
+                ffi::lua_setmetatable(state, -2);
+                ffi::lua_error(state)
+            }
+
            // Build `CallbackError` with traceback
            let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
                ffi::luaL_traceback(state, state, ptr::null(), 0);
@@ -138,31 +150,3 @@ where
        }
    }
 }
-
-pub(super) unsafe fn ref_stack_pop(extra: *mut ExtraData) -> c_int {
-    let extra = &mut *extra;
-    if let Some(free) = extra.ref_free.pop() {
-        ffi::lua_replace(extra.ref_thread, free);
-        return free;
-    }
-
-    // Try to grow max stack size
-    if extra.ref_stack_top >= extra.ref_stack_size {
-        let mut inc = extra.ref_stack_size; // Try to double stack size
-        while inc > 0 && ffi::lua_checkstack(extra.ref_thread, inc) == 0 {
-            inc /= 2;
-        }
-        if inc == 0 {
-            // Pop item on top of the stack to avoid stack leaking and successfully run destructors
-            // during unwinding.
-            ffi::lua_pop(extra.ref_thread, 1);
-            let top = extra.ref_stack_top;
-            // It is a user error to create enough references to exhaust the Lua max stack size for
-            // the ref thread.
-            panic!("cannot create a Lua reference, out of auxiliary stack space (used {top} slots)");
-        }
-        extra.ref_stack_size += inc;
-    }
-    extra.ref_stack_top += 1;
-    extra.ref_stack_top
-}
@@ -1,4 +1,4 @@
-use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
+use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not};

 /// Flags describing the set of lua standard libraries to load.
 #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -6,9 +6,23 @@ pub struct StdLib(u32);

 impl StdLib {
    /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
-    ///
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    #[cfg(any(
+        feature = "lua55",
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(
+            feature = "lua55",
+            feature = "lua54",
+            feature = "lua53",
+            feature = "lua52",
+            feature = "luau"
+        )))
+    )]
    pub const COROUTINE: StdLib = StdLib(1);

    /// [`table`](https://www.lua.org/manual/5.4/manual.html#6.6) library
@@ -26,21 +40,27 @@ impl StdLib {
    pub const STRING: StdLib = StdLib(1 << 4);

    /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
-    ///
-    /// Requires `feature = "lua54/lua53/luau"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "luau"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "luau")))
+    )]
    pub const UTF8: StdLib = StdLib(1 << 5);

    /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
-    ///
-    /// Requires `feature = "lua52/luajit/luau"`
    #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua52", feature = "luajit", feature = "luau")))
+    )]
    pub const BIT: StdLib = StdLib(1 << 6);

    /// [`math`](https://www.lua.org/manual/5.4/manual.html#6.7) library
    pub const MATH: StdLib = StdLib(1 << 7);

    /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub const PACKAGE: StdLib = StdLib(1 << 8);

    /// [`buffer`](https://luau.org/library#buffer-library) library
@@ -53,16 +73,17 @@ impl StdLib {
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub const VECTOR: StdLib = StdLib(1 << 10);

+    /// [`integer`](https://luau.org/library#integer-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const INTEGER: StdLib = StdLib(1 << 11);
+
    /// [`jit`](http://luajit.org/ext_jit.html) library
-    ///
-    /// Requires `feature = "luajit"`
    #[cfg(any(feature = "luajit", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
-    pub const JIT: StdLib = StdLib(1 << 11);
+    pub const JIT: StdLib = StdLib(1 << 12);

    /// (**unsafe**) [`ffi`](http://luajit.org/ext_ffi.html) library
-    ///
-    /// Requires `feature = "luajit"`
    #[cfg(any(feature = "luajit", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
    pub const FFI: StdLib = StdLib(1 << 30);
@@ -123,3 +144,10 @@ impl BitXorAssign for StdLib {
        *self = StdLib(self.0 ^ rhs.0)
    }
 }
+
+impl Not for StdLib {
+    type Output = Self;
+    fn not(self) -> Self::Output {
+        StdLib(!self.0)
+    }
+}
@@ -1,9 +1,12 @@
+//! Lua string handling.
+//!
+//! This module provides types for working with Lua strings from Rust.
+
 use std::borrow::Borrow;
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::os::raw::{c_int, c_void};
-use std::string::String as StdString;
-use std::{cmp, fmt, slice, str};
+use std::{cmp, fmt, mem, slice, str};

 use crate::error::{Error, Result};
 use crate::state::Lua;
@@ -11,7 +14,7 @@ use crate::traits::IntoLua;
 use crate::types::{LuaType, ValueRef};
 use crate::value::Value;

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 use {
    serde::ser::{Serialize, Serializer},
    std::result::Result as StdResult,
@@ -20,44 +23,41 @@ use {
 /// Handle to an internal Lua string.
 ///
 /// Unlike Rust strings, Lua strings may not be valid UTF-8.
-#[derive(Clone)]
-pub struct String(pub(crate) ValueRef);
+#[derive(Clone, PartialEq)]
+pub struct LuaString(pub(crate) ValueRef);

-impl String {
+impl LuaString {
    /// Get a [`BorrowedStr`] if the Lua string is valid UTF-8.
    ///
+    /// The returned `BorrowedStr` holds a strong reference to the Lua state to guarantee the
+    /// validity of the underlying data.
+    ///
    /// # Examples
    ///
    /// ```
-    /// # use mlua::{Lua, Result, String};
+    /// # use mlua::{Lua, LuaString, Result};
    /// # fn main() -> Result<()> {
    /// # let lua = Lua::new();
    /// let globals = lua.globals();
    ///
-    /// let version: String = globals.get("_VERSION")?;
+    /// let version: LuaString = globals.get("_VERSION")?;
    /// assert!(version.to_str()?.contains("Lua"));
    ///
-    /// let non_utf8: String = lua.load(r#"  "test\255"  "#).eval()?;
+    /// let non_utf8: LuaString = lua.load(r#"  "test\255"  "#).eval()?;
    /// assert!(non_utf8.to_str().is_err());
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn to_str(&self) -> Result<BorrowedStr> {
-        let BorrowedBytes(bytes, guard) = self.as_bytes();
-        let s = str::from_utf8(bytes).map_err(|e| Error::FromLuaConversionError {
-            from: "string",
-            to: "&str".to_string(),
-            message: Some(e.to_string()),
-        })?;
-        Ok(BorrowedStr(s, guard))
+        BorrowedStr::try_from(self)
    }

-    /// Converts this string to a [`StdString`].
+    /// Converts this Lua string to a [`String`].
    ///
    /// Any non-Unicode sequences are replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
    ///
-    /// This method returns [`StdString`] instead of [`Cow<'_, str>`] because lifetime cannot be
+    /// This method returns [`String`] instead of [`Cow<'_, str>`] because lifetime cannot be
    /// bound to a weak Lua object.
    ///
    /// [U+FFFD]: std::char::REPLACEMENT_CHARACTER
@@ -76,11 +76,11 @@ impl String {
    /// # }
    /// ```
    #[inline]
-    pub fn to_string_lossy(&self) -> StdString {
-        StdString::from_utf8_lossy(&self.as_bytes()).into_owned()
+    pub fn to_string_lossy(&self) -> String {
+        String::from_utf8_lossy(&self.as_bytes()).into_owned()
    }

-    /// Returns an object that implements [`Display`] for safely printing a Lua [`String`] that may
+    /// Returns an object that implements [`Display`] for safely printing a [`LuaString`] that may
    /// contain non-Unicode data.
    ///
    /// This may perform lossy conversion.
@@ -92,16 +92,17 @@ 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
-    /// bytes embedded into the Lua string.
+    /// The returned `BorrowedStr` holds a strong reference to the Lua state to guarantee the
+    /// validity of the underlying data. The data will not contain the terminating null byte, but
+    /// will contain any null bytes embedded into the Lua string.
    ///
    /// # Examples
    ///
    /// ```
-    /// # use mlua::{Lua, Result, String};
+    /// # use mlua::{Lua, LuaString, Result};
    /// # fn main() -> Result<()> {
    /// # let lua = Lua::new();
-    /// let non_utf8: String = lua.load(r#"  "test\255"  "#).eval()?;
+    /// let non_utf8: LuaString = lua.load(r#"  "test\255"  "#).eval()?;
    /// assert!(non_utf8.to_str().is_err());    // oh no :(
    /// assert_eq!(non_utf8.as_bytes(), &b"test\xff"[..]);
    /// # Ok(())
@@ -109,19 +110,21 @@ impl String {
    /// ```
    #[inline]
    pub fn as_bytes(&self) -> BorrowedBytes {
-        let (bytes, guard) = unsafe { self.to_slice() };
-        BorrowedBytes(&bytes[..bytes.len() - 1], guard)
+        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 (bytes, guard) = unsafe { self.to_slice() };
-        BorrowedBytes(bytes, guard)
+        let BorrowedBytes { buf, vref, _lua } = BorrowedBytes::from(self);
+        // 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, vref, _lua }
    }

+    // Does not return the terminating null byte
    unsafe fn to_slice(&self) -> (&[u8], Lua) {
        let lua = self.0.lua.upgrade();
-        let slice = unsafe {
+        let slice = {
            let rawlua = lua.lock();
            let ref_thread = rawlua.ref_thread();

@@ -134,23 +137,26 @@ impl String {
            // string type
            let mut size = 0;
            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
-            slice::from_raw_parts(data as *const u8, size + 1)
+            slice::from_raw_parts(data as *const u8, size)
        };
        (slice, lua)
    }

-    /// Converts this string to a generic C pointer.
+    /// Converts this Lua string to a generic C pointer.
    ///
    /// There is no way to convert the pointer back to its original value.
    ///
    /// Typically this function is used only for hashing and debug information.
    #[inline]
    pub fn to_pointer(&self) -> *const c_void {
-        self.0.to_pointer()
+        // In Lua < 5.4 (excluding Luau), string pointers are NULL
+        // Use alternative approach
+        let lua = self.0.lua.lock();
+        unsafe { ffi::lua_tostring(lua.ref_thread(), self.0.index) as *const c_void }
    }
 }

-impl fmt::Debug for String {
+impl fmt::Debug for LuaString {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let bytes = self.as_bytes();
        // Check if the string is valid utf8
@@ -166,12 +172,12 @@ impl fmt::Debug for String {

 // Lua strings are basically `&[u8]` slices, so implement `PartialEq` for anything resembling that.
 //
-// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str` and `String`.
+// This makes our `LuaString` comparable with `Vec<u8>`, `[u8]`, `&str` and `String`.
 //
 // The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
 // `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
 // in other ways.
-impl<T> PartialEq<T> for String
+impl<T> PartialEq<T> for LuaString
 where
    T: AsRef<[u8]> + ?Sized,
 {
@@ -180,43 +186,37 @@ where
    }
 }

-impl PartialEq for String {
-    fn eq(&self, other: &String) -> bool {
-        self.as_bytes() == other.as_bytes()
-    }
-}
+impl Eq for LuaString {}

-impl Eq for String {}
-
-impl<T> PartialOrd<T> for String
+impl<T> PartialOrd<T> for LuaString
 where
    T: AsRef<[u8]> + ?Sized,
 {
    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
-        self.as_bytes().partial_cmp(&other.as_ref())
+        <[u8]>::partial_cmp(&self.as_bytes(), other.as_ref())
    }
 }

-impl PartialOrd for String {
-    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
+impl PartialOrd for LuaString {
+    fn partial_cmp(&self, other: &LuaString) -> Option<cmp::Ordering> {
        Some(self.cmp(other))
    }
 }

-impl Ord for String {
-    fn cmp(&self, other: &String) -> cmp::Ordering {
+impl Ord for LuaString {
+    fn cmp(&self, other: &LuaString) -> cmp::Ordering {
        self.as_bytes().cmp(&other.as_bytes())
    }
 }

-impl Hash for String {
+impl Hash for LuaString {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.as_bytes().hash(state);
    }
 }

-#[cfg(feature = "serialize")]
-impl Serialize for String {
+#[cfg(feature = "serde")]
+impl Serialize for LuaString {
    fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
    where
        S: Serializer,
@@ -228,7 +228,7 @@ impl Serialize for String {
    }
 }

-struct Display<'a>(&'a String);
+struct Display<'a>(&'a LuaString);

 impl fmt::Display for Display<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -238,139 +238,172 @@ impl fmt::Display for Display<'_> {
 }

 /// A borrowed string (`&str`) that holds a strong reference to the Lua state.
-pub struct BorrowedStr<'a>(&'a str, #[allow(unused)] Lua);
+pub struct BorrowedStr {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'static str,
+    pub(crate) vref: ValueRef,
+    pub(crate) _lua: Lua,
+}

-impl Deref for BorrowedStr<'_> {
+impl Deref for BorrowedStr {
    type Target = str;

    #[inline(always)]
    fn deref(&self) -> &str {
-        self.0
+        self.buf
    }
 }

-impl Borrow<str> for BorrowedStr<'_> {
+impl Borrow<str> for BorrowedStr {
    #[inline(always)]
    fn borrow(&self) -> &str {
-        self.0
+        self.buf
    }
 }

-impl AsRef<str> for BorrowedStr<'_> {
+impl AsRef<str> for BorrowedStr {
    #[inline(always)]
    fn as_ref(&self) -> &str {
-        self.0
+        self.buf
    }
 }

-impl fmt::Display for BorrowedStr<'_> {
+impl fmt::Display for BorrowedStr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
+        self.buf.fmt(f)
    }
 }

-impl fmt::Debug for BorrowedStr<'_> {
+impl fmt::Debug for BorrowedStr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
+        self.buf.fmt(f)
    }
 }

-impl<T> PartialEq<T> for BorrowedStr<'_>
+impl<T> PartialEq<T> for BorrowedStr
 where
    T: AsRef<str>,
 {
    fn eq(&self, other: &T) -> bool {
-        self.0 == other.as_ref()
+        self.buf == other.as_ref()
    }
 }

-impl Eq for BorrowedStr<'_> {}
+impl Eq for BorrowedStr {}

-impl<T> PartialOrd<T> for BorrowedStr<'_>
+impl<T> PartialOrd<T> for BorrowedStr
 where
    T: AsRef<str>,
 {
    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
-        self.0.partial_cmp(other.as_ref())
+        self.buf.partial_cmp(other.as_ref())
    }
 }

-impl Ord for BorrowedStr<'_> {
+impl Ord for BorrowedStr {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.0.cmp(other.0)
+        self.buf.cmp(other.buf)
+    }
+}
+
+impl TryFrom<&LuaString> for BorrowedStr {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(value: &LuaString) -> Result<Self> {
+        let BorrowedBytes { buf, vref, _lua } = BorrowedBytes::from(value);
+        let buf =
+            str::from_utf8(buf).map_err(|e| Error::from_lua_conversion("string", "&str", e.to_string()))?;
+        Ok(Self { buf, vref, _lua })
    }
 }

 /// A borrowed byte slice (`&[u8]`) that holds a strong reference to the Lua state.
-pub struct BorrowedBytes<'a>(&'a [u8], #[allow(unused)] Lua);
+pub struct BorrowedBytes {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'static [u8],
+    pub(crate) vref: ValueRef,
+    pub(crate) _lua: Lua,
+}

-impl Deref for BorrowedBytes<'_> {
+impl Deref for BorrowedBytes {
    type Target = [u8];

    #[inline(always)]
    fn deref(&self) -> &[u8] {
-        self.0
+        self.buf
    }
 }

-impl Borrow<[u8]> for BorrowedBytes<'_> {
+impl Borrow<[u8]> for BorrowedBytes {
    #[inline(always)]
    fn borrow(&self) -> &[u8] {
-        self.0
+        self.buf
    }
 }

-impl AsRef<[u8]> for BorrowedBytes<'_> {
+impl AsRef<[u8]> for BorrowedBytes {
    #[inline(always)]
    fn as_ref(&self) -> &[u8] {
-        self.0
+        self.buf
    }
 }

-impl fmt::Debug for BorrowedBytes<'_> {
+impl fmt::Debug for BorrowedBytes {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
+        self.buf.fmt(f)
    }
 }

-impl<T> PartialEq<T> for BorrowedBytes<'_>
+impl<T> PartialEq<T> for BorrowedBytes
 where
    T: AsRef<[u8]>,
 {
    fn eq(&self, other: &T) -> bool {
-        self.0 == other.as_ref()
+        self.buf == other.as_ref()
    }
 }

-impl Eq for BorrowedBytes<'_> {}
+impl Eq for BorrowedBytes {}

-impl<T> PartialOrd<T> for BorrowedBytes<'_>
+impl<T> PartialOrd<T> for BorrowedBytes
 where
    T: AsRef<[u8]>,
 {
    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
-        self.0.partial_cmp(other.as_ref())
+        self.buf.partial_cmp(other.as_ref())
    }
 }

-impl Ord for BorrowedBytes<'_> {
+impl Ord for BorrowedBytes {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.0.cmp(other.0)
+        self.buf.cmp(other.buf)
    }
 }

-impl<'a> IntoIterator for BorrowedBytes<'a> {
+impl<'a> IntoIterator for &'a BorrowedBytes {
    type Item = &'a u8;
    type IntoIter = slice::Iter<'a, u8>;

    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
+        self.iter()
+    }
+}
+
+impl From<&LuaString> for BorrowedBytes {
+    #[inline]
+    fn from(value: &LuaString) -> Self {
+        let (buf, _lua) = unsafe { value.to_slice() };
+        let vref = value.0.clone();
+        // SAFETY: The `buf` is valid for the lifetime of the Lua state and occupied slot index
+        let buf = unsafe { mem::transmute::<&[u8], &'static [u8]>(buf) };
+        Self { buf, vref, _lua }
    }
 }

 struct WrappedString<T: AsRef<[u8]>>(T);

-impl String {
+impl LuaString {
    /// Wraps bytes, returning an opaque type that implements [`IntoLua`] trait.
    ///
    /// This function uses [`Lua::create_string`] under the hood.
@@ -385,7 +418,7 @@ impl<T: AsRef<[u8]>> IntoLua for WrappedString<T> {
    }
 }

-impl LuaType for String {
+impl LuaType for LuaString {
    const TYPE_ID: c_int = ffi::LUA_TSTRING;
 }

@@ -394,9 +427,9 @@ mod assertions {
    use super::*;

    #[cfg(not(feature = "send"))]
-    static_assertions::assert_not_impl_any!(String: Send);
+    static_assertions::assert_not_impl_any!(LuaString: Send);
    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(String: Send, Sync);
+    static_assertions::assert_impl_all!(LuaString: Send, Sync);
    #[cfg(feature = "send")]
    static_assertions::assert_impl_all!(BorrowedBytes: Send, Sync);
    #[cfg(feature = "send")]
@@ -1,21 +1,173 @@
+//! Lua table handling.
+//!
+//! Tables are Lua's primary data structure, used for arrays, dictionaries, objects, modules,
+//! and more. This module provides types for creating and manipulating Lua tables from Rust.
+//!
+//! # Basic Operations
+//!
+//! Tables support key-value access similar to Rust's `HashMap`:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let table = lua.create_table()?;
+//!
+//! // Set and get values
+//! table.set("key", "value")?;
+//! let value: String = table.get("key")?;
+//! assert_eq!(value, "value");
+//!
+//! // Keys and values can be any Lua-compatible type
+//! table.set(1, "first")?;
+//! table.set("nested", lua.create_table()?)?;
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Array Operations
+//!
+//! Tables can be used as arrays with 1-based indexing:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let array = lua.create_table()?;
+//!
+//! // Push values to the end (like Vec::push)
+//! array.push("first")?;
+//! array.push("second")?;
+//! array.push("third")?;
+//!
+//! // Pop from the end
+//! let last: String = array.pop()?;
+//! assert_eq!(last, "third");
+//!
+//! // Get length
+//! assert_eq!(array.raw_len(), 2);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Iteration
+//!
+//! Iterate over all key-value pairs with [`Table::pairs`]:
+//!
+//! ```
+//! # use mlua::{Lua, Result, Value};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let table = lua.create_table()?;
+//! table.set("a", 1)?;
+//! table.set("b", 2)?;
+//!
+//! for pair in table.pairs::<String, i32>() {
+//!     let (key, value) = pair?;
+//!     println!("{key} = {value}");
+//! }
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! For array portions, use [`Table::sequence_values`]:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let array = lua.create_sequence_from(["a", "b", "c"])?;
+//!
+//! for value in array.sequence_values::<String>() {
+//!     println!("{}", value?);
+//! }
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Raw vs Normal Access
+//!
+//! Methods prefixed with `raw_` (like [`Table::raw_get`], [`Table::raw_set`]) bypass
+//! metamethods, directly accessing the table's contents. Normal methods may trigger
+//! `__index`, `__newindex`, and other metamethods:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//!
+//! // raw_set bypasses __newindex metamethod
+//! let t = lua.create_table()?;
+//! t.raw_set("key", "value")?;
+//!
+//! // raw_get bypasses __index metamethod
+//! let v: String = t.raw_get("key")?;
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Metatables
+//!
+//! Tables can have metatables that customize their behavior:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//!
+//! let table = lua.create_table()?;
+//! let metatable = lua.create_table()?;
+//!
+//! // Set a default value via __index
+//! metatable.set("__index", lua.create_function(|_, _: ()| Ok("default"))?)?;
+//! table.set_metatable(Some(metatable))?;
+//!
+//! // Accessing missing keys returns "default"
+//! let value: String = table.get("missing")?;
+//! assert_eq!(value, "default");
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Global Table
+//!
+//! The Lua global environment is itself a table, accessible via [`Lua::globals`]:
+//!
+//! ```
+//! # use mlua::{Lua, Result};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let globals = lua.globals();
+//!
+//! // Set a global variable
+//! globals.set("my_var", 42)?;
+//!
+//! // Now accessible from Lua code
+//! let result: i32 = lua.load("my_var + 8").eval()?;
+//! assert_eq!(result, 50);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! [`Lua::globals`]: crate::Lua::globals
+
 use std::collections::HashSet;
 use std::fmt;
 use std::marker::PhantomData;
-use std::os::raw::{c_int, c_void};
-use std::string::String as StdString;
+use std::os::raw::c_void;

 use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::state::{LuaGuard, RawLua};
+use crate::state::{LuaGuard, RawLua, WeakLua};
 use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, ObjectLike};
-use crate::types::{Integer, LuaType, ValueRef};
-use crate::util::{assert_stack, check_stack, get_metatable_ptr, StackGuard};
+use crate::types::{Integer, ValueRef};
+use crate::util::{StackGuard, assert_stack, check_stack, get_metatable_ptr};
 use crate::value::{Nil, Value};

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

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 use {
    rustc_hash::FxHashSet,
    serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer},
@@ -211,7 +363,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)?);
@@ -226,15 +378,15 @@ impl Table {
        // Compare using `__eq` metamethod if exists
        // First, check the self for the metamethod.
        // If self does not define it, then check the other table.
-        if let Some(mt) = self.metatable() {
-            if mt.contains_key("__eq")? {
-                return mt.get::<Function>("__eq")?.call((self, other));
-            }
+        if let Some(mt) = self.metatable()
+            && let Some(eq_func) = mt.get::<Option<Function>>("__eq")?
+        {
+            return eq_func.call((self, other));
        }
-        if let Some(mt) = other.metatable() {
-            if mt.contains_key("__eq")? {
-                return mt.get::<Function>("__eq")?.call((self, other));
-            }
+        if let Some(mt) = other.metatable()
+            && let Some(eq_func) = mt.get::<Option<Function>>("__eq")?
+        {
+            return eq_func.call((self, other));
        }

        Ok(false)
@@ -416,14 +568,7 @@ impl Table {

                lua.push_ref(&self.0);

-                // Clear array part
-                for i in 1..=ffi::lua_rawlen(state, -1) {
-                    ffi::lua_pushnil(state);
-                    ffi::lua_rawseti(state, -2, i as Integer);
-                }
-
-                // Clear hash part
-                // It must be safe as long as we don't use invalid keys
+                // This is safe as long as we don't assign new keys
                ffi::lua_pushnil(state);
                while ffi::lua_next(state, -2) != 0 {
                    ffi::lua_pop(state, 1); // pop value
@@ -468,26 +613,16 @@ impl Table {
    ///
    /// It checks both the array part and the hash part.
    pub fn is_empty(&self) -> bool {
-        // Check array part
-        if self.raw_len() != 0 {
-            return false;
-        }
-
-        // Check hash part
        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, 4);
-
-            lua.push_ref(&self.0);
-            ffi::lua_pushnil(state);
-            if ffi::lua_next(state, -2) != 0 {
-                return false;
+            ffi::lua_pushnil(ref_thread);
+            if ffi::lua_next(ref_thread, self.0.index) == 0 {
+                return true;
            }
+            ffi::lua_pop(ref_thread, 2);
        }
-
-        true
+        false
    }

    /// Returns a reference to the metatable of this table, or `None` if no metatable is set.
@@ -497,52 +632,37 @@ 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()))
            }
        }
    }

-    #[doc(hidden)]
-    #[deprecated(since = "0.10.0", note = "please use `metatable` instead")]
-    #[cfg(not(tarpaulin_include))]
-    pub fn get_metatable(&self) -> Option<Table> {
-        self.metatable()
-    }
-
    /// Sets or removes the metatable of this 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.
@@ -554,8 +674,6 @@ impl Table {
    }

    /// Sets `readonly` attribute on the table.
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub fn set_readonly(&self, enabled: bool) {
@@ -571,8 +689,6 @@ impl Table {
    }

    /// Returns `readonly` attribute of the table.
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub fn is_readonly(&self) -> bool {
@@ -590,8 +706,6 @@ impl Table {
    /// - Fast-path for some built-in functions (fastcall).
    ///
    /// For `safeenv` environments, monkey patching or modifying values may not work as expected.
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub fn set_safeenv(&self, enabled: bool) {
@@ -636,7 +750,7 @@ impl Table {
    /// ```
    ///
    /// [Lua manual]: http://www.lua.org/manual/5.4/manual.html#pdf-next
-    pub fn pairs<K: FromLua, V: FromLua>(&self) -> TablePairs<K, V> {
+    pub fn pairs<K: FromLua, V: FromLua>(&self) -> TablePairs<'_, K, V> {
        TablePairs {
            guard: self.0.lua.lock(),
            table: self,
@@ -664,10 +778,8 @@ impl Table {
            ffi::lua_pushnil(state);
            while ffi::lua_next(state, -2) != 0 {
                let k = K::from_stack(-2, &lua)?;
-                let v = V::from_stack(-1, &lua)?;
+                let v = lua.pop::<V>()?;
                f(k, v)?;
-                // Keep key for next iteration
-                ffi::lua_pop(state, 1);
            }
        }
        Ok(())
@@ -701,21 +813,30 @@ impl Table {
    /// # Ok(())
    /// # }
    /// ```
-    pub fn sequence_values<V: FromLua>(&self) -> TableSequence<V> {
+    pub fn sequence_values<V: FromLua>(&self) -> TableSequence<'_, V> {
        TableSequence {
            guard: self.0.lua.lock(),
            table: self,
            index: 1,
+            len: None,
            _phantom: PhantomData,
        }
    }

    /// Iterates over the sequence part of the table, invoking the given closure on each value.
+    ///
+    /// This methods is similar to [`Table::sequence_values`], but optimized for performance.
    #[doc(hidden)]
-    pub fn for_each_value<V>(&self, mut f: impl FnMut(V) -> Result<()>) -> Result<()>
-    where
-        V: FromLua,
-    {
+    pub fn for_each_value<V: FromLua>(&self, f: impl FnMut(V) -> Result<()>) -> Result<()> {
+        self.for_each_value_by_len(None, f)
+    }
+
+    fn for_each_value_by_len<V: FromLua>(
+        &self,
+        len: impl Into<Option<usize>>,
+        mut f: impl FnMut(V) -> Result<()>,
+    ) -> Result<()> {
+        let len = len.into();
        let lua = self.0.lua.lock();
        let state = lua.state();
        unsafe {
@@ -723,11 +844,15 @@ impl Table {
            check_stack(state, 4)?;

            lua.push_ref(&self.0);
-            let len = ffi::lua_rawlen(state, -1);
-            for i in 1..=len {
-                ffi::lua_rawgeti(state, -1, i as _);
-                f(V::from_stack(-1, &lua)?)?;
-                ffi::lua_pop(state, 1);
+            for i in 1.. {
+                if len.map(|len| i > len).unwrap_or(false) {
+                    break;
+                }
+                let t = ffi::lua_rawgeti(state, -1, i as _);
+                if len.is_none() && t == ffi::LUA_TNIL {
+                    break;
+                }
+                f(lua.pop::<V>()?)?;
            }
        }
        Ok(())
@@ -758,8 +883,9 @@ impl Table {
        Ok(())
    }

-    #[cfg(feature = "serialize")]
-    pub(crate) fn is_array(&self) -> bool {
+    /// Checks if the table has the array metatable attached.
+    #[cfg(feature = "serde")]
+    fn has_array_metatable(&self) -> bool {
        let lua = self.0.lua.lock();
        let state = lua.state();
        unsafe {
@@ -775,6 +901,70 @@ impl Table {
        }
    }

+    /// If the table is an array, returns the number of non-nil elements and max index.
+    ///
+    /// Returns `None` if the table is not an array.
+    ///
+    /// This operation has O(n) complexity.
+    #[cfg(feature = "serde")]
+    fn find_array_len(&self) -> Option<(usize, usize)> {
+        let lua = self.0.lua.lock();
+        let ref_thread = lua.ref_thread();
+        unsafe {
+            let _sg = StackGuard::new(ref_thread);
+
+            let (mut count, mut max_index) = (0, 0);
+            ffi::lua_pushnil(ref_thread);
+            while ffi::lua_next(ref_thread, self.0.index) != 0 {
+                if ffi::lua_type(ref_thread, -2) != ffi::LUA_TNUMBER {
+                    return None;
+                }
+
+                let k = ffi::lua_tonumber(ref_thread, -2);
+                if k.trunc() != k || k < 1.0 {
+                    return None;
+                }
+                max_index = std::cmp::max(max_index, k as usize);
+                count += 1;
+                ffi::lua_pop(ref_thread, 1);
+            }
+            Some((count, max_index))
+        }
+    }
+
+    /// Determines if the table should be encoded as an array or a map.
+    ///
+    /// The algorithm is the following:
+    /// 1. If `detect_mixed_tables` is enabled, iterate over all keys in the table checking is they
+    ///    all are positive integers. If non-array key is found, return `None` (encode as map).
+    ///    Otherwise check the sparsity of the array. Too sparse arrays are encoded as maps.
+    ///
+    /// 2. If `detect_mixed_tables` is disabled, check if the table has a positive length or has the
+    ///    array metatable. If so, encode as array. If the table is empty and
+    ///    `encode_empty_tables_as_array` is enabled, encode as array.
+    ///
+    /// Returns the length of the array if it should be encoded as an array.
+    #[cfg(feature = "serde")]
+    pub(crate) fn encode_as_array(&self, options: crate::serde::de::Options) -> Option<usize> {
+        if options.detect_mixed_tables {
+            if let Some((len, max_idx)) = self.find_array_len() {
+                // If the array is too sparse, serialize it as a map instead
+                if len < 10 || len * 2 >= max_idx {
+                    return Some(max_idx);
+                }
+            }
+        } else {
+            let len = self.raw_len();
+            if len > 0 || self.has_array_metatable() {
+                return Some(len);
+            }
+            if options.encode_empty_tables_as_array && self.is_empty() {
+                return Some(0);
+            }
+        }
+        None
+    }
+
    #[cfg(feature = "luau")]
    #[inline(always)]
    fn check_readonly_write(&self, lua: &RawLua) -> Result<()> {
@@ -894,10 +1084,6 @@ where
    }
 }

-impl LuaType for Table {
-    const TYPE_ID: c_int = ffi::LUA_TTABLE;
-}
-
 impl ObjectLike for Table {
    #[inline]
    fn get<V: FromLua>(&self, key: impl IntoLua) -> Result<V> {
@@ -915,16 +1101,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]
@@ -936,7 +1122,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,
    {
@@ -956,35 +1142,45 @@ 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()
+    fn to_string(&self) -> Result<String> {
+        Value::Table(Table(self.0.clone())).to_string()
+    }
+
+    #[inline]
+    fn to_value(&self) -> Value {
+        Value::Table(self.clone())
+    }
+
+    #[inline]
+    fn weak_lua(&self) -> &WeakLua {
+        &self.0.lua
    }
 }

 /// A wrapped [`Table`] with customized serialization behavior.
-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 pub(crate) struct SerializableTable<'a> {
    table: &'a Table,
    options: crate::serde::de::Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl Serialize for Table {
    #[inline]
    fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
@@ -992,7 +1188,7 @@ impl Serialize for Table {
    }
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl<'a> SerializableTable<'a> {
    #[inline]
    pub(crate) fn new(
@@ -1008,13 +1204,22 @@ impl<'a> SerializableTable<'a> {
    }
 }

-#[cfg(feature = "serialize")]
+impl<V> TableSequence<'_, V> {
+    /// Sets the length (hint) of the sequence.
+    #[cfg(feature = "serde")]
+    pub(crate) fn with_len(mut self, len: usize) -> Self {
+        self.len = Some(len);
+        self
+    }
+}
+
+#[cfg(feature = "serde")]
 impl Serialize for SerializableTable<'_> {
    fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
    where
        S: Serializer,
    {
-        use crate::serde::de::{check_value_for_skip, MapPairs, RecursionGuard};
+        use crate::serde::de::{MapPairs, RecursionGuard, check_value_for_skip};
        use crate::value::SerializableValue;

        let convert_result = |res: Result<()>, serialize_err: Option<S::Error>| match res {
@@ -1029,11 +1234,10 @@ impl Serialize for SerializableTable<'_> {
        let _guard = RecursionGuard::new(self.table, visited);

        // Array
-        let len = self.table.raw_len();
-        if len > 0 || self.table.is_array() {
+        if let Some(len) = self.table.encode_as_array(self.options) {
            let mut seq = serializer.serialize_seq(Some(len))?;
            let mut serialize_err = None;
-            let res = self.table.for_each_value::<Value>(|value| {
+            let res = self.table.for_each_value_by_len::<Value>(len, |value| {
                let skip = check_value_for_skip(&value, self.options, visited)
                    .map_err(|err| Error::SerializeError(err.to_string()))?;
                if skip {
@@ -1043,7 +1247,7 @@ impl Serialize for SerializableTable<'_> {
                seq.serialize_element(&SerializableValue::new(&value, options, Some(visited)))
                    .map_err(|err| {
                        serialize_err = Some(err);
-                        Error::SerializeError(StdString::new())
+                        Error::SerializeError(String::new())
                    })
            });
            convert_result(res, serialize_err)?;
@@ -1068,7 +1272,7 @@ impl Serialize for SerializableTable<'_> {
            )
            .map_err(|err| {
                serialize_err = Some(err);
-                Error::SerializeError(StdString::new())
+                Error::SerializeError(String::new())
            })
        };

@@ -1157,13 +1361,11 @@ pub struct TableSequence<'a, V> {
    guard: LuaGuard,
    table: &'a Table,
    index: Integer,
+    len: Option<usize>,
    _phantom: PhantomData<V>,
 }

-impl<V> Iterator for TableSequence<'_, V>
-where
-    V: FromLua,
-{
+impl<V: FromLua> Iterator for TableSequence<'_, V> {
    type Item = Result<V>;

    fn next(&mut self) -> Option<Self::Item> {
@@ -1177,7 +1379,7 @@ where

            lua.push_ref(&self.table.0);
            match ffi::lua_rawgeti(state, -1, self.index) {
-                ffi::LUA_TNIL => None,
+                ffi::LUA_TNIL if self.index as usize > self.len.unwrap_or(0) => None,
                _ => {
                    self.index += 1;
                    Some(V::from_stack(-1, lua))
@@ -1,18 +1,54 @@
+//! Lua thread (coroutine) handling.
+//!
+//! This module provides types for creating and working with Lua coroutines from Rust.
+//! Coroutines allow cooperative multitasking within a single Lua state by suspending and
+//! resuming execution at well-defined yield points.
+//!
+//! # Basic Usage
+//!
+//! Threads are created via [`Lua::create_thread`] and driven by calling [`Thread::resume`]:
+//!
+//! ```rust
+//! # use mlua::{Lua, Result, Thread};
+//! # fn main() -> Result<()> {
+//! let lua = Lua::new();
+//! let thread: Thread = lua.load(r#"
+//!     coroutine.create(function(a, b)
+//!         coroutine.yield(a + b)
+//!         return a * b
+//!     end)
+//! "#).eval()?;
+//!
+//! assert_eq!(thread.resume::<i32>((3, 4))?, 7);
+//! assert_eq!(thread.resume::<i32>(())?,    12);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Async Support
+//!
+//! When the `async` feature is enabled, a [`Thread`] can be converted into an [`AsyncThread`]
+//! via [`Thread::into_async`], which implements both [`Future`] and [`Stream`].
+//! This integrates Lua coroutines naturally with Rust async runtimes such as Tokio.
+//!
+//! [`Lua::create_thread`]: crate::Lua::create_thread
+//! [`Future`]: std::future::Future
+//! [`Stream`]: futures_util::stream::Stream
+
 use std::fmt;
 use std::os::raw::{c_int, c_void};

 use crate::error::{Error, Result};
-#[allow(unused)]
-use crate::state::Lua;
+use crate::function::Function;
 use crate::state::RawLua;
 use crate::traits::{FromLuaMulti, IntoLuaMulti};
-use crate::types::{LuaType, ValueRef};
-use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
+use crate::types::{LuaType, ValueRef, XRc};
+use crate::util::{StackGuard, check_stack, error_traceback_thread, pop_error};

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

 #[cfg(feature = "async")]
@@ -27,6 +63,85 @@ use {
    },
 };

+/// Controls which thread lifecycle events trigger the callback.
+#[derive(Clone, Copy, Debug, Default)]
+#[non_exhaustive]
+pub struct ThreadTriggers {
+    /// Trigger the callback when a new thread is created.
+    pub on_create: bool,
+    /// Trigger the callback before a thread is resumed (via [`Thread::resume`]).
+    pub on_resume: bool,
+    /// Trigger the callback after a thread yields.
+    pub on_yield: bool,
+}
+
+impl ThreadTriggers {
+    /// An instance of [`ThreadTriggers`] with `on_create` trigger set.
+    pub const ON_CREATE: Self = Self::new().on_create();
+
+    /// An instance of [`ThreadTriggers`] with `on_resume` trigger set.
+    pub const ON_RESUME: Self = Self::new().on_resume();
+
+    /// An instance of [`ThreadTriggers`] with `on_yield` trigger set.
+    pub const ON_YIELD: Self = Self::new().on_yield();
+
+    /// Returns a new instance of `ThreadTriggers` with all triggers disabled.
+    pub const fn new() -> Self {
+        Self {
+            on_create: false,
+            on_resume: false,
+            on_yield: false,
+        }
+    }
+
+    /// Returns an instance of `ThreadTriggers` with `on_create` trigger set.
+    pub const fn on_create(mut self) -> Self {
+        self.on_create = true;
+        self
+    }
+
+    /// Returns an instance of `ThreadTriggers` with `on_resume` trigger set.
+    pub const fn on_resume(mut self) -> Self {
+        self.on_resume = true;
+        self
+    }
+
+    /// Returns an instance of `ThreadTriggers` with `on_yield` trigger set.
+    pub const fn on_yield(mut self) -> Self {
+        self.on_yield = true;
+        self
+    }
+}
+
+impl std::ops::BitOr for ThreadTriggers {
+    type Output = Self;
+
+    fn bitor(mut self, rhs: Self) -> Self::Output {
+        self.on_create |= rhs.on_create;
+        self.on_resume |= rhs.on_resume;
+        self.on_yield |= rhs.on_yield;
+        self
+    }
+}
+
+impl std::ops::BitOrAssign for ThreadTriggers {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
+}
+
+/// Represents a thread (coroutine) event.
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub enum ThreadEvent {
+    /// A new thread was created.
+    Create(Thread),
+    /// A thread is about to be resumed via [`Thread::resume`].
+    Resume(Thread),
+    /// A thread has just yielded.
+    Yield(Thread),
+}
+
 /// Status of a Lua thread (coroutine).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum ThreadStatus {
@@ -42,8 +157,34 @@ pub enum ThreadStatus {
    Error,
 }

+/// Internal representation of a Lua thread status.
+///
+/// The number in `New` and `Yielded` variants is the number of arguments pushed
+/// to the thread stack.
+#[derive(Clone, Copy)]
+enum ThreadStatusInner {
+    New(c_int),
+    Running,
+    Yielded(c_int),
+    Finished,
+    Error,
+}
+
+impl ThreadStatusInner {
+    #[cfg(feature = "async")]
+    #[inline(always)]
+    fn is_resumable(self) -> bool {
+        matches!(self, ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_))
+    }
+
+    #[inline(always)]
+    fn is_yielded(self) -> bool {
+        matches!(self, ThreadStatusInner::Yielded(_))
+    }
+}
+
 /// Handle to an internal Lua thread (coroutine).
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct Thread(pub(crate) ValueRef, pub(crate) *mut ffi::lua_State);

 #[cfg(feature = "send")]
@@ -53,23 +194,21 @@ unsafe impl Sync for Thread {}

 /// Thread (coroutine) representation as an async [`Future`] or [`Stream`].
 ///
-/// Requires `feature = "async"`
-///
 /// [`Future`]: std::future::Future
 /// [`Stream`]: futures_util::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct AsyncThread<A, R> {
+pub struct AsyncThread<R> {
    thread: Thread,
-    init_args: Option<A>,
-    ret: PhantomData<R>,
+    ret: PhantomData<fn() -> R>,
    recycle: bool,
 }

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

@@ -122,17 +261,94 @@ impl Thread {
        R: FromLuaMulti,
    {
        let lua = self.0.lua.lock();
-        if self.status_inner(&lua) != ThreadStatus::Resumable {
-            return Err(Error::CoroutineUnresumable);
-        }
+        let mut pushed_nargs = match self.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
+            _ => return Err(Error::CoroutineUnresumable),
+        };

        let state = lua.state();
        let thread_state = self.state();
        unsafe {
            let _sg = StackGuard::new(state);
-            let _thread_sg = StackGuard::with_top(thread_state, 0);

-            let nresults = self.resume_inner(&lua, args)?;
+            // Exec thread resume callback
+            if lua.thread_event_triggers().on_resume
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Resume(self.clone()))?;
+            }
+
+            let nargs = args.push_into_stack_multi(&lua)?;
+            if nargs > 0 {
+                check_stack(thread_state, nargs)?;
+                ffi::lua_xmove(state, thread_state, nargs);
+                pushed_nargs += nargs;
+            }
+
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let (status, nresults) = self.resume_inner(&lua, pushed_nargs)?;
+
+            // Exec thread yield callback
+            if lua.thread_event_triggers().on_yield
+                && status.is_yielded()
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Yield(self.clone()))?;
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            R::from_stack_multi(nresults, &lua)
+        }
+    }
+
+    /// Resumes execution of this thread, immediately raising an error.
+    ///
+    /// This is a Luau specific extension.
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn resume_error<R>(&self, error: impl crate::IntoLua) -> Result<R>
+    where
+        R: FromLuaMulti,
+    {
+        let lua = self.0.lua.lock();
+        match self.status_inner(&lua) {
+            ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_) => {}
+            _ => return Err(Error::CoroutineUnresumable),
+        };
+
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+
+            // Exec thread resume callback
+            if lua.thread_event_triggers().on_resume
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Resume(self.clone()))?;
+            }
+
+            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 (status, nresults) = self.resume_inner(&lua, ffi::LUA_RESUMEERROR)?;
+
+            // Exec thread yield callback
+            if lua.thread_event_triggers().on_yield
+                && status.is_yielded()
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Yield(self.clone()))?;
+            }
+
            check_stack(state, nresults + 1)?;
            ffi::lua_xmove(thread_state, state, nresults);

@@ -143,103 +359,134 @@ impl Thread {
    /// Resumes execution of this thread.
    ///
    /// It's similar to `resume()` but leaves `nresults` values on the thread stack.
-    unsafe fn resume_inner(&self, lua: &RawLua, args: impl IntoLuaMulti) -> Result<c_int> {
+    unsafe fn resume_inner(&self, lua: &RawLua, nargs: c_int) -> Result<(ThreadStatusInner, c_int)> {
        let state = lua.state();
        let thread_state = self.state();
-
-        let nargs = args.push_into_stack_multi(lua)?;
-        if nargs > 0 {
-            check_stack(thread_state, nargs)?;
-            ffi::lua_xmove(state, thread_state, nargs);
-        }
-
        let mut nresults = 0;
+        #[cfg(not(feature = "luau"))]
        let ret = ffi::lua_resume(thread_state, state, nargs, &mut nresults as *mut c_int);
-        if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-            if ret == ffi::LUA_ERRMEM {
+        #[cfg(feature = "luau")]
+        let ret = ffi::lua_resumex(thread_state, state, nargs, &mut nresults as *mut c_int);
+        match ret {
+            ffi::LUA_OK => Ok((ThreadStatusInner::Finished, nresults)),
+            ffi::LUA_YIELD => Ok((ThreadStatusInner::Yielded(0), nresults)),
+            ffi::LUA_ERRMEM => {
                // Don't call error handler for memory errors
-                return Err(pop_error(thread_state, ret));
+                Err(pop_error(thread_state, ret))
+            }
+            _ => {
+                check_stack(state, 3)?;
+                protect_lua!(state, 0, 1, |state| error_traceback_thread(state, thread_state))?;
+                Err(pop_error(state, ret))
            }
-            check_stack(state, 3)?;
-            protect_lua!(state, 0, 1, |state| error_traceback_thread(state, thread_state))?;
-            return Err(pop_error(state, ret));
        }
-
-        Ok(nresults)
    }

    /// Gets the status of the thread.
    pub fn status(&self) -> ThreadStatus {
-        self.status_inner(&self.0.lua.lock())
+        match self.status_inner(&self.0.lua.lock()) {
+            ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_) => ThreadStatus::Resumable,
+            ThreadStatusInner::Running => ThreadStatus::Running,
+            ThreadStatusInner::Finished => ThreadStatus::Finished,
+            ThreadStatusInner::Error => ThreadStatus::Error,
+        }
    }

    /// Gets the status of the thread (internal implementation).
-    pub(crate) fn status_inner(&self, lua: &RawLua) -> ThreadStatus {
+    fn status_inner(&self, lua: &RawLua) -> ThreadStatusInner {
        let thread_state = self.state();
        if thread_state == lua.state() {
            // The thread is currently running
-            return ThreadStatus::Running;
+            return ThreadStatusInner::Running;
        }
        let status = unsafe { ffi::lua_status(thread_state) };
-        if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
-            ThreadStatus::Error
-        } else if status == ffi::LUA_YIELD || unsafe { ffi::lua_gettop(thread_state) > 0 } {
-            ThreadStatus::Resumable
-        } else {
-            ThreadStatus::Finished
+        let top = unsafe { ffi::lua_gettop(thread_state) };
+        match status {
+            ffi::LUA_YIELD => ThreadStatusInner::Yielded(top),
+            ffi::LUA_OK if top > 0 => ThreadStatusInner::New(top - 1),
+            ffi::LUA_OK => ThreadStatusInner::Finished,
+            _ => ThreadStatusInner::Error,
        }
    }

+    /// Returns `true` if this thread is resumable (meaning it can be resumed by calling
+    /// [`Thread::resume`]).
+    #[inline(always)]
+    pub fn is_resumable(&self) -> bool {
+        self.status() == ThreadStatus::Resumable
+    }
+
+    /// Returns `true` if this thread is currently running.
+    #[inline(always)]
+    pub fn is_running(&self) -> bool {
+        self.status() == ThreadStatus::Running
+    }
+
+    /// Returns `true` if this thread has finished executing.
+    #[inline(always)]
+    pub fn is_finished(&self) -> bool {
+        self.status() == ThreadStatus::Finished
+    }
+
+    /// Returns `true` if this thread has raised a Lua error during execution.
+    #[inline(always)]
+    pub fn is_error(&self) -> bool {
+        self.status() == ThreadStatus::Error
+    }
+
    /// Sets a hook function that will periodically be called as Lua code executes.
    ///
    /// This function is similar or [`Lua::set_hook`] except that it sets for the thread.
-    /// To remove a hook call [`Lua::remove_hook`].
+    /// You can have multiple hooks for different threads.
+    ///
+    /// To remove a hook call [`Thread::remove_hook`].
+    ///
+    /// [`Lua::set_hook`]: crate::Lua::set_hook
    #[cfg(not(feature = "luau"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
-    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)
+    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
    where
-        F: Fn(&Lua, Debug) -> Result<crate::VmState> + MaybeSend + 'static,
+        F: Fn(&crate::Lua, &Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
    {
        let lua = self.0.lua.lock();
        unsafe {
-            lua.set_thread_hook(self.state(), triggers, callback);
+            lua.set_thread_hook(
+                self.state(),
+                HookKind::Thread(triggers, crate::types::XRc::new(callback)),
+            )
+        }
+    }
+
+    /// Removes any hook function from this thread.
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn remove_hook(&self) {
+        let _lua = self.0.lua.lock();
+        unsafe {
+            ffi::lua_sethook(self.state(), None, 0, 0);
        }
    }

    /// Resets a thread
    ///
    /// In [Lua 5.4]: cleans its call stack and closes all pending to-be-closed variables.
-    /// Returns a error in case of either the original error that stopped the thread or errors
+    /// Returns an error in case of either the original error that stopped the thread or errors
    /// in closing methods.
    ///
    /// In Luau: resets to the initial state of a newly created Lua thread.
    /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
    ///
+    /// Other Lua versions can reset only new or finished threads.
+    ///
    /// Sets a Lua function for the thread afterwards.
    ///
-    /// Requires `feature = "lua54"` OR `feature = "luau"`.
-    ///
    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_closethread
-    #[cfg(any(feature = "lua54", feature = "luau"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua54", feature = "luau"))))]
-    pub fn reset(&self, func: crate::function::Function) -> Result<()> {
+    pub fn reset(&self, func: Function) -> Result<()> {
        let lua = self.0.lua.lock();
-        if self.status_inner(&lua) == ThreadStatus::Running {
-            return Err(Error::runtime("cannot reset a running thread"));
-        }
-
        let thread_state = self.state();
        unsafe {
-            #[cfg(all(feature = "lua54", not(feature = "vendored")))]
-            let status = ffi::lua_resetthread(thread_state);
-            #[cfg(all(feature = "lua54", feature = "vendored"))]
-            let status = ffi::lua_closethread(thread_state, lua.state());
-            #[cfg(feature = "lua54")]
-            if status != ffi::LUA_OK {
-                return Err(pop_error(thread_state, status));
-            }
-            #[cfg(feature = "luau")]
-            ffi::lua_resetthread(thread_state);
+            let status = self.status_inner(&lua);
+            self.reset_inner(status)?;

            // Push function to the top of the thread stack
            ffi::lua_xpush(lua.ref_thread(), thread_state, func.0.index);
@@ -255,9 +502,47 @@ impl Thread {
        }
    }

+    unsafe fn reset_inner(&self, status: ThreadStatusInner) -> Result<()> {
+        match status {
+            ThreadStatusInner::New(_) => {
+                // The thread is new, so we can just set the top to 0
+                ffi::lua_settop(self.state(), 0);
+                Ok(())
+            }
+            ThreadStatusInner::Running => Err(Error::runtime("cannot reset a running thread")),
+            ThreadStatusInner::Finished => Ok(()),
+            #[cfg(not(any(feature = "lua55", feature = "lua54", feature = "luau")))]
+            ThreadStatusInner::Yielded(_) | ThreadStatusInner::Error => {
+                Err(Error::runtime("cannot reset non-finished thread"))
+            }
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "luau"))]
+            ThreadStatusInner::Yielded(_) | ThreadStatusInner::Error => {
+                let thread_state = self.state();
+
+                #[cfg(all(feature = "lua54", not(feature = "vendored")))]
+                let status = ffi::lua_resetthread(thread_state);
+                #[cfg(any(feature = "lua55", all(feature = "lua54", feature = "vendored")))]
+                let status = {
+                    let lua = self.0.lua.lock();
+                    ffi::lua_closethread(thread_state, lua.state())
+                };
+                #[cfg(any(feature = "lua55", feature = "lua54"))]
+                if status != ffi::LUA_OK {
+                    return Err(pop_error(thread_state, status));
+                }
+                #[cfg(feature = "luau")]
+                ffi::lua_resetthread(thread_state);
+
+                Ok(())
+            }
+        }
+    }
+
    /// Converts [`Thread`] to an [`AsyncThread`] which implements [`Future`] and [`Stream`] traits.
    ///
-    /// `args` are passed as arguments to the thread function for first call.
+    /// Only resumable threads can be converted to [`AsyncThread`].
+    ///
+    /// `args` are pushed to the thread stack and will be used when the thread is resumed.
    /// The object calls [`resume`] while polling and also allow to run Rust futures
    /// to completion using an executor.
    ///
@@ -265,8 +550,6 @@ impl Thread {
    /// values whereas [`Future`] version discards that values and poll until the final
    /// one (returned from the thread function).
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`Future`]: std::future::Future
    /// [`Stream`]: futures_util::stream::Stream
    /// [`resume`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
@@ -290,7 +573,7 @@ impl Thread {
    ///     end)
    /// "#).eval()?;
    ///
-    /// let mut stream = thread.into_async::<i64>(1);
+    /// let mut stream = thread.into_async::<i64>(1)?;
    /// let mut sum = 0;
    /// while let Some(n) = stream.try_next().await? {
    ///     sum += n;
@@ -303,15 +586,31 @@ impl Thread {
    /// ```
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn into_async<R>(self, args: impl IntoLuaMulti) -> AsyncThread<impl IntoLuaMulti, R>
+    pub fn into_async<R>(self, args: impl IntoLuaMulti) -> Result<AsyncThread<R>>
    where
        R: FromLuaMulti,
    {
-        AsyncThread {
-            thread: self,
-            init_args: Some(args),
-            ret: PhantomData,
-            recycle: false,
+        let lua = self.0.lua.lock();
+        if !self.status_inner(&lua).is_resumable() {
+            return Err(Error::CoroutineUnresumable);
+        }
+
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+
+            let nargs = args.push_into_stack_multi(&lua)?;
+            if nargs > 0 {
+                check_stack(thread_state, nargs)?;
+                ffi::lua_xmove(state, thread_state, nargs);
+            }
+
+            Ok(AsyncThread {
+                thread: self,
+                ret: PhantomData,
+                recycle: false,
+            })
        }
    }

@@ -325,6 +624,8 @@ impl Thread {
    /// Please note that Luau links environment table with chunk when loading it into Lua state.
    /// Therefore you need to load chunks into a thread to link with the thread environment.
    ///
+    /// [`Lua::sandbox`]: crate::Lua::sandbox
+    ///
    /// # Examples
    ///
    /// ```
@@ -338,7 +639,7 @@ impl Thread {
    ///     Ok(())
    /// })?)?;
    /// thread.sandbox()?;
-    /// thread.resume(())?;
+    /// thread.resume::<()>(())?;
    ///
    /// // The global environment should be unchanged
    /// assert_eq!(lua.globals().get::<Option<u32>>("var")?, None);
@@ -348,11 +649,8 @@ impl Thread {
    /// # #[cfg(not(feature = "luau"))]
    /// # fn main() { }
    /// ```
-    ///
-    /// Requires `feature = "luau"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    #[doc(hidden)]
    pub fn sandbox(&self) -> Result<()> {
        let lua = self.0.lua.lock();
        let state = lua.state();
@@ -381,41 +679,39 @@ impl fmt::Debug for Thread {
    }
 }

-impl PartialEq for Thread {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-
 impl LuaType for Thread {
    const TYPE_ID: c_int = ffi::LUA_TTHREAD;
 }

 #[cfg(feature = "async")]
-impl<A, R> AsyncThread<A, R> {
-    #[inline]
+impl<R> AsyncThread<R> {
+    #[inline(always)]
    pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
        self.recycle = recyclable;
    }
 }

 #[cfg(feature = "async")]
-#[cfg(any(feature = "lua54", feature = "luau"))]
-impl<A, R> Drop for AsyncThread<A, R> {
+impl<R> Drop for AsyncThread<R> {
    fn drop(&mut self) {
+        #[allow(clippy::collapsible_if)]
        if self.recycle {
            if let Some(lua) = self.thread.0.lua.try_lock() {
                unsafe {
-                    // For Lua 5.4 this also closes all pending to-be-closed variables
-                    if !lua.recycle_thread(&mut self.thread) {
-                        #[cfg(feature = "lua54")]
-                        if self.thread.status_inner(&lua) == ThreadStatus::Error {
-                            #[cfg(not(feature = "vendored"))]
-                            ffi::lua_resetthread(self.thread.state());
-                            #[cfg(feature = "vendored")]
-                            ffi::lua_closethread(self.thread.state(), lua.state());
+                    let mut status = self.thread.status_inner(&lua);
+                    if matches!(status, ThreadStatusInner::Yielded(0)) {
+                        // The thread is dropped while yielded, resume it with the "terminate" signal
+                        ffi::lua_pushlightuserdata(self.thread.1, crate::Lua::poll_terminate().0);
+                        if let Ok((new_status, _)) = self.thread.resume_inner(&lua, 1) {
+                            // `new_status` should always be `ThreadStatusInner::Yielded(0)`
+                            status = new_status;
                        }
                    }
+
+                    // For Lua 5.4 this also closes all pending to-be-closed variables
+                    if self.thread.reset_inner(status).is_ok() {
+                        lua.recycle_thread(&mut self.thread);
+                    }
                }
            }
        }
@@ -423,14 +719,15 @@ impl<A, R> Drop for AsyncThread<A, R> {
 }

 #[cfg(feature = "async")]
-impl<A: IntoLuaMulti, R: FromLuaMulti> Stream for AsyncThread<A, R> {
+impl<R: FromLuaMulti> Stream for AsyncThread<R> {
    type Item = Result<R>;

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let lua = self.thread.0.lua.lock();
-        if self.thread.status_inner(&lua) != ThreadStatus::Resumable {
-            return Poll::Ready(None);
-        }
+        let nargs = match self.thread.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
+            _ => return Poll::Ready(None),
+        };

        let state = lua.state();
        let thread_state = self.thread.state();
@@ -439,36 +736,50 @@ impl<A: IntoLuaMulti, R: FromLuaMulti> Stream for AsyncThread<A, R> {
            let _thread_sg = StackGuard::with_top(thread_state, 0);
            let _wg = WakerGuard::new(&lua, cx.waker());

-            // This is safe as we are not moving the whole struct
-            let this = self.get_unchecked_mut();
-            let nresults = if let Some(args) = this.init_args.take() {
-                this.thread.resume_inner(&lua, args)?
-            } else {
-                this.thread.resume_inner(&lua, ())?
-            };
+            // Exec thread resume callback
+            if lua.thread_event_triggers().on_resume
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Resume(self.thread.clone()))?;
+            }

-            if nresults == 1 && is_poll_pending(thread_state) {
-                return Poll::Pending;
+            let (status, nresults) = (self.thread).resume_inner(&lua, nargs)?;
+
+            if status.is_yielded() {
+                // Exec thread yield callback
+                if lua.thread_event_triggers().on_yield
+                    && let Some(cb) = lua.thread_event_callback()
+                    && XRc::strong_count(&cb) <= 2
+                {
+                    cb(lua.lua(), ThreadEvent::Yield(self.thread.clone()))?;
+                }
+
+                if nresults == 1 && is_poll_pending(thread_state) {
+                    return Poll::Pending;
+                }
+                // Continue polling
+                cx.waker().wake_by_ref();
            }

            check_stack(state, nresults + 1)?;
            ffi::lua_xmove(thread_state, state, nresults);

-            cx.waker().wake_by_ref();
            Poll::Ready(Some(R::from_stack_multi(nresults, &lua)))
        }
    }
 }

 #[cfg(feature = "async")]
-impl<A: IntoLuaMulti, R: FromLuaMulti> Future for AsyncThread<A, R> {
+impl<R: FromLuaMulti> Future for AsyncThread<R> {
    type Output = Result<R>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let lua = self.thread.0.lua.lock();
-        if self.thread.status_inner(&lua) != ThreadStatus::Resumable {
-            return Poll::Ready(Err(Error::CoroutineUnresumable));
-        }
+        let nargs = match self.thread.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
+            _ => return Poll::Ready(Err(Error::CoroutineUnresumable)),
+        };

        let state = lua.state();
        let thread_state = self.thread.state();
@@ -477,21 +788,29 @@ impl<A: IntoLuaMulti, R: FromLuaMulti> Future for AsyncThread<A, R> {
            let _thread_sg = StackGuard::with_top(thread_state, 0);
            let _wg = WakerGuard::new(&lua, cx.waker());

-            // This is safe as we are not moving the whole struct
-            let this = self.get_unchecked_mut();
-            let nresults = if let Some(args) = this.init_args.take() {
-                this.thread.resume_inner(&lua, args)?
-            } else {
-                this.thread.resume_inner(&lua, ())?
-            };
-
-            if nresults == 1 && is_poll_pending(thread_state) {
-                return Poll::Pending;
+            // Exec thread resume callback
+            if lua.thread_event_triggers().on_resume
+                && let Some(cb) = lua.thread_event_callback()
+                && XRc::strong_count(&cb) <= 2
+            {
+                cb(lua.lua(), ThreadEvent::Resume(self.thread.clone()))?;
            }

-            if ffi::lua_status(thread_state) == ffi::LUA_YIELD {
-                // Ignore value returned via yield()
-                cx.waker().wake_by_ref();
+            let (status, nresults) = self.thread.resume_inner(&lua, nargs)?;
+
+            if status.is_yielded() {
+                // Exec thread yield callback
+                if lua.thread_event_triggers().on_yield
+                    && let Some(cb) = lua.thread_event_callback()
+                    && XRc::strong_count(&cb) <= 2
+                {
+                    cb(lua.lua(), ThreadEvent::Yield(self.thread.clone()))?;
+                }
+
+                if !(nresults == 1 && is_poll_pending(thread_state)) {
+                    // Ignore values returned via yield()
+                    cx.waker().wake_by_ref();
+                }
                return Poll::Pending;
            }

@@ -506,7 +825,7 @@ impl<A: IntoLuaMulti, R: FromLuaMulti> Future for AsyncThread<A, R> {
 #[cfg(feature = "async")]
 #[inline(always)]
 unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
-    ffi::lua_tolightuserdata(state, -1) == Lua::poll_pending().0
+    ffi::lua_tolightuserdata(state, -1) == crate::Lua::poll_pending().0
 }

 #[cfg(feature = "async")]
@@ -520,7 +839,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,
@@ -532,7 +851,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);
    }
 }

@@ -545,7 +864,7 @@ mod assertions {
    #[cfg(feature = "send")]
    static_assertions::assert_impl_all!(Thread: Send, Sync);
    #[cfg(all(feature = "async", not(feature = "send")))]
-    static_assertions::assert_not_impl_any!(AsyncThread<(), ()>: Send);
+    static_assertions::assert_not_impl_any!(AsyncThread<()>: Send);
    #[cfg(all(feature = "async", feature = "send"))]
-    static_assertions::assert_impl_all!(AsyncThread<(), ()>: Send, Sync);
+    static_assertions::assert_impl_all!(AsyncThread<()>: Send, Sync);
 }
@@ -1,17 +1,20 @@
+//! Core conversion and extension traits.
+//!
+//! This module provides the fundamental traits for converting values between Rust and Lua,
+//! and for defining native Lua callable functions.
+
 use std::os::raw::c_int;
-use std::string::String as StdString;
 use std::sync::Arc;

 use crate::error::{Error, Result};
 use crate::multi::MultiValue;
 use crate::private::Sealed;
-use crate::state::{Lua, RawLua};
-use crate::types::MaybeSend;
-use crate::util::{check_stack, short_type_name};
+use crate::state::{Lua, RawLua, WeakLua};
+use crate::util::{check_stack, parse_lookup_path, short_type_name};
 use crate::value::Value;

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

 /// Trait for types convertible to [`Value`].
 pub trait IntoLua: Sized {
@@ -162,7 +165,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;

@@ -175,12 +178,10 @@ pub trait ObjectLike: Sealed {
    /// Gets the function associated to key `name` from the object and asynchronously calls it,
    /// passing the object itself along with `args` as function arguments.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// 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;

@@ -195,115 +196,62 @@ pub trait ObjectLike: Sealed {
    /// Gets the function associated to key `name` from the object and asynchronously calls it,
    /// passing `args` as function arguments.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// 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;

+    /// Look up a value by a path of keys.
+    ///
+    /// The syntax is similar to accessing nested tables in Lua, with additional support for
+    /// `?` operator to perform safe navigation.
+    ///
+    /// For example, the path `a[1].c` is equivalent to `table.a[1].c` in Lua.
+    /// With `?` operator, `a[1]?.c` is equivalent to `table.a[1] and table.a[1].c or nil` in Lua.
+    ///
+    /// Bracket notation rules:
+    /// - `[123]` - integer keys
+    /// - `["string key"]` or `['string key']` - string keys (must be quoted)
+    /// - String keys support escape sequences: `\"`, `\'`, `\\`
+    fn get_path<V: FromLua>(&self, path: &str) -> Result<V> {
+        let mut current = self.to_value();
+        for (key, safe_nil) in parse_lookup_path(path)? {
+            current = match current {
+                Value::Table(table) => table.get::<Value>(key),
+                Value::UserData(ud) => ud.get::<Value>(key),
+                _ => {
+                    let type_name = current.type_name();
+                    let err = format!("attempt to index a {type_name} value with key '{key}'");
+                    Err(Error::runtime(err))
+                }
+            }?;
+            if safe_nil && (current == Value::Nil || current == Value::NULL) {
+                break;
+            }
+        }
+
+        let lua = self.weak_lua().lock();
+        V::from_lua(current, lua.lua())
+    }
+
    /// Converts the object to a string in a human-readable format.
    ///
    /// This might invoke the `__tostring` metamethod.
-    fn to_string(&self) -> Result<StdString>;
+    fn to_string(&self) -> Result<String>;
+
+    /// Converts the object to a Lua value.
+    fn to_value(&self) -> Value;
+
+    /// Gets a reference to the associated Lua state.
+    #[doc(hidden)]
+    fn weak_lua(&self) -> &WeakLua;
 }

-/// A trait for types that can be used as Lua functions.
-pub trait LuaNativeFn<A: FromLuaMulti> {
-    type Output: IntoLuaMulti;
-
-    fn call(&self, args: A) -> Self::Output;
-}
-
-/// A trait for types with mutable state that can be used as Lua functions.
-pub trait LuaNativeFnMut<A: FromLuaMulti> {
-    type Output: IntoLuaMulti;
-
-    fn call(&mut self, args: A) -> Self::Output;
-}
-
-/// A trait for types that returns a future and can be used as Lua functions.
-#[cfg(feature = "async")]
-pub trait LuaNativeAsyncFn<A: FromLuaMulti> {
-    type Output: IntoLuaMulti;
-
-    fn call(&self, args: A) -> impl Future<Output = Self::Output> + MaybeSend + 'static;
-}
-
-macro_rules! impl_lua_native_fn {
-    ($($A:ident),*) => {
-        impl<FN, $($A,)* R> LuaNativeFn<($($A,)*)> for FN
-        where
-            FN: Fn($($A,)*) -> R + MaybeSend + 'static,
-            ($($A,)*): FromLuaMulti,
-            R: IntoLuaMulti,
-        {
-            type Output = R;
-
-            #[allow(non_snake_case)]
-            fn call(&self, args: ($($A,)*)) -> Self::Output {
-                let ($($A,)*) = args;
-                self($($A,)*)
-            }
-        }
-
-        impl<FN, $($A,)* R> LuaNativeFnMut<($($A,)*)> for FN
-        where
-            FN: FnMut($($A,)*) -> R + MaybeSend + 'static,
-            ($($A,)*): FromLuaMulti,
-            R: IntoLuaMulti,
-        {
-            type Output = R;
-
-            #[allow(non_snake_case)]
-            fn call(&mut self, args: ($($A,)*)) -> Self::Output {
-                let ($($A,)*) = args;
-                self($($A,)*)
-            }
-        }
-
-        #[cfg(feature = "async")]
-        impl<FN, $($A,)* Fut, R> LuaNativeAsyncFn<($($A,)*)> for FN
-        where
-            FN: Fn($($A,)*) -> Fut + MaybeSend + 'static,
-            ($($A,)*): FromLuaMulti,
-            Fut: Future<Output = R> + MaybeSend + 'static,
-            R: IntoLuaMulti,
-        {
-            type Output = R;
-
-            #[allow(non_snake_case)]
-            fn call(&self, args: ($($A,)*)) -> impl Future<Output = Self::Output> + MaybeSend + 'static {
-                let ($($A,)*) = args;
-                self($($A,)*)
-            }
-        }
-    };
-}
-
-impl_lua_native_fn!();
-impl_lua_native_fn!(A);
-impl_lua_native_fn!(A, B);
-impl_lua_native_fn!(A, B, C);
-impl_lua_native_fn!(A, B, C, D);
-impl_lua_native_fn!(A, B, C, D, E);
-impl_lua_native_fn!(A, B, C, D, E, F);
-impl_lua_native_fn!(A, B, C, D, E, F, G);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
-
 pub(crate) trait ShortTypeName {
    #[inline(always)]
-    fn type_name() -> StdString {
+    fn type_name() -> String {
        short_type_name::<Self>()
    }
 }
@@ -1,10 +1,9 @@
 use std::cell::UnsafeCell;
 use std::os::raw::{c_int, c_void};
-use std::rc::Rc;

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

 // Re-export mutex wrappers
@@ -21,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.
@@ -36,10 +38,13 @@ unsafe impl Send for LightUserData {}
 unsafe impl Sync for LightUserData {}

 #[cfg(feature = "send")]
-pub(crate) type Callback = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + Send + 'static>;
+type CallbackFn<'a> = dyn Fn(&RawLua, c_int) -> Result<c_int> + Send + 'a;

 #[cfg(not(feature = "send"))]
-pub(crate) type Callback = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + 'static>;
+type CallbackFn<'a> = dyn Fn(&RawLua, c_int) -> Result<c_int> + 'a;
+
+pub(crate) type Callback = Box<CallbackFn<'static>>;
+pub(crate) type CallbackPtr = *const CallbackFn<'static>;

 pub(crate) type ScopedCallback<'s> = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + 's>;

@@ -62,7 +67,7 @@ pub(crate) type AsyncCallback =
 pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback>;

 #[cfg(feature = "async")]
-pub(crate) type AsyncPollUpvalue = Upvalue<BoxFuture<'static, Result<c_int>>>;
+pub(crate) type AsyncPollUpvalue = Upvalue<Option<BoxFuture<'static, Result<c_int>>>>;

 /// Type to set next Lua VM action after executing interrupt or hook function.
 pub enum VmState {
@@ -73,23 +78,37 @@ pub enum VmState {
    Yield,
 }

+#[cfg(not(feature = "luau"))]
+pub(crate) enum HookKind {
+    Global,
+    Thread(HookTriggers, HookCallback),
+}
+
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Rc<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 = Rc<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 = Rc<dyn Fn(&Lua) -> Result<VmState> + Send>;
+pub(crate) type InterruptCallback = XRc<dyn Fn(&Lua) -> Result<VmState> + Send>;

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

-#[cfg(all(feature = "send", feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
+#[cfg(feature = "send")]
+pub(crate) type ThreadEventCallback = XRc<dyn Fn(&Lua, crate::thread::ThreadEvent) -> Result<()> + Send>;

-#[cfg(all(not(feature = "send"), feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()>>;
+#[cfg(not(feature = "send"))]
+pub(crate) type ThreadEventCallback = XRc<dyn Fn(&Lua, crate::thread::ThreadEvent) -> Result<()>>;
+
+#[cfg(feature = "send")]
+#[cfg(any(feature = "lua55", feature = "lua54"))]
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
+
+#[cfg(not(feature = "send"))]
+#[cfg(any(feature = "lua55", feature = "lua54"))]
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()>>;

 /// A trait that adds `Send` requirement if `send` feature is enabled.
 #[cfg(feature = "send")]
@@ -97,11 +116,24 @@ pub trait MaybeSend: Send {}
 #[cfg(feature = "send")]
 impl<T: Send> MaybeSend for T {}

+/// A trait that adds `Send` requirement if `send` feature is enabled.
 #[cfg(not(feature = "send"))]
 pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}

+/// A trait that adds `Sync` requirement if `send` feature is enabled.
+#[cfg(feature = "send")]
+pub trait MaybeSync: Sync {}
+#[cfg(feature = "send")]
+impl<T: Sync> MaybeSync for T {}
+
+/// A trait that adds `Sync` requirement if `send` feature is enabled.
+#[cfg(not(feature = "send"))]
+pub trait MaybeSync {}
+#[cfg(not(feature = "send"))]
+impl<T> MaybeSync for T {}
+
 pub(crate) struct DestructedUserdata;

 pub(crate) trait LuaType {
@@ -43,7 +43,7 @@ impl AppData {

    #[inline]
    #[track_caller]
-    pub(crate) fn borrow<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRef<T>> {
+    pub(crate) fn borrow<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRef<'_, T>> {
        match self.try_borrow(guard) {
            Ok(data) => data,
            Err(err) => panic!("already mutably borrowed: {err:?}"),
@@ -53,7 +53,7 @@ impl AppData {
    pub(crate) fn try_borrow<T: 'static>(
        &self,
        guard: Option<LuaGuard>,
-    ) -> Result<Option<AppDataRef<T>>, BorrowError> {
+    ) -> Result<Option<AppDataRef<'_, T>>, BorrowError> {
        let data = unsafe { &*self.container.get() }
            .get(&TypeId::of::<T>())
            .map(|c| c.try_borrow())
@@ -74,7 +74,7 @@ impl AppData {

    #[inline]
    #[track_caller]
-    pub(crate) fn borrow_mut<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRefMut<T>> {
+    pub(crate) fn borrow_mut<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRefMut<'_, T>> {
        match self.try_borrow_mut(guard) {
            Ok(data) => data,
            Err(err) => panic!("already borrowed: {err:?}"),
@@ -84,7 +84,7 @@ impl AppData {
    pub(crate) fn try_borrow_mut<T: 'static>(
        &self,
        guard: Option<LuaGuard>,
-    ) -> Result<Option<AppDataRefMut<T>>, BorrowMutError> {
+    ) -> Result<Option<AppDataRefMut<'_, T>>, BorrowMutError> {
        let data = unsafe { &*self.container.get() }
            .get(&TypeId::of::<T>())
            .map(|c| c.try_borrow_mut())
@@ -31,7 +31,7 @@ mod inner {
        }

        #[inline(always)]
-        pub(crate) fn lock(&self) -> ReentrantMutexGuard<T> {
+        pub(crate) fn lock(&self) -> ReentrantMutexGuard<'_, T> {
            ReentrantMutexGuard(&self.0)
        }

@@ -69,7 +69,7 @@ mod inner {

        #[inline(always)]
        fn deref(&self) -> &Self::Target {
-            &self.0 .0
+            &self.0.0
        }
    }
 }
@@ -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()
+                && let Some(lua) = self.lua.try_lock()
+            {
+                unsafe { lua.drop_ref(self) }
            }
        }
    }
@@ -1,24 +1,28 @@
+//! Lua userdata handling.
+//!
+//! This module provides types for creating and working with Lua userdata from Rust.
+
 use std::any::TypeId;
 use std::ffi::CStr;
 use std::fmt;
 use std::hash::Hash;
 use std::os::raw::{c_char, c_void};
-use std::string::String as StdString;

+use crate::Either;
 use crate::error::{Error, Result};
 use crate::function::Function;
 use crate::state::Lua;
-use crate::string::String;
+use crate::string::LuaString;
 use crate::table::{Table, TablePairs};
 use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
-use crate::types::{MaybeSend, ValueRef};
-use crate::util::{check_stack, get_userdata, push_string, take_userdata, StackGuard};
+use crate::types::{MaybeSend, MaybeSync, ValueRef};
+use crate::util::{StackGuard, check_stack, get_userdata, push_string, short_type_name, take_userdata};
 use crate::value::Value;

 #[cfg(feature = "async")]
 use std::future::Future;

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 use {
    serde::ser::{self, Serialize, Serializer},
    std::result::Result as StdResult,
@@ -26,9 +30,13 @@ use {

 // Re-export for convenience
 pub(crate) use cell::UserDataStorage;
-pub use cell::{UserDataRef, UserDataRefMut};
+pub use r#ref::{UserDataOwned, UserDataRef, UserDataRefMut};
 pub use registry::UserDataRegistry;
 pub(crate) use registry::{RawUserDataRegistry, UserDataProxy};
+pub(crate) use util::{
+    TypeIdHints, borrow_userdata_scoped, borrow_userdata_scoped_mut, collect_userdata,
+    init_userdata_metatable,
+};

 /// Kinds of metamethods that can be overridden.
 ///
@@ -52,30 +60,53 @@ pub enum MetaMethod {
    /// The unary minus (`-`) operator.
    Unm,
    /// The floor division (//) operator.
-    /// Requires `feature = "lua54/lua53/luau"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "luau"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "luau")))
+    )]
    IDiv,
    /// The bitwise AND (&) operator.
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    BAnd,
    /// The bitwise OR (|) operator.
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    BOr,
    /// The bitwise XOR (binary ~) operator.
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    BXor,
    /// The bitwise NOT (unary ~) operator.
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    BNot,
    /// The bitwise left shift (<<) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    Shl,
    /// The bitwise right shift (>>) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua55", feature = "lua54", feature = "lua53")))
+    )]
    Shr,
    /// The string concatenation operator `..`.
    Concat,
@@ -97,19 +128,36 @@ pub enum MetaMethod {
    ///
    /// This is not an operator, but will be called by methods such as `tostring` and `print`.
    ToString,
+    /// The `__todebugstring` metamethod for debug purposes.
+    ///
+    /// This is an mlua-specific metamethod that can be used to provide debug representation for
+    /// userdata.
+    ToDebugString,
    /// The `__pairs` metamethod.
    ///
    /// This is not an operator, but it will be called by the built-in `pairs` function.
-    ///
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit52",))]
+    #[cfg(any(
+        feature = "lua55",
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(
+            feature = "lua55",
+            feature = "lua54",
+            feature = "lua53",
+            feature = "lua52",
+            feature = "luajit52"
+        )))
+    )]
    Pairs,
    /// The `__ipairs` metamethod.
    ///
    /// This is not an operator, but it will be called by the built-in [`ipairs`] function.
    ///
-    /// Requires `feature = "lua52"`
-    ///
    /// [`ipairs`]: https://www.lua.org/manual/5.2/manual.html#pdf-ipairs
    #[cfg(any(feature = "lua52", feature = "luajit52", doc))]
    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua52", feature = "luajit52"))))]
@@ -118,8 +166,6 @@ pub enum MetaMethod {
    ///
    /// Executed before the iteration begins, and should return an iterator function like `next`
    /// (or a custom one).
-    ///
-    /// Requires `feature = "lua"`
    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    Iter,
@@ -130,11 +176,9 @@ pub enum MetaMethod {
    /// More information about to-be-closed variables can be found in the Lua 5.4
    /// [documentation][lua_doc].
    ///
-    /// Requires `feature = "lua54"`
-    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#3.3.8
-    #[cfg(feature = "lua54")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
+    #[cfg(any(feature = "lua55", feature = "lua54"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua55", feature = "lua54"))))]
    Close,
    /// The `__name`/`__type` metafield.
    ///
@@ -150,7 +194,7 @@ impl PartialEq<MetaMethod> for &str {
    }
 }

-impl PartialEq<MetaMethod> for StdString {
+impl PartialEq<MetaMethod> for String {
    fn eq(&self, other: &MetaMethod) -> bool {
        self == other.name()
    }
@@ -174,19 +218,19 @@ impl MetaMethod {
            MetaMethod::Pow => "__pow",
            MetaMethod::Unm => "__unm",

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53", feature = "luau"))]
            MetaMethod::IDiv => "__idiv",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::BAnd => "__band",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::BOr => "__bor",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::BXor => "__bxor",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::BNot => "__bnot",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::Shl => "__shl",
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua55", feature = "lua54", feature = "lua53"))]
            MetaMethod::Shr => "__shr",

            MetaMethod::Concat => "__concat",
@@ -198,15 +242,22 @@ impl MetaMethod {
            MetaMethod::NewIndex => "__newindex",
            MetaMethod::Call => "__call",
            MetaMethod::ToString => "__tostring",
+            MetaMethod::ToDebugString => "__todebugstring",

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit52"))]
+            #[cfg(any(
+                feature = "lua55",
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            MetaMethod::Pairs => "__pairs",
            #[cfg(any(feature = "lua52", feature = "luajit52"))]
            MetaMethod::IPairs => "__ipairs",
            #[cfg(feature = "luau")]
            MetaMethod::Iter => "__iter",

-            #[cfg(feature = "lua54")]
+            #[cfg(any(feature = "lua55", feature = "lua54"))]
            MetaMethod::Close => "__close",

            #[rustfmt::skip]
@@ -217,9 +268,7 @@ impl MetaMethod {
    pub(crate) const fn as_cstr(self) -> &'static CStr {
        match self {
            #[rustfmt::skip]
-            MetaMethod::Type => unsafe {
-                CStr::from_bytes_with_nul_unchecked(if cfg!(feature = "luau") { b"__type\0" } else { b"__name\0" })
-            },
+            MetaMethod::Type => if cfg!(feature = "luau") { c"__type" } else { c"__name" },
            _ => unreachable!(),
        }
    }
@@ -240,6 +289,13 @@ impl AsRef<str> for MetaMethod {
    }
 }

+impl From<MetaMethod> for String {
+    #[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 +305,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<String>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -260,22 +316,42 @@ 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<String>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
        R: IntoLuaMulti;

+    /// Add a method which accepts `T` as the first parameter.
+    ///
+    /// The userdata `T` will be moved out of the userdata container. This is useful for
+    /// methods that need to consume the userdata.
+    ///
+    /// The method can be called only once per userdata instance, subsequent calls will result in a
+    /// [`Error::UserDataDestructed`] error.
+    fn add_method_once<M, A, R>(&mut self, name: impl Into<String>, method: M)
+    where
+        T: 'static,
+        M: Fn(&Lua, T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.into();
+        let method_name = format!("{}.{name}", short_type_name::<T>());
+        self.add_function(name, move |lua, (ud, args): (AnyUserData, A)| {
+            let this = (ud.take()).map_err(|err| Error::bad_self_argument(&method_name, err))?;
+            method(lua, this, args)
+        });
+    }
+
    /// Add an async method which accepts a `&T` as the first parameter and returns [`Future`].
    ///
    /// Refer to [`add_method`] for more information about the implementation.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`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<String>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -287,12 +363,10 @@ pub trait UserDataMethods<T> {
    ///
    /// Refer to [`add_method`] for more information about the implementation.
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`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<String>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -300,12 +374,39 @@ pub trait UserDataMethods<T> {
        MR: Future<Output = Result<R>> + MaybeSend + 'static,
        R: IntoLuaMulti;

+    /// Add an async method which accepts a `T` as the first parameter and returns [`Future`].
+    ///
+    /// The userdata `T` will be moved out of the userdata container. This is useful for
+    /// methods that need to consume the userdata.
+    ///
+    /// The method can be called only once per userdata instance, subsequent calls will result in a
+    /// [`Error::UserDataDestructed`] error.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_method_once<M, A, MR, R>(&mut self, name: impl Into<String>, method: M)
+    where
+        T: 'static,
+        M: Fn(Lua, T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.into();
+        let method_name = format!("{}.{name}", short_type_name::<T>());
+        self.add_async_function(name, move |lua, (ud, args): (AnyUserData, A)| {
+            match (ud.take()).map_err(|err| Error::bad_self_argument(&method_name, err)) {
+                Ok(this) => either::Either::Left(method(lua, this, args)),
+                Err(err) => either::Either::Right(async move { Err(err) }),
+            }
+        });
+    }
+
    /// Add a regular method as a function which accepts generic arguments.
    ///
    /// 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<String>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -316,7 +417,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<String>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -327,12 +428,10 @@ pub trait UserDataMethods<T> {
    ///
    /// This is an async version of [`add_function`].
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`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<String>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -347,7 +446,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<String>, method: M)
    where
        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -361,7 +460,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<String>, method: M)
    where
        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -371,12 +470,13 @@ pub trait UserDataMethods<T> {
    ///
    /// This is an async version of [`add_meta_method`].
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`add_meta_method`]: UserDataMethods::add_meta_method
    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    #[cfg_attr(
+        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 Into<String>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -389,12 +489,10 @@ pub trait UserDataMethods<T> {
    ///
    /// This is an async version of [`add_meta_method_mut`].
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`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<String>, method: M)
    where
        T: 'static,
        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -407,7 +505,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<String>, function: F)
    where
        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -418,7 +516,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<String>, function: F)
    where
        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -428,12 +526,13 @@ pub trait UserDataMethods<T> {
    ///
    /// This is an async version of [`add_meta_function`].
    ///
-    /// Requires `feature = "async"`
-    ///
    /// [`add_meta_function`]: UserDataMethods::add_meta_function
    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    #[cfg_attr(
+        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 Into<String>, function: F)
    where
        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
        A: FromLuaMulti,
@@ -452,7 +551,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<String>, value: V)
    where
        V: IntoLua + 'static;

@@ -463,7 +562,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<String>, method: M)
    where
        M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
        R: IntoLua;
@@ -476,21 +575,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<String>, 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<String>, 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<String>, function: F)
    where
        F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
        A: FromLua;
@@ -503,7 +602,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<String>, value: V)
    where
        V: IntoLua + 'static;

@@ -515,7 +614,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<String>, f: F)
    where
        F: FnOnce(&Lua) -> Result<R> + 'static,
        R: IntoLua;
@@ -615,14 +714,24 @@ pub trait UserData: Sized {
 ///
 /// [`is`]: crate::AnyUserData::is
 /// [`borrow`]: crate::AnyUserData::borrow
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct AnyUserData(pub(crate) ValueRef);

 impl AnyUserData {
    /// Checks whether the type of this userdata is `T`.
    #[inline]
    pub fn is<T: 'static>(&self) -> bool {
-        self.inspect::<T, _, _>(|_| Ok(())).is_ok()
+        let type_id = self.type_id();
+        // We do not use wrapped types here, rather prefer to check the "real" type of the userdata
+        matches!(type_id, Some(type_id) if type_id == TypeId::of::<T>())
+    }
+
+    /// Checks whether the type of this userdata is a [proxy object] for `T`.
+    ///
+    /// [proxy object]: crate::Lua::create_proxy
+    #[inline]
+    pub fn is_proxy<T: 'static>(&self) -> bool {
+        self.is::<UserDataProxy<T>>()
    }

    /// Borrow this userdata immutably if it is of type `T`.
@@ -637,7 +746,8 @@ impl AnyUserData {
    /// [`DataTypeMismatch`]: crate::Error::UserDataTypeMismatch
    #[inline]
    pub fn borrow<T: 'static>(&self) -> Result<UserDataRef<T>> {
-        self.inspect(|ud| ud.try_borrow_owned())
+        let lua = self.0.lua.lock();
+        unsafe { UserDataRef::borrow_from_stack(&lua, lua.ref_thread(), self.0.index) }
    }

    /// Borrow this userdata immutably if it is of type `T`, passing the borrowed value
@@ -645,7 +755,10 @@ impl AnyUserData {
    ///
    /// This method is the only way to borrow scoped userdata (created inside [`Lua::scope`]).
    pub fn borrow_scoped<T: 'static, R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
-        self.inspect(|ud| ud.try_borrow_scoped(|ud| f(ud)))
+        let lua = self.0.lua.lock();
+        let type_id = lua.get_userdata_ref_type_id(&self.0)?;
+        let type_hints = TypeIdHints::new::<T>();
+        unsafe { borrow_userdata_scoped(lua.ref_thread(), self.0.index, type_id, type_hints, f) }
    }

    /// Borrow this userdata mutably if it is of type `T`.
@@ -660,7 +773,8 @@ impl AnyUserData {
    /// [`UserDataTypeMismatch`]: crate::Error::UserDataTypeMismatch
    #[inline]
    pub fn borrow_mut<T: 'static>(&self) -> Result<UserDataRefMut<T>> {
-        self.inspect(|ud| ud.try_borrow_owned_mut())
+        let lua = self.0.lua.lock();
+        unsafe { UserDataRefMut::borrow_from_stack(&lua, lua.ref_thread(), self.0.index) }
    }

    /// Borrow this userdata mutably if it is of type `T`, passing the borrowed value
@@ -668,7 +782,10 @@ impl AnyUserData {
    ///
    /// This method is the only way to borrow scoped userdata (created inside [`Lua::scope`]).
    pub fn borrow_mut_scoped<T: 'static, R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
-        self.inspect(|ud| ud.try_borrow_scoped_mut(|ud| f(ud)))
+        let lua = self.0.lua.lock();
+        let type_id = lua.get_userdata_ref_type_id(&self.0)?;
+        let type_hints = TypeIdHints::new::<T>();
+        unsafe { borrow_userdata_scoped_mut(lua.ref_thread(), self.0.index, type_id, type_hints, f) }
    }

    /// Takes the value out of this userdata.
@@ -679,20 +796,16 @@ impl AnyUserData {
    /// Keeps associated user values unchanged (they will be collected by Lua's GC).
    pub fn take<T: 'static>(&self) -> Result<T> {
        let lua = self.0.lua.lock();
-        let state = lua.state();
-        unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 2)?;
-
-            let type_id = lua.push_userdata_ref(&self.0)?;
-            match type_id {
-                Some(type_id) if type_id == TypeId::of::<T>() => {
-                    // Try to borrow userdata exclusively
-                    let _ = (*get_userdata::<UserDataStorage<T>>(state, -1)).try_borrow_mut()?;
-                    take_userdata::<UserDataStorage<T>>(state).into_inner()
+        match lua.get_userdata_ref_type_id(&self.0)? {
+            Some(type_id) if type_id == TypeId::of::<T>() => unsafe {
+                let ref_thread = lua.ref_thread();
+                if (*get_userdata::<UserDataStorage<T>>(ref_thread, self.0.index)).has_exclusive_access() {
+                    take_userdata::<UserDataStorage<T>>(ref_thread, self.0.index).into_inner()
+                } else {
+                    Err(Error::UserDataBorrowMutError)
                }
-                _ => Err(Error::UserDataTypeMismatch),
-            }
+            },
+            _ => Err(Error::UserDataTypeMismatch),
        }
    }

@@ -881,22 +994,17 @@ impl AnyUserData {
        self.raw_metatable().map(UserDataMetatable)
    }

-    #[doc(hidden)]
-    #[deprecated(since = "0.10.0", note = "please use `metatable` instead")]
-    pub fn get_metatable(&self) -> Result<UserDataMetatable> {
-        self.metatable()
-    }
-
+    /// 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()))
        }
    }

@@ -910,8 +1018,19 @@ impl AnyUserData {
        self.0.to_pointer()
    }

-    /// Returns a type name of this `UserData` (from a metatable field).
-    pub(crate) fn type_name(&self) -> Result<Option<StdString>> {
+    /// Returns [`TypeId`] of this userdata if it is registered and `'static`.
+    ///
+    /// This method is not available for scoped userdata.
+    #[inline]
+    pub fn type_id(&self) -> Option<TypeId> {
+        let lua = self.0.lua.lock();
+        lua.get_userdata_ref_type_id(&self.0).ok().flatten()
+    }
+
+    /// Returns a type name of this userdata (from a metatable field).
+    ///
+    /// If no type name is set, returns `userdata`.
+    pub fn type_name(&self) -> Result<LuaString> {
        let lua = self.0.lua.lock();
        let state = lua.state();
        unsafe {
@@ -928,8 +1047,8 @@ impl AnyUserData {
                ffi::luaL_getmetafield(state, -1, MetaMethod::Type.as_cstr().as_ptr())
            };
            match name_type {
-                ffi::LUA_TSTRING => Ok(Some(String(lua.pop_ref()).to_str()?.to_owned())),
-                _ => Ok(None),
+                ffi::LUA_TSTRING => Ok(LuaString(lua.pop_ref())),
+                _ => lua.create_string(b"userdata"),
            }
        }
    }
@@ -954,7 +1073,7 @@ impl AnyUserData {

    /// Returns `true` if this [`AnyUserData`] is serializable (e.g. was created using
    /// [`Lua::create_ser_userdata`]).
-    #[cfg(feature = "serialize")]
+    #[cfg(feature = "serde")]
    pub(crate) fn is_serializable(&self) -> bool {
        let lua = self.0.lua.lock();
        let is_serializable = || unsafe {
@@ -966,25 +1085,49 @@ impl AnyUserData {
        is_serializable().unwrap_or(false)
    }

-    pub(crate) fn inspect<T, F, R>(&self, func: F) -> Result<R>
-    where
-        T: 'static,
-        F: FnOnce(&UserDataStorage<T>) -> Result<R>,
-    {
+    unsafe fn invoke_tostring_dbg(&self) -> Result<Option<String>> {
        let lua = self.0.lua.lock();
-        unsafe {
-            let type_id = lua.get_userdata_ref_type_id(&self.0)?;
-            match type_id {
-                Some(type_id) if type_id == TypeId::of::<T>() => {
-                    let ud = get_userdata::<UserDataStorage<T>>(lua.ref_thread(), self.0.index);
-                    func(&*ud)
+        let state = lua.state();
+        let _guard = StackGuard::new(state);
+        check_stack(state, 3)?;
+
+        lua.push_ref(&self.0);
+        protect_lua!(state, 1, 1, fn(state) {
+            // Try `__todebugstring` metamethod first, then `__tostring`
+            #[allow(clippy::collapsible_if)]
+            if ffi::luaL_callmeta(state, -1, cstr!("__todebugstring")) == 0 {
+                if ffi::luaL_callmeta(state, -1, cstr!("__tostring")) == 0 {
+                    ffi::lua_pushnil(state);
                }
-                _ => Err(Error::UserDataTypeMismatch),
+            }
+        })?;
+        Ok(lua.pop_value().as_string().map(|s| s.to_string_lossy()))
+    }
+
+    pub(crate) fn fmt_pretty(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        // Try converting to a (debug) string first, with fallback to `__name/__type`
+        match unsafe { self.invoke_tostring_dbg() } {
+            Ok(Some(s)) => write!(fmt, "{s}"),
+            _ => {
+                let name = self.type_name().ok();
+                let name = (name.as_ref())
+                    .map(|s| Either::Left(s.display()))
+                    .unwrap_or(Either::Right("userdata"));
+                write!(fmt, "{name}: {:?}", self.to_pointer())
            }
        }
    }
 }

+impl fmt::Debug for AnyUserData {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        if fmt.alternate() {
+            return self.fmt_pretty(fmt);
+        }
+        fmt.debug_tuple("AnyUserData").field(&self.0).finish()
+    }
+}
+
 /// Handle to a [`AnyUserData`] metatable.
 #[derive(Clone, Debug)]
 pub struct UserDataMetatable(pub(crate) Table);
@@ -1023,7 +1166,7 @@ impl UserDataMetatable {
    /// The pairs are wrapped in a [`Result`], since they are lazily converted to `V` type.
    ///
    /// [`Result`]: crate::Result
-    pub fn pairs<V: FromLua>(&self) -> UserDataMetatablePairs<V> {
+    pub fn pairs<V: FromLua>(&self) -> UserDataMetatablePairs<'_, V> {
        UserDataMetatablePairs(self.0.pairs())
    }
 }
@@ -1033,13 +1176,13 @@ impl UserDataMetatable {
 /// It skips restricted metamethods, such as `__gc` or `__metatable`.
 ///
 /// This struct is created by the [`UserDataMetatable::pairs`] method.
-pub struct UserDataMetatablePairs<'a, V>(TablePairs<'a, StdString, V>);
+pub struct UserDataMetatablePairs<'a, V>(TablePairs<'a, String, V>);

 impl<V> Iterator for UserDataMetatablePairs<'_, V>
 where
    V: FromLua,
 {
-    type Item = Result<(StdString, V)>;
+    type Item = Result<(String, V)>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
@@ -1056,7 +1199,7 @@ where
    }
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl Serialize for AnyUserData {
    fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
    where
@@ -1079,7 +1222,7 @@ impl AnyUserData {
    /// Wraps any Rust type, returning an opaque type that implements [`IntoLua`] trait.
    ///
    /// This function uses [`Lua::create_any_userdata`] under the hood.
-    pub fn wrap<T: MaybeSend + 'static>(data: T) -> impl IntoLua {
+    pub fn wrap<T: MaybeSend + MaybeSync + 'static>(data: T) -> impl IntoLua {
        WrappedUserdata(move |lua| lua.create_any_userdata(data))
    }

@@ -1087,9 +1230,9 @@ impl AnyUserData {
    /// [`IntoLua`] trait.
    ///
    /// This function uses [`Lua::create_ser_any_userdata`] under the hood.
-    #[cfg(feature = "serialize")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-    pub fn wrap_ser<T: Serialize + MaybeSend + 'static>(data: T) -> impl IntoLua {
+    #[cfg(feature = "serde")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+    pub fn wrap_ser<T: Serialize + MaybeSend + MaybeSync + 'static>(data: T) -> impl IntoLua {
        WrappedUserdata(move |lua| lua.create_ser_any_userdata(data))
    }
 }
@@ -1106,6 +1249,7 @@ where
 mod cell;
 mod lock;
 mod object;
+mod r#ref;
 mod registry;
 mod util;

@@ -1,28 +1,19 @@
-use std::any::{type_name, TypeId};
-use std::cell::{Cell, RefCell, UnsafeCell};
-use std::fmt;
-use std::ops::{Deref, DerefMut};
-use std::os::raw::c_int;
+use std::cell::RefCell;

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 use serde::ser::{Serialize, Serializer};

 use crate::error::{Error, Result};
-use crate::state::{Lua, RawLua};
-use crate::traits::FromLua;
 use crate::types::XRc;
-use crate::userdata::AnyUserData;
-use crate::util::get_userdata;
-use crate::value::Value;

-use super::lock::{RawLock, UserDataLock};
-use super::util::is_sync;
+use super::lock::{RawLock, RwLock, UserDataLock};
+use super::r#ref::{UserDataRef, UserDataRefMut};

-#[cfg(all(feature = "serialize", not(feature = "send")))]
+#[cfg(all(feature = "serde", not(feature = "send")))]
 type DynSerialize = dyn erased_serde::Serialize;

-#[cfg(all(feature = "serialize", feature = "send"))]
-type DynSerialize = dyn erased_serde::Serialize + Send;
+#[cfg(all(feature = "serde", feature = "send"))]
+type DynSerialize = dyn erased_serde::Serialize + Send + Sync;

 pub(crate) enum UserDataStorage<T> {
    Owned(UserDataVariant<T>),
@@ -32,9 +23,9 @@ pub(crate) enum UserDataStorage<T> {
 // A enum for storing userdata values.
 // It's stored inside a Lua VM and protected by the outer `ReentrantMutex`.
 pub(crate) enum UserDataVariant<T> {
-    Default(XRc<UserDataCell<T>>),
-    #[cfg(feature = "serialize")]
-    Serializable(XRc<UserDataCell<Box<DynSerialize>>>),
+    Default(XRc<RwLock<T>>),
+    #[cfg(feature = "serde")]
+    Serializable(XRc<RwLock<Box<DynSerialize>>>),
 }

 impl<T> Clone for UserDataVariant<T> {
@@ -42,17 +33,31 @@ impl<T> Clone for UserDataVariant<T> {
    fn clone(&self) -> Self {
        match self {
            Self::Default(inner) => Self::Default(XRc::clone(inner)),
-            #[cfg(feature = "serialize")]
+            #[cfg(feature = "serde")]
            Self::Serializable(inner) => Self::Serializable(XRc::clone(inner)),
        }
    }
 }

 impl<T> UserDataVariant<T> {
-    // Immutably borrows the wrapped value in-place.
    #[inline(always)]
-    fn try_borrow(&self) -> Result<UserDataBorrowRef<T>> {
-        UserDataBorrowRef::try_from(self)
+    pub(super) fn try_borrow_scoped<R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
+        // Shared (read) lock is always correct for in-place borrows:
+        // - this method is called internally while the Lua mutex is held, ensuring exclusive Lua-level
+        //   access per call frame
+        // - with `send` feature, all owned userdata satisfies `T: Sync`, so simultaneous shared references
+        //   from multiple threads are sound
+        // - without `send` feature, single-threaded execution makes shared lock safe for any `T`
+        let _guard = (self.raw_lock().try_lock_shared_guarded()).map_err(|_| Error::UserDataBorrowError)?;
+        Ok(f(unsafe { &*self.as_ptr() }))
+    }
+
+    // Mutably borrows the wrapped value in-place.
+    #[inline(always)]
+    fn try_borrow_scoped_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
+        let _guard =
+            (self.raw_lock().try_lock_exclusive_guarded()).map_err(|_| Error::UserDataBorrowMutError)?;
+        Ok(f(unsafe { &mut *self.as_ptr() }))
    }

    // Immutably borrows the wrapped value and returns an owned reference.
@@ -61,12 +66,6 @@ impl<T> UserDataVariant<T> {
        UserDataRef::try_from(self.clone())
    }

-    // Mutably borrows the wrapped value in-place.
-    #[inline(always)]
-    fn try_borrow_mut(&self) -> Result<UserDataBorrowMut<T>> {
-        UserDataBorrowMut::try_from(self)
-    }
-
    // Mutably borrows the wrapped value and returns an owned reference.
    #[inline(always)]
    fn try_borrow_owned_mut(&self) -> Result<UserDataRefMut<T>> {
@@ -81,314 +80,59 @@ impl<T> UserDataVariant<T> {
            return Err(Error::UserDataBorrowMutError);
        }
        Ok(match self {
-            Self::Default(inner) => XRc::into_inner(inner).unwrap().value.into_inner(),
-            #[cfg(feature = "serialize")]
+            Self::Default(inner) => XRc::into_inner(inner).unwrap().into_inner(),
+            #[cfg(feature = "serde")]
            Self::Serializable(inner) => unsafe {
-                let raw = Box::into_raw(XRc::into_inner(inner).unwrap().value.into_inner());
+                // The serde variant erases `T` to `Box<DynSerialize>`, so we
+                // must cast the raw pointer back to recover the concrete type.
+                let raw = Box::into_raw(XRc::into_inner(inner).unwrap().into_inner());
                *Box::from_raw(raw as *mut T)
            },
        })
    }

    #[inline(always)]
-    fn raw_lock(&self) -> &RawLock {
+    fn strong_count(&self) -> usize {
        match self {
-            Self::Default(inner) => &inner.raw_lock,
-            #[cfg(feature = "serialize")]
-            Self::Serializable(inner) => &inner.raw_lock,
+            Self::Default(inner) => XRc::strong_count(inner),
+            #[cfg(feature = "serde")]
+            Self::Serializable(inner) => XRc::strong_count(inner),
        }
    }

    #[inline(always)]
-    fn borrow_count(&self) -> &Cell<usize> {
+    pub(super) fn raw_lock(&self) -> &RawLock {
        match self {
-            Self::Default(inner) => &inner.borrow_count,
-            #[cfg(feature = "serialize")]
-            Self::Serializable(inner) => &inner.borrow_count,
+            Self::Default(inner) => unsafe { inner.raw() },
+            #[cfg(feature = "serde")]
+            Self::Serializable(inner) => unsafe { inner.raw() },
        }
    }

    #[inline(always)]
-    fn as_ptr(&self) -> *mut T {
+    pub(super) fn as_ptr(&self) -> *mut T {
        match self {
-            Self::Default(inner) => inner.value.get(),
-            #[cfg(feature = "serialize")]
-            Self::Serializable(inner) => unsafe { &mut **(inner.value.get() as *mut Box<T>) },
+            Self::Default(inner) => inner.data_ptr(),
+            #[cfg(feature = "serde")]
+            Self::Serializable(inner) => unsafe { (&mut **inner.data_ptr()) as *mut DynSerialize as *mut T },
        }
    }
 }

-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl Serialize for UserDataStorage<()> {
    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
        match self {
-            Self::Owned(UserDataVariant::Serializable(inner)) => unsafe {
-                // We need to borrow the inner value exclusively to serialize it.
-                #[cfg(feature = "send")]
-                let _guard = self.try_borrow_mut().map_err(serde::ser::Error::custom)?;
-                // No need to do this if the `send` feature is disabled.
-                #[cfg(not(feature = "send"))]
-                let _guard = self.try_borrow().map_err(serde::ser::Error::custom)?;
-                (*inner.value.get()).serialize(serializer)
+            Self::Owned(variant @ UserDataVariant::Serializable(inner)) => unsafe {
+                let _guard = (variant.raw_lock().try_lock_shared_guarded())
+                    .map_err(|_| serde::ser::Error::custom(Error::UserDataBorrowError))?;
+                (*inner.data_ptr()).serialize(serializer)
            },
            _ => Err(serde::ser::Error::custom("cannot serialize <userdata>")),
        }
    }
 }

-/// A type that provides interior mutability for a userdata value (thread-safe).
-pub(crate) struct UserDataCell<T> {
-    raw_lock: RawLock,
-    borrow_count: Cell<usize>,
-    value: UnsafeCell<T>,
-}
-
-#[cfg(feature = "send")]
-unsafe impl<T: Send> Send for UserDataCell<T> {}
-#[cfg(feature = "send")]
-unsafe impl<T: Send> Sync for UserDataCell<T> {}
-
-impl<T> UserDataCell<T> {
-    #[inline(always)]
-    fn new(value: T) -> Self {
-        UserDataCell {
-            raw_lock: RawLock::INIT,
-            borrow_count: Cell::new(0),
-            value: UnsafeCell::new(value),
-        }
-    }
-}
-
-/// A wrapper type for a userdata value that provides read access.
-///
-/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
-pub struct UserDataRef<T>(UserDataVariant<T>);
-
-impl<T> Deref for UserDataRef<T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        unsafe { &*self.0.as_ptr() }
-    }
-}
-
-impl<T> Drop for UserDataRef<T> {
-    #[inline]
-    fn drop(&mut self) {
-        if !cfg!(feature = "send") || is_sync::<T>() {
-            unsafe { self.0.raw_lock().unlock_shared() };
-        } else {
-            unsafe { self.0.raw_lock().unlock_exclusive() };
-        }
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for UserDataRef<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T: fmt::Display> fmt::Display for UserDataRef<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T> TryFrom<UserDataVariant<T>> for UserDataRef<T> {
-    type Error = Error;
-
-    #[inline]
-    fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
-        if !cfg!(feature = "send") || is_sync::<T>() {
-            if !variant.raw_lock().try_lock_shared() {
-                return Err(Error::UserDataBorrowError);
-            }
-        } else if !variant.raw_lock().try_lock_exclusive() {
-            return Err(Error::UserDataBorrowError);
-        }
-        Ok(UserDataRef(variant))
-    }
-}
-
-impl<T: 'static> FromLua for UserDataRef<T> {
-    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
-        try_value_to_userdata::<T>(value)?.borrow()
-    }
-
-    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
-        let type_id = lua.get_userdata_type_id::<T>(idx)?;
-        match type_id {
-            Some(type_id) if type_id == TypeId::of::<T>() => {
-                (*get_userdata::<UserDataStorage<T>>(lua.state(), idx)).try_borrow_owned()
-            }
-            _ => Err(Error::UserDataTypeMismatch),
-        }
-    }
-}
-
-/// A wrapper type for a userdata value that provides read and write access.
-///
-/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
-pub struct UserDataRefMut<T>(UserDataVariant<T>);
-
-impl<T> Deref for UserDataRefMut<T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0.as_ptr() }
-    }
-}
-
-impl<T> DerefMut for UserDataRefMut<T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe { &mut *self.0.as_ptr() }
-    }
-}
-
-impl<T> Drop for UserDataRefMut<T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe { self.0.raw_lock().unlock_exclusive() };
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for UserDataRefMut<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T: fmt::Display> fmt::Display for UserDataRefMut<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T> TryFrom<UserDataVariant<T>> for UserDataRefMut<T> {
-    type Error = Error;
-
-    #[inline]
-    fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
-        if !variant.raw_lock().try_lock_exclusive() {
-            return Err(Error::UserDataBorrowMutError);
-        }
-        Ok(UserDataRefMut(variant))
-    }
-}
-
-impl<T: 'static> FromLua for UserDataRefMut<T> {
-    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
-        try_value_to_userdata::<T>(value)?.borrow_mut()
-    }
-
-    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
-        let type_id = lua.get_userdata_type_id::<T>(idx)?;
-        match type_id {
-            Some(type_id) if type_id == TypeId::of::<T>() => {
-                (*get_userdata::<UserDataStorage<T>>(lua.state(), idx)).try_borrow_owned_mut()
-            }
-            _ => Err(Error::UserDataTypeMismatch),
-        }
-    }
-}
-
-/// A type that provides read access to a userdata value (borrowing the value).
-pub(crate) struct UserDataBorrowRef<'a, T>(&'a UserDataVariant<T>);
-
-impl<T> Drop for UserDataBorrowRef<'_, T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            self.0.borrow_count().set(self.0.borrow_count().get() - 1);
-            self.0.raw_lock().unlock_shared();
-        }
-    }
-}
-
-impl<T> Deref for UserDataBorrowRef<'_, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        // SAFETY: `UserDataBorrowRef` is only created with shared access to the value.
-        unsafe { &*self.0.as_ptr() }
-    }
-}
-
-impl<'a, T> TryFrom<&'a UserDataVariant<T>> for UserDataBorrowRef<'a, T> {
-    type Error = Error;
-
-    #[inline(always)]
-    fn try_from(variant: &'a UserDataVariant<T>) -> Result<Self> {
-        // We don't need to check for `T: Sync` because when this method is used (internally),
-        // Lua mutex is already locked.
-        // If non-`Sync` userdata is already borrowed by another thread (via `UserDataRef`), it will be
-        // exclusively locked.
-        if !variant.raw_lock().try_lock_shared() {
-            return Err(Error::UserDataBorrowError);
-        }
-        variant.borrow_count().set(variant.borrow_count().get() + 1);
-        Ok(UserDataBorrowRef(variant))
-    }
-}
-
-pub(crate) struct UserDataBorrowMut<'a, T>(&'a UserDataVariant<T>);
-
-impl<T> Drop for UserDataBorrowMut<'_, T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            self.0.borrow_count().set(self.0.borrow_count().get() - 1);
-            self.0.raw_lock().unlock_exclusive();
-        }
-    }
-}
-
-impl<T> Deref for UserDataBorrowMut<'_, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        unsafe { &*self.0.as_ptr() }
-    }
-}
-
-impl<T> DerefMut for UserDataBorrowMut<'_, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.0.as_ptr() }
-    }
-}
-
-impl<'a, T> TryFrom<&'a UserDataVariant<T>> for UserDataBorrowMut<'a, T> {
-    type Error = Error;
-
-    #[inline(always)]
-    fn try_from(variant: &'a UserDataVariant<T>) -> Result<Self> {
-        if !variant.raw_lock().try_lock_exclusive() {
-            return Err(Error::UserDataBorrowMutError);
-        }
-        variant.borrow_count().set(variant.borrow_count().get() + 1);
-        Ok(UserDataBorrowMut(variant))
-    }
-}
-
-#[inline]
-fn try_value_to_userdata<T>(value: Value) -> Result<AnyUserData> {
-    match value {
-        Value::UserData(ud) => Ok(ud),
-        _ => Err(Error::FromLuaConversionError {
-            from: value.type_name(),
-            to: "userdata".to_string(),
-            message: Some(format!("expected userdata of type {}", type_name::<T>())),
-        }),
-    }
-}
-
 pub(crate) enum ScopedUserDataVariant<T> {
    Ref(*const T),
    RefMut(RefCell<*mut T>),
@@ -398,10 +142,10 @@ pub(crate) enum ScopedUserDataVariant<T> {
 impl<T> Drop for ScopedUserDataVariant<T> {
    #[inline]
    fn drop(&mut self) {
-        if let Self::Boxed(value) = self {
-            if let Ok(value) = value.try_borrow_mut() {
-                unsafe { drop(Box::from_raw(*value)) };
-            }
+        if let Self::Boxed(value) = self
+            && let Ok(value) = value.try_borrow_mut()
+        {
+            unsafe { drop(Box::from_raw(*value)) }
        }
    }
 }
@@ -409,7 +153,7 @@ impl<T> Drop for ScopedUserDataVariant<T> {
 impl<T: 'static> UserDataStorage<T> {
    #[inline(always)]
    pub(crate) fn new(data: T) -> Self {
-        Self::Owned(UserDataVariant::Default(XRc::new(UserDataCell::new(data))))
+        Self::Owned(UserDataVariant::Default(XRc::new(RwLock::new(data))))
    }

    #[inline(always)]
@@ -422,20 +166,21 @@ impl<T: 'static> UserDataStorage<T> {
        Self::Scoped(ScopedUserDataVariant::RefMut(RefCell::new(data)))
    }

-    #[cfg(feature = "serialize")]
+    #[cfg(feature = "serde")]
    #[inline(always)]
    pub(crate) fn new_ser(data: T) -> Self
    where
-        T: Serialize + crate::types::MaybeSend,
+        T: Serialize + crate::types::MaybeSend + crate::types::MaybeSync,
    {
        let data = Box::new(data) as Box<DynSerialize>;
-        Self::Owned(UserDataVariant::Serializable(XRc::new(UserDataCell::new(data))))
+        let variant = UserDataVariant::Serializable(XRc::new(RwLock::new(data)));
+        Self::Owned(variant)
    }

-    #[cfg(feature = "serialize")]
+    #[cfg(feature = "serde")]
    #[inline(always)]
    pub(crate) fn is_serializable(&self) -> bool {
-        matches!(self, Self::Owned(UserDataVariant::Serializable(_)))
+        matches!(self, Self::Owned(UserDataVariant::Serializable(..)))
    }

    // Immutably borrows the wrapped value and returns an owned reference.
@@ -447,23 +192,6 @@ impl<T: 'static> UserDataStorage<T> {
        }
    }

-    #[allow(unused)]
-    #[inline(always)]
-    pub(crate) fn try_borrow(&self) -> Result<UserDataBorrowRef<T>> {
-        match self {
-            Self::Owned(data) => data.try_borrow(),
-            Self::Scoped(_) => Err(Error::UserDataTypeMismatch),
-        }
-    }
-
-    #[inline(always)]
-    pub(crate) fn try_borrow_mut(&self) -> Result<UserDataBorrowMut<T>> {
-        match self {
-            Self::Owned(data) => data.try_borrow_mut(),
-            Self::Scoped(_) => Err(Error::UserDataTypeMismatch),
-        }
-    }
-
    // Mutably borrows the wrapped value and returns an owned reference.
    #[inline(always)]
    pub(crate) fn try_borrow_owned_mut(&self) -> Result<UserDataRefMut<T>> {
@@ -489,18 +217,31 @@ impl<T> UserDataStorage<T> {
        Self::Scoped(ScopedUserDataVariant::Boxed(RefCell::new(data)))
    }

+    /// Returns `true` if it's safe to destroy the container.
+    ///
+    /// It's safe to destroy the container if the reference count is greater than 1 or the lock is
+    /// not acquired.
    #[inline(always)]
-    pub(crate) fn is_borrowed(&self) -> bool {
+    pub(crate) fn is_safe_to_destroy(&self) -> bool {
        match self {
-            Self::Owned(variant) => variant.borrow_count().get() > 0,
-            Self::Scoped(_) => true,
+            Self::Owned(variant) => variant.strong_count() > 1 || !variant.raw_lock().is_locked(),
+            Self::Scoped(_) => false,
+        }
+    }
+
+    /// Returns `true` if the container has exclusive access to the value.
+    #[inline(always)]
+    pub(crate) fn has_exclusive_access(&self) -> bool {
+        match self {
+            Self::Owned(variant) => !variant.raw_lock().is_locked(),
+            Self::Scoped(_) => false,
        }
    }

    #[inline]
    pub(crate) fn try_borrow_scoped<R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
        match self {
-            Self::Owned(data) => Ok(f(&*data.try_borrow()?)),
+            Self::Owned(data) => data.try_borrow_scoped(f),
            Self::Scoped(ScopedUserDataVariant::Ref(value)) => Ok(f(unsafe { &**value })),
            Self::Scoped(ScopedUserDataVariant::RefMut(value) | ScopedUserDataVariant::Boxed(value)) => {
                let t = value.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
@@ -512,7 +253,7 @@ impl<T> UserDataStorage<T> {
    #[inline]
    pub(crate) fn try_borrow_scoped_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
        match self {
-            Self::Owned(data) => Ok(f(&mut *data.try_borrow_mut()?)),
+            Self::Owned(data) => data.try_borrow_scoped_mut(f),
            Self::Scoped(ScopedUserDataVariant::Ref(_)) => Err(Error::UserDataBorrowMutError),
            Self::Scoped(ScopedUserDataVariant::RefMut(value) | ScopedUserDataVariant::Boxed(value)) => {
                let mut t = value
@@ -523,30 +264,3 @@ impl<T> UserDataStorage<T> {
        }
    }
 }
-
-#[cfg(test)]
-mod assertions {
-    use super::*;
-
-    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(UserDataRef<()>: Send, Sync);
-    #[cfg(feature = "send")]
-    static_assertions::assert_not_impl_all!(UserDataRef<std::rc::Rc<()>>: Send, Sync);
-    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(UserDataRefMut<()>: Sync, Send);
-    #[cfg(feature = "send")]
-    static_assertions::assert_not_impl_all!(UserDataRefMut<std::rc::Rc<()>>: Send, Sync);
-    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(UserDataBorrowRef<'_, ()>: Send, Sync);
-    #[cfg(feature = "send")]
-    static_assertions::assert_impl_all!(UserDataBorrowMut<'_, ()>: Send, Sync);
-
-    #[cfg(not(feature = "send"))]
-    static_assertions::assert_not_impl_all!(UserDataRef<()>: Send, Sync);
-    #[cfg(not(feature = "send"))]
-    static_assertions::assert_not_impl_all!(UserDataRefMut<()>: Send, Sync);
-    #[cfg(not(feature = "send"))]
-    static_assertions::assert_not_impl_all!(UserDataBorrowRef<'_, ()>: Send, Sync);
-    #[cfg(not(feature = "send"))]
-    static_assertions::assert_not_impl_all!(UserDataBorrowMut<'_, ()>: Send, Sync);
-}
--- a/Show More
+++ b/Show More